]> git.proxmox.com Git - mirror_qemu.git/blame - linux-user/syscall.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging
[mirror_qemu.git] / linux-user / syscall.c
CommitLineData
31e31b8a
FB		 1/*
2 * Linux syscalls
5fafdf24 3 *
31e31b8a
FB		 4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
8167ee88 17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
31e31b8a 18 */
d5b3a9b6 19#define _ATFILE_SOURCE
d39594e9 20#include "qemu/osdep.h"
f348b6d1
VB		 21#include "qemu/cutils.h"
22#include "qemu/path.h"
31e31b8a
FB		 23#include <elf.h>
24#include <endian.h>
c56dc774 25#include <grp.h>
d08d3bb8
TS		 26#include <sys/ipc.h>
27#include <sys/msg.h>
31e31b8a 28#include <sys/wait.h>
31e31b8a 29#include <sys/mount.h>
586b0bef
JS		 30#include <sys/file.h>
31#include <sys/fsuid.h>
32#include <sys/personality.h>
39b9aae1 33#include <sys/prctl.h>
31e31b8a 34#include <sys/resource.h>
31e31b8a 35#include <sys/swap.h>
e0eb210e 36#include <linux/capability.h>
31e31b8a 37#include <sched.h>
19f59bce 38#include <sys/timex.h>
60e99246
AJ		 39#ifdef __ia64__
40int __clone2(int (*fn)(void *), void *child_stack_base,
41 size_t stack_size, int flags, void *arg, ...);
42#endif
31e31b8a 43#include <sys/socket.h>
607175e0 44#include <sys/un.h>
31e31b8a 45#include <sys/uio.h>
0839f11c 46#include <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>
38860a03 51#include <time.h>
ebc05488 52#include <utime.h>
a5448a7d 53#include <sys/sysinfo.h>
e36800c9 54#include <sys/signalfd.h>
72f03900 55//#include <sys/user.h>
8853f86e 56#include <netinet/ip.h>
7854b056 57#include <netinet/tcp.h>
86fcd946 58#include <linux/wireless.h>
920394db 59#include <linux/icmp.h>
ee1ac3a1
HD		 60#include <linux/icmpv6.h>
61#include <linux/errqueue.h>
5a61cb60 62#include "qemu-common.h"
d80a1905
RV		 63#ifdef CONFIG_TIMERFD
64#include <sys/timerfd.h>
65#endif
9788c9ca 66#ifdef TARGET_GPROF
6d946cda
AJ		 67#include <sys/gmon.h>
68#endif
c2882b96
RV		 69#ifdef CONFIG_EVENTFD
70#include <sys/eventfd.h>
71#endif
3b6edd16
PM		 72#ifdef CONFIG_EPOLL
73#include <sys/epoll.h>
74#endif
a790ae38 75#ifdef CONFIG_ATTR
1de7afc9 76#include "qemu/xattr.h"
a790ae38 77#endif
a8fd1aba
PM		 78#ifdef CONFIG_SENDFILE
79#include <sys/sendfile.h>
80#endif
31e31b8a
FB		 81
82#define termios host_termios
83#define winsize host_winsize
84#define termio host_termio
04369ff2
FB		 85#define sgttyb host_sgttyb /* same as target */
86#define tchars host_tchars /* same as target */
87#define ltchars host_ltchars /* same as target */
31e31b8a
FB		 88
89#include <linux/termios.h>
90#include <linux/unistd.h>
31e31b8a
FB		 91#include <linux/cdrom.h>
92#include <linux/hdreg.h>
93#include <linux/soundcard.h>
19b84f3c 94#include <linux/kd.h>
8fbd6b52 95#include <linux/mtio.h>
350d1779 96#include <linux/fs.h>
dace20dc 97#if defined(CONFIG_FIEMAP)
285da2b9 98#include <linux/fiemap.h>
dace20dc 99#endif
f7680a55
UH		 100#include <linux/fb.h>
101#include <linux/vt.h>
56e904ec 102#include <linux/dm-ioctl.h>
c07ecc68 103#include <linux/reboot.h>
7ff7b666 104#include <linux/route.h>
f57d4192 105#include <linux/filter.h>
fff8c539 106#include <linux/blkpg.h>
a82ea939 107#include <netpacket/packet.h>
6c5b5645 108#include <linux/netlink.h>
575b22b1 109#ifdef CONFIG_RTNETLINK
6c5b5645 110#include <linux/rtnetlink.h>
c5dff280 111#include <linux/if_bridge.h>
575b22b1 112#endif
5ce9bb59 113#include <linux/audit.h>
d7e4036e 114#include "linux_loop.h"
18cb0088 115#include "uname.h"
31e31b8a 116
3ef693a0 117#include "qemu.h"
31e31b8a 118
5ea2fc84
PM		 119#ifndef CLONE_IO
120#define CLONE_IO 0x80000000 /* Clone io context */
121#endif
122
123/* We can't directly call the host clone syscall, because this will
124 * badly confuse libc (breaking mutexes, for example). So we must
125 * divide clone flags into:
126 * * flag combinations that look like pthread_create()
127 * * flag combinations that look like fork()
128 * * flags we can implement within QEMU itself
129 * * flags we can't support and will return an error for
130 */
131/* For thread creation, all these flags must be present; for
132 * fork, none must be present.
133 */
134#define CLONE_THREAD_FLAGS \
135 (CLONE_VM | CLONE_FS | CLONE_FILES | \
136 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
137
138/* These flags are ignored:
139 * CLONE_DETACHED is now ignored by the kernel;
140 * CLONE_IO is just an optimisation hint to the I/O scheduler
141 */
142#define CLONE_IGNORED_FLAGS \
143 (CLONE_DETACHED | CLONE_IO)
144
145/* Flags for fork which we can implement within QEMU itself */
146#define CLONE_OPTIONAL_FORK_FLAGS \
147 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
148 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
149
150/* Flags for thread creation which we can implement within QEMU itself */
151#define CLONE_OPTIONAL_THREAD_FLAGS \
152 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
153 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
154
155#define CLONE_INVALID_FORK_FLAGS \
156 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
157
158#define CLONE_INVALID_THREAD_FLAGS \
159 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
160 CLONE_IGNORED_FLAGS))
161
162/* CLONE_VFORK is special cased early in do_fork(). The other flag bits
163 * have almost all been allocated. We cannot support any of
164 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
165 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
166 * The checks against the invalid thread masks above will catch these.
167 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
168 */
30813cea 169
72f03900 170//#define DEBUG
71a8f7fe
TB		 171/* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
172 * once. This exercises the codepaths for restart.
173 */
174//#define DEBUG_ERESTARTSYS
31e31b8a 175
1a9353d2 176//#include <linux/msdos_fs.h>
6556a833
AJ		 177#define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
178#define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
1a9353d2 179
70a194b9
FB		 180#undef _syscall0
181#undef _syscall1
182#undef _syscall2
183#undef _syscall3
184#undef _syscall4
185#undef _syscall5
83fcb515 186#undef _syscall6
70a194b9 187
83fcb515 188#define _syscall0(type,name) \
8fcd3692 189static type name (void) \
83fcb515
FB		 190{ \
191 return syscall(__NR_##name); \
192}
70a194b9 193
83fcb515 194#define _syscall1(type,name,type1,arg1) \
8fcd3692 195static type name (type1 arg1) \
83fcb515
FB		 196{ \
197 return syscall(__NR_##name, arg1); \
70a194b9
FB		 198}
199
83fcb515 200#define _syscall2(type,name,type1,arg1,type2,arg2) \
8fcd3692 201static type name (type1 arg1,type2 arg2) \
83fcb515
FB		 202{ \
203 return syscall(__NR_##name, arg1, arg2); \
70a194b9
FB		 204}
205
83fcb515 206#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
8fcd3692 207static type name (type1 arg1,type2 arg2,type3 arg3) \
83fcb515
FB		 208{ \
209 return syscall(__NR_##name, arg1, arg2, arg3); \
70a194b9
FB		 210}
211
83fcb515 212#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
8fcd3692 213static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
83fcb515
FB		 214{ \
215 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
70a194b9
FB		 216}
217
83fcb515
FB		 218#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
219 type5,arg5) \
8fcd3692 220static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
83fcb515
FB		 221{ \
222 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
70a194b9
FB		 223}
224
83fcb515
FB		 225
226#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
227 type5,arg5,type6,arg6) \
8fcd3692
BS		 228static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
229 type6 arg6) \
83fcb515
FB		 230{ \
231 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
70a194b9 232}
83fcb515 233
70a194b9 234
31e31b8a 235#define __NR_sys_uname __NR_uname
72f03900 236#define __NR_sys_getcwd1 __NR_getcwd
72f03900 237#define __NR_sys_getdents __NR_getdents
dab2ed99 238#define __NR_sys_getdents64 __NR_getdents64
c6cda17a 239#define __NR_sys_getpriority __NR_getpriority
66fb9763 240#define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
7494b0f9 241#define __NR_sys_syslog __NR_syslog
bd0c5661 242#define __NR_sys_futex __NR_futex
39b59763
AJ		 243#define __NR_sys_inotify_init __NR_inotify_init
244#define __NR_sys_inotify_add_watch __NR_inotify_add_watch
245#define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
31e31b8a 246
42a39fbe
AG		 247#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__) || \
248 defined(__s390x__)
9af9eaaa
FB		 249#define __NR__llseek __NR_lseek
250#endif
251
a29e5ba2
JH		 252/* Newer kernel ports have llseek() instead of _llseek() */
253#if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
254#define TARGET_NR__llseek TARGET_NR_llseek
255#endif
256
72f03900 257#ifdef __NR_gettid
31e31b8a 258_syscall0(int, gettid)
72f03900 259#else
0da46a6e
TS		 260/* This is a replacement for the host gettid() and must return a host
261 errno. */
72f03900
FB		 262static int gettid(void) {
263 return -ENOSYS;
264}
265#endif
704eff6c 266#if defined(TARGET_NR_getdents) && defined(__NR_getdents)
3b3f24ad 267_syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
3307e236
PM		 268#endif
269#if !defined(__NR_getdents) || \
270 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
3b3f24ad
AJ		 271_syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
272#endif
d35b261c 273#if defined(TARGET_NR__llseek) && defined(__NR_llseek)
3b3f24ad
AJ		 274_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
275 loff_t *, res, uint, wh);
276#endif
277_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
278_syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
3b3f24ad
AJ		 279#ifdef __NR_exit_group
280_syscall1(int,exit_group,int,error_code)
281#endif
282#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
283_syscall1(int,set_tid_address,int *,tidptr)
284#endif
3b3f24ad
AJ		 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)
288#endif
737de1d1
MF		 289#define __NR_sys_sched_getaffinity __NR_sched_getaffinity
290_syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len,
291 unsigned long *, user_mask_ptr);
292#define __NR_sys_sched_setaffinity __NR_sched_setaffinity
293_syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len,
294 unsigned long *, user_mask_ptr);
0f6b4d21
AG		 295_syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd,
296 void *, arg);
e0eb210e
PM		 297_syscall2(int, capget, struct __user_cap_header_struct *, header,
298 struct __user_cap_data_struct *, data);
299_syscall2(int, capset, struct __user_cap_header_struct *, header,
300 struct __user_cap_data_struct *, data);
ab31cda3
PB		 301#if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
302_syscall2(int, ioprio_get, int, which, int, who)
303#endif
304#if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
305_syscall3(int, ioprio_set, int, which, int, who, int, ioprio)
306#endif
f894efd1
LV		 307#if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
308_syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags)
309#endif
3b3f24ad 310
2f14788c
LV		 311#if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
312_syscall5(int, kcmp, pid_t, pid1, pid_t, pid2, int, type,
313 unsigned long, idx1, unsigned long, idx2)
314#endif
315
3b3f24ad
AJ		 316static bitmask_transtbl fcntl_flags_tbl[] = {
317 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
318 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
319 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
320 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
321 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
322 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
323 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
324 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
afc8763f 325 { TARGET_O_SYNC, TARGET_O_DSYNC, O_SYNC, O_DSYNC, },
3b3f24ad
AJ		 326 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
327 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
328 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
329 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
3b3f24ad
AJ		 330#if defined(O_DIRECT)
331 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
afc8763f
RH		 332#endif
333#if defined(O_NOATIME)
334 { TARGET_O_NOATIME, TARGET_O_NOATIME, O_NOATIME, O_NOATIME },
335#endif
336#if defined(O_CLOEXEC)
337 { TARGET_O_CLOEXEC, TARGET_O_CLOEXEC, O_CLOEXEC, O_CLOEXEC },
338#endif
339#if defined(O_PATH)
340 { TARGET_O_PATH, TARGET_O_PATH, O_PATH, O_PATH },
341#endif
342 /* Don't terminate the list prematurely on 64-bit host+guest. */
343#if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
344 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
3b3f24ad
AJ		 345#endif
346 { 0, 0, 0, 0 }
347};
348
60c6b790
MP		 349enum {
350 QEMU_IFLA_BR_UNSPEC,
351 QEMU_IFLA_BR_FORWARD_DELAY,
352 QEMU_IFLA_BR_HELLO_TIME,
353 QEMU_IFLA_BR_MAX_AGE,
354 QEMU_IFLA_BR_AGEING_TIME,
355 QEMU_IFLA_BR_STP_STATE,
356 QEMU_IFLA_BR_PRIORITY,
357 QEMU_IFLA_BR_VLAN_FILTERING,
358 QEMU_IFLA_BR_VLAN_PROTOCOL,
359 QEMU_IFLA_BR_GROUP_FWD_MASK,
360 QEMU_IFLA_BR_ROOT_ID,
361 QEMU_IFLA_BR_BRIDGE_ID,
362 QEMU_IFLA_BR_ROOT_PORT,
363 QEMU_IFLA_BR_ROOT_PATH_COST,
364 QEMU_IFLA_BR_TOPOLOGY_CHANGE,
365 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
366 QEMU_IFLA_BR_HELLO_TIMER,
367 QEMU_IFLA_BR_TCN_TIMER,
368 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER,
369 QEMU_IFLA_BR_GC_TIMER,
370 QEMU_IFLA_BR_GROUP_ADDR,
371 QEMU_IFLA_BR_FDB_FLUSH,
372 QEMU_IFLA_BR_MCAST_ROUTER,
373 QEMU_IFLA_BR_MCAST_SNOOPING,
374 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR,
375 QEMU_IFLA_BR_MCAST_QUERIER,
376 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY,
377 QEMU_IFLA_BR_MCAST_HASH_MAX,
378 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT,
379 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT,
380 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL,
381 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL,
382 QEMU_IFLA_BR_MCAST_QUERIER_INTVL,
383 QEMU_IFLA_BR_MCAST_QUERY_INTVL,
384 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL,
385 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL,
386 QEMU_IFLA_BR_NF_CALL_IPTABLES,
387 QEMU_IFLA_BR_NF_CALL_IP6TABLES,
388 QEMU_IFLA_BR_NF_CALL_ARPTABLES,
389 QEMU_IFLA_BR_VLAN_DEFAULT_PVID,
390 QEMU_IFLA_BR_PAD,
391 QEMU_IFLA_BR_VLAN_STATS_ENABLED,
392 QEMU_IFLA_BR_MCAST_STATS_ENABLED,
393 QEMU___IFLA_BR_MAX,
394};
395
396enum {
397 QEMU_IFLA_UNSPEC,
398 QEMU_IFLA_ADDRESS,
399 QEMU_IFLA_BROADCAST,
400 QEMU_IFLA_IFNAME,
401 QEMU_IFLA_MTU,
402 QEMU_IFLA_LINK,
403 QEMU_IFLA_QDISC,
404 QEMU_IFLA_STATS,
405 QEMU_IFLA_COST,
406 QEMU_IFLA_PRIORITY,
407 QEMU_IFLA_MASTER,
408 QEMU_IFLA_WIRELESS,
409 QEMU_IFLA_PROTINFO,
410 QEMU_IFLA_TXQLEN,
411 QEMU_IFLA_MAP,
412 QEMU_IFLA_WEIGHT,
413 QEMU_IFLA_OPERSTATE,
414 QEMU_IFLA_LINKMODE,
415 QEMU_IFLA_LINKINFO,
416 QEMU_IFLA_NET_NS_PID,
417 QEMU_IFLA_IFALIAS,
418 QEMU_IFLA_NUM_VF,
419 QEMU_IFLA_VFINFO_LIST,
420 QEMU_IFLA_STATS64,
421 QEMU_IFLA_VF_PORTS,
422 QEMU_IFLA_PORT_SELF,
423 QEMU_IFLA_AF_SPEC,
424 QEMU_IFLA_GROUP,
425 QEMU_IFLA_NET_NS_FD,
426 QEMU_IFLA_EXT_MASK,
427 QEMU_IFLA_PROMISCUITY,
428 QEMU_IFLA_NUM_TX_QUEUES,
429 QEMU_IFLA_NUM_RX_QUEUES,
430 QEMU_IFLA_CARRIER,
431 QEMU_IFLA_PHYS_PORT_ID,
432 QEMU_IFLA_CARRIER_CHANGES,
433 QEMU_IFLA_PHYS_SWITCH_ID,
434 QEMU_IFLA_LINK_NETNSID,
435 QEMU_IFLA_PHYS_PORT_NAME,
436 QEMU_IFLA_PROTO_DOWN,
437 QEMU_IFLA_GSO_MAX_SEGS,
438 QEMU_IFLA_GSO_MAX_SIZE,
439 QEMU_IFLA_PAD,
440 QEMU_IFLA_XDP,
441 QEMU___IFLA_MAX
442};
443
444enum {
445 QEMU_IFLA_BRPORT_UNSPEC,
446 QEMU_IFLA_BRPORT_STATE,
447 QEMU_IFLA_BRPORT_PRIORITY,
448 QEMU_IFLA_BRPORT_COST,
449 QEMU_IFLA_BRPORT_MODE,
450 QEMU_IFLA_BRPORT_GUARD,
451 QEMU_IFLA_BRPORT_PROTECT,
452 QEMU_IFLA_BRPORT_FAST_LEAVE,
453 QEMU_IFLA_BRPORT_LEARNING,
454 QEMU_IFLA_BRPORT_UNICAST_FLOOD,
455 QEMU_IFLA_BRPORT_PROXYARP,
456 QEMU_IFLA_BRPORT_LEARNING_SYNC,
457 QEMU_IFLA_BRPORT_PROXYARP_WIFI,
458 QEMU_IFLA_BRPORT_ROOT_ID,
459 QEMU_IFLA_BRPORT_BRIDGE_ID,
460 QEMU_IFLA_BRPORT_DESIGNATED_PORT,
461 QEMU_IFLA_BRPORT_DESIGNATED_COST,
462 QEMU_IFLA_BRPORT_ID,
463 QEMU_IFLA_BRPORT_NO,
464 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
465 QEMU_IFLA_BRPORT_CONFIG_PENDING,
466 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER,
467 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER,
468 QEMU_IFLA_BRPORT_HOLD_TIMER,
469 QEMU_IFLA_BRPORT_FLUSH,
470 QEMU_IFLA_BRPORT_MULTICAST_ROUTER,
471 QEMU_IFLA_BRPORT_PAD,
472 QEMU___IFLA_BRPORT_MAX
473};
474
475enum {
476 QEMU_IFLA_INFO_UNSPEC,
477 QEMU_IFLA_INFO_KIND,
478 QEMU_IFLA_INFO_DATA,
479 QEMU_IFLA_INFO_XSTATS,
480 QEMU_IFLA_INFO_SLAVE_KIND,
481 QEMU_IFLA_INFO_SLAVE_DATA,
482 QEMU___IFLA_INFO_MAX,
483};
484
485enum {
486 QEMU_IFLA_INET_UNSPEC,
487 QEMU_IFLA_INET_CONF,
488 QEMU___IFLA_INET_MAX,
489};
490
491enum {
492 QEMU_IFLA_INET6_UNSPEC,
493 QEMU_IFLA_INET6_FLAGS,
494 QEMU_IFLA_INET6_CONF,
495 QEMU_IFLA_INET6_STATS,
496 QEMU_IFLA_INET6_MCAST,
497 QEMU_IFLA_INET6_CACHEINFO,
498 QEMU_IFLA_INET6_ICMP6STATS,
499 QEMU_IFLA_INET6_TOKEN,
500 QEMU_IFLA_INET6_ADDR_GEN_MODE,
501 QEMU___IFLA_INET6_MAX
502};
503
5d4d3665 504typedef abi_long (*TargetFdDataFunc)(void *, size_t);
7b36f782 505typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t);
e36800c9 506typedef struct TargetFdTrans {
5d4d3665
LV		 507 TargetFdDataFunc host_to_target_data;
508 TargetFdDataFunc target_to_host_data;
7b36f782 509 TargetFdAddrFunc target_to_host_addr;
e36800c9
LV		 510} TargetFdTrans;
511
512static TargetFdTrans **target_fd_trans;
513
514static unsigned int target_fd_max;
515
6c5b5645
LV		 516static TargetFdDataFunc fd_trans_target_to_host_data(int fd)
517{
518 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
519 return target_fd_trans[fd]->target_to_host_data;
520 }
521 return NULL;
522}
523
5d4d3665 524static TargetFdDataFunc fd_trans_host_to_target_data(int fd)
e36800c9 525{
861d72cd 526 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
5d4d3665 527 return target_fd_trans[fd]->host_to_target_data;
e36800c9
LV		 528 }
529 return NULL;
530}
531
7b36f782
LV		 532static TargetFdAddrFunc fd_trans_target_to_host_addr(int fd)
533{
861d72cd 534 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
7b36f782
LV		 535 return target_fd_trans[fd]->target_to_host_addr;
536 }
537 return NULL;
538}
539
e36800c9
LV		 540static void fd_trans_register(int fd, TargetFdTrans *trans)
541{
542 unsigned int oldmax;
543
544 if (fd >= target_fd_max) {
545 oldmax = target_fd_max;
546 target_fd_max = ((fd >> 6) + 1) << 6; /* by slice of 64 entries */
5089c7ce
LV		 547 target_fd_trans = g_renew(TargetFdTrans *,
548 target_fd_trans, target_fd_max);
e36800c9
LV		 549 memset((void *)(target_fd_trans + oldmax), 0,
550 (target_fd_max - oldmax) * sizeof(TargetFdTrans *));
551 }
552 target_fd_trans[fd] = trans;
553}
554
555static void fd_trans_unregister(int fd)
556{
557 if (fd >= 0 && fd < target_fd_max) {
558 target_fd_trans[fd] = NULL;
559 }
560}
561
562static void fd_trans_dup(int oldfd, int newfd)
563{
564 fd_trans_unregister(newfd);
565 if (oldfd < target_fd_max && target_fd_trans[oldfd]) {
566 fd_trans_register(newfd, target_fd_trans[oldfd]);
567 }
568}
569
3b3f24ad
AJ		 570static int sys_getcwd1(char *buf, size_t size)
571{
572 if (getcwd(buf, size) == NULL) {
573 /* getcwd() sets errno */
574 return (-1);
575 }
aaf4ad39 576 return strlen(buf)+1;
3b3f24ad
AJ		 577}
578
1acae9f2 579#ifdef TARGET_NR_utimensat
700fa58e 580#if defined(__NR_utimensat)
1acae9f2 581#define __NR_sys_utimensat __NR_utimensat
9007f0ef
TS		 582_syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
583 const struct timespec *,tsp,int,flags)
1acae9f2
PM		 584#else
585static int sys_utimensat(int dirfd, const char *pathname,
586 const struct timespec times[2], int flags)
587{
588 errno = ENOSYS;
589 return -1;
590}
9007f0ef 591#endif
1acae9f2 592#endif /* TARGET_NR_utimensat */
3b3f24ad
AJ		 593
594#ifdef CONFIG_INOTIFY
8690e420 595#include <sys/inotify.h>
3b3f24ad 596
39b59763 597#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
3b3f24ad
AJ		 598static int sys_inotify_init(void)
599{
600 return (inotify_init());
601}
39b59763
AJ		 602#endif
603#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
3b3f24ad
AJ		 604static int sys_inotify_add_watch(int fd,const char *pathname, int32_t mask)
605{
606 return (inotify_add_watch(fd, pathname, mask));
607}
39b59763
AJ		 608#endif
609#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
3b3f24ad
AJ		 610static int sys_inotify_rm_watch(int fd, int32_t wd)
611{
8690e420 612 return (inotify_rm_watch(fd, wd));
3b3f24ad 613}
bd0c5661 614#endif
c05c7a73
RV		 615#ifdef CONFIG_INOTIFY1
616#if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
617static int sys_inotify_init1(int flags)
618{
619 return (inotify_init1(flags));
620}
621#endif
622#endif
3b3f24ad
AJ		 623#else
624/* Userspace can usually survive runtime without inotify */
625#undef TARGET_NR_inotify_init
c05c7a73 626#undef TARGET_NR_inotify_init1
3b3f24ad
AJ		 627#undef TARGET_NR_inotify_add_watch
628#undef TARGET_NR_inotify_rm_watch
629#endif /* CONFIG_INOTIFY */
630
163a05a8
PM		 631#if defined(TARGET_NR_prlimit64)
632#ifndef __NR_prlimit64
633# define __NR_prlimit64 -1
634#endif
635#define __NR_sys_prlimit64 __NR_prlimit64
636/* The glibc rlimit structure may not be that used by the underlying syscall */
637struct host_rlimit64 {
638 uint64_t rlim_cur;
639 uint64_t rlim_max;
640};
641_syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
642 const struct host_rlimit64 *, new_limit,
643 struct host_rlimit64 *, old_limit)
644#endif
645
f4f1e10a
ECL		 646
647#if defined(TARGET_NR_timer_create)
648/* Maxiumum of 32 active POSIX timers allowed at any one time. */
649static timer_t g_posix_timers[32] = { 0, } ;
650
651static inline int next_free_host_timer(void)
652{
653 int k ;
654 /* FIXME: Does finding the next free slot require a lock? */
655 for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) {
656 if (g_posix_timers[k] == 0) {
657 g_posix_timers[k] = (timer_t) 1;
658 return k;
659 }
660 }
661 return -1;
662}
663#endif
664
48e515d4 665/* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
4a1def4e 666#ifdef TARGET_ARM
48e515d4
RV		 667static inline int regpairs_aligned(void *cpu_env) {
668 return ((((CPUARMState *)cpu_env)->eabi) == 1) ;
669}
d7779acb 670#elif defined(TARGET_MIPS) && (TARGET_ABI_BITS == 32)
48e515d4 671static inline int regpairs_aligned(void *cpu_env) { return 1; }
4a1def4e
AG		 672#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
673/* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
674 * of registers which translates to the same as ARM/MIPS, because we start with
675 * r3 as arg1 */
676static inline int regpairs_aligned(void *cpu_env) { return 1; }
48e515d4
RV		 677#else
678static inline int regpairs_aligned(void *cpu_env) { return 0; }
679#endif
680
b92c47c1
TS		 681#define ERRNO_TABLE_SIZE 1200
682
683/* target_to_host_errno_table[] is initialized from
684 * host_to_target_errno_table[] in syscall_init(). */
685static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
686};
687
637947f1 688/*
fe8f096b 689 * This list is the union of errno values overridden in asm-<arch>/errno.h
637947f1
TS		 690 * minus the errnos that are not actually generic to all archs.
691 */
b92c47c1 692static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
08703b9f 693 [EAGAIN] = TARGET_EAGAIN,
637947f1
TS		 694 [EIDRM] = TARGET_EIDRM,
695 [ECHRNG] = TARGET_ECHRNG,
696 [EL2NSYNC] = TARGET_EL2NSYNC,
697 [EL3HLT] = TARGET_EL3HLT,
698 [EL3RST] = TARGET_EL3RST,
699 [ELNRNG] = TARGET_ELNRNG,
700 [EUNATCH] = TARGET_EUNATCH,
701 [ENOCSI] = TARGET_ENOCSI,
702 [EL2HLT] = TARGET_EL2HLT,
703 [EDEADLK] = TARGET_EDEADLK,
704 [ENOLCK] = TARGET_ENOLCK,
705 [EBADE] = TARGET_EBADE,
706 [EBADR] = TARGET_EBADR,
707 [EXFULL] = TARGET_EXFULL,
708 [ENOANO] = TARGET_ENOANO,
709 [EBADRQC] = TARGET_EBADRQC,
710 [EBADSLT] = TARGET_EBADSLT,
711 [EBFONT] = TARGET_EBFONT,
712 [ENOSTR] = TARGET_ENOSTR,
713 [ENODATA] = TARGET_ENODATA,
714 [ETIME] = TARGET_ETIME,
715 [ENOSR] = TARGET_ENOSR,
716 [ENONET] = TARGET_ENONET,
717 [ENOPKG] = TARGET_ENOPKG,
718 [EREMOTE] = TARGET_EREMOTE,
719 [ENOLINK] = TARGET_ENOLINK,
720 [EADV] = TARGET_EADV,
721 [ESRMNT] = TARGET_ESRMNT,
722 [ECOMM] = TARGET_ECOMM,
723 [EPROTO] = TARGET_EPROTO,
724 [EDOTDOT] = TARGET_EDOTDOT,
725 [EMULTIHOP] = TARGET_EMULTIHOP,
726 [EBADMSG] = TARGET_EBADMSG,
727 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
728 [EOVERFLOW] = TARGET_EOVERFLOW,
729 [ENOTUNIQ] = TARGET_ENOTUNIQ,
730 [EBADFD] = TARGET_EBADFD,
731 [EREMCHG] = TARGET_EREMCHG,
732 [ELIBACC] = TARGET_ELIBACC,
733 [ELIBBAD] = TARGET_ELIBBAD,
734 [ELIBSCN] = TARGET_ELIBSCN,
735 [ELIBMAX] = TARGET_ELIBMAX,
736 [ELIBEXEC] = TARGET_ELIBEXEC,
737 [EILSEQ] = TARGET_EILSEQ,
738 [ENOSYS] = TARGET_ENOSYS,
739 [ELOOP] = TARGET_ELOOP,
740 [ERESTART] = TARGET_ERESTART,
741 [ESTRPIPE] = TARGET_ESTRPIPE,
742 [ENOTEMPTY] = TARGET_ENOTEMPTY,
743 [EUSERS] = TARGET_EUSERS,
744 [ENOTSOCK] = TARGET_ENOTSOCK,
745 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
746 [EMSGSIZE] = TARGET_EMSGSIZE,
747 [EPROTOTYPE] = TARGET_EPROTOTYPE,
748 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
749 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
750 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
751 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
752 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
753 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
754 [EADDRINUSE] = TARGET_EADDRINUSE,
755 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
756 [ENETDOWN] = TARGET_ENETDOWN,
757 [ENETUNREACH] = TARGET_ENETUNREACH,
758 [ENETRESET] = TARGET_ENETRESET,
759 [ECONNABORTED] = TARGET_ECONNABORTED,
760 [ECONNRESET] = TARGET_ECONNRESET,
761 [ENOBUFS] = TARGET_ENOBUFS,
762 [EISCONN] = TARGET_EISCONN,
763 [ENOTCONN] = TARGET_ENOTCONN,
764 [EUCLEAN] = TARGET_EUCLEAN,
765 [ENOTNAM] = TARGET_ENOTNAM,
766 [ENAVAIL] = TARGET_ENAVAIL,
767 [EISNAM] = TARGET_EISNAM,
768 [EREMOTEIO] = TARGET_EREMOTEIO,
0444a3b7 769 [EDQUOT] = TARGET_EDQUOT,
637947f1
TS		 770 [ESHUTDOWN] = TARGET_ESHUTDOWN,
771 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
772 [ETIMEDOUT] = TARGET_ETIMEDOUT,
773 [ECONNREFUSED] = TARGET_ECONNREFUSED,
774 [EHOSTDOWN] = TARGET_EHOSTDOWN,
775 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
776 [EALREADY] = TARGET_EALREADY,
777 [EINPROGRESS] = TARGET_EINPROGRESS,
778 [ESTALE] = TARGET_ESTALE,
779 [ECANCELED] = TARGET_ECANCELED,
780 [ENOMEDIUM] = TARGET_ENOMEDIUM,
781 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
b7fe5db7 782#ifdef ENOKEY
637947f1 783 [ENOKEY] = TARGET_ENOKEY,
b7fe5db7
TS		 784#endif
785#ifdef EKEYEXPIRED
637947f1 786 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
b7fe5db7
TS		 787#endif
788#ifdef EKEYREVOKED
637947f1 789 [EKEYREVOKED] = TARGET_EKEYREVOKED,
b7fe5db7
TS		 790#endif
791#ifdef EKEYREJECTED
637947f1 792 [EKEYREJECTED] = TARGET_EKEYREJECTED,
b7fe5db7
TS		 793#endif
794#ifdef EOWNERDEAD
637947f1 795 [EOWNERDEAD] = TARGET_EOWNERDEAD,
b7fe5db7
TS		 796#endif
797#ifdef ENOTRECOVERABLE
637947f1 798 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
b7fe5db7 799#endif
da39db63
AM		 800#ifdef ENOMSG
801 [ENOMSG] = TARGET_ENOMSG,
802#endif
fe8ed7d5
RH		 803#ifdef ERKFILL
804 [ERFKILL] = TARGET_ERFKILL,
805#endif
806#ifdef EHWPOISON
807 [EHWPOISON] = TARGET_EHWPOISON,
808#endif
b92c47c1 809};
637947f1
TS		 810
811static inline int host_to_target_errno(int err)
812{
2466119c
TB		 813 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
814 host_to_target_errno_table[err]) {
637947f1 815 return host_to_target_errno_table[err];
2466119c 816 }
637947f1
TS		 817 return err;
818}
819
b92c47c1
TS		 820static inline int target_to_host_errno(int err)
821{
2466119c
TB		 822 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
823 target_to_host_errno_table[err]) {
b92c47c1 824 return target_to_host_errno_table[err];
2466119c 825 }
b92c47c1
TS		 826 return err;
827}
828
992f48a0 829static inline abi_long get_errno(abi_long ret)
31e31b8a
FB		 830{
831 if (ret == -1)
637947f1 832 return -host_to_target_errno(errno);
31e31b8a
FB		 833 else
834 return ret;
835}
836
992f48a0 837static inline int is_error(abi_long ret)
31e31b8a 838{
992f48a0 839 return (abi_ulong)ret >= (abi_ulong)(-4096);
31e31b8a
FB		 840}
841
7dcdaeaf 842const char *target_strerror(int err)
b92c47c1 843{
da2a34f7
PM		 844 if (err == TARGET_ERESTARTSYS) {
845 return "To be restarted";
846 }
847 if (err == TARGET_QEMU_ESIGRETURN) {
848 return "Successful exit from sigreturn";
849 }
850
962b289e
AG		 851 if ((err >= ERRNO_TABLE_SIZE) || (err < 0)) {
852 return NULL;
853 }
b92c47c1
TS		 854 return strerror(target_to_host_errno(err));
855}
856
4d330cee
TB		 857#define safe_syscall0(type, name) \
858static type safe_##name(void) \
859{ \
860 return safe_syscall(__NR_##name); \
861}
862
863#define safe_syscall1(type, name, type1, arg1) \
864static type safe_##name(type1 arg1) \
865{ \
866 return safe_syscall(__NR_##name, arg1); \
867}
868
869#define safe_syscall2(type, name, type1, arg1, type2, arg2) \
870static type safe_##name(type1 arg1, type2 arg2) \
871{ \
872 return safe_syscall(__NR_##name, arg1, arg2); \
873}
874
875#define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
876static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
877{ \
878 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
879}
880
881#define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
882 type4, arg4) \
883static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
884{ \
885 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
886}
887
888#define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
889 type4, arg4, type5, arg5) \
890static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
891 type5 arg5) \
892{ \
893 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
894}
895
896#define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
897 type4, arg4, type5, arg5, type6, arg6) \
898static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
899 type5 arg5, type6 arg6) \
900{ \
901 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
902}
903
50afd02b
TB		 904safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count)
905safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)
c10a0738
TB		 906safe_syscall4(int, openat, int, dirfd, const char *, pathname, \
907 int, flags, mode_t, mode)
4af80a37
TB		 908safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \
909 struct rusage *, rusage)
910safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
911 int, options, struct rusage *, rusage)
ffdcbe22 912safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
6df9d38d
PM		 913safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
914 fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
a6130237
PM		 915safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
916 struct timespec *, tsp, const sigset_t *, sigmask,
917 size_t, sigsetsize)
227f0214
PM		 918safe_syscall6(int, epoll_pwait, int, epfd, struct epoll_event *, events,
919 int, maxevents, int, timeout, const sigset_t *, sigmask,
920 size_t, sigsetsize)
d509eeb1
PM		 921safe_syscall6(int,futex,int *,uaddr,int,op,int,val, \
922 const struct timespec *,timeout,int *,uaddr2,int,val3)
2fe4fba1 923safe_syscall2(int, rt_sigsuspend, sigset_t *, newset, size_t, sigsetsize)
bef653d9
PM		 924safe_syscall2(int, kill, pid_t, pid, int, sig)
925safe_syscall2(int, tkill, int, tid, int, sig)
926safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig)
918c03ed
PM		 927safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt)
928safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt)
0f26386c
DJ		 929safe_syscall5(ssize_t, preadv, int, fd, const struct iovec *, iov, int, iovcnt,
930 unsigned long, pos_l, unsigned long, pos_h)
f8d00fba
DJ		 931safe_syscall5(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt,
932 unsigned long, pos_l, unsigned long, pos_h)
2a3c7619
PM		 933safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr,
934 socklen_t, addrlen)
66687530
PM		 935safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len,
936 int, flags, const struct sockaddr *, addr, socklen_t, addrlen)
937safe_syscall6(ssize_t, recvfrom, int, fd, void *, buf, size_t, len,
938 int, flags, struct sockaddr *, addr, socklen_t *, addrlen)
939safe_syscall3(ssize_t, sendmsg, int, fd, const struct msghdr *, msg, int, flags)
940safe_syscall3(ssize_t, recvmsg, int, fd, struct msghdr *, msg, int, flags)
2a845989 941safe_syscall2(int, flock, int, fd, int, operation)
b3f82330
PM		 942safe_syscall4(int, rt_sigtimedwait, const sigset_t *, these, siginfo_t *, uinfo,
943 const struct timespec *, uts, size_t, sigsetsize)
ff6dc130
PM		 944safe_syscall4(int, accept4, int, fd, struct sockaddr *, addr, socklen_t *, len,
945 int, flags)
9e518226
PM		 946safe_syscall2(int, nanosleep, const struct timespec *, req,
947 struct timespec *, rem)
948#ifdef TARGET_NR_clock_nanosleep
949safe_syscall4(int, clock_nanosleep, const clockid_t, clock, int, flags,
950 const struct timespec *, req, struct timespec *, rem)
951#endif
89f9fe44
PM		 952#ifdef __NR_msgsnd
953safe_syscall4(int, msgsnd, int, msgid, const void *, msgp, size_t, sz,
954 int, flags)
955safe_syscall5(int, msgrcv, int, msgid, void *, msgp, size_t, sz,
956 long, msgtype, int, flags)
ffb7ee79
PM		 957safe_syscall4(int, semtimedop, int, semid, struct sembuf *, tsops,
958 unsigned, nsops, const struct timespec *, timeout)
89f9fe44
PM		 959#else
960/* This host kernel architecture uses a single ipc syscall; fake up
961 * wrappers for the sub-operations to hide this implementation detail.
962 * Annoyingly we can't include linux/ipc.h to get the constant definitions
963 * for the call parameter because some structs in there conflict with the
964 * sys/ipc.h ones. So we just define them here, and rely on them being
965 * the same for all host architectures.
966 */
ffb7ee79 967#define Q_SEMTIMEDOP 4
89f9fe44
PM		 968#define Q_MSGSND 11
969#define Q_MSGRCV 12
970#define Q_IPCCALL(VERSION, OP) ((VERSION) << 16 | (OP))
971
972safe_syscall6(int, ipc, int, call, long, first, long, second, long, third,
973 void *, ptr, long, fifth)
974static int safe_msgsnd(int msgid, const void *msgp, size_t sz, int flags)
975{
976 return safe_ipc(Q_IPCCALL(0, Q_MSGSND), msgid, sz, flags, (void *)msgp, 0);
977}
978static int safe_msgrcv(int msgid, void *msgp, size_t sz, long type, int flags)
979{
980 return safe_ipc(Q_IPCCALL(1, Q_MSGRCV), msgid, sz, flags, msgp, type);
981}
ffb7ee79
PM		 982static int safe_semtimedop(int semid, struct sembuf *tsops, unsigned nsops,
983 const struct timespec *timeout)
984{
985 return safe_ipc(Q_IPCCALL(0, Q_SEMTIMEDOP), semid, nsops, 0, tsops,
986 (long)timeout);
987}
89f9fe44 988#endif
d40ecd66
PM		 989#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
990safe_syscall5(int, mq_timedsend, int, mqdes, const char *, msg_ptr,
991 size_t, len, unsigned, prio, const struct timespec *, timeout)
992safe_syscall5(int, mq_timedreceive, int, mqdes, char *, msg_ptr,
993 size_t, len, unsigned *, prio, const struct timespec *, timeout)
994#endif
49ca6f3e
PM		 995/* We do ioctl like this rather than via safe_syscall3 to preserve the
996 * "third argument might be integer or pointer or not present" behaviour of
997 * the libc function.
998 */
999#define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
435da5e7
PM		 1000/* Similarly for fcntl. Note that callers must always:
1001 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
1002 * use the flock64 struct rather than unsuffixed flock
1003 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
1004 */
1005#ifdef __NR_fcntl64
1006#define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
1007#else
1008#define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
1009#endif
50afd02b 1010
8289d112
PB		 1011static inline int host_to_target_sock_type(int host_type)
1012{
1013 int target_type;
1014
1015 switch (host_type & 0xf /* SOCK_TYPE_MASK */) {
1016 case SOCK_DGRAM:
1017 target_type = TARGET_SOCK_DGRAM;
1018 break;
1019 case SOCK_STREAM:
1020 target_type = TARGET_SOCK_STREAM;
1021 break;
1022 default:
1023 target_type = host_type & 0xf /* SOCK_TYPE_MASK */;
1024 break;
1025 }
1026
1027#if defined(SOCK_CLOEXEC)
1028 if (host_type & SOCK_CLOEXEC) {
1029 target_type |= TARGET_SOCK_CLOEXEC;
1030 }
1031#endif
1032
1033#if defined(SOCK_NONBLOCK)
1034 if (host_type & SOCK_NONBLOCK) {
1035 target_type |= TARGET_SOCK_NONBLOCK;
1036 }
1037#endif
1038
1039 return target_type;
1040}
1041
992f48a0
BS		 1042static abi_ulong target_brk;
1043static abi_ulong target_original_brk;
4d1de87c 1044static abi_ulong brk_page;
31e31b8a 1045
992f48a0 1046void target_set_brk(abi_ulong new_brk)
31e31b8a 1047{
4c1de73d 1048 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
4d1de87c 1049 brk_page = HOST_PAGE_ALIGN(target_brk);
31e31b8a
FB		 1050}
1051
4d1de87c
CV		 1052//#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
1053#define DEBUGF_BRK(message, args...)
1054
0da46a6e 1055/* do_brk() must return target values and target errnos. */
992f48a0 1056abi_long do_brk(abi_ulong new_brk)
31e31b8a 1057{
992f48a0 1058 abi_long mapped_addr;
ef4330c2 1059 abi_ulong new_alloc_size;
31e31b8a 1060
3a0c6c4a 1061 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk);
4d1de87c
CV		 1062
1063 if (!new_brk) {
3a0c6c4a 1064 DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk);
53a5960a 1065 return target_brk;
4d1de87c
CV		 1066 }
1067 if (new_brk < target_original_brk) {
3a0c6c4a
PB		 1068 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n",
1069 target_brk);
7ab240ad 1070 return target_brk;
4d1de87c 1071 }
3b46e624 1072
4d1de87c
CV		 1073 /* If the new brk is less than the highest page reserved to the
1074 * target heap allocation, set it and we're almost done... */
1075 if (new_brk <= brk_page) {
1076 /* Heap contents are initialized to zero, as for anonymous
1077 * mapped pages. */
1078 if (new_brk > target_brk) {
1079 memset(g2h(target_brk), 0, new_brk - target_brk);
1080 }
31e31b8a 1081 target_brk = new_brk;
3a0c6c4a 1082 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk);
53a5960a 1083 return target_brk;
31e31b8a
FB		 1084 }
1085
00faf08c
PM		 1086 /* We need to allocate more memory after the brk... Note that
1087 * we don't use MAP_FIXED because that will map over the top of
1088 * any existing mapping (like the one with the host libc or qemu
1089 * itself); instead we treat "mapped but at wrong address" as
1090 * a failure and unmap again.
1091 */
4d1de87c 1092 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page);
5fafdf24 1093 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
54936004 1094 PROT_READ|PROT_WRITE,
00faf08c
PM		 1095 MAP_ANON|MAP_PRIVATE, 0, 0));
1096
1097 if (mapped_addr == brk_page) {
70afc343
CV		 1098 /* Heap contents are initialized to zero, as for anonymous
1099 * mapped pages. Technically the new pages are already
1100 * initialized to zero since they *are* anonymous mapped
1101 * pages, however we have to take care with the contents that
1102 * come from the remaining part of the previous page: it may
1103 * contains garbage data due to a previous heap usage (grown
1104 * then shrunken). */
1105 memset(g2h(target_brk), 0, brk_page - target_brk);
1106
00faf08c 1107 target_brk = new_brk;
4d1de87c 1108 brk_page = HOST_PAGE_ALIGN(target_brk);
3a0c6c4a
PB		 1109 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n",
1110 target_brk);
00faf08c
PM		 1111 return target_brk;
1112 } else if (mapped_addr != -1) {
1113 /* Mapped but at wrong address, meaning there wasn't actually
1114 * enough space for this brk.
1115 */
1116 target_munmap(mapped_addr, new_alloc_size);
1117 mapped_addr = -1;
3a0c6c4a 1118 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk);
4d1de87c
CV		 1119 }
1120 else {
3a0c6c4a 1121 DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk);
00faf08c 1122 }
7ab240ad 1123
7dd46c02
RH		 1124#if defined(TARGET_ALPHA)
1125 /* We (partially) emulate OSF/1 on Alpha, which requires we
1126 return a proper errno, not an unchanged brk value. */
00faf08c 1127 return -TARGET_ENOMEM;
7dd46c02 1128#endif
00faf08c 1129 /* For everything else, return the previous break. */
7ab240ad 1130 return target_brk;
31e31b8a
FB		 1131}
1132
26edcf41
TS		 1133static inline abi_long copy_from_user_fdset(fd_set *fds,
1134 abi_ulong target_fds_addr,
1135 int n)
31e31b8a 1136{
26edcf41
TS		 1137 int i, nw, j, k;
1138 abi_ulong b, *target_fds;
1139
b1b2db29 1140 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
26edcf41
TS		 1141 if (!(target_fds = lock_user(VERIFY_READ,
1142 target_fds_addr,
1143 sizeof(abi_ulong) * nw,
1144 1)))
1145 return -TARGET_EFAULT;
1146
1147 FD_ZERO(fds);
1148 k = 0;
1149 for (i = 0; i < nw; i++) {
1150 /* grab the abi_ulong */
1151 __get_user(b, &target_fds[i]);
1152 for (j = 0; j < TARGET_ABI_BITS; j++) {
1153 /* check the bit inside the abi_ulong */
1154 if ((b >> j) & 1)
1155 FD_SET(k, fds);
1156 k++;
31e31b8a 1157 }
31e31b8a 1158 }
26edcf41
TS		 1159
1160 unlock_user(target_fds, target_fds_addr, 0);
1161
1162 return 0;
31e31b8a
FB		 1163}
1164
055e0906
MF		 1165static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr,
1166 abi_ulong target_fds_addr,
1167 int n)
1168{
1169 if (target_fds_addr) {
1170 if (copy_from_user_fdset(fds, target_fds_addr, n))
1171 return -TARGET_EFAULT;
1172 *fds_ptr = fds;
1173 } else {
1174 *fds_ptr = NULL;
1175 }
1176 return 0;
1177}
1178
26edcf41
TS		 1179static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
1180 const fd_set *fds,
1181 int n)
31e31b8a 1182{
31e31b8a 1183 int i, nw, j, k;
992f48a0 1184 abi_long v;
26edcf41 1185 abi_ulong *target_fds;
31e31b8a 1186
b1b2db29 1187 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
26edcf41
TS		 1188 if (!(target_fds = lock_user(VERIFY_WRITE,
1189 target_fds_addr,
1190 sizeof(abi_ulong) * nw,
1191 0)))
1192 return -TARGET_EFAULT;
1193
1194 k = 0;
1195 for (i = 0; i < nw; i++) {
1196 v = 0;
1197 for (j = 0; j < TARGET_ABI_BITS; j++) {
9ab709be 1198 v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j);
26edcf41 1199 k++;
31e31b8a 1200 }
26edcf41 1201 __put_user(v, &target_fds[i]);
31e31b8a 1202 }
26edcf41
TS		 1203
1204 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
1205
1206 return 0;
31e31b8a
FB		 1207}
1208
c596ed17
FB		 1209#if defined(__alpha__)
1210#define HOST_HZ 1024
1211#else
1212#define HOST_HZ 100
1213#endif
1214
992f48a0 1215static inline abi_long host_to_target_clock_t(long ticks)
c596ed17
FB		 1216{
1217#if HOST_HZ == TARGET_HZ
1218 return ticks;
1219#else
1220 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
1221#endif
1222}
1223
579a97f7
FB		 1224static inline abi_long host_to_target_rusage(abi_ulong target_addr,
1225 const struct rusage *rusage)
b409186b 1226{
53a5960a
PB		 1227 struct target_rusage *target_rusage;
1228
579a97f7
FB		 1229 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
1230 return -TARGET_EFAULT;
cbb21eed
MB		 1231 target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec);
1232 target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec);
1233 target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec);
1234 target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec);
1235 target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss);
1236 target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss);
1237 target_rusage->ru_idrss = tswapal(rusage->ru_idrss);
1238 target_rusage->ru_isrss = tswapal(rusage->ru_isrss);
1239 target_rusage->ru_minflt = tswapal(rusage->ru_minflt);
1240 target_rusage->ru_majflt = tswapal(rusage->ru_majflt);
1241 target_rusage->ru_nswap = tswapal(rusage->ru_nswap);
1242 target_rusage->ru_inblock = tswapal(rusage->ru_inblock);
1243 target_rusage->ru_oublock = tswapal(rusage->ru_oublock);
1244 target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd);
1245 target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv);
1246 target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals);
1247 target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw);
1248 target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw);
53a5960a 1249 unlock_user_struct(target_rusage, target_addr, 1);
579a97f7
FB		 1250
1251 return 0;
b409186b
FB		 1252}
1253
cbb21eed 1254static inline rlim_t target_to_host_rlim(abi_ulong target_rlim)
81bbe906 1255{
cbb21eed 1256 abi_ulong target_rlim_swap;
95b33b2f
WT		 1257 rlim_t result;
1258
cbb21eed
MB		 1259 target_rlim_swap = tswapal(target_rlim);
1260 if (target_rlim_swap == TARGET_RLIM_INFINITY)
1261 return RLIM_INFINITY;
1262
1263 result = target_rlim_swap;
1264 if (target_rlim_swap != (rlim_t)result)
1265 return RLIM_INFINITY;
95b33b2f
WT		 1266
1267 return result;
81bbe906
TY		 1268}
1269
cbb21eed 1270static inline abi_ulong host_to_target_rlim(rlim_t rlim)
81bbe906 1271{
cbb21eed
MB		 1272 abi_ulong target_rlim_swap;
1273 abi_ulong result;
95b33b2f 1274
cbb21eed 1275 if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim)
95b33b2f 1276 target_rlim_swap = TARGET_RLIM_INFINITY;
81bbe906 1277 else
95b33b2f 1278 target_rlim_swap = rlim;
cbb21eed 1279 result = tswapal(target_rlim_swap);
95b33b2f
WT		 1280
1281 return result;
81bbe906
TY		 1282}
1283
e22b7015
WT		 1284static inline int target_to_host_resource(int code)
1285{
1286 switch (code) {
1287 case TARGET_RLIMIT_AS:
1288 return RLIMIT_AS;
1289 case TARGET_RLIMIT_CORE:
1290 return RLIMIT_CORE;
1291 case TARGET_RLIMIT_CPU:
1292 return RLIMIT_CPU;
1293 case TARGET_RLIMIT_DATA:
1294 return RLIMIT_DATA;
1295 case TARGET_RLIMIT_FSIZE:
1296 return RLIMIT_FSIZE;
1297 case TARGET_RLIMIT_LOCKS:
1298 return RLIMIT_LOCKS;
1299 case TARGET_RLIMIT_MEMLOCK:
1300 return RLIMIT_MEMLOCK;
1301 case TARGET_RLIMIT_MSGQUEUE:
1302 return RLIMIT_MSGQUEUE;
1303 case TARGET_RLIMIT_NICE:
1304 return RLIMIT_NICE;
1305 case TARGET_RLIMIT_NOFILE:
1306 return RLIMIT_NOFILE;
1307 case TARGET_RLIMIT_NPROC:
1308 return RLIMIT_NPROC;
1309 case TARGET_RLIMIT_RSS:
1310 return RLIMIT_RSS;
1311 case TARGET_RLIMIT_RTPRIO:
1312 return RLIMIT_RTPRIO;
1313 case TARGET_RLIMIT_SIGPENDING:
1314 return RLIMIT_SIGPENDING;
1315 case TARGET_RLIMIT_STACK:
1316 return RLIMIT_STACK;
1317 default:
1318 return code;
1319 }
1320}
1321
788f5ec4
TS		 1322static inline abi_long copy_from_user_timeval(struct timeval *tv,
1323 abi_ulong target_tv_addr)
31e31b8a 1324{
53a5960a
PB		 1325 struct target_timeval *target_tv;
1326
788f5ec4 1327 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
579a97f7 1328 return -TARGET_EFAULT;
788f5ec4
TS		 1329
1330 __get_user(tv->tv_sec, &target_tv->tv_sec);
1331 __get_user(tv->tv_usec, &target_tv->tv_usec);
1332
1333 unlock_user_struct(target_tv, target_tv_addr, 0);
579a97f7
FB		 1334
1335 return 0;
31e31b8a
FB		 1336}
1337
788f5ec4
TS		 1338static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
1339 const struct timeval *tv)
31e31b8a 1340{
53a5960a
PB		 1341 struct target_timeval *target_tv;
1342
788f5ec4 1343 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
579a97f7 1344 return -TARGET_EFAULT;
788f5ec4
TS		 1345
1346 __put_user(tv->tv_sec, &target_tv->tv_sec);
1347 __put_user(tv->tv_usec, &target_tv->tv_usec);
1348
1349 unlock_user_struct(target_tv, target_tv_addr, 1);
579a97f7
FB		 1350
1351 return 0;
31e31b8a
FB		 1352}
1353
ef4467e9
PB		 1354static inline abi_long copy_from_user_timezone(struct timezone *tz,
1355 abi_ulong target_tz_addr)
1356{
1357 struct target_timezone *target_tz;
1358
1359 if (!lock_user_struct(VERIFY_READ, target_tz, target_tz_addr, 1)) {
1360 return -TARGET_EFAULT;
1361 }
1362
1363 __get_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1364 __get_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1365
1366 unlock_user_struct(target_tz, target_tz_addr, 0);
1367
1368 return 0;
1369}
1370
8ec9cf89
NF		 1371#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1372#include <mqueue.h>
1373
24e1003a
AJ		 1374static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr,
1375 abi_ulong target_mq_attr_addr)
1376{
1377 struct target_mq_attr *target_mq_attr;
1378
1379 if (!lock_user_struct(VERIFY_READ, target_mq_attr,
1380 target_mq_attr_addr, 1))
1381 return -TARGET_EFAULT;
1382
1383 __get_user(attr->mq_flags, &target_mq_attr->mq_flags);
1384 __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1385 __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1386 __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1387
1388 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0);
1389
1390 return 0;
1391}
1392
1393static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr,
1394 const struct mq_attr *attr)
1395{
1396 struct target_mq_attr *target_mq_attr;
1397
1398 if (!lock_user_struct(VERIFY_WRITE, target_mq_attr,
1399 target_mq_attr_addr, 0))
1400 return -TARGET_EFAULT;
1401
1402 __put_user(attr->mq_flags, &target_mq_attr->mq_flags);
1403 __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1404 __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1405 __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1406
1407 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1);
1408
1409 return 0;
1410}
8ec9cf89 1411#endif
31e31b8a 1412
055e0906 1413#if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
0da46a6e 1414/* do_select() must return target values and target errnos. */
992f48a0 1415static abi_long do_select(int n,
26edcf41
TS		 1416 abi_ulong rfd_addr, abi_ulong wfd_addr,
1417 abi_ulong efd_addr, abi_ulong target_tv_addr)
31e31b8a
FB		 1418{
1419 fd_set rfds, wfds, efds;
1420 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
6df9d38d
PM		 1421 struct timeval tv;
1422 struct timespec ts, *ts_ptr;
992f48a0 1423 abi_long ret;
31e31b8a 1424
055e0906
MF		 1425 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
1426 if (ret) {
1427 return ret;
53a5960a 1428 }
055e0906
MF		 1429 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
1430 if (ret) {
1431 return ret;
53a5960a 1432 }
055e0906
MF		 1433 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
1434 if (ret) {
1435 return ret;
53a5960a 1436 }
3b46e624 1437
26edcf41 1438 if (target_tv_addr) {
788f5ec4
TS		 1439 if (copy_from_user_timeval(&tv, target_tv_addr))
1440 return -TARGET_EFAULT;
6df9d38d
PM		 1441 ts.tv_sec = tv.tv_sec;
1442 ts.tv_nsec = tv.tv_usec * 1000;
1443 ts_ptr = &ts;
31e31b8a 1444 } else {
6df9d38d 1445 ts_ptr = NULL;
31e31b8a 1446 }
26edcf41 1447
6df9d38d
PM		 1448 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
1449 ts_ptr, NULL));
53a5960a 1450
26edcf41
TS		 1451 if (!is_error(ret)) {
1452 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
1453 return -TARGET_EFAULT;
1454 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
1455 return -TARGET_EFAULT;
1456 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
1457 return -TARGET_EFAULT;
31e31b8a 1458
6df9d38d
PM		 1459 if (target_tv_addr) {
1460 tv.tv_sec = ts.tv_sec;
1461 tv.tv_usec = ts.tv_nsec / 1000;
1462 if (copy_to_user_timeval(target_tv_addr, &tv)) {
1463 return -TARGET_EFAULT;
1464 }
1465 }
31e31b8a 1466 }
579a97f7 1467
31e31b8a
FB		 1468 return ret;
1469}
5457dc9e
LV		 1470
1471#if defined(TARGET_WANT_OLD_SYS_SELECT)
1472static abi_long do_old_select(abi_ulong arg1)
1473{
1474 struct target_sel_arg_struct *sel;
1475 abi_ulong inp, outp, exp, tvp;
1476 long nsel;
1477
1478 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1)) {
1479 return -TARGET_EFAULT;
1480 }
1481
1482 nsel = tswapal(sel->n);
1483 inp = tswapal(sel->inp);
1484 outp = tswapal(sel->outp);
1485 exp = tswapal(sel->exp);
1486 tvp = tswapal(sel->tvp);
1487
1488 unlock_user_struct(sel, arg1, 0);
1489
1490 return do_select(nsel, inp, outp, exp, tvp);
1491}
1492#endif
055e0906 1493#endif
31e31b8a 1494
099d6b0f
RV		 1495static abi_long do_pipe2(int host_pipe[], int flags)
1496{
1497#ifdef CONFIG_PIPE2
1498 return pipe2(host_pipe, flags);
1499#else
1500 return -ENOSYS;
1501#endif
1502}
1503
fb41a66e
RH		 1504static abi_long do_pipe(void *cpu_env, abi_ulong pipedes,
1505 int flags, int is_pipe2)
099d6b0f
RV		 1506{
1507 int host_pipe[2];
1508 abi_long ret;
1509 ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe);
1510
1511 if (is_error(ret))
1512 return get_errno(ret);
fb41a66e
RH		 1513
1514 /* Several targets have special calling conventions for the original
1515 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1516 if (!is_pipe2) {
1517#if defined(TARGET_ALPHA)
1518 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1];
1519 return host_pipe[0];
1520#elif defined(TARGET_MIPS)
1521 ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1];
1522 return host_pipe[0];
1523#elif defined(TARGET_SH4)
597c0212 1524 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
fb41a66e 1525 return host_pipe[0];
82f05b69
PM		 1526#elif defined(TARGET_SPARC)
1527 ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1];
1528 return host_pipe[0];
597c0212 1529#endif
fb41a66e
RH		 1530 }
1531
099d6b0f
RV		 1532 if (put_user_s32(host_pipe[0], pipedes)
1533 || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0])))
1534 return -TARGET_EFAULT;
099d6b0f
RV		 1535 return get_errno(ret);
1536}
1537
b975b83b
LL		 1538static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn,
1539 abi_ulong target_addr,
1540 socklen_t len)
1541{
1542 struct target_ip_mreqn *target_smreqn;
1543
1544 target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1);
1545 if (!target_smreqn)
1546 return -TARGET_EFAULT;
1547 mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr;
1548 mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr;
1549 if (len == sizeof(struct target_ip_mreqn))
cbb21eed 1550 mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex);
b975b83b
LL		 1551 unlock_user(target_smreqn, target_addr, 0);
1552
1553 return 0;
1554}
1555
7b36f782 1556static inline abi_long target_to_host_sockaddr(int fd, struct sockaddr *addr,
579a97f7
FB		 1557 abi_ulong target_addr,
1558 socklen_t len)
7854b056 1559{
607175e0
AJ		 1560 const socklen_t unix_maxlen = sizeof (struct sockaddr_un);
1561 sa_family_t sa_family;
53a5960a
PB		 1562 struct target_sockaddr *target_saddr;
1563
7b36f782
LV		 1564 if (fd_trans_target_to_host_addr(fd)) {
1565 return fd_trans_target_to_host_addr(fd)(addr, target_addr, len);
1566 }
1567
579a97f7
FB		 1568 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1569 if (!target_saddr)
1570 return -TARGET_EFAULT;
607175e0
AJ		 1571
1572 sa_family = tswap16(target_saddr->sa_family);
1573
1574 /* Oops. The caller might send a incomplete sun_path; sun_path
1575 * must be terminated by \0 (see the manual page), but
1576 * unfortunately it is quite common to specify sockaddr_un
1577 * length as "strlen(x->sun_path)" while it should be
1578 * "strlen(...) + 1". We'll fix that here if needed.
1579 * Linux kernel has a similar feature.
1580 */
1581
1582 if (sa_family == AF_UNIX) {
1583 if (len < unix_maxlen && len > 0) {
1584 char *cp = (char*)target_saddr;
1585
1586 if ( cp[len-1] && !cp[len] )
1587 len++;
1588 }
1589 if (len > unix_maxlen)
1590 len = unix_maxlen;
1591 }
1592
53a5960a 1593 memcpy(addr, target_saddr, len);
607175e0 1594 addr->sa_family = sa_family;
6c5b5645
LV		 1595 if (sa_family == AF_NETLINK) {
1596 struct sockaddr_nl *nladdr;
1597
1598 nladdr = (struct sockaddr_nl *)addr;
1599 nladdr->nl_pid = tswap32(nladdr->nl_pid);
1600 nladdr->nl_groups = tswap32(nladdr->nl_groups);
1601 } else if (sa_family == AF_PACKET) {
33a29b51
JT		 1602 struct target_sockaddr_ll *lladdr;
1603
1604 lladdr = (struct target_sockaddr_ll *)addr;
1605 lladdr->sll_ifindex = tswap32(lladdr->sll_ifindex);
1606 lladdr->sll_hatype = tswap16(lladdr->sll_hatype);
1607 }
53a5960a 1608 unlock_user(target_saddr, target_addr, 0);
579a97f7
FB		 1609
1610 return 0;
7854b056
FB		 1611}
1612
579a97f7
FB		 1613static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
1614 struct sockaddr *addr,
1615 socklen_t len)
7854b056 1616{
53a5960a
PB		 1617 struct target_sockaddr *target_saddr;
1618
a1e22192
PM		 1619 if (len == 0) {
1620 return 0;
1621 }
1622
579a97f7
FB		 1623 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
1624 if (!target_saddr)
1625 return -TARGET_EFAULT;
53a5960a 1626 memcpy(target_saddr, addr, len);
a1e22192
PM		 1627 if (len >= offsetof(struct target_sockaddr, sa_family) +
1628 sizeof(target_saddr->sa_family)) {
1629 target_saddr->sa_family = tswap16(addr->sa_family);
1630 }
1631 if (addr->sa_family == AF_NETLINK && len >= sizeof(struct sockaddr_nl)) {
6c5b5645
LV		 1632 struct sockaddr_nl *target_nl = (struct sockaddr_nl *)target_saddr;
1633 target_nl->nl_pid = tswap32(target_nl->nl_pid);
1634 target_nl->nl_groups = tswap32(target_nl->nl_groups);
a82ea939
LV		 1635 } else if (addr->sa_family == AF_PACKET) {
1636 struct sockaddr_ll *target_ll = (struct sockaddr_ll *)target_saddr;
1637 target_ll->sll_ifindex = tswap32(target_ll->sll_ifindex);
1638 target_ll->sll_hatype = tswap16(target_ll->sll_hatype);
ee1ac3a1
HD		 1639 } else if (addr->sa_family == AF_INET6 &&
1640 len >= sizeof(struct target_sockaddr_in6)) {
1641 struct target_sockaddr_in6 *target_in6 =
1642 (struct target_sockaddr_in6 *)target_saddr;
1643 target_in6->sin6_scope_id = tswap16(target_in6->sin6_scope_id);
6c5b5645 1644 }
53a5960a 1645 unlock_user(target_saddr, target_addr, len);
579a97f7
FB		 1646
1647 return 0;
7854b056
FB		 1648}
1649
5a4a898d
FB		 1650static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
1651 struct target_msghdr *target_msgh)
7854b056
FB		 1652{
1653 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 1654 abi_long msg_controllen;
1655 abi_ulong target_cmsg_addr;
ee104587 1656 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
7854b056 1657 socklen_t space = 0;
5a4a898d 1658
cbb21eed 1659 msg_controllen = tswapal(target_msgh->msg_controllen);
5a4a898d
FB		 1660 if (msg_controllen < sizeof (struct target_cmsghdr))
1661 goto the_end;
cbb21eed 1662 target_cmsg_addr = tswapal(target_msgh->msg_control);
5a4a898d 1663 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
ee104587 1664 target_cmsg_start = target_cmsg;
5a4a898d
FB		 1665 if (!target_cmsg)
1666 return -TARGET_EFAULT;
7854b056
FB		 1667
1668 while (cmsg && target_cmsg) {
1669 void *data = CMSG_DATA(cmsg);
1670 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1671
cbb21eed 1672 int len = tswapal(target_cmsg->cmsg_len)
7854b056
FB		 1673 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
1674
1675 space += CMSG_SPACE(len);
1676 if (space > msgh->msg_controllen) {
1677 space -= CMSG_SPACE(len);
c2aeb258
PM		 1678 /* This is a QEMU bug, since we allocated the payload
1679 * area ourselves (unlike overflow in host-to-target
1680 * conversion, which is just the guest giving us a buffer
1681 * that's too small). It can't happen for the payload types
1682 * we currently support; if it becomes an issue in future
1683 * we would need to improve our allocation strategy to
1684 * something more intelligent than "twice the size of the
1685 * target buffer we're reading from".
1686 */
31febb71 1687 gemu_log("Host cmsg overflow\n");
7854b056
FB		 1688 break;
1689 }
1690
dbf4f796
PJ		 1691 if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) {
1692 cmsg->cmsg_level = SOL_SOCKET;
1693 } else {
1694 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
1695 }
7854b056
FB		 1696 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
1697 cmsg->cmsg_len = CMSG_LEN(len);
1698
30b8b68e 1699 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7854b056
FB		 1700 int *fd = (int *)data;
1701 int *target_fd = (int *)target_data;
1702 int i, numfds = len / sizeof(int);
1703
876e23cb
PM		 1704 for (i = 0; i < numfds; i++) {
1705 __get_user(fd[i], target_fd + i);
1706 }
30b8b68e
AS		 1707 } else if (cmsg->cmsg_level == SOL_SOCKET
1708 && cmsg->cmsg_type == SCM_CREDENTIALS) {
1709 struct ucred *cred = (struct ucred *)data;
1710 struct target_ucred *target_cred =
1711 (struct target_ucred *)target_data;
1712
876e23cb
PM		 1713 __get_user(cred->pid, &target_cred->pid);
1714 __get_user(cred->uid, &target_cred->uid);
1715 __get_user(cred->gid, &target_cred->gid);
30b8b68e
AS		 1716 } else {
1717 gemu_log("Unsupported ancillary data: %d/%d\n",
1718 cmsg->cmsg_level, cmsg->cmsg_type);
1719 memcpy(data, target_data, len);
7854b056
FB		 1720 }
1721
1722 cmsg = CMSG_NXTHDR(msgh, cmsg);
ee104587
JN		 1723 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1724 target_cmsg_start);
7854b056 1725 }
5a4a898d
FB		 1726 unlock_user(target_cmsg, target_cmsg_addr, 0);
1727 the_end:
7854b056 1728 msgh->msg_controllen = space;
5a4a898d 1729 return 0;
7854b056
FB		 1730}
1731
5a4a898d
FB		 1732static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
1733 struct msghdr *msgh)
7854b056
FB		 1734{
1735 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 1736 abi_long msg_controllen;
1737 abi_ulong target_cmsg_addr;
ee104587 1738 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
7854b056
FB		 1739 socklen_t space = 0;
1740
cbb21eed 1741 msg_controllen = tswapal(target_msgh->msg_controllen);
5a4a898d
FB		 1742 if (msg_controllen < sizeof (struct target_cmsghdr))
1743 goto the_end;
cbb21eed 1744 target_cmsg_addr = tswapal(target_msgh->msg_control);
5a4a898d 1745 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
ee104587 1746 target_cmsg_start = target_cmsg;
5a4a898d
FB		 1747 if (!target_cmsg)
1748 return -TARGET_EFAULT;
1749
7854b056
FB		 1750 while (cmsg && target_cmsg) {
1751 void *data = CMSG_DATA(cmsg);
1752 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1753
1754 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
c2aeb258 1755 int tgt_len, tgt_space;
7854b056 1756
c2aeb258
PM		 1757 /* We never copy a half-header but may copy half-data;
1758 * this is Linux's behaviour in put_cmsg(). Note that
1759 * truncation here is a guest problem (which we report
1760 * to the guest via the CTRUNC bit), unlike truncation
1761 * in target_to_host_cmsg, which is a QEMU bug.
1762 */
1763 if (msg_controllen < sizeof(struct cmsghdr)) {
1764 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
7854b056
FB		 1765 break;
1766 }
1767
dbf4f796
PJ		 1768 if (cmsg->cmsg_level == SOL_SOCKET) {
1769 target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET);
1770 } else {
1771 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
1772 }
7854b056 1773 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
7854b056 1774
c2aeb258
PM		 1775 tgt_len = TARGET_CMSG_LEN(len);
1776
1777 /* Payload types which need a different size of payload on
1778 * the target must adjust tgt_len here.
1779 */
1780 switch (cmsg->cmsg_level) {
1781 case SOL_SOCKET:
1782 switch (cmsg->cmsg_type) {
1783 case SO_TIMESTAMP:
1784 tgt_len = sizeof(struct target_timeval);
1785 break;
1786 default:
1787 break;
1788 }
1789 default:
1790 break;
1791 }
1792
1793 if (msg_controllen < tgt_len) {
1794 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1795 tgt_len = msg_controllen;
1796 }
1797
1798 /* We must now copy-and-convert len bytes of payload
1799 * into tgt_len bytes of destination space. Bear in mind
1800 * that in both source and destination we may be dealing
1801 * with a truncated value!
1802 */
52b65494
HD		 1803 switch (cmsg->cmsg_level) {
1804 case SOL_SOCKET:
1805 switch (cmsg->cmsg_type) {
1806 case SCM_RIGHTS:
1807 {
1808 int *fd = (int *)data;
1809 int *target_fd = (int *)target_data;
c2aeb258 1810 int i, numfds = tgt_len / sizeof(int);
52b65494 1811
876e23cb
PM		 1812 for (i = 0; i < numfds; i++) {
1813 __put_user(fd[i], target_fd + i);
1814 }
52b65494
HD		 1815 break;
1816 }
1817 case SO_TIMESTAMP:
1818 {
1819 struct timeval *tv = (struct timeval *)data;
1820 struct target_timeval *target_tv =
1821 (struct target_timeval *)target_data;
1822
c2aeb258
PM		 1823 if (len != sizeof(struct timeval) ||
1824 tgt_len != sizeof(struct target_timeval)) {
52b65494 1825 goto unimplemented;
c2aeb258 1826 }
52b65494
HD		 1827
1828 /* copy struct timeval to target */
876e23cb
PM		 1829 __put_user(tv->tv_sec, &target_tv->tv_sec);
1830 __put_user(tv->tv_usec, &target_tv->tv_usec);
52b65494
HD		 1831 break;
1832 }
4bc29756
HD		 1833 case SCM_CREDENTIALS:
1834 {
1835 struct ucred *cred = (struct ucred *)data;
1836 struct target_ucred *target_cred =
1837 (struct target_ucred *)target_data;
1838
1839 __put_user(cred->pid, &target_cred->pid);
1840 __put_user(cred->uid, &target_cred->uid);
1841 __put_user(cred->gid, &target_cred->gid);
1842 break;
1843 }
52b65494
HD		 1844 default:
1845 goto unimplemented;
1846 }
1847 break;
7854b056 1848
ee1ac3a1
HD		 1849 case SOL_IP:
1850 switch (cmsg->cmsg_type) {
1851 case IP_TTL:
1852 {
1853 uint32_t *v = (uint32_t *)data;
1854 uint32_t *t_int = (uint32_t *)target_data;
1855
1856 __put_user(*v, t_int);
1857 break;
1858 }
1859 case IP_RECVERR:
1860 {
1861 struct errhdr_t {
1862 struct sock_extended_err ee;
1863 struct sockaddr_in offender;
1864 };
1865 struct errhdr_t *errh = (struct errhdr_t *)data;
1866 struct errhdr_t *target_errh =
1867 (struct errhdr_t *)target_data;
1868
1869 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
1870 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
1871 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type);
1872 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
1873 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
1874 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
1875 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
1876 host_to_target_sockaddr((unsigned long) &target_errh->offender,
1877 (void *) &errh->offender, sizeof(errh->offender));
1878 break;
1879 }
1880 default:
1881 goto unimplemented;
1882 }
1883 break;
1884
1885 case SOL_IPV6:
1886 switch (cmsg->cmsg_type) {
1887 case IPV6_HOPLIMIT:
1888 {
1889 uint32_t *v = (uint32_t *)data;
1890 uint32_t *t_int = (uint32_t *)target_data;
1891
1892 __put_user(*v, t_int);
1893 break;
1894 }
1895 case IPV6_RECVERR:
1896 {
1897 struct errhdr6_t {
1898 struct sock_extended_err ee;
1899 struct sockaddr_in6 offender;
1900 };
1901 struct errhdr6_t *errh = (struct errhdr6_t *)data;
1902 struct errhdr6_t *target_errh =
1903 (struct errhdr6_t *)target_data;
1904
1905 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
1906 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
1907 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type);
1908 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
1909 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
1910 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
1911 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
1912 host_to_target_sockaddr((unsigned long) &target_errh->offender,
1913 (void *) &errh->offender, sizeof(errh->offender));
1914 break;
1915 }
1916 default:
1917 goto unimplemented;
1918 }
1919 break;
1920
52b65494
HD		 1921 default:
1922 unimplemented:
aebf5bc7
JH		 1923 gemu_log("Unsupported ancillary data: %d/%d\n",
1924 cmsg->cmsg_level, cmsg->cmsg_type);
c2aeb258
PM		 1925 memcpy(target_data, data, MIN(len, tgt_len));
1926 if (tgt_len > len) {
1927 memset(target_data + len, 0, tgt_len - len);
1928 }
7854b056
FB		 1929 }
1930
c2aeb258 1931 target_cmsg->cmsg_len = tswapal(tgt_len);
ee104587 1932 tgt_space = TARGET_CMSG_SPACE(len);
c2aeb258
PM		 1933 if (msg_controllen < tgt_space) {
1934 tgt_space = msg_controllen;
1935 }
1936 msg_controllen -= tgt_space;
1937 space += tgt_space;
7854b056 1938 cmsg = CMSG_NXTHDR(msgh, cmsg);
ee104587
JN		 1939 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1940 target_cmsg_start);
7854b056 1941 }
5a4a898d
FB		 1942 unlock_user(target_cmsg, target_cmsg_addr, space);
1943 the_end:
cbb21eed 1944 target_msgh->msg_controllen = tswapal(space);
5a4a898d 1945 return 0;
7854b056
FB		 1946}
1947
6c5b5645
LV		 1948static void tswap_nlmsghdr(struct nlmsghdr *nlh)
1949{
1950 nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
1951 nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
1952 nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
1953 nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
1954 nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
1955}
1956
1957static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
1958 size_t len,
1959 abi_long (*host_to_target_nlmsg)
1960 (struct nlmsghdr *))
1961{
1962 uint32_t nlmsg_len;
1963 abi_long ret;
1964
1965 while (len > sizeof(struct nlmsghdr)) {
1966
1967 nlmsg_len = nlh->nlmsg_len;
1968 if (nlmsg_len < sizeof(struct nlmsghdr) ||
1969 nlmsg_len > len) {
1970 break;
1971 }
1972
1973 switch (nlh->nlmsg_type) {
1974 case NLMSG_DONE:
1975 tswap_nlmsghdr(nlh);
1976 return 0;
1977 case NLMSG_NOOP:
1978 break;
1979 case NLMSG_ERROR:
1980 {
1981 struct nlmsgerr *e = NLMSG_DATA(nlh);
1982 e->error = tswap32(e->error);
1983 tswap_nlmsghdr(&e->msg);
1984 tswap_nlmsghdr(nlh);
1985 return 0;
1986 }
1987 default:
1988 ret = host_to_target_nlmsg(nlh);
1989 if (ret < 0) {
1990 tswap_nlmsghdr(nlh);
1991 return ret;
1992 }
1993 break;
1994 }
1995 tswap_nlmsghdr(nlh);
1996 len -= NLMSG_ALIGN(nlmsg_len);
1997 nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
1998 }
1999 return 0;
2000}
2001
2002static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
2003 size_t len,
2004 abi_long (*target_to_host_nlmsg)
2005 (struct nlmsghdr *))
2006{
2007 int ret;
2008
2009 while (len > sizeof(struct nlmsghdr)) {
2010 if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
2011 tswap32(nlh->nlmsg_len) > len) {
2012 break;
2013 }
2014 tswap_nlmsghdr(nlh);
2015 switch (nlh->nlmsg_type) {
2016 case NLMSG_DONE:
2017 return 0;
2018 case NLMSG_NOOP:
2019 break;
2020 case NLMSG_ERROR:
2021 {
2022 struct nlmsgerr *e = NLMSG_DATA(nlh);
2023 e->error = tswap32(e->error);
2024 tswap_nlmsghdr(&e->msg);
84f34b00 2025 return 0;
6c5b5645
LV		 2026 }
2027 default:
2028 ret = target_to_host_nlmsg(nlh);
2029 if (ret < 0) {
2030 return ret;
2031 }
2032 }
2033 len -= NLMSG_ALIGN(nlh->nlmsg_len);
2034 nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
2035 }
2036 return 0;
2037}
2038
575b22b1 2039#ifdef CONFIG_RTNETLINK
c5dff280
LV		 2040static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
2041 size_t len, void *context,
2042 abi_long (*host_to_target_nlattr)
2043 (struct nlattr *,
2044 void *context))
2045{
2046 unsigned short nla_len;
2047 abi_long ret;
2048
2049 while (len > sizeof(struct nlattr)) {
2050 nla_len = nlattr->nla_len;
2051 if (nla_len < sizeof(struct nlattr) ||
2052 nla_len > len) {
2053 break;
2054 }
2055 ret = host_to_target_nlattr(nlattr, context);
2056 nlattr->nla_len = tswap16(nlattr->nla_len);
2057 nlattr->nla_type = tswap16(nlattr->nla_type);
2058 if (ret < 0) {
2059 return ret;
2060 }
2061 len -= NLA_ALIGN(nla_len);
2062 nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
2063 }
2064 return 0;
2065}
2066
6c5b5645
LV		 2067static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
2068 size_t len,
2069 abi_long (*host_to_target_rtattr)
2070 (struct rtattr *))
2071{
2072 unsigned short rta_len;
2073 abi_long ret;
2074
2075 while (len > sizeof(struct rtattr)) {
2076 rta_len = rtattr->rta_len;
2077 if (rta_len < sizeof(struct rtattr) ||
2078 rta_len > len) {
2079 break;
2080 }
2081 ret = host_to_target_rtattr(rtattr);
2082 rtattr->rta_len = tswap16(rtattr->rta_len);
2083 rtattr->rta_type = tswap16(rtattr->rta_type);
2084 if (ret < 0) {
2085 return ret;
2086 }
2087 len -= RTA_ALIGN(rta_len);
2088 rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
2089 }
2090 return 0;
2091}
2092
c5dff280
LV		 2093#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
2094
2095static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
2096 void *context)
2097{
2098 uint16_t *u16;
2099 uint32_t *u32;
2100 uint64_t *u64;
2101
2102 switch (nlattr->nla_type) {
2103 /* no data */
60c6b790 2104 case QEMU_IFLA_BR_FDB_FLUSH:
c5dff280
LV		 2105 break;
2106 /* binary */
60c6b790 2107 case QEMU_IFLA_BR_GROUP_ADDR:
c5dff280
LV		 2108 break;
2109 /* uint8_t */
60c6b790
MP		 2110 case QEMU_IFLA_BR_VLAN_FILTERING:
2111 case QEMU_IFLA_BR_TOPOLOGY_CHANGE:
2112 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
2113 case QEMU_IFLA_BR_MCAST_ROUTER:
2114 case QEMU_IFLA_BR_MCAST_SNOOPING:
2115 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR:
2116 case QEMU_IFLA_BR_MCAST_QUERIER:
2117 case QEMU_IFLA_BR_NF_CALL_IPTABLES:
2118 case QEMU_IFLA_BR_NF_CALL_IP6TABLES:
2119 case QEMU_IFLA_BR_NF_CALL_ARPTABLES:
c5dff280
LV		 2120 break;
2121 /* uint16_t */
60c6b790
MP		 2122 case QEMU_IFLA_BR_PRIORITY:
2123 case QEMU_IFLA_BR_VLAN_PROTOCOL:
2124 case QEMU_IFLA_BR_GROUP_FWD_MASK:
2125 case QEMU_IFLA_BR_ROOT_PORT:
2126 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID:
c5dff280
LV		 2127 u16 = NLA_DATA(nlattr);
2128 *u16 = tswap16(*u16);
2129 break;
2130 /* uint32_t */
60c6b790
MP		 2131 case QEMU_IFLA_BR_FORWARD_DELAY:
2132 case QEMU_IFLA_BR_HELLO_TIME:
2133 case QEMU_IFLA_BR_MAX_AGE:
2134 case QEMU_IFLA_BR_AGEING_TIME:
2135 case QEMU_IFLA_BR_STP_STATE:
2136 case QEMU_IFLA_BR_ROOT_PATH_COST:
2137 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY:
2138 case QEMU_IFLA_BR_MCAST_HASH_MAX:
2139 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT:
2140 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT:
c5dff280
LV		 2141 u32 = NLA_DATA(nlattr);
2142 *u32 = tswap32(*u32);
2143 break;
2144 /* uint64_t */
60c6b790
MP		 2145 case QEMU_IFLA_BR_HELLO_TIMER:
2146 case QEMU_IFLA_BR_TCN_TIMER:
2147 case QEMU_IFLA_BR_GC_TIMER:
2148 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER:
2149 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL:
2150 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL:
2151 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL:
2152 case QEMU_IFLA_BR_MCAST_QUERY_INTVL:
2153 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
2154 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
c5dff280
LV		 2155 u64 = NLA_DATA(nlattr);
2156 *u64 = tswap64(*u64);
2157 break;
2158 /* ifla_bridge_id: uin8_t[] */
60c6b790
MP		 2159 case QEMU_IFLA_BR_ROOT_ID:
2160 case QEMU_IFLA_BR_BRIDGE_ID:
c5dff280
LV		 2161 break;
2162 default:
60c6b790 2163 gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type);
c5dff280
LV		 2164 break;
2165 }
2166 return 0;
2167}
2168
2169static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
2170 void *context)
2171{
2172 uint16_t *u16;
2173 uint32_t *u32;
2174 uint64_t *u64;
2175
2176 switch (nlattr->nla_type) {
2177 /* uint8_t */
60c6b790
MP		 2178 case QEMU_IFLA_BRPORT_STATE:
2179 case QEMU_IFLA_BRPORT_MODE:
2180 case QEMU_IFLA_BRPORT_GUARD:
2181 case QEMU_IFLA_BRPORT_PROTECT:
2182 case QEMU_IFLA_BRPORT_FAST_LEAVE:
2183 case QEMU_IFLA_BRPORT_LEARNING:
2184 case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
2185 case QEMU_IFLA_BRPORT_PROXYARP:
2186 case QEMU_IFLA_BRPORT_LEARNING_SYNC:
2187 case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
2188 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
2189 case QEMU_IFLA_BRPORT_CONFIG_PENDING:
2190 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
c5dff280
LV		 2191 break;
2192 /* uint16_t */
60c6b790
MP		 2193 case QEMU_IFLA_BRPORT_PRIORITY:
2194 case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
2195 case QEMU_IFLA_BRPORT_DESIGNATED_COST:
2196 case QEMU_IFLA_BRPORT_ID:
2197 case QEMU_IFLA_BRPORT_NO:
c5dff280
LV		 2198 u16 = NLA_DATA(nlattr);
2199 *u16 = tswap16(*u16);
2200 break;
2201 /* uin32_t */
60c6b790 2202 case QEMU_IFLA_BRPORT_COST:
c5dff280
LV		 2203 u32 = NLA_DATA(nlattr);
2204 *u32 = tswap32(*u32);
2205 break;
2206 /* uint64_t */
60c6b790
MP		 2207 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
2208 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
2209 case QEMU_IFLA_BRPORT_HOLD_TIMER:
c5dff280
LV		 2210 u64 = NLA_DATA(nlattr);
2211 *u64 = tswap64(*u64);
2212 break;
2213 /* ifla_bridge_id: uint8_t[] */
60c6b790
MP		 2214 case QEMU_IFLA_BRPORT_ROOT_ID:
2215 case QEMU_IFLA_BRPORT_BRIDGE_ID:
c5dff280
LV		 2216 break;
2217 default:
60c6b790 2218 gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type);
c5dff280
LV		 2219 break;
2220 }
2221 return 0;
2222}
2223
2224struct linkinfo_context {
2225 int len;
2226 char *name;
2227 int slave_len;
2228 char *slave_name;
2229};
2230
2231static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
2232 void *context)
2233{
2234 struct linkinfo_context *li_context = context;
2235
2236 switch (nlattr->nla_type) {
2237 /* string */
60c6b790 2238 case QEMU_IFLA_INFO_KIND:
c5dff280
LV		 2239 li_context->name = NLA_DATA(nlattr);
2240 li_context->len = nlattr->nla_len - NLA_HDRLEN;
2241 break;
60c6b790 2242 case QEMU_IFLA_INFO_SLAVE_KIND:
c5dff280
LV		 2243 li_context->slave_name = NLA_DATA(nlattr);
2244 li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
2245 break;
2246 /* stats */
60c6b790 2247 case QEMU_IFLA_INFO_XSTATS:
c5dff280
LV		 2248 /* FIXME: only used by CAN */
2249 break;
2250 /* nested */
60c6b790 2251 case QEMU_IFLA_INFO_DATA:
c5dff280
LV		 2252 if (strncmp(li_context->name, "bridge",
2253 li_context->len) == 0) {
2254 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
2255 nlattr->nla_len,
2256 NULL,
2257 host_to_target_data_bridge_nlattr);
2258 } else {
60c6b790 2259 gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name);
c5dff280
LV		 2260 }
2261 break;
60c6b790 2262 case QEMU_IFLA_INFO_SLAVE_DATA:
c5dff280
LV		 2263 if (strncmp(li_context->slave_name, "bridge",
2264 li_context->slave_len) == 0) {
2265 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
2266 nlattr->nla_len,
2267 NULL,
2268 host_to_target_slave_data_bridge_nlattr);
2269 } else {
60c6b790 2270 gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
c5dff280
LV		 2271 li_context->slave_name);
2272 }
2273 break;
2274 default:
60c6b790 2275 gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type);
c5dff280
LV		 2276 break;
2277 }
2278
2279 return 0;
2280}
2281
2282static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
2283 void *context)
2284{
2285 uint32_t *u32;
2286 int i;
2287
2288 switch (nlattr->nla_type) {
60c6b790 2289 case QEMU_IFLA_INET_CONF:
c5dff280
LV		 2290 u32 = NLA_DATA(nlattr);
2291 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
2292 i++) {
2293 u32[i] = tswap32(u32[i]);
2294 }
2295 break;
2296 default:
2297 gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type);
2298 }
2299 return 0;
2300}
2301
2302static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
2303 void *context)
2304{
2305 uint32_t *u32;
2306 uint64_t *u64;
2307 struct ifla_cacheinfo *ci;
2308 int i;
2309
2310 switch (nlattr->nla_type) {
2311 /* binaries */
60c6b790 2312 case QEMU_IFLA_INET6_TOKEN:
c5dff280
LV		 2313 break;
2314 /* uint8_t */
60c6b790 2315 case QEMU_IFLA_INET6_ADDR_GEN_MODE:
c5dff280
LV		 2316 break;
2317 /* uint32_t */
60c6b790 2318 case QEMU_IFLA_INET6_FLAGS:
c5dff280
LV		 2319 u32 = NLA_DATA(nlattr);
2320 *u32 = tswap32(*u32);
2321 break;
2322 /* uint32_t[] */
60c6b790 2323 case QEMU_IFLA_INET6_CONF:
c5dff280
LV		 2324 u32 = NLA_DATA(nlattr);
2325 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
2326 i++) {
2327 u32[i] = tswap32(u32[i]);
2328 }
2329 break;
2330 /* ifla_cacheinfo */
60c6b790 2331 case QEMU_IFLA_INET6_CACHEINFO:
c5dff280
LV		 2332 ci = NLA_DATA(nlattr);
2333 ci->max_reasm_len = tswap32(ci->max_reasm_len);
2334 ci->tstamp = tswap32(ci->tstamp);
2335 ci->reachable_time = tswap32(ci->reachable_time);
2336 ci->retrans_time = tswap32(ci->retrans_time);
2337 break;
2338 /* uint64_t[] */
60c6b790
MP		 2339 case QEMU_IFLA_INET6_STATS:
2340 case QEMU_IFLA_INET6_ICMP6STATS:
c5dff280
LV		 2341 u64 = NLA_DATA(nlattr);
2342 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
2343 i++) {
2344 u64[i] = tswap64(u64[i]);
2345 }
2346 break;
2347 default:
2348 gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type);
2349 }
2350 return 0;
2351}
2352
2353static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
2354 void *context)
2355{
2356 switch (nlattr->nla_type) {
2357 case AF_INET:
2358 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2359 NULL,
2360 host_to_target_data_inet_nlattr);
2361 case AF_INET6:
2362 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2363 NULL,
2364 host_to_target_data_inet6_nlattr);
2365 default:
2366 gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type);
2367 break;
2368 }
2369 return 0;
2370}
2371
6c5b5645
LV		 2372static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
2373{
2374 uint32_t *u32;
2375 struct rtnl_link_stats *st;
2376 struct rtnl_link_stats64 *st64;
2377 struct rtnl_link_ifmap *map;
c5dff280 2378 struct linkinfo_context li_context;
6c5b5645
LV		 2379
2380 switch (rtattr->rta_type) {
2381 /* binary stream */
60c6b790
MP		 2382 case QEMU_IFLA_ADDRESS:
2383 case QEMU_IFLA_BROADCAST:
6c5b5645 2384 /* string */
60c6b790
MP		 2385 case QEMU_IFLA_IFNAME:
2386 case QEMU_IFLA_QDISC:
6c5b5645
LV		 2387 break;
2388 /* uin8_t */
60c6b790
MP		 2389 case QEMU_IFLA_OPERSTATE:
2390 case QEMU_IFLA_LINKMODE:
2391 case QEMU_IFLA_CARRIER:
2392 case QEMU_IFLA_PROTO_DOWN:
6c5b5645
LV		 2393 break;
2394 /* uint32_t */
60c6b790
MP		 2395 case QEMU_IFLA_MTU:
2396 case QEMU_IFLA_LINK:
2397 case QEMU_IFLA_WEIGHT:
2398 case QEMU_IFLA_TXQLEN:
2399 case QEMU_IFLA_CARRIER_CHANGES:
2400 case QEMU_IFLA_NUM_RX_QUEUES:
2401 case QEMU_IFLA_NUM_TX_QUEUES:
2402 case QEMU_IFLA_PROMISCUITY:
2403 case QEMU_IFLA_EXT_MASK:
2404 case QEMU_IFLA_LINK_NETNSID:
2405 case QEMU_IFLA_GROUP:
2406 case QEMU_IFLA_MASTER:
2407 case QEMU_IFLA_NUM_VF:
a1488b86
LV		 2408 case QEMU_IFLA_GSO_MAX_SEGS:
2409 case QEMU_IFLA_GSO_MAX_SIZE:
6c5b5645
LV		 2410 u32 = RTA_DATA(rtattr);
2411 *u32 = tswap32(*u32);
2412 break;
2413 /* struct rtnl_link_stats */
60c6b790 2414 case QEMU_IFLA_STATS:
6c5b5645
LV		 2415 st = RTA_DATA(rtattr);
2416 st->rx_packets = tswap32(st->rx_packets);
2417 st->tx_packets = tswap32(st->tx_packets);
2418 st->rx_bytes = tswap32(st->rx_bytes);
2419 st->tx_bytes = tswap32(st->tx_bytes);
2420 st->rx_errors = tswap32(st->rx_errors);
2421 st->tx_errors = tswap32(st->tx_errors);
2422 st->rx_dropped = tswap32(st->rx_dropped);
2423 st->tx_dropped = tswap32(st->tx_dropped);
2424 st->multicast = tswap32(st->multicast);
2425 st->collisions = tswap32(st->collisions);
2426
2427 /* detailed rx_errors: */
2428 st->rx_length_errors = tswap32(st->rx_length_errors);
2429 st->rx_over_errors = tswap32(st->rx_over_errors);
2430 st->rx_crc_errors = tswap32(st->rx_crc_errors);
2431 st->rx_frame_errors = tswap32(st->rx_frame_errors);
2432 st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
2433 st->rx_missed_errors = tswap32(st->rx_missed_errors);
2434
2435 /* detailed tx_errors */
2436 st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
2437 st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
2438 st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
2439 st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
2440 st->tx_window_errors = tswap32(st->tx_window_errors);
2441
2442 /* for cslip etc */
2443 st->rx_compressed = tswap32(st->rx_compressed);
2444 st->tx_compressed = tswap32(st->tx_compressed);
2445 break;
2446 /* struct rtnl_link_stats64 */
60c6b790 2447 case QEMU_IFLA_STATS64:
6c5b5645
LV		 2448 st64 = RTA_DATA(rtattr);
2449 st64->rx_packets = tswap64(st64->rx_packets);
2450 st64->tx_packets = tswap64(st64->tx_packets);
2451 st64->rx_bytes = tswap64(st64->rx_bytes);
2452 st64->tx_bytes = tswap64(st64->tx_bytes);
2453 st64->rx_errors = tswap64(st64->rx_errors);
2454 st64->tx_errors = tswap64(st64->tx_errors);
2455 st64->rx_dropped = tswap64(st64->rx_dropped);
2456 st64->tx_dropped = tswap64(st64->tx_dropped);
2457 st64->multicast = tswap64(st64->multicast);
2458 st64->collisions = tswap64(st64->collisions);
2459
2460 /* detailed rx_errors: */
2461 st64->rx_length_errors = tswap64(st64->rx_length_errors);
2462 st64->rx_over_errors = tswap64(st64->rx_over_errors);
2463 st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
2464 st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
2465 st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
2466 st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
2467
2468 /* detailed tx_errors */
2469 st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
2470 st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
2471 st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
2472 st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
2473 st64->tx_window_errors = tswap64(st64->tx_window_errors);
2474
2475 /* for cslip etc */
2476 st64->rx_compressed = tswap64(st64->rx_compressed);
2477 st64->tx_compressed = tswap64(st64->tx_compressed);
2478 break;
2479 /* struct rtnl_link_ifmap */
60c6b790 2480 case QEMU_IFLA_MAP:
6c5b5645
LV		 2481 map = RTA_DATA(rtattr);
2482 map->mem_start = tswap64(map->mem_start);
2483 map->mem_end = tswap64(map->mem_end);
2484 map->base_addr = tswap64(map->base_addr);
2485 map->irq = tswap16(map->irq);
2486 break;
2487 /* nested */
60c6b790 2488 case QEMU_IFLA_LINKINFO:
c5dff280
LV		 2489 memset(&li_context, 0, sizeof(li_context));
2490 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2491 &li_context,
2492 host_to_target_data_linkinfo_nlattr);
60c6b790 2493 case QEMU_IFLA_AF_SPEC:
c5dff280
LV		 2494 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2495 NULL,
2496 host_to_target_data_spec_nlattr);
6c5b5645 2497 default:
60c6b790 2498 gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type);
6c5b5645
LV		 2499 break;
2500 }
2501 return 0;
2502}
2503
2504static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
2505{
2506 uint32_t *u32;
2507 struct ifa_cacheinfo *ci;
2508
2509 switch (rtattr->rta_type) {
2510 /* binary: depends on family type */
2511 case IFA_ADDRESS:
2512 case IFA_LOCAL:
2513 break;
2514 /* string */
2515 case IFA_LABEL:
2516 break;
2517 /* u32 */
2518 case IFA_FLAGS:
2519 case IFA_BROADCAST:
2520 u32 = RTA_DATA(rtattr);
2521 *u32 = tswap32(*u32);
2522 break;
2523 /* struct ifa_cacheinfo */
2524 case IFA_CACHEINFO:
2525 ci = RTA_DATA(rtattr);
2526 ci->ifa_prefered = tswap32(ci->ifa_prefered);
2527 ci->ifa_valid = tswap32(ci->ifa_valid);
2528 ci->cstamp = tswap32(ci->cstamp);
2529 ci->tstamp = tswap32(ci->tstamp);
2530 break;
2531 default:
2532 gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type);
2533 break;
2534 }
2535 return 0;
2536}
2537
2538static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
2539{
2540 uint32_t *u32;
2541 switch (rtattr->rta_type) {
2542 /* binary: depends on family type */
2543 case RTA_GATEWAY:
2544 case RTA_DST:
2545 case RTA_PREFSRC:
2546 break;
2547 /* u32 */
2548 case RTA_PRIORITY:
2549 case RTA_TABLE:
2550 case RTA_OIF:
2551 u32 = RTA_DATA(rtattr);
2552 *u32 = tswap32(*u32);
2553 break;
2554 default:
2555 gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type);
2556 break;
2557 }
2558 return 0;
2559}
2560
2561static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
2562 uint32_t rtattr_len)
2563{
2564 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2565 host_to_target_data_link_rtattr);
2566}
2567
2568static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
2569 uint32_t rtattr_len)
2570{
2571 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2572 host_to_target_data_addr_rtattr);
2573}
2574
2575static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
2576 uint32_t rtattr_len)
2577{
2578 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2579 host_to_target_data_route_rtattr);
2580}
2581
2582static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
2583{
2584 uint32_t nlmsg_len;
2585 struct ifinfomsg *ifi;
2586 struct ifaddrmsg *ifa;
2587 struct rtmsg *rtm;
2588
2589 nlmsg_len = nlh->nlmsg_len;
2590 switch (nlh->nlmsg_type) {
2591 case RTM_NEWLINK:
2592 case RTM_DELLINK:
2593 case RTM_GETLINK:
b9403979
LV		 2594 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2595 ifi = NLMSG_DATA(nlh);
2596 ifi->ifi_type = tswap16(ifi->ifi_type);
2597 ifi->ifi_index = tswap32(ifi->ifi_index);
2598 ifi->ifi_flags = tswap32(ifi->ifi_flags);
2599 ifi->ifi_change = tswap32(ifi->ifi_change);
2600 host_to_target_link_rtattr(IFLA_RTA(ifi),
2601 nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
2602 }
6c5b5645
LV		 2603 break;
2604 case RTM_NEWADDR:
2605 case RTM_DELADDR:
2606 case RTM_GETADDR:
b9403979
LV		 2607 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2608 ifa = NLMSG_DATA(nlh);
2609 ifa->ifa_index = tswap32(ifa->ifa_index);
2610 host_to_target_addr_rtattr(IFA_RTA(ifa),
2611 nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
2612 }
6c5b5645
LV		 2613 break;
2614 case RTM_NEWROUTE:
2615 case RTM_DELROUTE:
2616 case RTM_GETROUTE:
b9403979
LV		 2617 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2618 rtm = NLMSG_DATA(nlh);
2619 rtm->rtm_flags = tswap32(rtm->rtm_flags);
2620 host_to_target_route_rtattr(RTM_RTA(rtm),
2621 nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
2622 }
6c5b5645
LV		 2623 break;
2624 default:
2625 return -TARGET_EINVAL;
2626 }
2627 return 0;
2628}
2629
2630static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
2631 size_t len)
2632{
2633 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
2634}
2635
2636static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
2637 size_t len,
2638 abi_long (*target_to_host_rtattr)
2639 (struct rtattr *))
2640{
2641 abi_long ret;
2642
2643 while (len >= sizeof(struct rtattr)) {
2644 if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
2645 tswap16(rtattr->rta_len) > len) {
2646 break;
2647 }
2648 rtattr->rta_len = tswap16(rtattr->rta_len);
2649 rtattr->rta_type = tswap16(rtattr->rta_type);
2650 ret = target_to_host_rtattr(rtattr);
2651 if (ret < 0) {
2652 return ret;
2653 }
2654 len -= RTA_ALIGN(rtattr->rta_len);
2655 rtattr = (struct rtattr *)(((char *)rtattr) +
2656 RTA_ALIGN(rtattr->rta_len));
2657 }
2658 return 0;
2659}
2660
2661static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
2662{
2663 switch (rtattr->rta_type) {
2664 default:
60c6b790 2665 gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type);
6c5b5645
LV		 2666 break;
2667 }
2668 return 0;
2669}
2670
2671static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
2672{
2673 switch (rtattr->rta_type) {
2674 /* binary: depends on family type */
2675 case IFA_LOCAL:
2676 case IFA_ADDRESS:
2677 break;
2678 default:
2679 gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type);
2680 break;
2681 }
2682 return 0;
2683}
2684
2685static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
2686{
2687 uint32_t *u32;
2688 switch (rtattr->rta_type) {
2689 /* binary: depends on family type */
2690 case RTA_DST:
2691 case RTA_SRC:
2692 case RTA_GATEWAY:
2693 break;
2694 /* u32 */
434f286b 2695 case RTA_PRIORITY:
6c5b5645
LV		 2696 case RTA_OIF:
2697 u32 = RTA_DATA(rtattr);
2698 *u32 = tswap32(*u32);
2699 break;
2700 default:
2701 gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type);
2702 break;
2703 }
2704 return 0;
2705}
2706
2707static void target_to_host_link_rtattr(struct rtattr *rtattr,
2708 uint32_t rtattr_len)
2709{
2710 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2711 target_to_host_data_link_rtattr);
2712}
2713
2714static void target_to_host_addr_rtattr(struct rtattr *rtattr,
2715 uint32_t rtattr_len)
2716{
2717 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2718 target_to_host_data_addr_rtattr);
2719}
2720
2721static void target_to_host_route_rtattr(struct rtattr *rtattr,
2722 uint32_t rtattr_len)
2723{
2724 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2725 target_to_host_data_route_rtattr);
2726}
2727
2728static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
2729{
2730 struct ifinfomsg *ifi;
2731 struct ifaddrmsg *ifa;
2732 struct rtmsg *rtm;
2733
2734 switch (nlh->nlmsg_type) {
2735 case RTM_GETLINK:
2736 break;
2737 case RTM_NEWLINK:
2738 case RTM_DELLINK:
b9403979
LV		 2739 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2740 ifi = NLMSG_DATA(nlh);
2741 ifi->ifi_type = tswap16(ifi->ifi_type);
2742 ifi->ifi_index = tswap32(ifi->ifi_index);
2743 ifi->ifi_flags = tswap32(ifi->ifi_flags);
2744 ifi->ifi_change = tswap32(ifi->ifi_change);
2745 target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
2746 NLMSG_LENGTH(sizeof(*ifi)));
2747 }
6c5b5645
LV		 2748 break;
2749 case RTM_GETADDR:
2750 case RTM_NEWADDR:
2751 case RTM_DELADDR:
b9403979
LV		 2752 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2753 ifa = NLMSG_DATA(nlh);
2754 ifa->ifa_index = tswap32(ifa->ifa_index);
2755 target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
2756 NLMSG_LENGTH(sizeof(*ifa)));
2757 }
6c5b5645
LV		 2758 break;
2759 case RTM_GETROUTE:
2760 break;
2761 case RTM_NEWROUTE:
2762 case RTM_DELROUTE:
b9403979
LV		 2763 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2764 rtm = NLMSG_DATA(nlh);
2765 rtm->rtm_flags = tswap32(rtm->rtm_flags);
2766 target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
2767 NLMSG_LENGTH(sizeof(*rtm)));
2768 }
6c5b5645
LV		 2769 break;
2770 default:
2771 return -TARGET_EOPNOTSUPP;
2772 }
2773 return 0;
2774}
2775
2776static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
2777{
2778 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
2779}
575b22b1 2780#endif /* CONFIG_RTNETLINK */
6c5b5645 2781
5ce9bb59
LV		 2782static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
2783{
2784 switch (nlh->nlmsg_type) {
2785 default:
2786 gemu_log("Unknown host audit message type %d\n",
2787 nlh->nlmsg_type);
2788 return -TARGET_EINVAL;
2789 }
2790 return 0;
2791}
2792
2793static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
2794 size_t len)
2795{
2796 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
2797}
2798
2799static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
2800{
2801 switch (nlh->nlmsg_type) {
2802 case AUDIT_USER:
2803 case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
2804 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
2805 break;
2806 default:
2807 gemu_log("Unknown target audit message type %d\n",
2808 nlh->nlmsg_type);
2809 return -TARGET_EINVAL;
2810 }
2811
2812 return 0;
2813}
2814
2815static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
2816{
2817 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
2818}
2819
0da46a6e 2820/* do_setsockopt() Must return target values and target errnos. */
992f48a0 2821static abi_long do_setsockopt(int sockfd, int level, int optname,
2f619698 2822 abi_ulong optval_addr, socklen_t optlen)
7854b056 2823{
992f48a0 2824 abi_long ret;
32407103 2825 int val;
b975b83b 2826 struct ip_mreqn *ip_mreq;
6e3cb58f 2827 struct ip_mreq_source *ip_mreq_source;
3b46e624 2828
8853f86e
FB		 2829 switch(level) {
2830 case SOL_TCP:
7854b056 2831 /* TCP options all take an 'int' value. */
7854b056 2832 if (optlen < sizeof(uint32_t))
0da46a6e 2833 return -TARGET_EINVAL;
3b46e624 2834
2f619698
FB		 2835 if (get_user_u32(val, optval_addr))
2836 return -TARGET_EFAULT;
8853f86e
FB		 2837 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2838 break;
2839 case SOL_IP:
2840 switch(optname) {
2efbe911
FB		 2841 case IP_TOS:
2842 case IP_TTL:
8853f86e 2843 case IP_HDRINCL:
2efbe911
FB		 2844 case IP_ROUTER_ALERT:
2845 case IP_RECVOPTS:
2846 case IP_RETOPTS:
2847 case IP_PKTINFO:
2848 case IP_MTU_DISCOVER:
2849 case IP_RECVERR:
ee1ac3a1 2850 case IP_RECVTTL:
2efbe911
FB		 2851 case IP_RECVTOS:
2852#ifdef IP_FREEBIND
2853 case IP_FREEBIND:
2854#endif
2855 case IP_MULTICAST_TTL:
2856 case IP_MULTICAST_LOOP:
8853f86e
FB		 2857 val = 0;
2858 if (optlen >= sizeof(uint32_t)) {
2f619698
FB		 2859 if (get_user_u32(val, optval_addr))
2860 return -TARGET_EFAULT;
8853f86e 2861 } else if (optlen >= 1) {
2f619698
FB		 2862 if (get_user_u8(val, optval_addr))
2863 return -TARGET_EFAULT;
8853f86e
FB		 2864 }
2865 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2866 break;
b975b83b
LL		 2867 case IP_ADD_MEMBERSHIP:
2868 case IP_DROP_MEMBERSHIP:
2869 if (optlen < sizeof (struct target_ip_mreq) ||
2870 optlen > sizeof (struct target_ip_mreqn))
2871 return -TARGET_EINVAL;
2872
2873 ip_mreq = (struct ip_mreqn *) alloca(optlen);
2874 target_to_host_ip_mreq(ip_mreq, optval_addr, optlen);
2875 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen));
2876 break;
2877
6e3cb58f
LL		 2878 case IP_BLOCK_SOURCE:
2879 case IP_UNBLOCK_SOURCE:
2880 case IP_ADD_SOURCE_MEMBERSHIP:
2881 case IP_DROP_SOURCE_MEMBERSHIP:
2882 if (optlen != sizeof (struct target_ip_mreq_source))
2883 return -TARGET_EINVAL;
2884
2885 ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2886 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen));
2887 unlock_user (ip_mreq_source, optval_addr, 0);
2888 break;
2889
920394db
JH		 2890 default:
2891 goto unimplemented;
2892 }
2893 break;
0d78b3b5
LV		 2894 case SOL_IPV6:
2895 switch (optname) {
2896 case IPV6_MTU_DISCOVER:
2897 case IPV6_MTU:
2898 case IPV6_V6ONLY:
2899 case IPV6_RECVPKTINFO:
ee1ac3a1
HD		 2900 case IPV6_UNICAST_HOPS:
2901 case IPV6_RECVERR:
2902 case IPV6_RECVHOPLIMIT:
2903 case IPV6_2292HOPLIMIT:
2904 case IPV6_CHECKSUM:
0d78b3b5
LV		 2905 val = 0;
2906 if (optlen < sizeof(uint32_t)) {
2907 return -TARGET_EINVAL;
2908 }
2909 if (get_user_u32(val, optval_addr)) {
2910 return -TARGET_EFAULT;
2911 }
2912 ret = get_errno(setsockopt(sockfd, level, optname,
2913 &val, sizeof(val)));
2914 break;
ee1ac3a1
HD		 2915 case IPV6_PKTINFO:
2916 {
2917 struct in6_pktinfo pki;
2918
2919 if (optlen < sizeof(pki)) {
2920 return -TARGET_EINVAL;
2921 }
2922
2923 if (copy_from_user(&pki, optval_addr, sizeof(pki))) {
2924 return -TARGET_EFAULT;
2925 }
2926
2927 pki.ipi6_ifindex = tswap32(pki.ipi6_ifindex);
2928
2929 ret = get_errno(setsockopt(sockfd, level, optname,
2930 &pki, sizeof(pki)));
2931 break;
2932 }
2933 default:
2934 goto unimplemented;
2935 }
2936 break;
2937 case SOL_ICMPV6:
2938 switch (optname) {
2939 case ICMPV6_FILTER:
2940 {
2941 struct icmp6_filter icmp6f;
2942
2943 if (optlen > sizeof(icmp6f)) {
2944 optlen = sizeof(icmp6f);
2945 }
2946
2947 if (copy_from_user(&icmp6f, optval_addr, optlen)) {
2948 return -TARGET_EFAULT;
2949 }
2950
2951 for (val = 0; val < 8; val++) {
2952 icmp6f.data[val] = tswap32(icmp6f.data[val]);
2953 }
2954
2955 ret = get_errno(setsockopt(sockfd, level, optname,
2956 &icmp6f, optlen));
2957 break;
2958 }
0d78b3b5
LV		 2959 default:
2960 goto unimplemented;
2961 }
2962 break;
920394db
JH		 2963 case SOL_RAW:
2964 switch (optname) {
2965 case ICMP_FILTER:
ee1ac3a1
HD		 2966 case IPV6_CHECKSUM:
2967 /* those take an u32 value */
920394db
JH		 2968 if (optlen < sizeof(uint32_t)) {
2969 return -TARGET_EINVAL;
2970 }
2971
2972 if (get_user_u32(val, optval_addr)) {
2973 return -TARGET_EFAULT;
2974 }
2975 ret = get_errno(setsockopt(sockfd, level, optname,
2976 &val, sizeof(val)));
2977 break;
2978
8853f86e
FB		 2979 default:
2980 goto unimplemented;
2981 }
2982 break;
3532fa74 2983 case TARGET_SOL_SOCKET:
8853f86e 2984 switch (optname) {
1b09aeb9
LV		 2985 case TARGET_SO_RCVTIMEO:
2986 {
2987 struct timeval tv;
2988
2989 optname = SO_RCVTIMEO;
2990
2991set_timeout:
2992 if (optlen != sizeof(struct target_timeval)) {
2993 return -TARGET_EINVAL;
2994 }
2995
2996 if (copy_from_user_timeval(&tv, optval_addr)) {
2997 return -TARGET_EFAULT;
2998 }
2999
3000 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
3001 &tv, sizeof(tv)));
3002 return ret;
3003 }
3004 case TARGET_SO_SNDTIMEO:
3005 optname = SO_SNDTIMEO;
3006 goto set_timeout;
f57d4192
LV		 3007 case TARGET_SO_ATTACH_FILTER:
3008 {
3009 struct target_sock_fprog *tfprog;
3010 struct target_sock_filter *tfilter;
3011 struct sock_fprog fprog;
3012 struct sock_filter *filter;
3013 int i;
3014
3015 if (optlen != sizeof(*tfprog)) {
3016 return -TARGET_EINVAL;
3017 }
3018 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) {
3019 return -TARGET_EFAULT;
3020 }
3021 if (!lock_user_struct(VERIFY_READ, tfilter,
3022 tswapal(tfprog->filter), 0)) {
3023 unlock_user_struct(tfprog, optval_addr, 1);
3024 return -TARGET_EFAULT;
3025 }
3026
3027 fprog.len = tswap16(tfprog->len);
0e173b24 3028 filter = g_try_new(struct sock_filter, fprog.len);
f57d4192
LV		 3029 if (filter == NULL) {
3030 unlock_user_struct(tfilter, tfprog->filter, 1);
3031 unlock_user_struct(tfprog, optval_addr, 1);
3032 return -TARGET_ENOMEM;
3033 }
3034 for (i = 0; i < fprog.len; i++) {
3035 filter[i].code = tswap16(tfilter[i].code);
3036 filter[i].jt = tfilter[i].jt;
3037 filter[i].jf = tfilter[i].jf;
3038 filter[i].k = tswap32(tfilter[i].k);
3039 }
3040 fprog.filter = filter;
3041
3042 ret = get_errno(setsockopt(sockfd, SOL_SOCKET,
3043 SO_ATTACH_FILTER, &fprog, sizeof(fprog)));
0e173b24 3044 g_free(filter);
f57d4192
LV		 3045
3046 unlock_user_struct(tfilter, tfprog->filter, 1);
3047 unlock_user_struct(tfprog, optval_addr, 1);
3048 return ret;
3049 }
451aaf68
JT		 3050 case TARGET_SO_BINDTODEVICE:
3051 {
3052 char *dev_ifname, *addr_ifname;
3053
3054 if (optlen > IFNAMSIZ - 1) {
3055 optlen = IFNAMSIZ - 1;
3056 }
3057 dev_ifname = lock_user(VERIFY_READ, optval_addr, optlen, 1);
3058 if (!dev_ifname) {
3059 return -TARGET_EFAULT;
3060 }
3061 optname = SO_BINDTODEVICE;
3062 addr_ifname = alloca(IFNAMSIZ);
3063 memcpy(addr_ifname, dev_ifname, optlen);
3064 addr_ifname[optlen] = 0;
fad6c58a
CG		 3065 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
3066 addr_ifname, optlen));
451aaf68
JT		 3067 unlock_user (dev_ifname, optval_addr, 0);
3068 return ret;
3069 }
8853f86e 3070 /* Options with 'int' argument. */
3532fa74
FB		 3071 case TARGET_SO_DEBUG:
3072 optname = SO_DEBUG;
3073 break;
3074 case TARGET_SO_REUSEADDR:
3075 optname = SO_REUSEADDR;
3076 break;
3077 case TARGET_SO_TYPE:
3078 optname = SO_TYPE;
3079 break;
3080 case TARGET_SO_ERROR:
3081 optname = SO_ERROR;
3082 break;
3083 case TARGET_SO_DONTROUTE:
3084 optname = SO_DONTROUTE;
3085 break;
3086 case TARGET_SO_BROADCAST:
3087 optname = SO_BROADCAST;
3088 break;
3089 case TARGET_SO_SNDBUF:
3090 optname = SO_SNDBUF;
3091 break;
d79b6cc4
PB		 3092 case TARGET_SO_SNDBUFFORCE:
3093 optname = SO_SNDBUFFORCE;
3094 break;
3532fa74
FB		 3095 case TARGET_SO_RCVBUF:
3096 optname = SO_RCVBUF;
3097 break;
d79b6cc4
PB		 3098 case TARGET_SO_RCVBUFFORCE:
3099 optname = SO_RCVBUFFORCE;
3100 break;
3532fa74
FB		 3101 case TARGET_SO_KEEPALIVE:
3102 optname = SO_KEEPALIVE;
3103 break;
3104 case TARGET_SO_OOBINLINE:
3105 optname = SO_OOBINLINE;
3106 break;
3107 case TARGET_SO_NO_CHECK:
3108 optname = SO_NO_CHECK;
3109 break;
3110 case TARGET_SO_PRIORITY:
3111 optname = SO_PRIORITY;
3112 break;
5e83e8e3 3113#ifdef SO_BSDCOMPAT
3532fa74
FB		 3114 case TARGET_SO_BSDCOMPAT:
3115 optname = SO_BSDCOMPAT;
3116 break;
5e83e8e3 3117#endif
3532fa74
FB		 3118 case TARGET_SO_PASSCRED:
3119 optname = SO_PASSCRED;
3120 break;
82d0fe6b
PB		 3121 case TARGET_SO_PASSSEC:
3122 optname = SO_PASSSEC;
3123 break;
3532fa74
FB		 3124 case TARGET_SO_TIMESTAMP:
3125 optname = SO_TIMESTAMP;
3126 break;
3127 case TARGET_SO_RCVLOWAT:
3128 optname = SO_RCVLOWAT;
3129 break;
8853f86e
FB		 3130 break;
3131 default:
3132 goto unimplemented;
3133 }
3532fa74 3134 if (optlen < sizeof(uint32_t))
2f619698 3135 return -TARGET_EINVAL;
3532fa74 3136
2f619698
FB		 3137 if (get_user_u32(val, optval_addr))
3138 return -TARGET_EFAULT;
3532fa74 3139 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
8853f86e 3140 break;
7854b056 3141 default:
8853f86e 3142 unimplemented:
b2bedb21 3143 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level, optname);
6fa13c17 3144 ret = -TARGET_ENOPROTOOPT;
7854b056 3145 }
8853f86e 3146 return ret;
7854b056
FB		 3147}
3148
0da46a6e 3149/* do_getsockopt() Must return target values and target errnos. */
992f48a0 3150static abi_long do_getsockopt(int sockfd, int level, int optname,
2f619698 3151 abi_ulong optval_addr, abi_ulong optlen)
7854b056 3152{
992f48a0 3153 abi_long ret;
b55266b5
BS		 3154 int len, val;
3155 socklen_t lv;
8853f86e
FB		 3156
3157 switch(level) {
3532fa74 3158 case TARGET_SOL_SOCKET:
f3b974cd
JL		 3159 level = SOL_SOCKET;
3160 switch (optname) {
3161 /* These don't just return a single integer */
3162 case TARGET_SO_LINGER:
3163 case TARGET_SO_RCVTIMEO:
3164 case TARGET_SO_SNDTIMEO:
f3b974cd
JL		 3165 case TARGET_SO_PEERNAME:
3166 goto unimplemented;
583359a6
AP		 3167 case TARGET_SO_PEERCRED: {
3168 struct ucred cr;
3169 socklen_t crlen;
3170 struct target_ucred *tcr;
3171
3172 if (get_user_u32(len, optlen)) {
3173 return -TARGET_EFAULT;
3174 }
3175 if (len < 0) {
3176 return -TARGET_EINVAL;
3177 }
3178
3179 crlen = sizeof(cr);
3180 ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED,
3181 &cr, &crlen));
3182 if (ret < 0) {
3183 return ret;
3184 }
3185 if (len > crlen) {
3186 len = crlen;
3187 }
3188 if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) {
3189 return -TARGET_EFAULT;
3190 }
3191 __put_user(cr.pid, &tcr->pid);
3192 __put_user(cr.uid, &tcr->uid);
3193 __put_user(cr.gid, &tcr->gid);
3194 unlock_user_struct(tcr, optval_addr, 1);
3195 if (put_user_u32(len, optlen)) {
3196 return -TARGET_EFAULT;
3197 }
3198 break;
3199 }
f3b974cd
JL		 3200 /* Options with 'int' argument. */
3201 case TARGET_SO_DEBUG:
3202 optname = SO_DEBUG;
3203 goto int_case;
3204 case TARGET_SO_REUSEADDR:
3205 optname = SO_REUSEADDR;
3206 goto int_case;
3207 case TARGET_SO_TYPE:
3208 optname = SO_TYPE;
3209 goto int_case;
3210 case TARGET_SO_ERROR:
3211 optname = SO_ERROR;
3212 goto int_case;
3213 case TARGET_SO_DONTROUTE:
3214 optname = SO_DONTROUTE;
3215 goto int_case;
3216 case TARGET_SO_BROADCAST:
3217 optname = SO_BROADCAST;
3218 goto int_case;
3219 case TARGET_SO_SNDBUF:
3220 optname = SO_SNDBUF;
3221 goto int_case;
3222 case TARGET_SO_RCVBUF:
3223 optname = SO_RCVBUF;
3224 goto int_case;
3225 case TARGET_SO_KEEPALIVE:
3226 optname = SO_KEEPALIVE;
3227 goto int_case;
3228 case TARGET_SO_OOBINLINE:
3229 optname = SO_OOBINLINE;
3230 goto int_case;
3231 case TARGET_SO_NO_CHECK:
3232 optname = SO_NO_CHECK;
3233 goto int_case;
3234 case TARGET_SO_PRIORITY:
3235 optname = SO_PRIORITY;
3236 goto int_case;
3237#ifdef SO_BSDCOMPAT
3238 case TARGET_SO_BSDCOMPAT:
3239 optname = SO_BSDCOMPAT;
3240 goto int_case;
3241#endif
3242 case TARGET_SO_PASSCRED:
3243 optname = SO_PASSCRED;
3244 goto int_case;
3245 case TARGET_SO_TIMESTAMP:
3246 optname = SO_TIMESTAMP;
3247 goto int_case;
3248 case TARGET_SO_RCVLOWAT:
3249 optname = SO_RCVLOWAT;
3250 goto int_case;
aec1ca41
PB		 3251 case TARGET_SO_ACCEPTCONN:
3252 optname = SO_ACCEPTCONN;
3253 goto int_case;
8853f86e 3254 default:
2efbe911
FB		 3255 goto int_case;
3256 }
3257 break;
3258 case SOL_TCP:
3259 /* TCP options all take an 'int' value. */
3260 int_case:
2f619698
FB		 3261 if (get_user_u32(len, optlen))
3262 return -TARGET_EFAULT;
2efbe911 3263 if (len < 0)
0da46a6e 3264 return -TARGET_EINVAL;
73160d95 3265 lv = sizeof(lv);
2efbe911
FB		 3266 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
3267 if (ret < 0)
3268 return ret;
8289d112
PB		 3269 if (optname == SO_TYPE) {
3270 val = host_to_target_sock_type(val);
3271 }
2efbe911
FB		 3272 if (len > lv)
3273 len = lv;
2f619698
FB		 3274 if (len == 4) {
3275 if (put_user_u32(val, optval_addr))
3276 return -TARGET_EFAULT;
3277 } else {
3278 if (put_user_u8(val, optval_addr))
3279 return -TARGET_EFAULT;
f3b974cd 3280 }
2f619698
FB		 3281 if (put_user_u32(len, optlen))
3282 return -TARGET_EFAULT;
2efbe911
FB		 3283 break;
3284 case SOL_IP:
3285 switch(optname) {
3286 case IP_TOS:
3287 case IP_TTL:
3288 case IP_HDRINCL:
3289 case IP_ROUTER_ALERT:
3290 case IP_RECVOPTS:
3291 case IP_RETOPTS:
3292 case IP_PKTINFO:
3293 case IP_MTU_DISCOVER:
3294 case IP_RECVERR:
3295 case IP_RECVTOS:
3296#ifdef IP_FREEBIND
3297 case IP_FREEBIND:
3298#endif
3299 case IP_MULTICAST_TTL:
3300 case IP_MULTICAST_LOOP:
2f619698
FB		 3301 if (get_user_u32(len, optlen))
3302 return -TARGET_EFAULT;
8853f86e 3303 if (len < 0)
0da46a6e 3304 return -TARGET_EINVAL;
73160d95 3305 lv = sizeof(lv);
8853f86e
FB		 3306 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
3307 if (ret < 0)
3308 return ret;
2efbe911 3309 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2efbe911 3310 len = 1;
2f619698
FB		 3311 if (put_user_u32(len, optlen)
3312 || put_user_u8(val, optval_addr))
3313 return -TARGET_EFAULT;
2efbe911 3314 } else {
2efbe911
FB		 3315 if (len > sizeof(int))
3316 len = sizeof(int);
2f619698
FB		 3317 if (put_user_u32(len, optlen)
3318 || put_user_u32(val, optval_addr))
3319 return -TARGET_EFAULT;
2efbe911 3320 }
8853f86e 3321 break;
2efbe911 3322 default:
c02f499e
TS		 3323 ret = -TARGET_ENOPROTOOPT;
3324 break;
8853f86e
FB		 3325 }
3326 break;
3327 default:
3328 unimplemented:
3329 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
3330 level, optname);
c02f499e 3331 ret = -TARGET_EOPNOTSUPP;
8853f86e
FB		 3332 break;
3333 }
3334 return ret;
7854b056
FB		 3335}
3336
f287b2c2 3337static struct iovec *lock_iovec(int type, abi_ulong target_addr,
dab32b32 3338 abi_ulong count, int copy)
53a5960a
PB		 3339{
3340 struct target_iovec *target_vec;
f287b2c2
RH		 3341 struct iovec *vec;
3342 abi_ulong total_len, max_len;
d732dcb4 3343 int i;
501bb4b0 3344 int err = 0;
29560a6c 3345 bool bad_address = false;
53a5960a 3346
f287b2c2
RH		 3347 if (count == 0) {
3348 errno = 0;
3349 return NULL;
3350 }
dab32b32 3351 if (count > IOV_MAX) {
f287b2c2
RH		 3352 errno = EINVAL;
3353 return NULL;
3354 }
3355
0e173b24 3356 vec = g_try_new0(struct iovec, count);
f287b2c2
RH		 3357 if (vec == NULL) {
3358 errno = ENOMEM;
3359 return NULL;
3360 }
3361
3362 target_vec = lock_user(VERIFY_READ, target_addr,
3363 count * sizeof(struct target_iovec), 1);
3364 if (target_vec == NULL) {
501bb4b0 3365 err = EFAULT;
f287b2c2
RH		 3366 goto fail2;
3367 }
3368
3369 /* ??? If host page size > target page size, this will result in a
3370 value larger than what we can actually support. */
3371 max_len = 0x7fffffff & TARGET_PAGE_MASK;
3372 total_len = 0;
3373
3374 for (i = 0; i < count; i++) {
3375 abi_ulong base = tswapal(target_vec[i].iov_base);
3376 abi_long len = tswapal(target_vec[i].iov_len);
3377
3378 if (len < 0) {
501bb4b0 3379 err = EINVAL;
f287b2c2
RH		 3380 goto fail;
3381 } else if (len == 0) {
3382 /* Zero length pointer is ignored. */
3383 vec[i].iov_base = 0;
41df8411 3384 } else {
f287b2c2 3385 vec[i].iov_base = lock_user(type, base, len, copy);
29560a6c
TM		 3386 /* If the first buffer pointer is bad, this is a fault. But
3387 * subsequent bad buffers will result in a partial write; this
3388 * is realized by filling the vector with null pointers and
3389 * zero lengths. */
f287b2c2 3390 if (!vec[i].iov_base) {
29560a6c
TM		 3391 if (i == 0) {
3392 err = EFAULT;
3393 goto fail;
3394 } else {
3395 bad_address = true;
3396 }
3397 }
3398 if (bad_address) {
3399 len = 0;
f287b2c2
RH		 3400 }
3401 if (len > max_len - total_len) {
3402 len = max_len - total_len;
3403 }
41df8411 3404 }
f287b2c2
RH		 3405 vec[i].iov_len = len;
3406 total_len += len;
579a97f7 3407 }
f287b2c2
RH		 3408
3409 unlock_user(target_vec, target_addr, 0);
3410 return vec;
3411
3412 fail:
7eff518b
CG		 3413 while (--i >= 0) {
3414 if (tswapal(target_vec[i].iov_len) > 0) {
3415 unlock_user(vec[i].iov_base, tswapal(target_vec[i].iov_base), 0);
3416 }
3417 }
f287b2c2 3418 unlock_user(target_vec, target_addr, 0);
501bb4b0 3419 fail2:
0e173b24 3420 g_free(vec);
501bb4b0 3421 errno = err;
f287b2c2 3422 return NULL;
53a5960a
PB		 3423}
3424
f287b2c2 3425static void unlock_iovec(struct iovec *vec, abi_ulong target_addr,
dab32b32 3426 abi_ulong count, int copy)
53a5960a
PB		 3427{
3428 struct target_iovec *target_vec;
53a5960a
PB		 3429 int i;
3430
f287b2c2
RH		 3431 target_vec = lock_user(VERIFY_READ, target_addr,
3432 count * sizeof(struct target_iovec), 1);
3433 if (target_vec) {
3434 for (i = 0; i < count; i++) {
3435 abi_ulong base = tswapal(target_vec[i].iov_base);
71ec7cef 3436 abi_long len = tswapal(target_vec[i].iov_len);
f287b2c2
RH		 3437 if (len < 0) {
3438 break;
3439 }
d732dcb4
AZ		 3440 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
3441 }
f287b2c2 3442 unlock_user(target_vec, target_addr, 0);
53a5960a 3443 }
579a97f7 3444
0e173b24 3445 g_free(vec);
53a5960a
PB		 3446}
3447
53d09b76 3448static inline int target_to_host_sock_type(int *type)
3532fa74 3449{
f651e6ae
PJ		 3450 int host_type = 0;
3451 int target_type = *type;
3452
3453 switch (target_type & TARGET_SOCK_TYPE_MASK) {
3532fa74 3454 case TARGET_SOCK_DGRAM:
f651e6ae 3455 host_type = SOCK_DGRAM;
3532fa74
FB		 3456 break;
3457 case TARGET_SOCK_STREAM:
f651e6ae 3458 host_type = SOCK_STREAM;
3532fa74 3459 break;
f651e6ae
PJ		 3460 default:
3461 host_type = target_type & TARGET_SOCK_TYPE_MASK;
3532fa74
FB		 3462 break;
3463 }
f651e6ae 3464 if (target_type & TARGET_SOCK_CLOEXEC) {
53d09b76 3465#if defined(SOCK_CLOEXEC)
f651e6ae 3466 host_type |= SOCK_CLOEXEC;
53d09b76
EI		 3467#else
3468 return -TARGET_EINVAL;
3469#endif
f651e6ae
PJ		 3470 }
3471 if (target_type & TARGET_SOCK_NONBLOCK) {
53d09b76 3472#if defined(SOCK_NONBLOCK)
f651e6ae 3473 host_type |= SOCK_NONBLOCK;
53d09b76
EI		 3474#elif !defined(O_NONBLOCK)
3475 return -TARGET_EINVAL;
3476#endif
f651e6ae
PJ		 3477 }
3478 *type = host_type;
53d09b76
EI		 3479 return 0;
3480}
3481
3482/* Try to emulate socket type flags after socket creation. */
3483static int sock_flags_fixup(int fd, int target_type)
3484{
3485#if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3486 if (target_type & TARGET_SOCK_NONBLOCK) {
3487 int flags = fcntl(fd, F_GETFL);
3488 if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) {
3489 close(fd);
3490 return -TARGET_EINVAL;
3491 }
3492 }
3493#endif
3494 return fd;
f651e6ae
PJ		 3495}
3496
0cf22722
LV		 3497static abi_long packet_target_to_host_sockaddr(void *host_addr,
3498 abi_ulong target_addr,
3499 socklen_t len)
3500{
3501 struct sockaddr *addr = host_addr;
3502 struct target_sockaddr *target_saddr;
3503
3504 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
3505 if (!target_saddr) {
3506 return -TARGET_EFAULT;
3507 }
3508
3509 memcpy(addr, target_saddr, len);
3510 addr->sa_family = tswap16(target_saddr->sa_family);
3511 /* spkt_protocol is big-endian */
3512
3513 unlock_user(target_saddr, target_addr, 0);
3514 return 0;
3515}
3516
3517static TargetFdTrans target_packet_trans = {
3518 .target_to_host_addr = packet_target_to_host_sockaddr,
3519};
3520
575b22b1 3521#ifdef CONFIG_RTNETLINK
6c5b5645
LV		 3522static abi_long netlink_route_target_to_host(void *buf, size_t len)
3523{
ef759f6f
LV		 3524 abi_long ret;
3525
3526 ret = target_to_host_nlmsg_route(buf, len);
3527 if (ret < 0) {
3528 return ret;
3529 }
3530
3531 return len;
6c5b5645
LV		 3532}
3533
3534static abi_long netlink_route_host_to_target(void *buf, size_t len)
3535{
ef759f6f
LV		 3536 abi_long ret;
3537
3538 ret = host_to_target_nlmsg_route(buf, len);
3539 if (ret < 0) {
3540 return ret;
3541 }
3542
3543 return len;
6c5b5645
LV		 3544}
3545
3546static TargetFdTrans target_netlink_route_trans = {
3547 .target_to_host_data = netlink_route_target_to_host,
3548 .host_to_target_data = netlink_route_host_to_target,
3549};
575b22b1 3550#endif /* CONFIG_RTNETLINK */
6c5b5645 3551
5ce9bb59
LV		 3552static abi_long netlink_audit_target_to_host(void *buf, size_t len)
3553{
ef759f6f
LV		 3554 abi_long ret;
3555
3556 ret = target_to_host_nlmsg_audit(buf, len);
3557 if (ret < 0) {
3558 return ret;
3559 }
3560
3561 return len;
5ce9bb59
LV		 3562}
3563
3564static abi_long netlink_audit_host_to_target(void *buf, size_t len)
3565{
ef759f6f
LV		 3566 abi_long ret;
3567
3568 ret = host_to_target_nlmsg_audit(buf, len);
3569 if (ret < 0) {
3570 return ret;
3571 }
3572
3573 return len;
5ce9bb59
LV		 3574}
3575
3576static TargetFdTrans target_netlink_audit_trans = {
3577 .target_to_host_data = netlink_audit_target_to_host,
3578 .host_to_target_data = netlink_audit_host_to_target,
3579};
3580
f651e6ae
PJ		 3581/* do_socket() Must return target values and target errnos. */
3582static abi_long do_socket(int domain, int type, int protocol)
3583{
53d09b76
EI		 3584 int target_type = type;
3585 int ret;
3586
3587 ret = target_to_host_sock_type(&type);
3588 if (ret) {
3589 return ret;
3590 }
f651e6ae 3591
575b22b1
LV		 3592 if (domain == PF_NETLINK && !(
3593#ifdef CONFIG_RTNETLINK
3594 protocol == NETLINK_ROUTE ||
3595#endif
3596 protocol == NETLINK_KOBJECT_UEVENT ||
3597 protocol == NETLINK_AUDIT)) {
6c5b5645
LV		 3598 return -EPFNOSUPPORT;
3599 }
ff626f2d
LV		 3600
3601 if (domain == AF_PACKET ||
3602 (domain == AF_INET && type == SOCK_PACKET)) {
3603 protocol = tswap16(protocol);
3604 }
3605
53d09b76
EI		 3606 ret = get_errno(socket(domain, type, protocol));
3607 if (ret >= 0) {
3608 ret = sock_flags_fixup(ret, target_type);
0cf22722
LV		 3609 if (type == SOCK_PACKET) {
3610 /* Manage an obsolete case :
3611 * if socket type is SOCK_PACKET, bind by name
3612 */
3613 fd_trans_register(ret, &target_packet_trans);
6c5b5645
LV		 3614 } else if (domain == PF_NETLINK) {
3615 switch (protocol) {
575b22b1 3616#ifdef CONFIG_RTNETLINK
6c5b5645
LV		 3617 case NETLINK_ROUTE:
3618 fd_trans_register(ret, &target_netlink_route_trans);
3619 break;
575b22b1 3620#endif
b265620b
LV		 3621 case NETLINK_KOBJECT_UEVENT:
3622 /* nothing to do: messages are strings */
3623 break;
5ce9bb59
LV		 3624 case NETLINK_AUDIT:
3625 fd_trans_register(ret, &target_netlink_audit_trans);
3626 break;
6c5b5645
LV		 3627 default:
3628 g_assert_not_reached();
3629 }
0cf22722 3630 }
53d09b76
EI		 3631 }
3632 return ret;
3532fa74
FB		 3633}
3634
0da46a6e 3635/* do_bind() Must return target values and target errnos. */
992f48a0
BS		 3636static abi_long do_bind(int sockfd, abi_ulong target_addr,
3637 socklen_t addrlen)
3532fa74 3638{
8f7aeaf6 3639 void *addr;
917507b0 3640 abi_long ret;
8f7aeaf6 3641
38724253 3642 if ((int)addrlen < 0) {
8f7aeaf6 3643 return -TARGET_EINVAL;
38724253 3644 }
8f7aeaf6 3645
607175e0 3646 addr = alloca(addrlen+1);
3b46e624 3647
7b36f782 3648 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
917507b0
AP		 3649 if (ret)
3650 return ret;
3651
3532fa74
FB		 3652 return get_errno(bind(sockfd, addr, addrlen));
3653}
3654
0da46a6e 3655/* do_connect() Must return target values and target errnos. */
992f48a0
BS		 3656static abi_long do_connect(int sockfd, abi_ulong target_addr,
3657 socklen_t addrlen)
3532fa74 3658{
8f7aeaf6 3659 void *addr;
917507b0 3660 abi_long ret;
8f7aeaf6 3661
38724253 3662 if ((int)addrlen < 0) {
8f7aeaf6 3663 return -TARGET_EINVAL;
38724253 3664 }
8f7aeaf6 3665
2dd08dfd 3666 addr = alloca(addrlen+1);
3b46e624 3667
7b36f782 3668 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
917507b0
AP		 3669 if (ret)
3670 return ret;
3671
2a3c7619 3672 return get_errno(safe_connect(sockfd, addr, addrlen));
3532fa74
FB		 3673}
3674
f19e00d7
AG		 3675/* do_sendrecvmsg_locked() Must return target values and target errnos. */
3676static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp,
3677 int flags, int send)
3532fa74 3678{
6de645c7 3679 abi_long ret, len;
3532fa74 3680 struct msghdr msg;
dab32b32 3681 abi_ulong count;
3532fa74 3682 struct iovec *vec;
992f48a0 3683 abi_ulong target_vec;
3532fa74 3684
3532fa74
FB		 3685 if (msgp->msg_name) {
3686 msg.msg_namelen = tswap32(msgp->msg_namelen);
2dd08dfd 3687 msg.msg_name = alloca(msg.msg_namelen+1);
7b36f782
LV		 3688 ret = target_to_host_sockaddr(fd, msg.msg_name,
3689 tswapal(msgp->msg_name),
3690 msg.msg_namelen);
26a6fc96
PM		 3691 if (ret == -TARGET_EFAULT) {
3692 /* For connected sockets msg_name and msg_namelen must
3693 * be ignored, so returning EFAULT immediately is wrong.
3694 * Instead, pass a bad msg_name to the host kernel, and
3695 * let it decide whether to return EFAULT or not.
3696 */
3697 msg.msg_name = (void *)-1;
3698 } else if (ret) {
f287b2c2 3699 goto out2;
917507b0 3700 }
3532fa74
FB		 3701 } else {
3702 msg.msg_name = NULL;
3703 msg.msg_namelen = 0;
3704 }
cbb21eed 3705 msg.msg_controllen = 2 * tswapal(msgp->msg_controllen);
3532fa74
FB		 3706 msg.msg_control = alloca(msg.msg_controllen);
3707 msg.msg_flags = tswap32(msgp->msg_flags);
3b46e624 3708
cbb21eed 3709 count = tswapal(msgp->msg_iovlen);
cbb21eed 3710 target_vec = tswapal(msgp->msg_iov);
97b07970
PM		 3711
3712 if (count > IOV_MAX) {
3713 /* sendrcvmsg returns a different errno for this condition than
3714 * readv/writev, so we must catch it here before lock_iovec() does.
3715 */
3716 ret = -TARGET_EMSGSIZE;
3717 goto out2;
3718 }
3719
f287b2c2
RH		 3720 vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,
3721 target_vec, count, send);
3722 if (vec == NULL) {
3723 ret = -host_to_target_errno(errno);
3724 goto out2;
3725 }
3532fa74
FB		 3726 msg.msg_iovlen = count;
3727 msg.msg_iov = vec;
3b46e624 3728
3532fa74 3729 if (send) {
6c5b5645 3730 if (fd_trans_target_to_host_data(fd)) {
7d61d892
LV		 3731 void *host_msg;
3732
3733 host_msg = g_malloc(msg.msg_iov->iov_len);
3734 memcpy(host_msg, msg.msg_iov->iov_base, msg.msg_iov->iov_len);
3735 ret = fd_trans_target_to_host_data(fd)(host_msg,
6c5b5645 3736 msg.msg_iov->iov_len);
7d61d892
LV		 3737 if (ret >= 0) {
3738 msg.msg_iov->iov_base = host_msg;
3739 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3740 }
3741 g_free(host_msg);
6c5b5645
LV		 3742 } else {
3743 ret = target_to_host_cmsg(&msg, msgp);
7d61d892
LV		 3744 if (ret == 0) {
3745 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3746 }
6c5b5645 3747 }
3532fa74 3748 } else {
66687530 3749 ret = get_errno(safe_recvmsg(fd, &msg, flags));
6de645c7
AZ		 3750 if (!is_error(ret)) {
3751 len = ret;
6c5b5645
LV		 3752 if (fd_trans_host_to_target_data(fd)) {
3753 ret = fd_trans_host_to_target_data(fd)(msg.msg_iov->iov_base,
48dc0f2c 3754 len);
6c5b5645
LV		 3755 } else {
3756 ret = host_to_target_cmsg(msgp, &msg);
3757 }
ca619067
JH		 3758 if (!is_error(ret)) {
3759 msgp->msg_namelen = tswap32(msg.msg_namelen);
26a6fc96 3760 if (msg.msg_name != NULL && msg.msg_name != (void *)-1) {
ca619067
JH		 3761 ret = host_to_target_sockaddr(tswapal(msgp->msg_name),
3762 msg.msg_name, msg.msg_namelen);
3763 if (ret) {
3764 goto out;
3765 }
3766 }
3767
6de645c7 3768 ret = len;
ca619067 3769 }
6de645c7 3770 }
3532fa74 3771 }
ca619067
JH		 3772
3773out:
3532fa74 3774 unlock_iovec(vec, target_vec, count, !send);
f287b2c2 3775out2:
f19e00d7
AG		 3776 return ret;
3777}
3778
3779static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
3780 int flags, int send)
3781{
3782 abi_long ret;
3783 struct target_msghdr *msgp;
3784
3785 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
3786 msgp,
3787 target_msg,
3788 send ? 1 : 0)) {
3789 return -TARGET_EFAULT;
3790 }
3791 ret = do_sendrecvmsg_locked(fd, msgp, flags, send);
579a97f7 3792 unlock_user_struct(msgp, target_msg, send ? 0 : 1);
3532fa74
FB		 3793 return ret;
3794}
3795
f19e00d7
AG		 3796/* We don't rely on the C library to have sendmmsg/recvmmsg support,
3797 * so it might not have this *mmsg-specific flag either.
3798 */
3799#ifndef MSG_WAITFORONE
3800#define MSG_WAITFORONE 0x10000
3801#endif
3802
3803static abi_long do_sendrecvmmsg(int fd, abi_ulong target_msgvec,
3804 unsigned int vlen, unsigned int flags,
3805 int send)
3806{
3807 struct target_mmsghdr *mmsgp;
3808 abi_long ret = 0;
3809 int i;
3810
3811 if (vlen > UIO_MAXIOV) {
3812 vlen = UIO_MAXIOV;
3813 }
3814
3815 mmsgp = lock_user(VERIFY_WRITE, target_msgvec, sizeof(*mmsgp) * vlen, 1);
3816 if (!mmsgp) {
3817 return -TARGET_EFAULT;
3818 }
3819
3820 for (i = 0; i < vlen; i++) {
3821 ret = do_sendrecvmsg_locked(fd, &mmsgp[i].msg_hdr, flags, send);
3822 if (is_error(ret)) {
3823 break;
3824 }
3825 mmsgp[i].msg_len = tswap32(ret);
3826 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3827 if (flags & MSG_WAITFORONE) {
3828 flags |= MSG_DONTWAIT;
3829 }
3830 }
3831
3832 unlock_user(mmsgp, target_msgvec, sizeof(*mmsgp) * i);
3833
3834 /* Return number of datagrams sent if we sent any at all;
3835 * otherwise return the error.
3836 */
3837 if (i) {
3838 return i;
3839 }
3840 return ret;
3841}
f19e00d7 3842
a94b4987
PM		 3843/* do_accept4() Must return target values and target errnos. */
3844static abi_long do_accept4(int fd, abi_ulong target_addr,
3845 abi_ulong target_addrlen_addr, int flags)
1be9e1dc 3846{
2f619698
FB		 3847 socklen_t addrlen;
3848 void *addr;
992f48a0 3849 abi_long ret;
d25295d4
PJ		 3850 int host_flags;
3851
3852 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
1be9e1dc 3853
a94b4987 3854 if (target_addr == 0) {
ff6dc130 3855 return get_errno(safe_accept4(fd, NULL, NULL, host_flags));
a94b4987 3856 }
917507b0
AP		 3857
3858 /* linux returns EINVAL if addrlen pointer is invalid */
2f619698 3859 if (get_user_u32(addrlen, target_addrlen_addr))
917507b0 3860 return -TARGET_EINVAL;
2f619698 3861
38724253 3862 if ((int)addrlen < 0) {
8f7aeaf6 3863 return -TARGET_EINVAL;
38724253 3864 }
8f7aeaf6 3865
917507b0
AP		 3866 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3867 return -TARGET_EINVAL;
3868
2f619698
FB		 3869 addr = alloca(addrlen);
3870
ff6dc130 3871 ret = get_errno(safe_accept4(fd, addr, &addrlen, host_flags));
1be9e1dc
PB		 3872 if (!is_error(ret)) {
3873 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3874 if (put_user_u32(addrlen, target_addrlen_addr))
3875 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3876 }
3877 return ret;
3878}
3879
0da46a6e 3880/* do_getpeername() Must return target values and target errnos. */
992f48a0 3881static abi_long do_getpeername(int fd, abi_ulong target_addr,
2f619698 3882 abi_ulong target_addrlen_addr)
1be9e1dc 3883{
2f619698
FB		 3884 socklen_t addrlen;
3885 void *addr;
992f48a0 3886 abi_long ret;
1be9e1dc 3887
2f619698
FB		 3888 if (get_user_u32(addrlen, target_addrlen_addr))
3889 return -TARGET_EFAULT;
3890
38724253 3891 if ((int)addrlen < 0) {
8f7aeaf6 3892 return -TARGET_EINVAL;
38724253 3893 }
8f7aeaf6 3894
917507b0
AP		 3895 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3896 return -TARGET_EFAULT;
3897
2f619698
FB		 3898 addr = alloca(addrlen);
3899
1be9e1dc
PB		 3900 ret = get_errno(getpeername(fd, addr, &addrlen));
3901 if (!is_error(ret)) {
3902 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3903 if (put_user_u32(addrlen, target_addrlen_addr))
3904 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3905 }
3906 return ret;
3907}
3908
0da46a6e 3909/* do_getsockname() Must return target values and target errnos. */
992f48a0 3910static abi_long do_getsockname(int fd, abi_ulong target_addr,
2f619698 3911 abi_ulong target_addrlen_addr)
1be9e1dc 3912{
2f619698
FB		 3913 socklen_t addrlen;
3914 void *addr;
992f48a0 3915 abi_long ret;
1be9e1dc 3916
2f619698
FB		 3917 if (get_user_u32(addrlen, target_addrlen_addr))
3918 return -TARGET_EFAULT;
3919
38724253 3920 if ((int)addrlen < 0) {
8f7aeaf6 3921 return -TARGET_EINVAL;
38724253 3922 }
8f7aeaf6 3923
917507b0
AP		 3924 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3925 return -TARGET_EFAULT;
3926
2f619698
FB		 3927 addr = alloca(addrlen);
3928
1be9e1dc
PB		 3929 ret = get_errno(getsockname(fd, addr, &addrlen));
3930 if (!is_error(ret)) {
3931 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3932 if (put_user_u32(addrlen, target_addrlen_addr))
3933 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3934 }
3935 return ret;
3936}
3937
0da46a6e 3938/* do_socketpair() Must return target values and target errnos. */
992f48a0 3939static abi_long do_socketpair(int domain, int type, int protocol,
2f619698 3940 abi_ulong target_tab_addr)
1be9e1dc
PB		 3941{
3942 int tab[2];
992f48a0 3943 abi_long ret;
1be9e1dc 3944
f651e6ae
PJ		 3945 target_to_host_sock_type(&type);
3946
1be9e1dc
PB		 3947 ret = get_errno(socketpair(domain, type, protocol, tab));
3948 if (!is_error(ret)) {
2f619698
FB		 3949 if (put_user_s32(tab[0], target_tab_addr)
3950 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
3951 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3952 }
3953 return ret;
3954}
3955
0da46a6e 3956/* do_sendto() Must return target values and target errnos. */
992f48a0
BS		 3957static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
3958 abi_ulong target_addr, socklen_t addrlen)
1be9e1dc
PB		 3959{
3960 void *addr;
3961 void *host_msg;
7d61d892 3962 void *copy_msg = NULL;
992f48a0 3963 abi_long ret;
1be9e1dc 3964
38724253 3965 if ((int)addrlen < 0) {
8f7aeaf6 3966 return -TARGET_EINVAL;
38724253 3967 }
8f7aeaf6 3968
579a97f7
FB		 3969 host_msg = lock_user(VERIFY_READ, msg, len, 1);
3970 if (!host_msg)
3971 return -TARGET_EFAULT;
6c5b5645 3972 if (fd_trans_target_to_host_data(fd)) {
7d61d892
LV		 3973 copy_msg = host_msg;
3974 host_msg = g_malloc(len);
3975 memcpy(host_msg, copy_msg, len);
6c5b5645
LV		 3976 ret = fd_trans_target_to_host_data(fd)(host_msg, len);
3977 if (ret < 0) {
7d61d892 3978 goto fail;
6c5b5645
LV		 3979 }
3980 }
1be9e1dc 3981 if (target_addr) {
2dd08dfd 3982 addr = alloca(addrlen+1);
7b36f782 3983 ret = target_to_host_sockaddr(fd, addr, target_addr, addrlen);
917507b0 3984 if (ret) {
7d61d892 3985 goto fail;
917507b0 3986 }
66687530 3987 ret = get_errno(safe_sendto(fd, host_msg, len, flags, addr, addrlen));
1be9e1dc 3988 } else {
66687530 3989 ret = get_errno(safe_sendto(fd, host_msg, len, flags, NULL, 0));
1be9e1dc 3990 }
7d61d892
LV		 3991fail:
3992 if (copy_msg) {
3993 g_free(host_msg);
3994 host_msg = copy_msg;
3995 }
1be9e1dc
PB		 3996 unlock_user(host_msg, msg, 0);
3997 return ret;
3998}
3999
0da46a6e 4000/* do_recvfrom() Must return target values and target errnos. */
992f48a0
BS		 4001static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
4002 abi_ulong target_addr,
4003 abi_ulong target_addrlen)
1be9e1dc
PB		 4004{
4005 socklen_t addrlen;
4006 void *addr;
4007 void *host_msg;
992f48a0 4008 abi_long ret;
1be9e1dc 4009
579a97f7
FB		 4010 host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
4011 if (!host_msg)
4012 return -TARGET_EFAULT;
1be9e1dc 4013 if (target_addr) {
2f619698
FB		 4014 if (get_user_u32(addrlen, target_addrlen)) {
4015 ret = -TARGET_EFAULT;
4016 goto fail;
4017 }
38724253 4018 if ((int)addrlen < 0) {
8f7aeaf6
AJ		 4019 ret = -TARGET_EINVAL;
4020 goto fail;
4021 }
1be9e1dc 4022 addr = alloca(addrlen);
66687530
PM		 4023 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags,
4024 addr, &addrlen));
1be9e1dc
PB		 4025 } else {
4026 addr = NULL; /* To keep compiler quiet. */
66687530 4027 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, NULL, 0));
1be9e1dc
PB		 4028 }
4029 if (!is_error(ret)) {
c35e1f9c
LV		 4030 if (fd_trans_host_to_target_data(fd)) {
4031 ret = fd_trans_host_to_target_data(fd)(host_msg, ret);
4032 }
1be9e1dc
PB		 4033 if (target_addr) {
4034 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 4035 if (put_user_u32(addrlen, target_addrlen)) {
4036 ret = -TARGET_EFAULT;
4037 goto fail;
4038 }
1be9e1dc
PB		 4039 }
4040 unlock_user(host_msg, msg, len);
4041 } else {
2f619698 4042fail:
1be9e1dc
PB		 4043 unlock_user(host_msg, msg, 0);
4044 }
4045 return ret;
4046}
4047
32407103 4048#ifdef TARGET_NR_socketcall
ff71a454 4049/* do_socketcall() must return target values and target errnos. */
992f48a0 4050static abi_long do_socketcall(int num, abi_ulong vptr)
31e31b8a 4051{
ff71a454
AM		 4052 static const unsigned nargs[] = { /* number of arguments per operation */
4053 [TARGET_SYS_SOCKET] = 3, /* domain, type, protocol */
4054 [TARGET_SYS_BIND] = 3, /* fd, addr, addrlen */
4055 [TARGET_SYS_CONNECT] = 3, /* fd, addr, addrlen */
4056 [TARGET_SYS_LISTEN] = 2, /* fd, backlog */
4057 [TARGET_SYS_ACCEPT] = 3, /* fd, addr, addrlen */
4058 [TARGET_SYS_GETSOCKNAME] = 3, /* fd, addr, addrlen */
4059 [TARGET_SYS_GETPEERNAME] = 3, /* fd, addr, addrlen */
4060 [TARGET_SYS_SOCKETPAIR] = 4, /* domain, type, protocol, tab */
4061 [TARGET_SYS_SEND] = 4, /* fd, msg, len, flags */
4062 [TARGET_SYS_RECV] = 4, /* fd, msg, len, flags */
4063 [TARGET_SYS_SENDTO] = 6, /* fd, msg, len, flags, addr, addrlen */
4064 [TARGET_SYS_RECVFROM] = 6, /* fd, msg, len, flags, addr, addrlen */
4065 [TARGET_SYS_SHUTDOWN] = 2, /* fd, how */
4066 [TARGET_SYS_SETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
4067 [TARGET_SYS_GETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
4068 [TARGET_SYS_SENDMSG] = 3, /* fd, msg, flags */
4069 [TARGET_SYS_RECVMSG] = 3, /* fd, msg, flags */
4070 [TARGET_SYS_ACCEPT4] = 4, /* fd, addr, addrlen, flags */
4071 [TARGET_SYS_RECVMMSG] = 4, /* fd, msgvec, vlen, flags */
4072 [TARGET_SYS_SENDMMSG] = 4, /* fd, msgvec, vlen, flags */
62dc90c6
MT		 4073 };
4074 abi_long a[6]; /* max 6 args */
ff71a454 4075 unsigned i;
62dc90c6 4076
ff71a454
AM		 4077 /* check the range of the first argument num */
4078 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
4079 if (num < 1 || num > TARGET_SYS_SENDMMSG) {
4080 return -TARGET_EINVAL;
4081 }
4082 /* ensure we have space for args */
4083 if (nargs[num] > ARRAY_SIZE(a)) {
4084 return -TARGET_EINVAL;
4085 }
4086 /* collect the arguments in a[] according to nargs[] */
4087 for (i = 0; i < nargs[num]; ++i) {
4088 if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
4089 return -TARGET_EFAULT;
31e31b8a 4090 }
62dc90c6 4091 }
ff71a454 4092 /* now when we have the args, invoke the appropriate underlying function */
62dc90c6 4093 switch (num) {
ff71a454 4094 case TARGET_SYS_SOCKET: /* domain, type, protocol */
62dc90c6 4095 return do_socket(a[0], a[1], a[2]);
ff71a454 4096 case TARGET_SYS_BIND: /* sockfd, addr, addrlen */
62dc90c6 4097 return do_bind(a[0], a[1], a[2]);
ff71a454 4098 case TARGET_SYS_CONNECT: /* sockfd, addr, addrlen */
62dc90c6 4099 return do_connect(a[0], a[1], a[2]);
ff71a454 4100 case TARGET_SYS_LISTEN: /* sockfd, backlog */
62dc90c6 4101 return get_errno(listen(a[0], a[1]));
ff71a454 4102 case TARGET_SYS_ACCEPT: /* sockfd, addr, addrlen */
62dc90c6 4103 return do_accept4(a[0], a[1], a[2], 0);
ff71a454 4104 case TARGET_SYS_GETSOCKNAME: /* sockfd, addr, addrlen */
62dc90c6 4105 return do_getsockname(a[0], a[1], a[2]);
ff71a454 4106 case TARGET_SYS_GETPEERNAME: /* sockfd, addr, addrlen */
62dc90c6 4107 return do_getpeername(a[0], a[1], a[2]);
ff71a454 4108 case TARGET_SYS_SOCKETPAIR: /* domain, type, protocol, tab */
62dc90c6 4109 return do_socketpair(a[0], a[1], a[2], a[3]);
ff71a454 4110 case TARGET_SYS_SEND: /* sockfd, msg, len, flags */
62dc90c6 4111 return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
ff71a454 4112 case TARGET_SYS_RECV: /* sockfd, msg, len, flags */
62dc90c6 4113 return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
ff71a454 4114 case TARGET_SYS_SENDTO: /* sockfd, msg, len, flags, addr, addrlen */
62dc90c6 4115 return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
ff71a454 4116 case TARGET_SYS_RECVFROM: /* sockfd, msg, len, flags, addr, addrlen */
62dc90c6 4117 return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
ff71a454 4118 case TARGET_SYS_SHUTDOWN: /* sockfd, how */
62dc90c6 4119 return get_errno(shutdown(a[0], a[1]));
ff71a454
AM		 4120 case TARGET_SYS_SETSOCKOPT: /* sockfd, level, optname, optval, optlen */
4121 return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
4122 case TARGET_SYS_GETSOCKOPT: /* sockfd, level, optname, optval, optlen */
4123 return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
4124 case TARGET_SYS_SENDMSG: /* sockfd, msg, flags */
62dc90c6 4125 return do_sendrecvmsg(a[0], a[1], a[2], 1);
ff71a454 4126 case TARGET_SYS_RECVMSG: /* sockfd, msg, flags */
62dc90c6 4127 return do_sendrecvmsg(a[0], a[1], a[2], 0);
ff71a454
AM		 4128 case TARGET_SYS_ACCEPT4: /* sockfd, addr, addrlen, flags */
4129 return do_accept4(a[0], a[1], a[2], a[3]);
4130 case TARGET_SYS_RECVMMSG: /* sockfd, msgvec, vlen, flags */
5a53dc50 4131 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
ff71a454
AM		 4132 case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */
4133 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
31e31b8a
FB		 4134 default:
4135 gemu_log("Unsupported socketcall: %d\n", num);
ff71a454 4136 return -TARGET_EINVAL;
31e31b8a 4137 }
31e31b8a 4138}
32407103 4139#endif
31e31b8a 4140
8853f86e
FB		 4141#define N_SHM_REGIONS 32
4142
4143static struct shm_region {
b6e17875
PM		 4144 abi_ulong start;
4145 abi_ulong size;
4146 bool in_use;
8853f86e
FB		 4147} shm_regions[N_SHM_REGIONS];
4148
005eb2ae
PM		 4149#ifndef TARGET_SEMID64_DS
4150/* asm-generic version of this struct */
4151struct target_semid64_ds
3eb6b044
TS		 4152{
4153 struct target_ipc_perm sem_perm;
992f48a0 4154 abi_ulong sem_otime;
005eb2ae 4155#if TARGET_ABI_BITS == 32
992f48a0 4156 abi_ulong __unused1;
03527344 4157#endif
992f48a0 4158 abi_ulong sem_ctime;
005eb2ae 4159#if TARGET_ABI_BITS == 32
992f48a0 4160 abi_ulong __unused2;
03527344 4161#endif
992f48a0
BS		 4162 abi_ulong sem_nsems;
4163 abi_ulong __unused3;
4164 abi_ulong __unused4;
3eb6b044 4165};
005eb2ae 4166#endif
3eb6b044 4167
579a97f7
FB		 4168static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
4169 abi_ulong target_addr)
3eb6b044
TS		 4170{
4171 struct target_ipc_perm *target_ip;
005eb2ae 4172 struct target_semid64_ds *target_sd;
3eb6b044 4173
579a97f7
FB		 4174 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4175 return -TARGET_EFAULT;
e8bbe36c 4176 target_ip = &(target_sd->sem_perm);
55a2b163
PJ		 4177 host_ip->__key = tswap32(target_ip->__key);
4178 host_ip->uid = tswap32(target_ip->uid);
4179 host_ip->gid = tswap32(target_ip->gid);
4180 host_ip->cuid = tswap32(target_ip->cuid);
4181 host_ip->cgid = tswap32(target_ip->cgid);
4182#if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4183 host_ip->mode = tswap32(target_ip->mode);
4184#else
cbb21eed 4185 host_ip->mode = tswap16(target_ip->mode);
55a2b163
PJ		 4186#endif
4187#if defined(TARGET_PPC)
4188 host_ip->__seq = tswap32(target_ip->__seq);
4189#else
4190 host_ip->__seq = tswap16(target_ip->__seq);
4191#endif
3eb6b044 4192 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 4193 return 0;
3eb6b044
TS		 4194}
4195
579a97f7
FB		 4196static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
4197 struct ipc_perm *host_ip)
3eb6b044
TS		 4198{
4199 struct target_ipc_perm *target_ip;
005eb2ae 4200 struct target_semid64_ds *target_sd;
3eb6b044 4201
579a97f7
FB		 4202 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4203 return -TARGET_EFAULT;
3eb6b044 4204 target_ip = &(target_sd->sem_perm);
55a2b163
PJ		 4205 target_ip->__key = tswap32(host_ip->__key);
4206 target_ip->uid = tswap32(host_ip->uid);
4207 target_ip->gid = tswap32(host_ip->gid);
4208 target_ip->cuid = tswap32(host_ip->cuid);
4209 target_ip->cgid = tswap32(host_ip->cgid);
4210#if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4211 target_ip->mode = tswap32(host_ip->mode);
4212#else
cbb21eed 4213 target_ip->mode = tswap16(host_ip->mode);
55a2b163
PJ		 4214#endif
4215#if defined(TARGET_PPC)
4216 target_ip->__seq = tswap32(host_ip->__seq);
4217#else
4218 target_ip->__seq = tswap16(host_ip->__seq);
4219#endif
3eb6b044 4220 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 4221 return 0;
3eb6b044
TS		 4222}
4223
579a97f7
FB		 4224static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
4225 abi_ulong target_addr)
3eb6b044 4226{
005eb2ae 4227 struct target_semid64_ds *target_sd;
3eb6b044 4228
579a97f7
FB		 4229 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4230 return -TARGET_EFAULT;
e5289087
AJ		 4231 if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr))
4232 return -TARGET_EFAULT;
cbb21eed
MB		 4233 host_sd->sem_nsems = tswapal(target_sd->sem_nsems);
4234 host_sd->sem_otime = tswapal(target_sd->sem_otime);
4235 host_sd->sem_ctime = tswapal(target_sd->sem_ctime);
3eb6b044 4236 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 4237 return 0;
3eb6b044
TS		 4238}
4239
579a97f7
FB		 4240static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
4241 struct semid_ds *host_sd)
3eb6b044 4242{
005eb2ae 4243 struct target_semid64_ds *target_sd;
3eb6b044 4244
579a97f7
FB		 4245 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4246 return -TARGET_EFAULT;
e5289087 4247 if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)))
3a93113a 4248 return -TARGET_EFAULT;
cbb21eed
MB		 4249 target_sd->sem_nsems = tswapal(host_sd->sem_nsems);
4250 target_sd->sem_otime = tswapal(host_sd->sem_otime);
4251 target_sd->sem_ctime = tswapal(host_sd->sem_ctime);
3eb6b044 4252 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 4253 return 0;
3eb6b044
TS		 4254}
4255
e5289087
AJ		 4256struct target_seminfo {
4257 int semmap;
4258 int semmni;
4259 int semmns;
4260 int semmnu;
4261 int semmsl;
4262 int semopm;
4263 int semume;
4264 int semusz;
4265 int semvmx;
4266 int semaem;
4267};
4268
4269static inline abi_long host_to_target_seminfo(abi_ulong target_addr,
4270 struct seminfo *host_seminfo)
4271{
4272 struct target_seminfo *target_seminfo;
4273 if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0))
4274 return -TARGET_EFAULT;
4275 __put_user(host_seminfo->semmap, &target_seminfo->semmap);
4276 __put_user(host_seminfo->semmni, &target_seminfo->semmni);
4277 __put_user(host_seminfo->semmns, &target_seminfo->semmns);
4278 __put_user(host_seminfo->semmnu, &target_seminfo->semmnu);
4279 __put_user(host_seminfo->semmsl, &target_seminfo->semmsl);
4280 __put_user(host_seminfo->semopm, &target_seminfo->semopm);
4281 __put_user(host_seminfo->semume, &target_seminfo->semume);
4282 __put_user(host_seminfo->semusz, &target_seminfo->semusz);
4283 __put_user(host_seminfo->semvmx, &target_seminfo->semvmx);
4284 __put_user(host_seminfo->semaem, &target_seminfo->semaem);
4285 unlock_user_struct(target_seminfo, target_addr, 1);
4286 return 0;
4287}
4288
fa294816
TS		 4289union semun {
4290 int val;
3eb6b044 4291 struct semid_ds *buf;
fa294816 4292 unsigned short *array;
e5289087 4293 struct seminfo *__buf;
fa294816
TS		 4294};
4295
3eb6b044
TS		 4296union target_semun {
4297 int val;
e5289087
AJ		 4298 abi_ulong buf;
4299 abi_ulong array;
4300 abi_ulong __buf;
3eb6b044
TS		 4301};
4302
e5289087
AJ		 4303static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array,
4304 abi_ulong target_addr)
3eb6b044 4305{
e5289087
AJ		 4306 int nsems;
4307 unsigned short *array;
4308 union semun semun;
4309 struct semid_ds semid_ds;
4310 int i, ret;
3eb6b044 4311
e5289087
AJ		 4312 semun.buf = &semid_ds;
4313
4314 ret = semctl(semid, 0, IPC_STAT, semun);
4315 if (ret == -1)
4316 return get_errno(ret);
4317
4318 nsems = semid_ds.sem_nsems;
4319
0e173b24 4320 *host_array = g_try_new(unsigned short, nsems);
69d4c703
PM		 4321 if (!*host_array) {
4322 return -TARGET_ENOMEM;
4323 }
e5289087
AJ		 4324 array = lock_user(VERIFY_READ, target_addr,
4325 nsems*sizeof(unsigned short), 1);
69d4c703 4326 if (!array) {
0e173b24 4327 g_free(*host_array);
e5289087 4328 return -TARGET_EFAULT;
69d4c703 4329 }
e5289087
AJ		 4330
4331 for(i=0; i<nsems; i++) {
4332 __get_user((*host_array)[i], &array[i]);
3eb6b044 4333 }
e5289087
AJ		 4334 unlock_user(array, target_addr, 0);
4335
579a97f7 4336 return 0;
3eb6b044
TS		 4337}
4338
e5289087
AJ		 4339static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr,
4340 unsigned short **host_array)
3eb6b044 4341{
e5289087
AJ		 4342 int nsems;
4343 unsigned short *array;
4344 union semun semun;
4345 struct semid_ds semid_ds;
4346 int i, ret;
3eb6b044 4347
e5289087
AJ		 4348 semun.buf = &semid_ds;
4349
4350 ret = semctl(semid, 0, IPC_STAT, semun);
4351 if (ret == -1)
4352 return get_errno(ret);
4353
4354 nsems = semid_ds.sem_nsems;
4355
4356 array = lock_user(VERIFY_WRITE, target_addr,
4357 nsems*sizeof(unsigned short), 0);
4358 if (!array)
4359 return -TARGET_EFAULT;
4360
4361 for(i=0; i<nsems; i++) {
4362 __put_user((*host_array)[i], &array[i]);
3eb6b044 4363 }
0e173b24 4364 g_free(*host_array);
e5289087
AJ		 4365 unlock_user(array, target_addr, 1);
4366
579a97f7 4367 return 0;
3eb6b044
TS		 4368}
4369
e5289087 4370static inline abi_long do_semctl(int semid, int semnum, int cmd,
d1c002b6 4371 abi_ulong target_arg)
3eb6b044 4372{
d1c002b6 4373 union target_semun target_su = { .buf = target_arg };
3eb6b044
TS		 4374 union semun arg;
4375 struct semid_ds dsarg;
7b8118e8 4376 unsigned short *array = NULL;
e5289087
AJ		 4377 struct seminfo seminfo;
4378 abi_long ret = -TARGET_EINVAL;
4379 abi_long err;
4380 cmd &= 0xff;
3eb6b044
TS		 4381
4382 switch( cmd ) {
4383 case GETVAL:
3eb6b044 4384 case SETVAL:
5464baec
TM		 4385 /* In 64 bit cross-endian situations, we will erroneously pick up
4386 * the wrong half of the union for the "val" element. To rectify
4387 * this, the entire 8-byte structure is byteswapped, followed by
4388 * a swap of the 4 byte val field. In other cases, the data is
4389 * already in proper host byte order. */
4390 if (sizeof(target_su.val) != (sizeof(target_su.buf))) {
4391 target_su.buf = tswapal(target_su.buf);
4392 arg.val = tswap32(target_su.val);
4393 } else {
4394 arg.val = target_su.val;
4395 }
e5289087 4396 ret = get_errno(semctl(semid, semnum, cmd, arg));
3eb6b044
TS		 4397 break;
4398 case GETALL:
3eb6b044 4399 case SETALL:
e5289087
AJ		 4400 err = target_to_host_semarray(semid, &array, target_su.array);
4401 if (err)
4402 return err;
4403 arg.array = array;
4404 ret = get_errno(semctl(semid, semnum, cmd, arg));
4405 err = host_to_target_semarray(semid, target_su.array, &array);
4406 if (err)
4407 return err;
3eb6b044
TS		 4408 break;
4409 case IPC_STAT:
3eb6b044 4410 case IPC_SET:
e5289087
AJ		 4411 case SEM_STAT:
4412 err = target_to_host_semid_ds(&dsarg, target_su.buf);
4413 if (err)
4414 return err;
4415 arg.buf = &dsarg;
4416 ret = get_errno(semctl(semid, semnum, cmd, arg));
4417 err = host_to_target_semid_ds(target_su.buf, &dsarg);
4418 if (err)
4419 return err;
4420 break;
4421 case IPC_INFO:
4422 case SEM_INFO:
4423 arg.__buf = &seminfo;
4424 ret = get_errno(semctl(semid, semnum, cmd, arg));
4425 err = host_to_target_seminfo(target_su.__buf, &seminfo);
4426 if (err)
4427 return err;
4428 break;
4429 case IPC_RMID:
4430 case GETPID:
4431 case GETNCNT:
4432 case GETZCNT:
4433 ret = get_errno(semctl(semid, semnum, cmd, NULL));
3eb6b044 4434 break;
3eb6b044
TS		 4435 }
4436
4437 return ret;
4438}
4439
e5289087
AJ		 4440struct target_sembuf {
4441 unsigned short sem_num;
4442 short sem_op;
4443 short sem_flg;
4444};
4445
4446static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
4447 abi_ulong target_addr,
4448 unsigned nsops)
4449{
4450 struct target_sembuf *target_sembuf;
4451 int i;
4452
4453 target_sembuf = lock_user(VERIFY_READ, target_addr,
4454 nsops*sizeof(struct target_sembuf), 1);
4455 if (!target_sembuf)
4456 return -TARGET_EFAULT;
4457
4458 for(i=0; i<nsops; i++) {
4459 __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num);
4460 __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op);
4461 __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg);
4462 }
4463
4464 unlock_user(target_sembuf, target_addr, 0);
4465
4466 return 0;
4467}
4468
4469static inline abi_long do_semop(int semid, abi_long ptr, unsigned nsops)
4470{
4471 struct sembuf sops[nsops];
4472
4473 if (target_to_host_sembuf(sops, ptr, nsops))
4474 return -TARGET_EFAULT;
4475
ffb7ee79 4476 return get_errno(safe_semtimedop(semid, sops, nsops, NULL));
e5289087
AJ		 4477}
4478
1bc012f6
TS		 4479struct target_msqid_ds
4480{
1c54ff97
AJ		 4481 struct target_ipc_perm msg_perm;
4482 abi_ulong msg_stime;
4483#if TARGET_ABI_BITS == 32
4484 abi_ulong __unused1;
4485#endif
4486 abi_ulong msg_rtime;
4487#if TARGET_ABI_BITS == 32
4488 abi_ulong __unused2;
4489#endif
4490 abi_ulong msg_ctime;
4491#if TARGET_ABI_BITS == 32
4492 abi_ulong __unused3;
4493#endif
4494 abi_ulong __msg_cbytes;
4495 abi_ulong msg_qnum;
4496 abi_ulong msg_qbytes;
4497 abi_ulong msg_lspid;
4498 abi_ulong msg_lrpid;
4499 abi_ulong __unused4;
4500 abi_ulong __unused5;
1bc012f6
TS		 4501};
4502
579a97f7
FB		 4503static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
4504 abi_ulong target_addr)
1bc012f6
TS		 4505{
4506 struct target_msqid_ds *target_md;
4507
579a97f7
FB		 4508 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
4509 return -TARGET_EFAULT;
1c54ff97
AJ		 4510 if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
4511 return -TARGET_EFAULT;
cbb21eed
MB		 4512 host_md->msg_stime = tswapal(target_md->msg_stime);
4513 host_md->msg_rtime = tswapal(target_md->msg_rtime);
4514 host_md->msg_ctime = tswapal(target_md->msg_ctime);
4515 host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes);
4516 host_md->msg_qnum = tswapal(target_md->msg_qnum);
4517 host_md->msg_qbytes = tswapal(target_md->msg_qbytes);
4518 host_md->msg_lspid = tswapal(target_md->msg_lspid);
4519 host_md->msg_lrpid = tswapal(target_md->msg_lrpid);
1bc012f6 4520 unlock_user_struct(target_md, target_addr, 0);
579a97f7 4521 return 0;
1bc012f6
TS		 4522}
4523
579a97f7
FB		 4524static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
4525 struct msqid_ds *host_md)
1bc012f6
TS		 4526{
4527 struct target_msqid_ds *target_md;
4528
579a97f7
FB		 4529 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
4530 return -TARGET_EFAULT;
1c54ff97
AJ		 4531 if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
4532 return -TARGET_EFAULT;
cbb21eed
MB		 4533 target_md->msg_stime = tswapal(host_md->msg_stime);
4534 target_md->msg_rtime = tswapal(host_md->msg_rtime);
4535 target_md->msg_ctime = tswapal(host_md->msg_ctime);
4536 target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes);
4537 target_md->msg_qnum = tswapal(host_md->msg_qnum);
4538 target_md->msg_qbytes = tswapal(host_md->msg_qbytes);
4539 target_md->msg_lspid = tswapal(host_md->msg_lspid);
4540 target_md->msg_lrpid = tswapal(host_md->msg_lrpid);
1bc012f6 4541 unlock_user_struct(target_md, target_addr, 1);
579a97f7 4542 return 0;
1bc012f6
TS		 4543}
4544
1c54ff97
AJ		 4545struct target_msginfo {
4546 int msgpool;
4547 int msgmap;
4548 int msgmax;
4549 int msgmnb;
4550 int msgmni;
4551 int msgssz;
4552 int msgtql;
4553 unsigned short int msgseg;
4554};
4555
4556static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
4557 struct msginfo *host_msginfo)
4558{
4559 struct target_msginfo *target_msginfo;
4560 if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
4561 return -TARGET_EFAULT;
4562 __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
4563 __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
4564 __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
4565 __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
4566 __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
4567 __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
4568 __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
4569 __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
4570 unlock_user_struct(target_msginfo, target_addr, 1);
00b229ac 4571 return 0;
1c54ff97
AJ		 4572}
4573
4574static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
1bc012f6
TS		 4575{
4576 struct msqid_ds dsarg;
1c54ff97
AJ		 4577 struct msginfo msginfo;
4578 abi_long ret = -TARGET_EINVAL;
4579
4580 cmd &= 0xff;
4581
4582 switch (cmd) {
1bc012f6
TS		 4583 case IPC_STAT:
4584 case IPC_SET:
1c54ff97
AJ		 4585 case MSG_STAT:
4586 if (target_to_host_msqid_ds(&dsarg,ptr))
4587 return -TARGET_EFAULT;
4588 ret = get_errno(msgctl(msgid, cmd, &dsarg));
4589 if (host_to_target_msqid_ds(ptr,&dsarg))
4590 return -TARGET_EFAULT;
4591 break;
4592 case IPC_RMID:
4593 ret = get_errno(msgctl(msgid, cmd, NULL));
4594 break;
4595 case IPC_INFO:
4596 case MSG_INFO:
4597 ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
4598 if (host_to_target_msginfo(ptr, &msginfo))
4599 return -TARGET_EFAULT;
4600 break;
1bc012f6 4601 }
1c54ff97 4602
1bc012f6
TS		 4603 return ret;
4604}
4605
4606struct target_msgbuf {
1c54ff97
AJ		 4607 abi_long mtype;
4608 char mtext[1];
1bc012f6
TS		 4609};
4610
992f48a0 4611static inline abi_long do_msgsnd(int msqid, abi_long msgp,
edcc5f9d 4612 ssize_t msgsz, int msgflg)
1bc012f6
TS		 4613{
4614 struct target_msgbuf *target_mb;
4615 struct msgbuf *host_mb;
992f48a0 4616 abi_long ret = 0;
1bc012f6 4617
edcc5f9d
TM		 4618 if (msgsz < 0) {
4619 return -TARGET_EINVAL;
4620 }
4621
579a97f7
FB		 4622 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
4623 return -TARGET_EFAULT;
0e173b24 4624 host_mb = g_try_malloc(msgsz + sizeof(long));
29e03fcb
HZ		 4625 if (!host_mb) {
4626 unlock_user_struct(target_mb, msgp, 0);
4627 return -TARGET_ENOMEM;
4628 }
cbb21eed 4629 host_mb->mtype = (abi_long) tswapal(target_mb->mtype);
1c54ff97 4630 memcpy(host_mb->mtext, target_mb->mtext, msgsz);
89f9fe44 4631 ret = get_errno(safe_msgsnd(msqid, host_mb, msgsz, msgflg));
0e173b24 4632 g_free(host_mb);
1bc012f6
TS		 4633 unlock_user_struct(target_mb, msgp, 0);
4634
4635 return ret;
4636}
4637
992f48a0 4638static inline abi_long do_msgrcv(int msqid, abi_long msgp,
99874f65 4639 ssize_t msgsz, abi_long msgtyp,
992f48a0 4640 int msgflg)
1bc012f6
TS		 4641{
4642 struct target_msgbuf *target_mb;
579a97f7 4643 char *target_mtext;
1bc012f6 4644 struct msgbuf *host_mb;
992f48a0 4645 abi_long ret = 0;
1bc012f6 4646
99874f65
PM		 4647 if (msgsz < 0) {
4648 return -TARGET_EINVAL;
4649 }
4650
579a97f7
FB		 4651 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
4652 return -TARGET_EFAULT;
1c54ff97 4653
415d8471
PM		 4654 host_mb = g_try_malloc(msgsz + sizeof(long));
4655 if (!host_mb) {
4656 ret = -TARGET_ENOMEM;
4657 goto end;
4658 }
89f9fe44 4659 ret = get_errno(safe_msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg));
1c54ff97 4660
579a97f7
FB		 4661 if (ret > 0) {
4662 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
4663 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
4664 if (!target_mtext) {
4665 ret = -TARGET_EFAULT;
4666 goto end;
4667 }
1c54ff97 4668 memcpy(target_mb->mtext, host_mb->mtext, ret);
579a97f7
FB		 4669 unlock_user(target_mtext, target_mtext_addr, ret);
4670 }
1c54ff97 4671
cbb21eed 4672 target_mb->mtype = tswapal(host_mb->mtype);
1bc012f6 4673
579a97f7
FB		 4674end:
4675 if (target_mb)
4676 unlock_user_struct(target_mb, msgp, 1);
0d07fe47 4677 g_free(host_mb);
1bc012f6
TS		 4678 return ret;
4679}
4680
88a8c984
RV		 4681static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
4682 abi_ulong target_addr)
4683{
4684 struct target_shmid_ds *target_sd;
4685
4686 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4687 return -TARGET_EFAULT;
4688 if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr))
4689 return -TARGET_EFAULT;
4690 __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4691 __get_user(host_sd->shm_atime, &target_sd->shm_atime);
4692 __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4693 __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4694 __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4695 __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4696 __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4697 unlock_user_struct(target_sd, target_addr, 0);
4698 return 0;
4699}
4700
4701static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr,
4702 struct shmid_ds *host_sd)
4703{
4704 struct target_shmid_ds *target_sd;
4705
4706 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4707 return -TARGET_EFAULT;
4708 if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm)))
4709 return -TARGET_EFAULT;
4710 __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4711 __put_user(host_sd->shm_atime, &target_sd->shm_atime);
4712 __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4713 __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4714 __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4715 __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4716 __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4717 unlock_user_struct(target_sd, target_addr, 1);
4718 return 0;
4719}
4720
4721struct target_shminfo {
4722 abi_ulong shmmax;
4723 abi_ulong shmmin;
4724 abi_ulong shmmni;
4725 abi_ulong shmseg;
4726 abi_ulong shmall;
4727};
4728
4729static inline abi_long host_to_target_shminfo(abi_ulong target_addr,
4730 struct shminfo *host_shminfo)
4731{
4732 struct target_shminfo *target_shminfo;
4733 if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0))
4734 return -TARGET_EFAULT;
4735 __put_user(host_shminfo->shmmax, &target_shminfo->shmmax);
4736 __put_user(host_shminfo->shmmin, &target_shminfo->shmmin);
4737 __put_user(host_shminfo->shmmni, &target_shminfo->shmmni);
4738 __put_user(host_shminfo->shmseg, &target_shminfo->shmseg);
4739 __put_user(host_shminfo->shmall, &target_shminfo->shmall);
4740 unlock_user_struct(target_shminfo, target_addr, 1);
4741 return 0;
4742}
4743
4744struct target_shm_info {
4745 int used_ids;
4746 abi_ulong shm_tot;
4747 abi_ulong shm_rss;
4748 abi_ulong shm_swp;
4749 abi_ulong swap_attempts;
4750 abi_ulong swap_successes;
4751};
4752
4753static inline abi_long host_to_target_shm_info(abi_ulong target_addr,
4754 struct shm_info *host_shm_info)
4755{
4756 struct target_shm_info *target_shm_info;
4757 if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0))
4758 return -TARGET_EFAULT;
4759 __put_user(host_shm_info->used_ids, &target_shm_info->used_ids);
4760 __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot);
4761 __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss);
4762 __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp);
4763 __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts);
4764 __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes);
4765 unlock_user_struct(target_shm_info, target_addr, 1);
4766 return 0;
4767}
4768
4769static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf)
4770{
4771 struct shmid_ds dsarg;
4772 struct shminfo shminfo;
4773 struct shm_info shm_info;
4774 abi_long ret = -TARGET_EINVAL;
4775
4776 cmd &= 0xff;
4777
4778 switch(cmd) {
4779 case IPC_STAT:
4780 case IPC_SET:
4781 case SHM_STAT:
4782 if (target_to_host_shmid_ds(&dsarg, buf))
4783 return -TARGET_EFAULT;
4784 ret = get_errno(shmctl(shmid, cmd, &dsarg));
4785 if (host_to_target_shmid_ds(buf, &dsarg))
4786 return -TARGET_EFAULT;
4787 break;
4788 case IPC_INFO:
4789 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo));
4790 if (host_to_target_shminfo(buf, &shminfo))
4791 return -TARGET_EFAULT;
4792 break;
4793 case SHM_INFO:
4794 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info));
4795 if (host_to_target_shm_info(buf, &shm_info))
4796 return -TARGET_EFAULT;
4797 break;
4798 case IPC_RMID:
4799 case SHM_LOCK:
4800 case SHM_UNLOCK:
4801 ret = get_errno(shmctl(shmid, cmd, NULL));
4802 break;
4803 }
4804
4805 return ret;
4806}
4807
ee8e7614
PM		 4808#ifndef TARGET_FORCE_SHMLBA
4809/* For most architectures, SHMLBA is the same as the page size;
4810 * some architectures have larger values, in which case they should
4811 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
4812 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
4813 * and defining its own value for SHMLBA.
4814 *
4815 * The kernel also permits SHMLBA to be set by the architecture to a
4816 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
4817 * this means that addresses are rounded to the large size if
4818 * SHM_RND is set but addresses not aligned to that size are not rejected
4819 * as long as they are at least page-aligned. Since the only architecture
4820 * which uses this is ia64 this code doesn't provide for that oddity.
4821 */
4822static inline abi_ulong target_shmlba(CPUArchState *cpu_env)
4823{
4824 return TARGET_PAGE_SIZE;
4825}
4826#endif
4827
4828static inline abi_ulong do_shmat(CPUArchState *cpu_env,
4829 int shmid, abi_ulong shmaddr, int shmflg)
88a8c984
RV		 4830{
4831 abi_long raddr;
4832 void *host_raddr;
4833 struct shmid_ds shm_info;
4834 int i,ret;
ee8e7614 4835 abi_ulong shmlba;
88a8c984
RV		 4836
4837 /* find out the length of the shared memory segment */
4838 ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
4839 if (is_error(ret)) {
4840 /* can't get length, bail out */
4841 return ret;
4842 }
4843
ee8e7614
PM		 4844 shmlba = target_shmlba(cpu_env);
4845
4846 if (shmaddr & (shmlba - 1)) {
4847 if (shmflg & SHM_RND) {
4848 shmaddr &= ~(shmlba - 1);
4849 } else {
4850 return -TARGET_EINVAL;
4851 }
4852 }
4853
88a8c984
RV		 4854 mmap_lock();
4855
4856 if (shmaddr)
4857 host_raddr = shmat(shmid, (void *)g2h(shmaddr), shmflg);
4858 else {
4859 abi_ulong mmap_start;
4860
4861 mmap_start = mmap_find_vma(0, shm_info.shm_segsz);
4862
4863 if (mmap_start == -1) {
4864 errno = ENOMEM;
4865 host_raddr = (void *)-1;
4866 } else
4867 host_raddr = shmat(shmid, g2h(mmap_start), shmflg | SHM_REMAP);
4868 }
4869
4870 if (host_raddr == (void *)-1) {
4871 mmap_unlock();
4872 return get_errno((long)host_raddr);
4873 }
4874 raddr=h2g((unsigned long)host_raddr);
4875
4876 page_set_flags(raddr, raddr + shm_info.shm_segsz,
4877 PAGE_VALID | PAGE_READ |
4878 ((shmflg & SHM_RDONLY)? 0 : PAGE_WRITE));
4879
4880 for (i = 0; i < N_SHM_REGIONS; i++) {
b6e17875
PM		 4881 if (!shm_regions[i].in_use) {
4882 shm_regions[i].in_use = true;
88a8c984
RV		 4883 shm_regions[i].start = raddr;
4884 shm_regions[i].size = shm_info.shm_segsz;
4885 break;
4886 }
4887 }
4888
4889 mmap_unlock();
4890 return raddr;
4891
4892}
4893
4894static inline abi_long do_shmdt(abi_ulong shmaddr)
4895{
4896 int i;
4897
4898 for (i = 0; i < N_SHM_REGIONS; ++i) {
b6e17875
PM		 4899 if (shm_regions[i].in_use && shm_regions[i].start == shmaddr) {
4900 shm_regions[i].in_use = false;
e00ac249 4901 page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0);
88a8c984
RV		 4902 break;
4903 }
4904 }
4905
4906 return get_errno(shmdt(g2h(shmaddr)));
4907}
4908
1c54ff97 4909#ifdef TARGET_NR_ipc
53a5960a 4910/* ??? This only works with linear mappings. */
0da46a6e 4911/* do_ipc() must return target values and target errnos. */
ee8e7614
PM		 4912static abi_long do_ipc(CPUArchState *cpu_env,
4913 unsigned int call, abi_long first,
37ed0956 4914 abi_long second, abi_long third,
992f48a0 4915 abi_long ptr, abi_long fifth)
8853f86e
FB		 4916{
4917 int version;
992f48a0 4918 abi_long ret = 0;
8853f86e
FB		 4919
4920 version = call >> 16;
4921 call &= 0xffff;
4922
4923 switch (call) {
fa294816 4924 case IPCOP_semop:
e5289087 4925 ret = do_semop(first, ptr, second);
fa294816
TS		 4926 break;
4927
4928 case IPCOP_semget:
4929 ret = get_errno(semget(first, second, third));
4930 break;
4931
5d2fa8eb
TM		 4932 case IPCOP_semctl: {
4933 /* The semun argument to semctl is passed by value, so dereference the
4934 * ptr argument. */
4935 abi_ulong atptr;
37ed0956 4936 get_user_ual(atptr, ptr);
d1c002b6 4937 ret = do_semctl(first, second, third, atptr);
fa294816 4938 break;
5d2fa8eb 4939 }
d96372ef 4940
1c54ff97
AJ		 4941 case IPCOP_msgget:
4942 ret = get_errno(msgget(first, second));
4943 break;
d96372ef 4944
1c54ff97
AJ		 4945 case IPCOP_msgsnd:
4946 ret = do_msgsnd(first, ptr, second, third);
4947 break;
d96372ef 4948
1c54ff97
AJ		 4949 case IPCOP_msgctl:
4950 ret = do_msgctl(first, second, ptr);
4951 break;
d96372ef 4952
1c54ff97
AJ		 4953 case IPCOP_msgrcv:
4954 switch (version) {
4955 case 0:
4956 {
4957 struct target_ipc_kludge {
4958 abi_long msgp;
4959 abi_long msgtyp;
4960 } *tmp;
4961
4962 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
4963 ret = -TARGET_EFAULT;
4964 break;
4965 }
d96372ef 4966
79dd77de 4967 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third);
d96372ef 4968
1c54ff97
AJ		 4969 unlock_user_struct(tmp, ptr, 0);
4970 break;
4971 }
4972 default:
4973 ret = do_msgrcv(first, ptr, second, fifth, third);
4974 }
4975 break;
d96372ef 4976
8853f86e 4977 case IPCOP_shmat:
88a8c984
RV		 4978 switch (version) {
4979 default:
5a4a898d
FB		 4980 {
4981 abi_ulong raddr;
ee8e7614 4982 raddr = do_shmat(cpu_env, first, ptr, second);
88a8c984
RV		 4983 if (is_error(raddr))
4984 return get_errno(raddr);
2f619698 4985 if (put_user_ual(raddr, third))
5a4a898d 4986 return -TARGET_EFAULT;
88a8c984
RV		 4987 break;
4988 }
4989 case 1:
4990 ret = -TARGET_EINVAL;
4991 break;
5a4a898d 4992 }
8853f86e
FB		 4993 break;
4994 case IPCOP_shmdt:
88a8c984 4995 ret = do_shmdt(ptr);
8853f86e
FB		 4996 break;
4997
4998 case IPCOP_shmget:
4999 /* IPC_* flag values are the same on all linux platforms */
5000 ret = get_errno(shmget(first, second, third));
5001 break;
5002
5003 /* IPC_* and SHM_* command values are the same on all linux platforms */
5004 case IPCOP_shmctl:
a2926784 5005 ret = do_shmctl(first, second, ptr);
8853f86e
FB		 5006 break;
5007 default:
32407103 5008 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
0da46a6e 5009 ret = -TARGET_ENOSYS;
8853f86e
FB		 5010 break;
5011 }
5012 return ret;
5013}
32407103 5014#endif
8853f86e 5015
31e31b8a 5016/* kernel structure types definitions */
31e31b8a 5017
001faf32 5018#define STRUCT(name, ...) STRUCT_ ## name,
31e31b8a
FB		 5019#define STRUCT_SPECIAL(name) STRUCT_ ## name,
5020enum {
5021#include "syscall_types.h"
8be656b8 5022STRUCT_MAX
31e31b8a
FB		 5023};
5024#undef STRUCT
5025#undef STRUCT_SPECIAL
5026
001faf32 5027#define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
31e31b8a
FB		 5028#define STRUCT_SPECIAL(name)
5029#include "syscall_types.h"
5030#undef STRUCT
5031#undef STRUCT_SPECIAL
5032
d2ef05bb
PM		 5033typedef struct IOCTLEntry IOCTLEntry;
5034
5035typedef abi_long do_ioctl_fn(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5036 int fd, int cmd, abi_long arg);
d2ef05bb
PM		 5037
5038struct IOCTLEntry {
9c6bf9c7 5039 int target_cmd;
2ab83ea7 5040 unsigned int host_cmd;
31e31b8a
FB		 5041 const char *name;
5042 int access;
d2ef05bb 5043 do_ioctl_fn *do_ioctl;
1a9353d2 5044 const argtype arg_type[5];
d2ef05bb 5045};
31e31b8a
FB		 5046
5047#define IOC_R 0x0001
5048#define IOC_W 0x0002
5049#define IOC_RW (IOC_R | IOC_W)
5050
5051#define MAX_STRUCT_SIZE 4096
5052
dace20dc 5053#ifdef CONFIG_FIEMAP
285da2b9
PM		 5054/* So fiemap access checks don't overflow on 32 bit systems.
5055 * This is very slightly smaller than the limit imposed by
5056 * the underlying kernel.
5057 */
5058#define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
5059 / sizeof(struct fiemap_extent))
5060
5061static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5062 int fd, int cmd, abi_long arg)
285da2b9
PM		 5063{
5064 /* The parameter for this ioctl is a struct fiemap followed
5065 * by an array of struct fiemap_extent whose size is set
5066 * in fiemap->fm_extent_count. The array is filled in by the
5067 * ioctl.
5068 */
5069 int target_size_in, target_size_out;
5070 struct fiemap *fm;
5071 const argtype *arg_type = ie->arg_type;
5072 const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) };
5073 void *argptr, *p;
5074 abi_long ret;
5075 int i, extent_size = thunk_type_size(extent_arg_type, 0);
5076 uint32_t outbufsz;
5077 int free_fm = 0;
5078
5079 assert(arg_type[0] == TYPE_PTR);
5080 assert(ie->access == IOC_RW);
5081 arg_type++;
5082 target_size_in = thunk_type_size(arg_type, 0);
5083 argptr = lock_user(VERIFY_READ, arg, target_size_in, 1);
5084 if (!argptr) {
5085 return -TARGET_EFAULT;
5086 }
5087 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5088 unlock_user(argptr, arg, 0);
5089 fm = (struct fiemap *)buf_temp;
5090 if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) {
5091 return -TARGET_EINVAL;
5092 }
5093
5094 outbufsz = sizeof (*fm) +
5095 (sizeof(struct fiemap_extent) * fm->fm_extent_count);
5096
5097 if (outbufsz > MAX_STRUCT_SIZE) {
5098 /* We can't fit all the extents into the fixed size buffer.
5099 * Allocate one that is large enough and use it instead.
5100 */
0e173b24 5101 fm = g_try_malloc(outbufsz);
285da2b9
PM		 5102 if (!fm) {
5103 return -TARGET_ENOMEM;
5104 }
5105 memcpy(fm, buf_temp, sizeof(struct fiemap));
5106 free_fm = 1;
5107 }
49ca6f3e 5108 ret = get_errno(safe_ioctl(fd, ie->host_cmd, fm));
285da2b9
PM		 5109 if (!is_error(ret)) {
5110 target_size_out = target_size_in;
5111 /* An extent_count of 0 means we were only counting the extents
5112 * so there are no structs to copy
5113 */
5114 if (fm->fm_extent_count != 0) {
5115 target_size_out += fm->fm_mapped_extents * extent_size;
5116 }
5117 argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0);
5118 if (!argptr) {
5119 ret = -TARGET_EFAULT;
5120 } else {
5121 /* Convert the struct fiemap */
5122 thunk_convert(argptr, fm, arg_type, THUNK_TARGET);
5123 if (fm->fm_extent_count != 0) {
5124 p = argptr + target_size_in;
5125 /* ...and then all the struct fiemap_extents */
5126 for (i = 0; i < fm->fm_mapped_extents; i++) {
5127 thunk_convert(p, &fm->fm_extents[i], extent_arg_type,
5128 THUNK_TARGET);
5129 p += extent_size;
5130 }
5131 }
5132 unlock_user(argptr, arg, target_size_out);
5133 }
5134 }
5135 if (free_fm) {
0e173b24 5136 g_free(fm);
285da2b9
PM		 5137 }
5138 return ret;
5139}
dace20dc 5140#endif
285da2b9 5141
059c2f2c 5142static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5143 int fd, int cmd, abi_long arg)
059c2f2c
LV		 5144{
5145 const argtype *arg_type = ie->arg_type;
5146 int target_size;
5147 void *argptr;
5148 int ret;
5149 struct ifconf *host_ifconf;
5150 uint32_t outbufsz;
5151 const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) };
5152 int target_ifreq_size;
5153 int nb_ifreq;
5154 int free_buf = 0;
5155 int i;
5156 int target_ifc_len;
5157 abi_long target_ifc_buf;
5158 int host_ifc_len;
5159 char *host_ifc_buf;
5160
5161 assert(arg_type[0] == TYPE_PTR);
5162 assert(ie->access == IOC_RW);
5163
5164 arg_type++;
5165 target_size = thunk_type_size(arg_type, 0);
5166
5167 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5168 if (!argptr)
5169 return -TARGET_EFAULT;
5170 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5171 unlock_user(argptr, arg, 0);
5172
5173 host_ifconf = (struct ifconf *)(unsigned long)buf_temp;
5174 target_ifc_len = host_ifconf->ifc_len;
5175 target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf;
5176
5177 target_ifreq_size = thunk_type_size(ifreq_arg_type, 0);
5178 nb_ifreq = target_ifc_len / target_ifreq_size;
5179 host_ifc_len = nb_ifreq * sizeof(struct ifreq);
5180
5181 outbufsz = sizeof(*host_ifconf) + host_ifc_len;
5182 if (outbufsz > MAX_STRUCT_SIZE) {
5183 /* We can't fit all the extents into the fixed size buffer.
5184 * Allocate one that is large enough and use it instead.
5185 */
5186 host_ifconf = malloc(outbufsz);
5187 if (!host_ifconf) {
5188 return -TARGET_ENOMEM;
5189 }
5190 memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf));
5191 free_buf = 1;
5192 }
5193 host_ifc_buf = (char*)host_ifconf + sizeof(*host_ifconf);
5194
5195 host_ifconf->ifc_len = host_ifc_len;
5196 host_ifconf->ifc_buf = host_ifc_buf;
5197
49ca6f3e 5198 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_ifconf));
059c2f2c
LV		 5199 if (!is_error(ret)) {
5200 /* convert host ifc_len to target ifc_len */
5201
5202 nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq);
5203 target_ifc_len = nb_ifreq * target_ifreq_size;
5204 host_ifconf->ifc_len = target_ifc_len;
5205
5206 /* restore target ifc_buf */
5207
5208 host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf;
5209
5210 /* copy struct ifconf to target user */
5211
5212 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5213 if (!argptr)
5214 return -TARGET_EFAULT;
5215 thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET);
5216 unlock_user(argptr, arg, target_size);
5217
5218 /* copy ifreq[] to target user */
5219
5220 argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0);
5221 for (i = 0; i < nb_ifreq ; i++) {
5222 thunk_convert(argptr + i * target_ifreq_size,
5223 host_ifc_buf + i * sizeof(struct ifreq),
5224 ifreq_arg_type, THUNK_TARGET);
5225 }
5226 unlock_user(argptr, target_ifc_buf, target_ifc_len);
5227 }
5228
5229 if (free_buf) {
5230 free(host_ifconf);
5231 }
5232
5233 return ret;
5234}
5235
56e904ec 5236static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
45c874eb 5237 int cmd, abi_long arg)
56e904ec
AG		 5238{
5239 void *argptr;
5240 struct dm_ioctl *host_dm;
5241 abi_long guest_data;
5242 uint32_t guest_data_size;
5243 int target_size;
5244 const argtype *arg_type = ie->arg_type;
5245 abi_long ret;
5246 void *big_buf = NULL;
5247 char *host_data;
5248
5249 arg_type++;
5250 target_size = thunk_type_size(arg_type, 0);
5251 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5252 if (!argptr) {
5253 ret = -TARGET_EFAULT;
5254 goto out;
5255 }
5256 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5257 unlock_user(argptr, arg, 0);
5258
5259 /* buf_temp is too small, so fetch things into a bigger buffer */
5260 big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2);
5261 memcpy(big_buf, buf_temp, target_size);
5262 buf_temp = big_buf;
5263 host_dm = big_buf;
5264
5265 guest_data = arg + host_dm->data_start;
5266 if ((guest_data - arg) < 0) {
f9757b1d 5267 ret = -TARGET_EINVAL;
56e904ec
AG		 5268 goto out;
5269 }
5270 guest_data_size = host_dm->data_size - host_dm->data_start;
5271 host_data = (char*)host_dm + host_dm->data_start;
5272
5273 argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1);
3211215e
PM		 5274 if (!argptr) {
5275 ret = -TARGET_EFAULT;
5276 goto out;
5277 }
5278
56e904ec
AG		 5279 switch (ie->host_cmd) {
5280 case DM_REMOVE_ALL:
5281 case DM_LIST_DEVICES:
5282 case DM_DEV_CREATE:
5283 case DM_DEV_REMOVE:
5284 case DM_DEV_SUSPEND:
5285 case DM_DEV_STATUS:
5286 case DM_DEV_WAIT:
5287 case DM_TABLE_STATUS:
5288 case DM_TABLE_CLEAR:
5289 case DM_TABLE_DEPS:
5290 case DM_LIST_VERSIONS:
5291 /* no input data */
5292 break;
5293 case DM_DEV_RENAME:
5294 case DM_DEV_SET_GEOMETRY:
5295 /* data contains only strings */
5296 memcpy(host_data, argptr, guest_data_size);
5297 break;
5298 case DM_TARGET_MSG:
5299 memcpy(host_data, argptr, guest_data_size);
5300 *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr);
5301 break;
5302 case DM_TABLE_LOAD:
5303 {
5304 void *gspec = argptr;
5305 void *cur_data = host_data;
5306 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5307 int spec_size = thunk_type_size(arg_type, 0);
5308 int i;
5309
5310 for (i = 0; i < host_dm->target_count; i++) {
5311 struct dm_target_spec *spec = cur_data;
5312 uint32_t next;
5313 int slen;
5314
5315 thunk_convert(spec, gspec, arg_type, THUNK_HOST);
5316 slen = strlen((char*)gspec + spec_size) + 1;
5317 next = spec->next;
5318 spec->next = sizeof(*spec) + slen;
5319 strcpy((char*)&spec[1], gspec + spec_size);
5320 gspec += next;
5321 cur_data += spec->next;
5322 }
5323 break;
5324 }
5325 default:
5326 ret = -TARGET_EINVAL;
dec0473d 5327 unlock_user(argptr, guest_data, 0);
56e904ec
AG		 5328 goto out;
5329 }
5330 unlock_user(argptr, guest_data, 0);
5331
49ca6f3e 5332 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
56e904ec
AG		 5333 if (!is_error(ret)) {
5334 guest_data = arg + host_dm->data_start;
5335 guest_data_size = host_dm->data_size - host_dm->data_start;
5336 argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0);
5337 switch (ie->host_cmd) {
5338 case DM_REMOVE_ALL:
5339 case DM_DEV_CREATE:
5340 case DM_DEV_REMOVE:
5341 case DM_DEV_RENAME:
5342 case DM_DEV_SUSPEND:
5343 case DM_DEV_STATUS:
5344 case DM_TABLE_LOAD:
5345 case DM_TABLE_CLEAR:
5346 case DM_TARGET_MSG:
5347 case DM_DEV_SET_GEOMETRY:
5348 /* no return data */
5349 break;
5350 case DM_LIST_DEVICES:
5351 {
5352 struct dm_name_list *nl = (void*)host_dm + host_dm->data_start;
5353 uint32_t remaining_data = guest_data_size;
5354 void *cur_data = argptr;
5355 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) };
5356 int nl_size = 12; /* can't use thunk_size due to alignment */
5357
5358 while (1) {
5359 uint32_t next = nl->next;
5360 if (next) {
5361 nl->next = nl_size + (strlen(nl->name) + 1);
5362 }
5363 if (remaining_data < nl->next) {
5364 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5365 break;
5366 }
5367 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET);
5368 strcpy(cur_data + nl_size, nl->name);
5369 cur_data += nl->next;
5370 remaining_data -= nl->next;
5371 if (!next) {
5372 break;
5373 }
5374 nl = (void*)nl + next;
5375 }
5376 break;
5377 }
5378 case DM_DEV_WAIT:
5379 case DM_TABLE_STATUS:
5380 {
5381 struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start;
5382 void *cur_data = argptr;
5383 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5384 int spec_size = thunk_type_size(arg_type, 0);
5385 int i;
5386
5387 for (i = 0; i < host_dm->target_count; i++) {
5388 uint32_t next = spec->next;
5389 int slen = strlen((char*)&spec[1]) + 1;
5390 spec->next = (cur_data - argptr) + spec_size + slen;
5391 if (guest_data_size < spec->next) {
5392 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5393 break;
5394 }
5395 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET);
5396 strcpy(cur_data + spec_size, (char*)&spec[1]);
5397 cur_data = argptr + spec->next;
5398 spec = (void*)host_dm + host_dm->data_start + next;
5399 }
5400 break;
5401 }
5402 case DM_TABLE_DEPS:
5403 {
5404 void *hdata = (void*)host_dm + host_dm->data_start;
5405 int count = *(uint32_t*)hdata;
5406 uint64_t *hdev = hdata + 8;
5407 uint64_t *gdev = argptr + 8;
5408 int i;
5409
5410 *(uint32_t*)argptr = tswap32(count);
5411 for (i = 0; i < count; i++) {
5412 *gdev = tswap64(*hdev);
5413 gdev++;
5414 hdev++;
5415 }
5416 break;
5417 }
5418 case DM_LIST_VERSIONS:
5419 {
5420 struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start;
5421 uint32_t remaining_data = guest_data_size;
5422 void *cur_data = argptr;
5423 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) };
5424 int vers_size = thunk_type_size(arg_type, 0);
5425
5426 while (1) {
5427 uint32_t next = vers->next;
5428 if (next) {
5429 vers->next = vers_size + (strlen(vers->name) + 1);
5430 }
5431 if (remaining_data < vers->next) {
5432 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5433 break;
5434 }
5435 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET);
5436 strcpy(cur_data + vers_size, vers->name);
5437 cur_data += vers->next;
5438 remaining_data -= vers->next;
5439 if (!next) {
5440 break;
5441 }
5442 vers = (void*)vers + next;
5443 }
5444 break;
5445 }
5446 default:
dec0473d 5447 unlock_user(argptr, guest_data, 0);
56e904ec
AG		 5448 ret = -TARGET_EINVAL;
5449 goto out;
5450 }
5451 unlock_user(argptr, guest_data, guest_data_size);
5452
5453 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5454 if (!argptr) {
5455 ret = -TARGET_EFAULT;
5456 goto out;
5457 }
5458 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5459 unlock_user(argptr, arg, target_size);
5460 }
5461out:
ad11ad77 5462 g_free(big_buf);
56e904ec
AG		 5463 return ret;
5464}
5465
a59b5e35 5466static abi_long do_ioctl_blkpg(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
45c874eb 5467 int cmd, abi_long arg)
a59b5e35
AG		 5468{
5469 void *argptr;
5470 int target_size;
5471 const argtype *arg_type = ie->arg_type;
5472 const argtype part_arg_type[] = { MK_STRUCT(STRUCT_blkpg_partition) };
5473 abi_long ret;
5474
5475 struct blkpg_ioctl_arg *host_blkpg = (void*)buf_temp;
5476 struct blkpg_partition host_part;
5477
5478 /* Read and convert blkpg */
5479 arg_type++;
5480 target_size = thunk_type_size(arg_type, 0);
5481 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5482 if (!argptr) {
5483 ret = -TARGET_EFAULT;
5484 goto out;
5485 }
5486 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5487 unlock_user(argptr, arg, 0);
5488
5489 switch (host_blkpg->op) {
5490 case BLKPG_ADD_PARTITION:
5491 case BLKPG_DEL_PARTITION:
5492 /* payload is struct blkpg_partition */
5493 break;
5494 default:
5495 /* Unknown opcode */
5496 ret = -TARGET_EINVAL;
5497 goto out;
5498 }
5499
5500 /* Read and convert blkpg->data */
5501 arg = (abi_long)(uintptr_t)host_blkpg->data;
5502 target_size = thunk_type_size(part_arg_type, 0);
5503 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5504 if (!argptr) {
5505 ret = -TARGET_EFAULT;
5506 goto out;
5507 }
5508 thunk_convert(&host_part, argptr, part_arg_type, THUNK_HOST);
5509 unlock_user(argptr, arg, 0);
5510
5511 /* Swizzle the data pointer to our local copy and call! */
5512 host_blkpg->data = &host_part;
49ca6f3e 5513 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_blkpg));
a59b5e35
AG		 5514
5515out:
5516 return ret;
5517}
5518
7ff7b666 5519static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5520 int fd, int cmd, abi_long arg)
7ff7b666
LV		 5521{
5522 const argtype *arg_type = ie->arg_type;
5523 const StructEntry *se;
5524 const argtype *field_types;
5525 const int *dst_offsets, *src_offsets;
5526 int target_size;
5527 void *argptr;
5528 abi_ulong *target_rt_dev_ptr;
5529 unsigned long *host_rt_dev_ptr;
5530 abi_long ret;
5531 int i;
5532
5533 assert(ie->access == IOC_W);
5534 assert(*arg_type == TYPE_PTR);
5535 arg_type++;
5536 assert(*arg_type == TYPE_STRUCT);
5537 target_size = thunk_type_size(arg_type, 0);
5538 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5539 if (!argptr) {
5540 return -TARGET_EFAULT;
5541 }
5542 arg_type++;
5543 assert(*arg_type == (int)STRUCT_rtentry);
5544 se = struct_entries + *arg_type++;
5545 assert(se->convert[0] == NULL);
5546 /* convert struct here to be able to catch rt_dev string */
5547 field_types = se->field_types;
5548 dst_offsets = se->field_offsets[THUNK_HOST];
5549 src_offsets = se->field_offsets[THUNK_TARGET];
5550 for (i = 0; i < se->nb_fields; i++) {
5551 if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) {
5552 assert(*field_types == TYPE_PTRVOID);
5553 target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]);
5554 host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]);
5555 if (*target_rt_dev_ptr != 0) {
5556 *host_rt_dev_ptr = (unsigned long)lock_user_string(
5557 tswapal(*target_rt_dev_ptr));
5558 if (!*host_rt_dev_ptr) {
5559 unlock_user(argptr, arg, 0);
5560 return -TARGET_EFAULT;
5561 }
5562 } else {
5563 *host_rt_dev_ptr = 0;
5564 }
5565 field_types++;
5566 continue;
5567 }
5568 field_types = thunk_convert(buf_temp + dst_offsets[i],
5569 argptr + src_offsets[i],
5570 field_types, THUNK_HOST);
5571 }
5572 unlock_user(argptr, arg, 0);
5573
49ca6f3e 5574 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
7ff7b666
LV		 5575 if (*host_rt_dev_ptr != 0) {
5576 unlock_user((void *)*host_rt_dev_ptr,
5577 *target_rt_dev_ptr, 0);
5578 }
5579 return ret;
5580}
5581
ca56f5b5 5582static abi_long do_ioctl_kdsigaccept(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5583 int fd, int cmd, abi_long arg)
ca56f5b5
PB		 5584{
5585 int sig = target_to_host_signal(arg);
49ca6f3e 5586 return get_errno(safe_ioctl(fd, ie->host_cmd, sig));
ca56f5b5
PB		 5587}
5588
9f106a75 5589static IOCTLEntry ioctl_entries[] = {
001faf32 5590#define IOCTL(cmd, access, ...) \
d2ef05bb
PM		 5591 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5592#define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5593 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
8cb762fe
HD		 5594#define IOCTL_IGNORE(cmd) \
5595 { TARGET_ ## cmd, 0, #cmd },
31e31b8a
FB		 5596#include "ioctls.h"
5597 { 0, 0, },
5598};
5599
53a5960a 5600/* ??? Implement proper locking for ioctls. */
0da46a6e 5601/* do_ioctl() Must return target values and target errnos. */
45c874eb 5602static abi_long do_ioctl(int fd, int cmd, abi_long arg)
31e31b8a
FB		 5603{
5604 const IOCTLEntry *ie;
5605 const argtype *arg_type;
992f48a0 5606 abi_long ret;
31e31b8a 5607 uint8_t buf_temp[MAX_STRUCT_SIZE];
53a5960a
PB		 5608 int target_size;
5609 void *argptr;
31e31b8a
FB		 5610
5611 ie = ioctl_entries;
5612 for(;;) {
5613 if (ie->target_cmd == 0) {
32407103 5614 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
0da46a6e 5615 return -TARGET_ENOSYS;
31e31b8a
FB		 5616 }
5617 if (ie->target_cmd == cmd)
5618 break;
5619 ie++;
5620 }
5621 arg_type = ie->arg_type;
9de5e440 5622#if defined(DEBUG)
32407103 5623 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
72f03900 5624#endif
d2ef05bb
PM		 5625 if (ie->do_ioctl) {
5626 return ie->do_ioctl(ie, buf_temp, fd, cmd, arg);
8cb762fe
HD		 5627 } else if (!ie->host_cmd) {
5628 /* Some architectures define BSD ioctls in their headers
5629 that are not implemented in Linux. */
5630 return -TARGET_ENOSYS;
d2ef05bb
PM		 5631 }
5632
31e31b8a
FB		 5633 switch(arg_type[0]) {
5634 case TYPE_NULL:
5635 /* no argument */
49ca6f3e 5636 ret = get_errno(safe_ioctl(fd, ie->host_cmd));
31e31b8a
FB		 5637 break;
5638 case TYPE_PTRVOID:
5639 case TYPE_INT:
49ca6f3e 5640 ret = get_errno(safe_ioctl(fd, ie->host_cmd, arg));
31e31b8a
FB		 5641 break;
5642 case TYPE_PTR:
5643 arg_type++;
53a5960a 5644 target_size = thunk_type_size(arg_type, 0);
31e31b8a
FB		 5645 switch(ie->access) {
5646 case IOC_R:
49ca6f3e 5647 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a 5648 if (!is_error(ret)) {
579a97f7
FB		 5649 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5650 if (!argptr)
5651 return -TARGET_EFAULT;
53a5960a
PB		 5652 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5653 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 5654 }
5655 break;
5656 case IOC_W:
579a97f7
FB		 5657 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5658 if (!argptr)
5659 return -TARGET_EFAULT;
53a5960a
PB		 5660 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5661 unlock_user(argptr, arg, 0);
49ca6f3e 5662 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a
FB		 5663 break;
5664 default:
5665 case IOC_RW:
579a97f7
FB		 5666 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5667 if (!argptr)
5668 return -TARGET_EFAULT;
53a5960a
PB		 5669 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5670 unlock_user(argptr, arg, 0);
49ca6f3e 5671 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a 5672 if (!is_error(ret)) {
579a97f7
FB		 5673 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5674 if (!argptr)
5675 return -TARGET_EFAULT;
53a5960a
PB		 5676 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5677 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 5678 }
5679 break;
5680 }
5681 break;
5682 default:
32407103
JM		 5683 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5684 (long)cmd, arg_type[0]);
0da46a6e 5685 ret = -TARGET_ENOSYS;
31e31b8a
FB		 5686 break;
5687 }
5688 return ret;
5689}
5690
b39bc503 5691static const bitmask_transtbl iflag_tbl[] = {
31e31b8a
FB		 5692 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
5693 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
5694 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
5695 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
5696 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
5697 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
5698 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
5699 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
5700 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
5701 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
5702 { TARGET_IXON, TARGET_IXON, IXON, IXON },
5703 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
5704 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
5705 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
5706 { 0, 0, 0, 0 }
5707};
5708
b39bc503 5709static const bitmask_transtbl oflag_tbl[] = {
31e31b8a
FB		 5710 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
5711 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
5712 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
5713 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
5714 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
5715 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
5716 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
5717 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
5718 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
5719 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
5720 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
5721 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
5722 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
5723 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
5724 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
5725 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
5726 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
5727 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
5728 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
5729 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
5730 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
5731 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
5732 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
5733 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
5734 { 0, 0, 0, 0 }
5735};
5736
b39bc503 5737static const bitmask_transtbl cflag_tbl[] = {
31e31b8a
FB		 5738 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
5739 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
5740 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
5741 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
5742 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
5743 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
5744 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
5745 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
5746 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
5747 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
5748 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
5749 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
5750 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
5751 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
5752 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
5753 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
5754 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
5755 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
5756 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
5757 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
5758 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
5759 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
5760 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
5761 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
5762 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
5763 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
5764 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
5765 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
5766 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
5767 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
5768 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
5769 { 0, 0, 0, 0 }
5770};
5771
b39bc503 5772static const bitmask_transtbl lflag_tbl[] = {
31e31b8a
FB		 5773 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
5774 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
5775 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
5776 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
5777 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
5778 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
5779 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
5780 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
5781 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
5782 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
5783 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
5784 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
5785 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
5786 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
5787 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
5788 { 0, 0, 0, 0 }
5789};
5790
5791static void target_to_host_termios (void *dst, const void *src)
5792{
5793 struct host_termios *host = dst;
5794 const struct target_termios *target = src;
3b46e624 5795
5fafdf24 5796 host->c_iflag =
31e31b8a 5797 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
5fafdf24 5798 host->c_oflag =
31e31b8a 5799 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
5fafdf24 5800 host->c_cflag =
31e31b8a 5801 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
5fafdf24 5802 host->c_lflag =
31e31b8a
FB		 5803 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
5804 host->c_line = target->c_line;
3b46e624 5805
44607123 5806 memset(host->c_cc, 0, sizeof(host->c_cc));
5fafdf24
TS		 5807 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
5808 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
3b46e624 5809 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
5fafdf24 5810 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
3b46e624 5811 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
5fafdf24 5812 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
3b46e624 5813 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
5fafdf24 5814 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
3b46e624 5815 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
5fafdf24
TS		 5816 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
5817 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
3b46e624
TS		 5818 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
5819 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
5820 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
5821 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
5822 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
5fafdf24 5823 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
31e31b8a 5824}
3b46e624 5825
31e31b8a
FB		 5826static void host_to_target_termios (void *dst, const void *src)
5827{
5828 struct target_termios *target = dst;
5829 const struct host_termios *host = src;
5830
5fafdf24 5831 target->c_iflag =
31e31b8a 5832 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
5fafdf24 5833 target->c_oflag =
31e31b8a 5834 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
5fafdf24 5835 target->c_cflag =
31e31b8a 5836 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
5fafdf24 5837 target->c_lflag =
31e31b8a
FB		 5838 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
5839 target->c_line = host->c_line;
3b46e624 5840
44607123 5841 memset(target->c_cc, 0, sizeof(target->c_cc));
31e31b8a
FB		 5842 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
5843 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
5844 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
5845 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
5846 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
5847 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
5848 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
5849 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
5850 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
5851 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
5852 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
5853 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
5854 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
5855 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
5856 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
5857 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
5858 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
5859}
5860
8e853dc7 5861static const StructEntry struct_termios_def = {
31e31b8a
FB		 5862 .convert = { host_to_target_termios, target_to_host_termios },
5863 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
5864 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
5865};
5866
5286db75
FB		 5867static bitmask_transtbl mmap_flags_tbl[] = {
5868 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
5869 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
5870 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
5871 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
5872 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
5873 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
5874 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
5875 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
e8efd8e7
CL		 5876 { TARGET_MAP_NORESERVE, TARGET_MAP_NORESERVE, MAP_NORESERVE,
5877 MAP_NORESERVE },
5286db75
FB		 5878 { 0, 0, 0, 0 }
5879};
5880
2ab83ea7 5881#if defined(TARGET_I386)
6dbad63e
FB		 5882
5883/* NOTE: there is really one LDT for all the threads */
b1d8e52e 5884static uint8_t *ldt_table;
6dbad63e 5885
03acab66 5886static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
6dbad63e
FB		 5887{
5888 int size;
53a5960a 5889 void *p;
6dbad63e
FB		 5890
5891 if (!ldt_table)
5892 return 0;
5893 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
5894 if (size > bytecount)
5895 size = bytecount;
579a97f7
FB		 5896 p = lock_user(VERIFY_WRITE, ptr, size, 0);
5897 if (!p)
03acab66 5898 return -TARGET_EFAULT;
579a97f7 5899 /* ??? Should this by byteswapped? */
53a5960a
PB		 5900 memcpy(p, ldt_table, size);
5901 unlock_user(p, ptr, size);
6dbad63e
FB		 5902 return size;
5903}
5904
5905/* XXX: add locking support */
03acab66
FB		 5906static abi_long write_ldt(CPUX86State *env,
5907 abi_ulong ptr, unsigned long bytecount, int oldmode)
6dbad63e
FB		 5908{
5909 struct target_modify_ldt_ldt_s ldt_info;
53a5960a 5910 struct target_modify_ldt_ldt_s *target_ldt_info;
6dbad63e 5911 int seg_32bit, contents, read_exec_only, limit_in_pages;
8d18e893 5912 int seg_not_present, useable, lm;
6dbad63e
FB		 5913 uint32_t *lp, entry_1, entry_2;
5914
5915 if (bytecount != sizeof(ldt_info))
03acab66 5916 return -TARGET_EINVAL;
579a97f7 5917 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
03acab66 5918 return -TARGET_EFAULT;
53a5960a 5919 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
cbb21eed 5920 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
53a5960a
PB		 5921 ldt_info.limit = tswap32(target_ldt_info->limit);
5922 ldt_info.flags = tswap32(target_ldt_info->flags);
5923 unlock_user_struct(target_ldt_info, ptr, 0);
3b46e624 5924
6dbad63e 5925 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
03acab66 5926 return -TARGET_EINVAL;
6dbad63e
FB		 5927 seg_32bit = ldt_info.flags & 1;
5928 contents = (ldt_info.flags >> 1) & 3;
5929 read_exec_only = (ldt_info.flags >> 3) & 1;
5930 limit_in_pages = (ldt_info.flags >> 4) & 1;
5931 seg_not_present = (ldt_info.flags >> 5) & 1;
5932 useable = (ldt_info.flags >> 6) & 1;
8d18e893
FB		 5933#ifdef TARGET_ABI32
5934 lm = 0;
5935#else
5936 lm = (ldt_info.flags >> 7) & 1;
5937#endif
6dbad63e
FB		 5938 if (contents == 3) {
5939 if (oldmode)
03acab66 5940 return -TARGET_EINVAL;
6dbad63e 5941 if (seg_not_present == 0)
03acab66 5942 return -TARGET_EINVAL;
6dbad63e
FB		 5943 }
5944 /* allocate the LDT */
5945 if (!ldt_table) {
e441570f
AZ		 5946 env->ldt.base = target_mmap(0,
5947 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
5948 PROT_READ|PROT_WRITE,
5949 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
5950 if (env->ldt.base == -1)
03acab66 5951 return -TARGET_ENOMEM;
e441570f
AZ		 5952 memset(g2h(env->ldt.base), 0,
5953 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
6dbad63e 5954 env->ldt.limit = 0xffff;
e441570f 5955 ldt_table = g2h(env->ldt.base);
6dbad63e
FB		 5956 }
5957
5958 /* NOTE: same code as Linux kernel */
5959 /* Allow LDTs to be cleared by the user. */
5960 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
5961 if (oldmode ||
5962 (contents == 0 &&
5963 read_exec_only == 1 &&
5964 seg_32bit == 0 &&
5965 limit_in_pages == 0 &&
5966 seg_not_present == 1 &&
5967 useable == 0 )) {
5968 entry_1 = 0;
5969 entry_2 = 0;
5970 goto install;
5971 }
5972 }
3b46e624 5973
6dbad63e
FB		 5974 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
5975 (ldt_info.limit & 0x0ffff);
5976 entry_2 = (ldt_info.base_addr & 0xff000000) |
5977 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
5978 (ldt_info.limit & 0xf0000) |
5979 ((read_exec_only ^ 1) << 9) |
5980 (contents << 10) |
5981 ((seg_not_present ^ 1) << 15) |
5982 (seg_32bit << 22) |
5983 (limit_in_pages << 23) |
8d18e893 5984 (lm << 21) |
6dbad63e
FB		 5985 0x7000;
5986 if (!oldmode)
5987 entry_2 |= (useable << 20);
14ae3ba7 5988
6dbad63e
FB		 5989 /* Install the new entry ... */
5990install:
5991 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
5992 lp[0] = tswap32(entry_1);
5993 lp[1] = tswap32(entry_2);
5994 return 0;
5995}
5996
5997/* specific and weird i386 syscalls */
8fcd3692
BS		 5998static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
5999 unsigned long bytecount)
6dbad63e 6000{
03acab66 6001 abi_long ret;
3b46e624 6002
6dbad63e
FB		 6003 switch (func) {
6004 case 0:
6005 ret = read_ldt(ptr, bytecount);
6006 break;
6007 case 1:
6008 ret = write_ldt(env, ptr, bytecount, 1);
6009 break;
6010 case 0x11:
6011 ret = write_ldt(env, ptr, bytecount, 0);
6012 break;
03acab66
FB		 6013 default:
6014 ret = -TARGET_ENOSYS;
6015 break;
6dbad63e
FB		 6016 }
6017 return ret;
6018}
1b6b029e 6019
4583f589 6020#if defined(TARGET_I386) && defined(TARGET_ABI32)
bc22eb44 6021abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 6022{
6023 uint64_t *gdt_table = g2h(env->gdt.base);
6024 struct target_modify_ldt_ldt_s ldt_info;
6025 struct target_modify_ldt_ldt_s *target_ldt_info;
6026 int seg_32bit, contents, read_exec_only, limit_in_pages;
6027 int seg_not_present, useable, lm;
6028 uint32_t *lp, entry_1, entry_2;
6029 int i;
6030
6031 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
6032 if (!target_ldt_info)
6033 return -TARGET_EFAULT;
6034 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
cbb21eed 6035 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
8d18e893
FB		 6036 ldt_info.limit = tswap32(target_ldt_info->limit);
6037 ldt_info.flags = tswap32(target_ldt_info->flags);
6038 if (ldt_info.entry_number == -1) {
6039 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
6040 if (gdt_table[i] == 0) {
6041 ldt_info.entry_number = i;
6042 target_ldt_info->entry_number = tswap32(i);
6043 break;
6044 }
6045 }
6046 }
6047 unlock_user_struct(target_ldt_info, ptr, 1);
6048
6049 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
6050 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
6051 return -TARGET_EINVAL;
6052 seg_32bit = ldt_info.flags & 1;
6053 contents = (ldt_info.flags >> 1) & 3;
6054 read_exec_only = (ldt_info.flags >> 3) & 1;
6055 limit_in_pages = (ldt_info.flags >> 4) & 1;
6056 seg_not_present = (ldt_info.flags >> 5) & 1;
6057 useable = (ldt_info.flags >> 6) & 1;
6058#ifdef TARGET_ABI32
6059 lm = 0;
6060#else
6061 lm = (ldt_info.flags >> 7) & 1;
6062#endif
6063
6064 if (contents == 3) {
6065 if (seg_not_present == 0)
6066 return -TARGET_EINVAL;
6067 }
6068
6069 /* NOTE: same code as Linux kernel */
6070 /* Allow LDTs to be cleared by the user. */
6071 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
6072 if ((contents == 0 &&
6073 read_exec_only == 1 &&
6074 seg_32bit == 0 &&
6075 limit_in_pages == 0 &&
6076 seg_not_present == 1 &&
6077 useable == 0 )) {
6078 entry_1 = 0;
6079 entry_2 = 0;
6080 goto install;
6081 }
6082 }
6083
6084 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
6085 (ldt_info.limit & 0x0ffff);
6086 entry_2 = (ldt_info.base_addr & 0xff000000) |
6087 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
6088 (ldt_info.limit & 0xf0000) |
6089 ((read_exec_only ^ 1) << 9) |
6090 (contents << 10) |
6091 ((seg_not_present ^ 1) << 15) |
6092 (seg_32bit << 22) |
6093 (limit_in_pages << 23) |
6094 (useable << 20) |
6095 (lm << 21) |
6096 0x7000;
6097
6098 /* Install the new entry ... */
6099install:
6100 lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
6101 lp[0] = tswap32(entry_1);
6102 lp[1] = tswap32(entry_2);
6103 return 0;
6104}
6105
8fcd3692 6106static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 6107{
6108 struct target_modify_ldt_ldt_s *target_ldt_info;
6109 uint64_t *gdt_table = g2h(env->gdt.base);
6110 uint32_t base_addr, limit, flags;
6111 int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
6112 int seg_not_present, useable, lm;
6113 uint32_t *lp, entry_1, entry_2;
6114
6115 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
6116 if (!target_ldt_info)
6117 return -TARGET_EFAULT;
6118 idx = tswap32(target_ldt_info->entry_number);
6119 if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
6120 idx > TARGET_GDT_ENTRY_TLS_MAX) {
6121 unlock_user_struct(target_ldt_info, ptr, 1);
6122 return -TARGET_EINVAL;
6123 }
6124 lp = (uint32_t *)(gdt_table + idx);
6125 entry_1 = tswap32(lp[0]);
6126 entry_2 = tswap32(lp[1]);
6127
6128 read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
6129 contents = (entry_2 >> 10) & 3;
6130 seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
6131 seg_32bit = (entry_2 >> 22) & 1;
6132 limit_in_pages = (entry_2 >> 23) & 1;
6133 useable = (entry_2 >> 20) & 1;
6134#ifdef TARGET_ABI32
6135 lm = 0;
6136#else
6137 lm = (entry_2 >> 21) & 1;
6138#endif
6139 flags = (seg_32bit << 0) | (contents << 1) |
6140 (read_exec_only << 3) | (limit_in_pages << 4) |
6141 (seg_not_present << 5) | (useable << 6) | (lm << 7);
6142 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000);
6143 base_addr = (entry_1 >> 16) |
6144 (entry_2 & 0xff000000) |
6145 ((entry_2 & 0xff) << 16);
cbb21eed 6146 target_ldt_info->base_addr = tswapal(base_addr);
8d18e893
FB		 6147 target_ldt_info->limit = tswap32(limit);
6148 target_ldt_info->flags = tswap32(flags);
6149 unlock_user_struct(target_ldt_info, ptr, 1);
6150 return 0;
6151}
4583f589 6152#endif /* TARGET_I386 && TARGET_ABI32 */
8d18e893 6153
d2fd1af7 6154#ifndef TARGET_ABI32
2667e71c 6155abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
d2fd1af7 6156{
1add8698 6157 abi_long ret = 0;
d2fd1af7
FB		 6158 abi_ulong val;
6159 int idx;
1add8698 6160
d2fd1af7
FB		 6161 switch(code) {
6162 case TARGET_ARCH_SET_GS:
6163 case TARGET_ARCH_SET_FS:
6164 if (code == TARGET_ARCH_SET_GS)
6165 idx = R_GS;
6166 else
6167 idx = R_FS;
6168 cpu_x86_load_seg(env, idx, 0);
6169 env->segs[idx].base = addr;
6170 break;
6171 case TARGET_ARCH_GET_GS:
6172 case TARGET_ARCH_GET_FS:
6173 if (code == TARGET_ARCH_GET_GS)
6174 idx = R_GS;
6175 else
6176 idx = R_FS;
6177 val = env->segs[idx].base;
6178 if (put_user(val, addr, abi_ulong))
1add8698 6179 ret = -TARGET_EFAULT;
d2fd1af7
FB		 6180 break;
6181 default:
6182 ret = -TARGET_EINVAL;
6183 break;
6184 }
1add8698 6185 return ret;
d2fd1af7
FB		 6186}
6187#endif
6188
2ab83ea7
FB		 6189#endif /* defined(TARGET_I386) */
6190
05098a93 6191#define NEW_STACK_SIZE 0x40000
d865bab5 6192
d865bab5
PB		 6193
6194static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
6195typedef struct {
9349b4f9 6196 CPUArchState *env;
d865bab5
PB		 6197 pthread_mutex_t mutex;
6198 pthread_cond_t cond;
6199 pthread_t thread;
6200 uint32_t tid;
6201 abi_ulong child_tidptr;
6202 abi_ulong parent_tidptr;
6203 sigset_t sigmask;
6204} new_thread_info;
6205
6206static void *clone_func(void *arg)
6207{
6208 new_thread_info *info = arg;
9349b4f9 6209 CPUArchState *env;
0d34282f 6210 CPUState *cpu;
edf8e2af 6211 TaskState *ts;
d865bab5 6212
70903763 6213 rcu_register_thread();
d865bab5 6214 env = info->env;
0d34282f 6215 cpu = ENV_GET_CPU(env);
a2247f8e 6216 thread_cpu = cpu;
0429a971 6217 ts = (TaskState *)cpu->opaque;
d865bab5 6218 info->tid = gettid();
0d34282f 6219 cpu->host_tid = info->tid;
edf8e2af 6220 task_settid(ts);
d865bab5
PB		 6221 if (info->child_tidptr)
6222 put_user_u32(info->tid, info->child_tidptr);
6223 if (info->parent_tidptr)
6224 put_user_u32(info->tid, info->parent_tidptr);
6225 /* Enable signals. */
6226 sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
6227 /* Signal to the parent that we're ready. */
6228 pthread_mutex_lock(&info->mutex);
6229 pthread_cond_broadcast(&info->cond);
6230 pthread_mutex_unlock(&info->mutex);
6231 /* Wait until the parent has finshed initializing the tls state. */
6232 pthread_mutex_lock(&clone_lock);
6233 pthread_mutex_unlock(&clone_lock);
6234 cpu_loop(env);
6235 /* never exits */
6236 return NULL;
6237}
1b6b029e 6238
0da46a6e
TS		 6239/* do_fork() Must return host values and target errnos (unlike most
6240 do_*() functions). */
9349b4f9 6241static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
d865bab5
PB		 6242 abi_ulong parent_tidptr, target_ulong newtls,
6243 abi_ulong child_tidptr)
1b6b029e 6244{
0429a971 6245 CPUState *cpu = ENV_GET_CPU(env);
1b6b029e 6246 int ret;
5cd4393b 6247 TaskState *ts;
0429a971 6248 CPUState *new_cpu;
9349b4f9 6249 CPUArchState *new_env;
d865bab5 6250 sigset_t sigmask;
3b46e624 6251
5ea2fc84
PM		 6252 flags &= ~CLONE_IGNORED_FLAGS;
6253
436d124b
AZ		 6254 /* Emulate vfork() with fork() */
6255 if (flags & CLONE_VFORK)
6256 flags &= ~(CLONE_VFORK | CLONE_VM);
6257
1b6b029e 6258 if (flags & CLONE_VM) {
0429a971 6259 TaskState *parent_ts = (TaskState *)cpu->opaque;
d865bab5
PB		 6260 new_thread_info info;
6261 pthread_attr_t attr;
24cb36a6 6262
5ea2fc84
PM		 6263 if (((flags & CLONE_THREAD_FLAGS) != CLONE_THREAD_FLAGS) ||
6264 (flags & CLONE_INVALID_THREAD_FLAGS)) {
6265 return -TARGET_EINVAL;
6266 }
6267
c78d65e8 6268 ts = g_new0(TaskState, 1);
624f7979 6269 init_task_state(ts);
1b6b029e 6270 /* we create a new CPU instance. */
c5be9f08 6271 new_env = cpu_copy(env);
6e68e076
PB		 6272 /* Init regs that differ from the parent. */
6273 cpu_clone_regs(new_env, newsp);
0429a971
AF		 6274 new_cpu = ENV_GET_CPU(new_env);
6275 new_cpu->opaque = ts;
edf8e2af
MW		 6276 ts->bprm = parent_ts->bprm;
6277 ts->info = parent_ts->info;
3d3efba0 6278 ts->signal_mask = parent_ts->signal_mask;
d865bab5 6279
7cfbd386 6280 if (flags & CLONE_CHILD_CLEARTID) {
c2764719
PB		 6281 ts->child_tidptr = child_tidptr;
6282 }
6283
7cfbd386 6284 if (flags & CLONE_SETTLS) {
d865bab5 6285 cpu_set_tls (new_env, newtls);
7cfbd386 6286 }
d865bab5
PB		 6287
6288 /* Grab a mutex so that thread setup appears atomic. */
6289 pthread_mutex_lock(&clone_lock);
6290
6291 memset(&info, 0, sizeof(info));
6292 pthread_mutex_init(&info.mutex, NULL);
6293 pthread_mutex_lock(&info.mutex);
6294 pthread_cond_init(&info.cond, NULL);
6295 info.env = new_env;
7cfbd386 6296 if (flags & CLONE_CHILD_SETTID) {
d865bab5 6297 info.child_tidptr = child_tidptr;
7cfbd386
PM		 6298 }
6299 if (flags & CLONE_PARENT_SETTID) {
d865bab5 6300 info.parent_tidptr = parent_tidptr;
7cfbd386 6301 }
d865bab5
PB		 6302
6303 ret = pthread_attr_init(&attr);
48e15fc2
NF		 6304 ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE);
6305 ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
d865bab5
PB		 6306 /* It is not safe to deliver signals until the child has finished
6307 initializing, so temporarily block all signals. */
6308 sigfillset(&sigmask);
6309 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
6310
b67cb68b
AB		 6311 /* If this is our first additional thread, we need to ensure we
6312 * generate code for parallel execution and flush old translations.
6313 */
6314 if (!parallel_cpus) {
6315 parallel_cpus = true;
6316 tb_flush(cpu);
6317 }
6318
d865bab5 6319 ret = pthread_create(&info.thread, &attr, clone_func, &info);
c2764719 6320 /* TODO: Free new CPU state if thread creation failed. */
d865bab5
PB		 6321
6322 sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
6323 pthread_attr_destroy(&attr);
6324 if (ret == 0) {
6325 /* Wait for the child to initialize. */
6326 pthread_cond_wait(&info.cond, &info.mutex);
6327 ret = info.tid;
d865bab5
PB		 6328 } else {
6329 ret = -1;
6330 }
6331 pthread_mutex_unlock(&info.mutex);
6332 pthread_cond_destroy(&info.cond);
6333 pthread_mutex_destroy(&info.mutex);
6334 pthread_mutex_unlock(&clone_lock);
1b6b029e
FB		 6335 } else {
6336 /* if no CLONE_VM, we consider it is a fork */
5ea2fc84
PM		 6337 if (flags & CLONE_INVALID_FORK_FLAGS) {
6338 return -TARGET_EINVAL;
6339 }
6340
6341 /* We can't support custom termination signals */
6342 if ((flags & CSIGNAL) != TARGET_SIGCHLD) {
93b4eff8
TB		 6343 return -TARGET_EINVAL;
6344 }
7d92d34e
TB		 6345
6346 if (block_signals()) {
6347 return -TARGET_ERESTARTSYS;
6348 }
6349
d865bab5 6350 fork_start();
1b6b029e 6351 ret = fork();
d865bab5 6352 if (ret == 0) {
2b1319c8 6353 /* Child Process. */
a59629fc 6354 rcu_after_fork();
d865bab5
PB		 6355 cpu_clone_regs(env, newsp);
6356 fork_end(1);
2b1319c8
AJ		 6357 /* There is a race condition here. The parent process could
6358 theoretically read the TID in the child process before the child
6359 tid is set. This would require using either ptrace
6360 (not implemented) or having *_tidptr to point at a shared memory
6361 mapping. We can't repeat the spinlock hack used above because
6362 the child process gets its own copy of the lock. */
d865bab5
PB		 6363 if (flags & CLONE_CHILD_SETTID)
6364 put_user_u32(gettid(), child_tidptr);
6365 if (flags & CLONE_PARENT_SETTID)
6366 put_user_u32(gettid(), parent_tidptr);
0429a971 6367 ts = (TaskState *)cpu->opaque;
d865bab5
PB		 6368 if (flags & CLONE_SETTLS)
6369 cpu_set_tls (env, newtls);
c2764719
PB		 6370 if (flags & CLONE_CHILD_CLEARTID)
6371 ts->child_tidptr = child_tidptr;
d865bab5
PB		 6372 } else {
6373 fork_end(0);
6374 }
1b6b029e
FB		 6375 }
6376 return ret;
6377}
6378
5f106811
APR		 6379/* warning : doesn't handle linux specific flags... */
6380static int target_to_host_fcntl_cmd(int cmd)
6381{
6382 switch(cmd) {
6383 case TARGET_F_DUPFD:
6384 case TARGET_F_GETFD:
6385 case TARGET_F_SETFD:
6386 case TARGET_F_GETFL:
6387 case TARGET_F_SETFL:
6388 return cmd;
6389 case TARGET_F_GETLK:
213d3e9e
PM		 6390 return F_GETLK64;
6391 case TARGET_F_SETLK:
6392 return F_SETLK64;
6393 case TARGET_F_SETLKW:
6394 return F_SETLKW64;
5f106811
APR		 6395 case TARGET_F_GETOWN:
6396 return F_GETOWN;
6397 case TARGET_F_SETOWN:
6398 return F_SETOWN;
6399 case TARGET_F_GETSIG:
6400 return F_GETSIG;
6401 case TARGET_F_SETSIG:
6402 return F_SETSIG;
6403#if TARGET_ABI_BITS == 32
6404 case TARGET_F_GETLK64:
6405 return F_GETLK64;
6406 case TARGET_F_SETLK64:
6407 return F_SETLK64;
6408 case TARGET_F_SETLKW64:
6409 return F_SETLKW64;
6410#endif
7e22e546
UH		 6411 case TARGET_F_SETLEASE:
6412 return F_SETLEASE;
6413 case TARGET_F_GETLEASE:
6414 return F_GETLEASE;
fbd5de9b 6415#ifdef F_DUPFD_CLOEXEC
7e22e546
UH		 6416 case TARGET_F_DUPFD_CLOEXEC:
6417 return F_DUPFD_CLOEXEC;
fbd5de9b 6418#endif
7e22e546
UH		 6419 case TARGET_F_NOTIFY:
6420 return F_NOTIFY;
8d5d3004
AS		 6421#ifdef F_GETOWN_EX
6422 case TARGET_F_GETOWN_EX:
6423 return F_GETOWN_EX;
6424#endif
6425#ifdef F_SETOWN_EX
6426 case TARGET_F_SETOWN_EX:
6427 return F_SETOWN_EX;
6428#endif
ddf31aa8 6429#ifdef F_SETPIPE_SZ
7e3b92ec
PM		 6430 case TARGET_F_SETPIPE_SZ:
6431 return F_SETPIPE_SZ;
6432 case TARGET_F_GETPIPE_SZ:
6433 return F_GETPIPE_SZ;
ddf31aa8 6434#endif
5f106811
APR		 6435 default:
6436 return -TARGET_EINVAL;
6437 }
6438 return -TARGET_EINVAL;
6439}
6440
2ba7f730
LV		 6441#define TRANSTBL_CONVERT(a) { -1, TARGET_##a, -1, a }
6442static const bitmask_transtbl flock_tbl[] = {
6443 TRANSTBL_CONVERT(F_RDLCK),
6444 TRANSTBL_CONVERT(F_WRLCK),
6445 TRANSTBL_CONVERT(F_UNLCK),
6446 TRANSTBL_CONVERT(F_EXLCK),
6447 TRANSTBL_CONVERT(F_SHLCK),
6448 { 0, 0, 0, 0 }
6449};
6450
213d3e9e
PM		 6451static inline abi_long copy_from_user_flock(struct flock64 *fl,
6452 abi_ulong target_flock_addr)
7775e9ec 6453{
53a5960a 6454 struct target_flock *target_fl;
213d3e9e
PM		 6455 short l_type;
6456
6457 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6458 return -TARGET_EFAULT;
6459 }
6460
6461 __get_user(l_type, &target_fl->l_type);
6462 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6463 __get_user(fl->l_whence, &target_fl->l_whence);
6464 __get_user(fl->l_start, &target_fl->l_start);
6465 __get_user(fl->l_len, &target_fl->l_len);
6466 __get_user(fl->l_pid, &target_fl->l_pid);
6467 unlock_user_struct(target_fl, target_flock_addr, 0);
6468 return 0;
6469}
6470
6471static inline abi_long copy_to_user_flock(abi_ulong target_flock_addr,
6472 const struct flock64 *fl)
6473{
6474 struct target_flock *target_fl;
6475 short l_type;
6476
6477 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6478 return -TARGET_EFAULT;
6479 }
6480
6481 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6482 __put_user(l_type, &target_fl->l_type);
6483 __put_user(fl->l_whence, &target_fl->l_whence);
6484 __put_user(fl->l_start, &target_fl->l_start);
6485 __put_user(fl->l_len, &target_fl->l_len);
6486 __put_user(fl->l_pid, &target_fl->l_pid);
6487 unlock_user_struct(target_fl, target_flock_addr, 1);
6488 return 0;
6489}
6490
6491typedef abi_long from_flock64_fn(struct flock64 *fl, abi_ulong target_addr);
6492typedef abi_long to_flock64_fn(abi_ulong target_addr, const struct flock64 *fl);
6493
6494#if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6495static inline abi_long copy_from_user_eabi_flock64(struct flock64 *fl,
6496 abi_ulong target_flock_addr)
6497{
6498 struct target_eabi_flock64 *target_fl;
6499 short l_type;
6500
6501 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6502 return -TARGET_EFAULT;
6503 }
6504
6505 __get_user(l_type, &target_fl->l_type);
6506 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6507 __get_user(fl->l_whence, &target_fl->l_whence);
6508 __get_user(fl->l_start, &target_fl->l_start);
6509 __get_user(fl->l_len, &target_fl->l_len);
6510 __get_user(fl->l_pid, &target_fl->l_pid);
6511 unlock_user_struct(target_fl, target_flock_addr, 0);
6512 return 0;
6513}
6514
6515static inline abi_long copy_to_user_eabi_flock64(abi_ulong target_flock_addr,
6516 const struct flock64 *fl)
6517{
6518 struct target_eabi_flock64 *target_fl;
6519 short l_type;
6520
6521 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6522 return -TARGET_EFAULT;
6523 }
6524
6525 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6526 __put_user(l_type, &target_fl->l_type);
6527 __put_user(fl->l_whence, &target_fl->l_whence);
6528 __put_user(fl->l_start, &target_fl->l_start);
6529 __put_user(fl->l_len, &target_fl->l_len);
6530 __put_user(fl->l_pid, &target_fl->l_pid);
6531 unlock_user_struct(target_fl, target_flock_addr, 1);
6532 return 0;
6533}
6534#endif
6535
6536static inline abi_long copy_from_user_flock64(struct flock64 *fl,
6537 abi_ulong target_flock_addr)
6538{
6539 struct target_flock64 *target_fl;
6540 short l_type;
6541
6542 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6543 return -TARGET_EFAULT;
6544 }
6545
6546 __get_user(l_type, &target_fl->l_type);
6547 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6548 __get_user(fl->l_whence, &target_fl->l_whence);
6549 __get_user(fl->l_start, &target_fl->l_start);
6550 __get_user(fl->l_len, &target_fl->l_len);
6551 __get_user(fl->l_pid, &target_fl->l_pid);
6552 unlock_user_struct(target_fl, target_flock_addr, 0);
6553 return 0;
6554}
6555
6556static inline abi_long copy_to_user_flock64(abi_ulong target_flock_addr,
6557 const struct flock64 *fl)
6558{
6559 struct target_flock64 *target_fl;
6560 short l_type;
6561
6562 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6563 return -TARGET_EFAULT;
6564 }
6565
6566 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6567 __put_user(l_type, &target_fl->l_type);
6568 __put_user(fl->l_whence, &target_fl->l_whence);
6569 __put_user(fl->l_start, &target_fl->l_start);
6570 __put_user(fl->l_len, &target_fl->l_len);
6571 __put_user(fl->l_pid, &target_fl->l_pid);
6572 unlock_user_struct(target_fl, target_flock_addr, 1);
6573 return 0;
6574}
6575
6576static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
6577{
43f238d7 6578 struct flock64 fl64;
8d5d3004
AS		 6579#ifdef F_GETOWN_EX
6580 struct f_owner_ex fox;
6581 struct target_f_owner_ex *target_fox;
6582#endif
992f48a0 6583 abi_long ret;
5f106811
APR		 6584 int host_cmd = target_to_host_fcntl_cmd(cmd);
6585
6586 if (host_cmd == -TARGET_EINVAL)
6587 return host_cmd;
53a5960a 6588
7775e9ec
FB		 6589 switch(cmd) {
6590 case TARGET_F_GETLK:
213d3e9e
PM		 6591 ret = copy_from_user_flock(&fl64, arg);
6592 if (ret) {
6593 return ret;
6594 }
435da5e7 6595 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec 6596 if (ret == 0) {
213d3e9e 6597 ret = copy_to_user_flock(arg, &fl64);
7775e9ec
FB		 6598 }
6599 break;
3b46e624 6600
7775e9ec
FB		 6601 case TARGET_F_SETLK:
6602 case TARGET_F_SETLKW:
213d3e9e
PM		 6603 ret = copy_from_user_flock(&fl64, arg);
6604 if (ret) {
6605 return ret;
6606 }
435da5e7 6607 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec 6608 break;
3b46e624 6609
7775e9ec 6610 case TARGET_F_GETLK64:
213d3e9e
PM		 6611 ret = copy_from_user_flock64(&fl64, arg);
6612 if (ret) {
6613 return ret;
6614 }
435da5e7 6615 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
43f238d7 6616 if (ret == 0) {
213d3e9e 6617 ret = copy_to_user_flock64(arg, &fl64);
43f238d7 6618 }
9ee1fa2c 6619 break;
7775e9ec
FB		 6620 case TARGET_F_SETLK64:
6621 case TARGET_F_SETLKW64:
213d3e9e
PM		 6622 ret = copy_from_user_flock64(&fl64, arg);
6623 if (ret) {
6624 return ret;
6625 }
435da5e7 6626 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec
FB		 6627 break;
6628
5f106811 6629 case TARGET_F_GETFL:
435da5e7 6630 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
9ee1fa2c
FB		 6631 if (ret >= 0) {
6632 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
6633 }
ffa65c3b
FB		 6634 break;
6635
5f106811 6636 case TARGET_F_SETFL:
435da5e7
PM		 6637 ret = get_errno(safe_fcntl(fd, host_cmd,
6638 target_to_host_bitmask(arg,
6639 fcntl_flags_tbl)));
5f106811
APR		 6640 break;
6641
8d5d3004
AS		 6642#ifdef F_GETOWN_EX
6643 case TARGET_F_GETOWN_EX:
435da5e7 6644 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
8d5d3004
AS		 6645 if (ret >= 0) {
6646 if (!lock_user_struct(VERIFY_WRITE, target_fox, arg, 0))
6647 return -TARGET_EFAULT;
6648 target_fox->type = tswap32(fox.type);
6649 target_fox->pid = tswap32(fox.pid);
6650 unlock_user_struct(target_fox, arg, 1);
6651 }
6652 break;
6653#endif
6654
6655#ifdef F_SETOWN_EX
6656 case TARGET_F_SETOWN_EX:
6657 if (!lock_user_struct(VERIFY_READ, target_fox, arg, 1))
6658 return -TARGET_EFAULT;
6659 fox.type = tswap32(target_fox->type);
6660 fox.pid = tswap32(target_fox->pid);
6661 unlock_user_struct(target_fox, arg, 0);
435da5e7 6662 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
8d5d3004
AS		 6663 break;
6664#endif
6665
5f106811
APR		 6666 case TARGET_F_SETOWN:
6667 case TARGET_F_GETOWN:
6668 case TARGET_F_SETSIG:
6669 case TARGET_F_GETSIG:
7e22e546
UH		 6670 case TARGET_F_SETLEASE:
6671 case TARGET_F_GETLEASE:
7e3b92ec
PM		 6672 case TARGET_F_SETPIPE_SZ:
6673 case TARGET_F_GETPIPE_SZ:
435da5e7 6674 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
ffa65c3b
FB		 6675 break;
6676
7775e9ec 6677 default:
435da5e7 6678 ret = get_errno(safe_fcntl(fd, cmd, arg));
7775e9ec
FB		 6679 break;
6680 }
6681 return ret;
6682}
6683
67867308 6684#ifdef USE_UID16
7775e9ec 6685
67867308
FB		 6686static inline int high2lowuid(int uid)
6687{
6688 if (uid > 65535)
6689 return 65534;
6690 else
6691 return uid;
6692}
6693
6694static inline int high2lowgid(int gid)
6695{
6696 if (gid > 65535)
6697 return 65534;
6698 else
6699 return gid;
6700}
6701
6702static inline int low2highuid(int uid)
6703{
6704 if ((int16_t)uid == -1)
6705 return -1;
6706 else
6707 return uid;
6708}
6709
6710static inline int low2highgid(int gid)
6711{
6712 if ((int16_t)gid == -1)
6713 return -1;
6714 else
6715 return gid;
6716}
0c866a7e
RV		 6717static inline int tswapid(int id)
6718{
6719 return tswap16(id);
6720}
76ca310a
PM		 6721
6722#define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6723
0c866a7e
RV		 6724#else /* !USE_UID16 */
6725static inline int high2lowuid(int uid)
6726{
6727 return uid;
6728}
6729static inline int high2lowgid(int gid)
6730{
6731 return gid;
6732}
6733static inline int low2highuid(int uid)
6734{
6735 return uid;
6736}
6737static inline int low2highgid(int gid)
6738{
6739 return gid;
6740}
6741static inline int tswapid(int id)
6742{
6743 return tswap32(id);
6744}
76ca310a
PM		 6745
6746#define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6747
67867308 6748#endif /* USE_UID16 */
1b6b029e 6749
fd6f7798
PM		 6750/* We must do direct syscalls for setting UID/GID, because we want to
6751 * implement the Linux system call semantics of "change only for this thread",
6752 * not the libc/POSIX semantics of "change for all threads in process".
6753 * (See http://ewontfix.com/17/ for more details.)
6754 * We use the 32-bit version of the syscalls if present; if it is not
6755 * then either the host architecture supports 32-bit UIDs natively with
6756 * the standard syscall, or the 16-bit UID is the best we can do.
6757 */
6758#ifdef __NR_setuid32
6759#define __NR_sys_setuid __NR_setuid32
6760#else
6761#define __NR_sys_setuid __NR_setuid
6762#endif
6763#ifdef __NR_setgid32
6764#define __NR_sys_setgid __NR_setgid32
6765#else
6766#define __NR_sys_setgid __NR_setgid
6767#endif
6768#ifdef __NR_setresuid32
6769#define __NR_sys_setresuid __NR_setresuid32
6770#else
6771#define __NR_sys_setresuid __NR_setresuid
6772#endif
6773#ifdef __NR_setresgid32
6774#define __NR_sys_setresgid __NR_setresgid32
6775#else
6776#define __NR_sys_setresgid __NR_setresgid
6777#endif
6778
6779_syscall1(int, sys_setuid, uid_t, uid)
6780_syscall1(int, sys_setgid, gid_t, gid)
6781_syscall3(int, sys_setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
6782_syscall3(int, sys_setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
6783
31e31b8a
FB		 6784void syscall_init(void)
6785{
2ab83ea7
FB		 6786 IOCTLEntry *ie;
6787 const argtype *arg_type;
6788 int size;
b92c47c1 6789 int i;
2ab83ea7 6790
8be656b8
AG		 6791 thunk_init(STRUCT_MAX);
6792
001faf32 6793#define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
5fafdf24 6794#define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
31e31b8a
FB		 6795#include "syscall_types.h"
6796#undef STRUCT
6797#undef STRUCT_SPECIAL
2ab83ea7 6798
dd6e957a
PM		 6799 /* Build target_to_host_errno_table[] table from
6800 * host_to_target_errno_table[]. */
6801 for (i = 0; i < ERRNO_TABLE_SIZE; i++) {
6802 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
6803 }
6804
2ab83ea7
FB		 6805 /* we patch the ioctl size if necessary. We rely on the fact that
6806 no ioctl has all the bits at '1' in the size field */
6807 ie = ioctl_entries;
6808 while (ie->target_cmd != 0) {
6809 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
6810 TARGET_IOC_SIZEMASK) {
6811 arg_type = ie->arg_type;
6812 if (arg_type[0] != TYPE_PTR) {
5fafdf24 6813 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
2ab83ea7
FB		 6814 ie->target_cmd);
6815 exit(1);
6816 }
6817 arg_type++;
6818 size = thunk_type_size(arg_type, 0);
5fafdf24 6819 ie->target_cmd = (ie->target_cmd &
2ab83ea7
FB		 6820 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
6821 (size << TARGET_IOC_SIZESHIFT);
6822 }
b92c47c1 6823
2ab83ea7 6824 /* automatic consistency check if same arch */
872ea0c0
AZ		 6825#if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6826 (defined(__x86_64__) && defined(TARGET_X86_64))
6827 if (unlikely(ie->target_cmd != ie->host_cmd)) {
6828 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6829 ie->name, ie->target_cmd, ie->host_cmd);
2ab83ea7
FB		 6830 }
6831#endif
6832 ie++;
6833 }
31e31b8a 6834}
c573ff67 6835
992f48a0 6836#if TARGET_ABI_BITS == 32
ce4defa0
PB		 6837static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
6838{
af325d36 6839#ifdef TARGET_WORDS_BIGENDIAN
ce4defa0
PB		 6840 return ((uint64_t)word0 << 32) | word1;
6841#else
6842 return ((uint64_t)word1 << 32) | word0;
6843#endif
6844}
992f48a0 6845#else /* TARGET_ABI_BITS == 32 */
32407103
JM		 6846static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
6847{
6848 return word0;
6849}
992f48a0 6850#endif /* TARGET_ABI_BITS != 32 */
ce4defa0
PB		 6851
6852#ifdef TARGET_NR_truncate64
992f48a0
BS		 6853static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
6854 abi_long arg2,
6855 abi_long arg3,
6856 abi_long arg4)
ce4defa0 6857{
48e515d4 6858 if (regpairs_aligned(cpu_env)) {
ce4defa0
PB		 6859 arg2 = arg3;
6860 arg3 = arg4;
48e515d4 6861 }
ce4defa0
PB		 6862 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
6863}
6864#endif
6865
6866#ifdef TARGET_NR_ftruncate64
992f48a0
BS		 6867static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
6868 abi_long arg2,
6869 abi_long arg3,
6870 abi_long arg4)
ce4defa0 6871{
48e515d4 6872 if (regpairs_aligned(cpu_env)) {
ce4defa0
PB		 6873 arg2 = arg3;
6874 arg3 = arg4;
48e515d4 6875 }
ce4defa0
PB		 6876 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
6877}
6878#endif
6879
579a97f7
FB		 6880static inline abi_long target_to_host_timespec(struct timespec *host_ts,
6881 abi_ulong target_addr)
53a5960a
PB		 6882{
6883 struct target_timespec *target_ts;
6884
579a97f7
FB		 6885 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
6886 return -TARGET_EFAULT;
c7e35da3
PM		 6887 __get_user(host_ts->tv_sec, &target_ts->tv_sec);
6888 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
53a5960a 6889 unlock_user_struct(target_ts, target_addr, 0);
b255bfa8 6890 return 0;
53a5960a
PB		 6891}
6892
579a97f7
FB		 6893static inline abi_long host_to_target_timespec(abi_ulong target_addr,
6894 struct timespec *host_ts)
53a5960a
PB		 6895{
6896 struct target_timespec *target_ts;
6897
579a97f7
FB		 6898 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
6899 return -TARGET_EFAULT;
c7e35da3
PM		 6900 __put_user(host_ts->tv_sec, &target_ts->tv_sec);
6901 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
53a5960a 6902 unlock_user_struct(target_ts, target_addr, 1);
b255bfa8 6903 return 0;
53a5960a
PB		 6904}
6905
f4f1e10a
ECL		 6906static inline abi_long target_to_host_itimerspec(struct itimerspec *host_itspec,
6907 abi_ulong target_addr)
6908{
6909 struct target_itimerspec *target_itspec;
6910
6911 if (!lock_user_struct(VERIFY_READ, target_itspec, target_addr, 1)) {
6912 return -TARGET_EFAULT;
6913 }
6914
6915 host_itspec->it_interval.tv_sec =
6916 tswapal(target_itspec->it_interval.tv_sec);
6917 host_itspec->it_interval.tv_nsec =
6918 tswapal(target_itspec->it_interval.tv_nsec);
6919 host_itspec->it_value.tv_sec = tswapal(target_itspec->it_value.tv_sec);
6920 host_itspec->it_value.tv_nsec = tswapal(target_itspec->it_value.tv_nsec);
6921
6922 unlock_user_struct(target_itspec, target_addr, 1);
6923 return 0;
6924}
6925
6926static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
6927 struct itimerspec *host_its)
6928{
6929 struct target_itimerspec *target_itspec;
6930
6931 if (!lock_user_struct(VERIFY_WRITE, target_itspec, target_addr, 0)) {
6932 return -TARGET_EFAULT;
6933 }
6934
6935 target_itspec->it_interval.tv_sec = tswapal(host_its->it_interval.tv_sec);
6936 target_itspec->it_interval.tv_nsec = tswapal(host_its->it_interval.tv_nsec);
6937
6938 target_itspec->it_value.tv_sec = tswapal(host_its->it_value.tv_sec);
6939 target_itspec->it_value.tv_nsec = tswapal(host_its->it_value.tv_nsec);
6940
6941 unlock_user_struct(target_itspec, target_addr, 0);
6942 return 0;
6943}
6944
19f59bce
AM		 6945static inline abi_long target_to_host_timex(struct timex *host_tx,
6946 abi_long target_addr)
6947{
6948 struct target_timex *target_tx;
6949
6950 if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
6951 return -TARGET_EFAULT;
6952 }
6953
6954 __get_user(host_tx->modes, &target_tx->modes);
6955 __get_user(host_tx->offset, &target_tx->offset);
6956 __get_user(host_tx->freq, &target_tx->freq);
6957 __get_user(host_tx->maxerror, &target_tx->maxerror);
6958 __get_user(host_tx->esterror, &target_tx->esterror);
6959 __get_user(host_tx->status, &target_tx->status);
6960 __get_user(host_tx->constant, &target_tx->constant);
6961 __get_user(host_tx->precision, &target_tx->precision);
6962 __get_user(host_tx->tolerance, &target_tx->tolerance);
6963 __get_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
6964 __get_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
6965 __get_user(host_tx->tick, &target_tx->tick);
6966 __get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
6967 __get_user(host_tx->jitter, &target_tx->jitter);
6968 __get_user(host_tx->shift, &target_tx->shift);
6969 __get_user(host_tx->stabil, &target_tx->stabil);
6970 __get_user(host_tx->jitcnt, &target_tx->jitcnt);
6971 __get_user(host_tx->calcnt, &target_tx->calcnt);
6972 __get_user(host_tx->errcnt, &target_tx->errcnt);
6973 __get_user(host_tx->stbcnt, &target_tx->stbcnt);
6974 __get_user(host_tx->tai, &target_tx->tai);
6975
6976 unlock_user_struct(target_tx, target_addr, 0);
6977 return 0;
6978}
6979
6980static inline abi_long host_to_target_timex(abi_long target_addr,
6981 struct timex *host_tx)
6982{
6983 struct target_timex *target_tx;
6984
6985 if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
6986 return -TARGET_EFAULT;
6987 }
6988
6989 __put_user(host_tx->modes, &target_tx->modes);
6990 __put_user(host_tx->offset, &target_tx->offset);
6991 __put_user(host_tx->freq, &target_tx->freq);
6992 __put_user(host_tx->maxerror, &target_tx->maxerror);
6993 __put_user(host_tx->esterror, &target_tx->esterror);
6994 __put_user(host_tx->status, &target_tx->status);
6995 __put_user(host_tx->constant, &target_tx->constant);
6996 __put_user(host_tx->precision, &target_tx->precision);
6997 __put_user(host_tx->tolerance, &target_tx->tolerance);
6998 __put_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
6999 __put_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
7000 __put_user(host_tx->tick, &target_tx->tick);
7001 __put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7002 __put_user(host_tx->jitter, &target_tx->jitter);
7003 __put_user(host_tx->shift, &target_tx->shift);
7004 __put_user(host_tx->stabil, &target_tx->stabil);
7005 __put_user(host_tx->jitcnt, &target_tx->jitcnt);
7006 __put_user(host_tx->calcnt, &target_tx->calcnt);
7007 __put_user(host_tx->errcnt, &target_tx->errcnt);
7008 __put_user(host_tx->stbcnt, &target_tx->stbcnt);
7009 __put_user(host_tx->tai, &target_tx->tai);
7010
7011 unlock_user_struct(target_tx, target_addr, 1);
7012 return 0;
7013}
7014
7015
c065976f
PM		 7016static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp,
7017 abi_ulong target_addr)
7018{
7019 struct target_sigevent *target_sevp;
7020
7021 if (!lock_user_struct(VERIFY_READ, target_sevp, target_addr, 1)) {
7022 return -TARGET_EFAULT;
7023 }
7024
7025 /* This union is awkward on 64 bit systems because it has a 32 bit
7026 * integer and a pointer in it; we follow the conversion approach
7027 * used for handling sigval types in signal.c so the guest should get
7028 * the correct value back even if we did a 64 bit byteswap and it's
7029 * using the 32 bit integer.
7030 */
7031 host_sevp->sigev_value.sival_ptr =
7032 (void *)(uintptr_t)tswapal(target_sevp->sigev_value.sival_ptr);
7033 host_sevp->sigev_signo =
7034 target_to_host_signal(tswap32(target_sevp->sigev_signo));
7035 host_sevp->sigev_notify = tswap32(target_sevp->sigev_notify);
7036 host_sevp->_sigev_un._tid = tswap32(target_sevp->_sigev_un._tid);
7037
7038 unlock_user_struct(target_sevp, target_addr, 1);
7039 return 0;
7040}
7041
6f6a4032
TM		 7042#if defined(TARGET_NR_mlockall)
7043static inline int target_to_host_mlockall_arg(int arg)
7044{
7045 int result = 0;
7046
7047 if (arg & TARGET_MLOCKALL_MCL_CURRENT) {
7048 result |= MCL_CURRENT;
7049 }
7050 if (arg & TARGET_MLOCKALL_MCL_FUTURE) {
7051 result |= MCL_FUTURE;
7052 }
7053 return result;
7054}
7055#endif
7056
6a24a778
AZ		 7057static inline abi_long host_to_target_stat64(void *cpu_env,
7058 abi_ulong target_addr,
7059 struct stat *host_st)
7060{
09701199 7061#if defined(TARGET_ARM) && defined(TARGET_ABI32)
6a24a778
AZ		 7062 if (((CPUARMState *)cpu_env)->eabi) {
7063 struct target_eabi_stat64 *target_st;
7064
7065 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7066 return -TARGET_EFAULT;
7067 memset(target_st, 0, sizeof(struct target_eabi_stat64));
7068 __put_user(host_st->st_dev, &target_st->st_dev);
7069 __put_user(host_st->st_ino, &target_st->st_ino);
7070#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7071 __put_user(host_st->st_ino, &target_st->__st_ino);
7072#endif
7073 __put_user(host_st->st_mode, &target_st->st_mode);
7074 __put_user(host_st->st_nlink, &target_st->st_nlink);
7075 __put_user(host_st->st_uid, &target_st->st_uid);
7076 __put_user(host_st->st_gid, &target_st->st_gid);
7077 __put_user(host_st->st_rdev, &target_st->st_rdev);
7078 __put_user(host_st->st_size, &target_st->st_size);
7079 __put_user(host_st->st_blksize, &target_st->st_blksize);
7080 __put_user(host_st->st_blocks, &target_st->st_blocks);
7081 __put_user(host_st->st_atime, &target_st->target_st_atime);
7082 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7083 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7084 unlock_user_struct(target_st, target_addr, 1);
7085 } else
7086#endif
7087 {
20d155bc 7088#if defined(TARGET_HAS_STRUCT_STAT64)
6a24a778 7089 struct target_stat64 *target_st;
20d155bc
SW		 7090#else
7091 struct target_stat *target_st;
9d33b76b 7092#endif
6a24a778
AZ		 7093
7094 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7095 return -TARGET_EFAULT;
9d33b76b 7096 memset(target_st, 0, sizeof(*target_st));
6a24a778
AZ		 7097 __put_user(host_st->st_dev, &target_st->st_dev);
7098 __put_user(host_st->st_ino, &target_st->st_ino);
7099#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7100 __put_user(host_st->st_ino, &target_st->__st_ino);
7101#endif
7102 __put_user(host_st->st_mode, &target_st->st_mode);
7103 __put_user(host_st->st_nlink, &target_st->st_nlink);
7104 __put_user(host_st->st_uid, &target_st->st_uid);
7105 __put_user(host_st->st_gid, &target_st->st_gid);
7106 __put_user(host_st->st_rdev, &target_st->st_rdev);
7107 /* XXX: better use of kernel struct */
7108 __put_user(host_st->st_size, &target_st->st_size);
7109 __put_user(host_st->st_blksize, &target_st->st_blksize);
7110 __put_user(host_st->st_blocks, &target_st->st_blocks);
7111 __put_user(host_st->st_atime, &target_st->target_st_atime);
7112 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7113 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7114 unlock_user_struct(target_st, target_addr, 1);
7115 }
7116
7117 return 0;
7118}
6a24a778 7119
bd0c5661
PB		 7120/* ??? Using host futex calls even when target atomic operations
7121 are not really atomic probably breaks things. However implementing
7122 futexes locally would make futexes shared between multiple processes
7123 tricky. However they're probably useless because guest atomic
7124 operations won't work either. */
8fcd3692
BS		 7125static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
7126 target_ulong uaddr2, int val3)
bd0c5661
PB		 7127{
7128 struct timespec ts, *pts;
a16aae0c 7129 int base_op;
bd0c5661
PB		 7130
7131 /* ??? We assume FUTEX_* constants are the same on both host
7132 and target. */
a29ccd63 7133#ifdef FUTEX_CMD_MASK
a16aae0c 7134 base_op = op & FUTEX_CMD_MASK;
a29ccd63 7135#else
a16aae0c 7136 base_op = op;
a29ccd63 7137#endif
a16aae0c 7138 switch (base_op) {
bd0c5661 7139 case FUTEX_WAIT:
cce246e0 7140 case FUTEX_WAIT_BITSET:
bd0c5661
PB		 7141 if (timeout) {
7142 pts = &ts;
7143 target_to_host_timespec(pts, timeout);
7144 } else {
7145 pts = NULL;
7146 }
d509eeb1 7147 return get_errno(safe_futex(g2h(uaddr), op, tswap32(val),
cce246e0 7148 pts, NULL, val3));
bd0c5661 7149 case FUTEX_WAKE:
d509eeb1 7150 return get_errno(safe_futex(g2h(uaddr), op, val, NULL, NULL, 0));
bd0c5661 7151 case FUTEX_FD:
d509eeb1 7152 return get_errno(safe_futex(g2h(uaddr), op, val, NULL, NULL, 0));
bd0c5661 7153 case FUTEX_REQUEUE:
bd0c5661 7154 case FUTEX_CMP_REQUEUE:
a16aae0c
NF		 7155 case FUTEX_WAKE_OP:
7156 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7157 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7158 But the prototype takes a `struct timespec *'; insert casts
7159 to satisfy the compiler. We do not need to tswap TIMEOUT
7160 since it's not compared to guest memory. */
7161 pts = (struct timespec *)(uintptr_t) timeout;
d509eeb1
PM		 7162 return get_errno(safe_futex(g2h(uaddr), op, val, pts,
7163 g2h(uaddr2),
7164 (base_op == FUTEX_CMP_REQUEUE
7165 ? tswap32(val3)
7166 : val3)));
bd0c5661
PB		 7167 default:
7168 return -TARGET_ENOSYS;
7169 }
7170}
0f0426f3
LV		 7171#if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7172static abi_long do_name_to_handle_at(abi_long dirfd, abi_long pathname,
7173 abi_long handle, abi_long mount_id,
7174 abi_long flags)
7175{
7176 struct file_handle *target_fh;
7177 struct file_handle *fh;
7178 int mid = 0;
7179 abi_long ret;
7180 char *name;
7181 unsigned int size, total_size;
7182
7183 if (get_user_s32(size, handle)) {
7184 return -TARGET_EFAULT;
7185 }
7186
7187 name = lock_user_string(pathname);
7188 if (!name) {
7189 return -TARGET_EFAULT;
7190 }
7191
7192 total_size = sizeof(struct file_handle) + size;
7193 target_fh = lock_user(VERIFY_WRITE, handle, total_size, 0);
7194 if (!target_fh) {
7195 unlock_user(name, pathname, 0);
7196 return -TARGET_EFAULT;
7197 }
7198
7199 fh = g_malloc0(total_size);
7200 fh->handle_bytes = size;
7201
7202 ret = get_errno(name_to_handle_at(dirfd, path(name), fh, &mid, flags));
7203 unlock_user(name, pathname, 0);
7204
7205 /* man name_to_handle_at(2):
7206 * Other than the use of the handle_bytes field, the caller should treat
7207 * the file_handle structure as an opaque data type
7208 */
7209
7210 memcpy(target_fh, fh, total_size);
7211 target_fh->handle_bytes = tswap32(fh->handle_bytes);
7212 target_fh->handle_type = tswap32(fh->handle_type);
7213 g_free(fh);
7214 unlock_user(target_fh, handle, total_size);
7215
7216 if (put_user_s32(mid, mount_id)) {
7217 return -TARGET_EFAULT;
7218 }
7219
7220 return ret;
7221
7222}
7223#endif
7224
7225#if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7226static abi_long do_open_by_handle_at(abi_long mount_fd, abi_long handle,
7227 abi_long flags)
7228{
7229 struct file_handle *target_fh;
7230 struct file_handle *fh;
7231 unsigned int size, total_size;
7232 abi_long ret;
7233
7234 if (get_user_s32(size, handle)) {
7235 return -TARGET_EFAULT;
7236 }
7237
7238 total_size = sizeof(struct file_handle) + size;
7239 target_fh = lock_user(VERIFY_READ, handle, total_size, 1);
7240 if (!target_fh) {
7241 return -TARGET_EFAULT;
7242 }
7243
e9d49d51 7244 fh = g_memdup(target_fh, total_size);
0f0426f3
LV		 7245 fh->handle_bytes = size;
7246 fh->handle_type = tswap32(target_fh->handle_type);
7247
7248 ret = get_errno(open_by_handle_at(mount_fd, fh,
7249 target_to_host_bitmask(flags, fcntl_flags_tbl)));
7250
7251 g_free(fh);
7252
7253 unlock_user(target_fh, handle, total_size);
7254
7255 return ret;
7256}
7257#endif
bd0c5661 7258
e36800c9
LV		 7259#if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7260
7261/* signalfd siginfo conversion */
7262
7263static void
7264host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
7265 const struct signalfd_siginfo *info)
7266{
7267 int sig = host_to_target_signal(info->ssi_signo);
7268
7269 /* linux/signalfd.h defines a ssi_addr_lsb
7270 * not defined in sys/signalfd.h but used by some kernels
7271 */
7272
7273#ifdef BUS_MCEERR_AO
7274 if (tinfo->ssi_signo == SIGBUS &&
7275 (tinfo->ssi_code == BUS_MCEERR_AR ||
7276 tinfo->ssi_code == BUS_MCEERR_AO)) {
7277 uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
7278 uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
7279 *tssi_addr_lsb = tswap16(*ssi_addr_lsb);
7280 }
7281#endif
7282
7283 tinfo->ssi_signo = tswap32(sig);
7284 tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
7285 tinfo->ssi_code = tswap32(info->ssi_code);
7286 tinfo->ssi_pid = tswap32(info->ssi_pid);
7287 tinfo->ssi_uid = tswap32(info->ssi_uid);
7288 tinfo->ssi_fd = tswap32(info->ssi_fd);
7289 tinfo->ssi_tid = tswap32(info->ssi_tid);
7290 tinfo->ssi_band = tswap32(info->ssi_band);
7291 tinfo->ssi_overrun = tswap32(info->ssi_overrun);
7292 tinfo->ssi_trapno = tswap32(info->ssi_trapno);
7293 tinfo->ssi_status = tswap32(info->ssi_status);
7294 tinfo->ssi_int = tswap32(info->ssi_int);
7295 tinfo->ssi_ptr = tswap64(info->ssi_ptr);
7296 tinfo->ssi_utime = tswap64(info->ssi_utime);
7297 tinfo->ssi_stime = tswap64(info->ssi_stime);
7298 tinfo->ssi_addr = tswap64(info->ssi_addr);
7299}
7300
5d4d3665 7301static abi_long host_to_target_data_signalfd(void *buf, size_t len)
e36800c9
LV		 7302{
7303 int i;
7304
7305 for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
7306 host_to_target_signalfd_siginfo(buf + i, buf + i);
7307 }
7308
7309 return len;
7310}
7311
7312static TargetFdTrans target_signalfd_trans = {
5d4d3665 7313 .host_to_target_data = host_to_target_data_signalfd,
e36800c9
LV		 7314};
7315
7316static abi_long do_signalfd4(int fd, abi_long mask, int flags)
7317{
7318 int host_flags;
7319 target_sigset_t *target_mask;
7320 sigset_t host_mask;
7321 abi_long ret;
7322
7323 if (flags & ~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC)) {
7324 return -TARGET_EINVAL;
7325 }
7326 if (!lock_user_struct(VERIFY_READ, target_mask, mask, 1)) {
7327 return -TARGET_EFAULT;
7328 }
7329
7330 target_to_host_sigset(&host_mask, target_mask);
7331
7332 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
7333
7334 ret = get_errno(signalfd(fd, &host_mask, host_flags));
7335 if (ret >= 0) {
7336 fd_trans_register(ret, &target_signalfd_trans);
7337 }
7338
7339 unlock_user_struct(target_mask, mask, 0);
7340
7341 return ret;
7342}
7343#endif
7344
1d9d8b55
PB		 7345/* Map host to target signal numbers for the wait family of syscalls.
7346 Assume all other status bits are the same. */
a05c6409 7347int host_to_target_waitstatus(int status)
1d9d8b55
PB		 7348{
7349 if (WIFSIGNALED(status)) {
7350 return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
7351 }
7352 if (WIFSTOPPED(status)) {
7353 return (host_to_target_signal(WSTOPSIG(status)) << 8)
7354 | (status & 0xff);
7355 }
7356 return status;
7357}
7358
76b94245
WVS		 7359static int open_self_cmdline(void *cpu_env, int fd)
7360{
7361 int fd_orig = -1;
7362 bool word_skipped = false;
7363
7364 fd_orig = open("/proc/self/cmdline", O_RDONLY);
7365 if (fd_orig < 0) {
7366 return fd_orig;
7367 }
7368
7369 while (true) {
7370 ssize_t nb_read;
7371 char buf[128];
7372 char *cp_buf = buf;
7373
7374 nb_read = read(fd_orig, buf, sizeof(buf));
7375 if (nb_read < 0) {
a3ca7bb2 7376 int e = errno;
76b94245 7377 fd_orig = close(fd_orig);
a3ca7bb2 7378 errno = e;
76b94245
WVS		 7379 return -1;
7380 } else if (nb_read == 0) {
7381 break;
7382 }
7383
7384 if (!word_skipped) {
7385 /* Skip the first string, which is the path to qemu-*-static
7386 instead of the actual command. */
ba4b3f66 7387 cp_buf = memchr(buf, 0, nb_read);
76b94245
WVS		 7388 if (cp_buf) {
7389 /* Null byte found, skip one string */
7390 cp_buf++;
7391 nb_read -= cp_buf - buf;
7392 word_skipped = true;
7393 }
7394 }
7395
7396 if (word_skipped) {
7397 if (write(fd, cp_buf, nb_read) != nb_read) {
a3ca7bb2 7398 int e = errno;
680dfde9 7399 close(fd_orig);
a3ca7bb2 7400 errno = e;
76b94245
WVS		 7401 return -1;
7402 }
7403 }
7404 }
7405
7406 return close(fd_orig);
7407}
7408
36c08d49
AG		 7409static int open_self_maps(void *cpu_env, int fd)
7410{
0429a971
AF		 7411 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
7412 TaskState *ts = cpu->opaque;
1a49ef2a
AG		 7413 FILE *fp;
7414 char *line = NULL;
7415 size_t len = 0;
7416 ssize_t read;
7417
7418 fp = fopen("/proc/self/maps", "r");
7419 if (fp == NULL) {
a3ca7bb2 7420 return -1;
1a49ef2a 7421 }
36c08d49 7422
1a49ef2a
AG		 7423 while ((read = getline(&line, &len, fp)) != -1) {
7424 int fields, dev_maj, dev_min, inode;
7425 uint64_t min, max, offset;
7426 char flag_r, flag_w, flag_x, flag_p;
7427 char path[512] = "";
7428 fields = sscanf(line, "%"PRIx64"-%"PRIx64" %c%c%c%c %"PRIx64" %x:%x %d"
7429 " %512s", &min, &max, &flag_r, &flag_w, &flag_x,
7430 &flag_p, &offset, &dev_maj, &dev_min, &inode, path);
7431
7432 if ((fields < 10) || (fields > 11)) {
7433 continue;
7434 }
d67f4aaa
MI		 7435 if (h2g_valid(min)) {
7436 int flags = page_get_flags(h2g(min));
7437 max = h2g_valid(max - 1) ? max : (uintptr_t)g2h(GUEST_ADDR_MAX);
7438 if (page_check_range(h2g(min), max - min, flags) == -1) {
7439 continue;
7440 }
7441 if (h2g(min) == ts->info->stack_limit) {
7442 pstrcpy(path, sizeof(path), " [stack]");
7443 }
1a49ef2a 7444 dprintf(fd, TARGET_ABI_FMT_lx "-" TARGET_ABI_FMT_lx
e24fed4e 7445 " %c%c%c%c %08" PRIx64 " %02x:%02x %d %s%s\n",
d67f4aaa 7446 h2g(min), h2g(max - 1) + 1, flag_r, flag_w,
1a49ef2a 7447 flag_x, flag_p, offset, dev_maj, dev_min, inode,
e24fed4e 7448 path[0] ? " " : "", path);
1a49ef2a
AG		 7449 }
7450 }
7451
7452 free(line);
7453 fclose(fp);
7454
36c08d49
AG		 7455 return 0;
7456}
7457
480b8e7d
AG		 7458static int open_self_stat(void *cpu_env, int fd)
7459{
0429a971
AF		 7460 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
7461 TaskState *ts = cpu->opaque;
480b8e7d
AG		 7462 abi_ulong start_stack = ts->info->start_stack;
7463 int i;
7464
7465 for (i = 0; i < 44; i++) {
7466 char buf[128];
7467 int len;
7468 uint64_t val = 0;
7469
e0e65bee
FE		 7470 if (i == 0) {
7471 /* pid */
7472 val = getpid();
7473 snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
7474 } else if (i == 1) {
7475 /* app name */
7476 snprintf(buf, sizeof(buf), "(%s) ", ts->bprm->argv[0]);
7477 } else if (i == 27) {
7478 /* stack bottom */
7479 val = start_stack;
7480 snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
7481 } else {
7482 /* for the rest, there is MasterCard */
7483 snprintf(buf, sizeof(buf), "0%c", i == 43 ? '\n' : ' ');
480b8e7d 7484 }
e0e65bee 7485
480b8e7d
AG		 7486 len = strlen(buf);
7487 if (write(fd, buf, len) != len) {
7488 return -1;
7489 }
7490 }
7491
7492 return 0;
7493}
7494
257450ee
AG		 7495static int open_self_auxv(void *cpu_env, int fd)
7496{
0429a971
AF		 7497 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
7498 TaskState *ts = cpu->opaque;
257450ee
AG		 7499 abi_ulong auxv = ts->info->saved_auxv;
7500 abi_ulong len = ts->info->auxv_len;
7501 char *ptr;
7502
7503 /*
7504 * Auxiliary vector is stored in target process stack.
7505 * read in whole auxv vector and copy it to file
7506 */
7507 ptr = lock_user(VERIFY_READ, auxv, len, 0);
7508 if (ptr != NULL) {
7509 while (len > 0) {
7510 ssize_t r;
7511 r = write(fd, ptr, len);
7512 if (r <= 0) {
7513 break;
7514 }
7515 len -= r;
7516 ptr += r;
7517 }
7518 lseek(fd, 0, SEEK_SET);
7519 unlock_user(ptr, auxv, len);
7520 }
7521
7522 return 0;
7523}
7524
463d8e73
AS		 7525static int is_proc_myself(const char *filename, const char *entry)
7526{
7527 if (!strncmp(filename, "/proc/", strlen("/proc/"))) {
7528 filename += strlen("/proc/");
7529 if (!strncmp(filename, "self/", strlen("self/"))) {
7530 filename += strlen("self/");
7531 } else if (*filename >= '1' && *filename <= '9') {
7532 char myself[80];
7533 snprintf(myself, sizeof(myself), "%d/", getpid());
7534 if (!strncmp(filename, myself, strlen(myself))) {
7535 filename += strlen(myself);
7536 } else {
7537 return 0;
7538 }
7539 } else {
7540 return 0;
7541 }
7542 if (!strcmp(filename, entry)) {
7543 return 1;
7544 }
7545 }
7546 return 0;
7547}
7548
de6b9933
LV		 7549#if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7550static int is_proc(const char *filename, const char *entry)
7551{
7552 return strcmp(filename, entry) == 0;
7553}
7554
7555static int open_net_route(void *cpu_env, int fd)
7556{
7557 FILE *fp;
7558 char *line = NULL;
7559 size_t len = 0;
7560 ssize_t read;
7561
7562 fp = fopen("/proc/net/route", "r");
7563 if (fp == NULL) {
a3ca7bb2 7564 return -1;
de6b9933
LV		 7565 }
7566
7567 /* read header */
7568
7569 read = getline(&line, &len, fp);
7570 dprintf(fd, "%s", line);
7571
7572 /* read routes */
7573
7574 while ((read = getline(&line, &len, fp)) != -1) {
7575 char iface[16];
7576 uint32_t dest, gw, mask;
7577 unsigned int flags, refcnt, use, metric, mtu, window, irtt;
7578 sscanf(line, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7579 iface, &dest, &gw, &flags, &refcnt, &use, &metric,
7580 &mask, &mtu, &window, &irtt);
7581 dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7582 iface, tswap32(dest), tswap32(gw), flags, refcnt, use,
7583 metric, tswap32(mask), mtu, window, irtt);
7584 }
7585
7586 free(line);
7587 fclose(fp);
7588
7589 return 0;
7590}
7591#endif
7592
0b2effd7 7593static int do_openat(void *cpu_env, int dirfd, const char *pathname, int flags, mode_t mode)
3be14d05
AG		 7594{
7595 struct fake_open {
7596 const char *filename;
7597 int (*fill)(void *cpu_env, int fd);
de6b9933 7598 int (*cmp)(const char *s1, const char *s2);
3be14d05
AG		 7599 };
7600 const struct fake_open *fake_open;
7601 static const struct fake_open fakes[] = {
de6b9933
LV		 7602 { "maps", open_self_maps, is_proc_myself },
7603 { "stat", open_self_stat, is_proc_myself },
7604 { "auxv", open_self_auxv, is_proc_myself },
76b94245 7605 { "cmdline", open_self_cmdline, is_proc_myself },
de6b9933
LV		 7606#if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7607 { "/proc/net/route", open_net_route, is_proc },
7608#endif
7609 { NULL, NULL, NULL }
3be14d05
AG		 7610 };
7611
aa07f5ec
MO		 7612 if (is_proc_myself(pathname, "exe")) {
7613 int execfd = qemu_getauxval(AT_EXECFD);
c10a0738 7614 return execfd ? execfd : safe_openat(dirfd, exec_path, flags, mode);
aa07f5ec
MO		 7615 }
7616
3be14d05 7617 for (fake_open = fakes; fake_open->filename; fake_open++) {
de6b9933 7618 if (fake_open->cmp(pathname, fake_open->filename)) {
3be14d05
AG		 7619 break;
7620 }
7621 }
7622
7623 if (fake_open->filename) {
7624 const char *tmpdir;
7625 char filename[PATH_MAX];
7626 int fd, r;
7627
7628 /* create temporary file to map stat to */
7629 tmpdir = getenv("TMPDIR");
7630 if (!tmpdir)
7631 tmpdir = "/tmp";
7632 snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir);
7633 fd = mkstemp(filename);
7634 if (fd < 0) {
7635 return fd;
7636 }
7637 unlink(filename);
7638
7639 if ((r = fake_open->fill(cpu_env, fd))) {
a3ca7bb2 7640 int e = errno;
3be14d05 7641 close(fd);
a3ca7bb2 7642 errno = e;
3be14d05
AG		 7643 return r;
7644 }
7645 lseek(fd, 0, SEEK_SET);
7646
7647 return fd;
7648 }
7649
c10a0738 7650 return safe_openat(dirfd, path(pathname), flags, mode);
3be14d05
AG		 7651}
7652
aecc8861
AG		 7653#define TIMER_MAGIC 0x0caf0000
7654#define TIMER_MAGIC_MASK 0xffff0000
7655
7656/* Convert QEMU provided timer ID back to internal 16bit index format */
7657static target_timer_t get_timer_id(abi_long arg)
7658{
7659 target_timer_t timerid = arg;
7660
7661 if ((timerid & TIMER_MAGIC_MASK) != TIMER_MAGIC) {
7662 return -TARGET_EINVAL;
7663 }
7664
7665 timerid &= 0xffff;
7666
7667 if (timerid >= ARRAY_SIZE(g_posix_timers)) {
7668 return -TARGET_EINVAL;
7669 }
7670
7671 return timerid;
7672}
7673
0da46a6e
TS		 7674/* do_syscall() should always have a single exit point at the end so
7675 that actions, such as logging of syscall results, can be performed.
7676 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
992f48a0
BS		 7677abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
7678 abi_long arg2, abi_long arg3, abi_long arg4,
5945cfcb
PM		 7679 abi_long arg5, abi_long arg6, abi_long arg7,
7680 abi_long arg8)
31e31b8a 7681{
182735ef 7682 CPUState *cpu = ENV_GET_CPU(cpu_env);
992f48a0 7683 abi_long ret;
31e31b8a 7684 struct stat st;
56c8f68f 7685 struct statfs stfs;
53a5960a 7686 void *p;
3b46e624 7687
71a8f7fe
TB		 7688#if defined(DEBUG_ERESTARTSYS)
7689 /* Debug-only code for exercising the syscall-restart code paths
7690 * in the per-architecture cpu main loops: restart every syscall
7691 * the guest makes once before letting it through.
7692 */
7693 {
7694 static int flag;
7695
7696 flag = !flag;
7697 if (flag) {
7698 return -TARGET_ERESTARTSYS;
7699 }
7700 }
7701#endif
7702
72f03900 7703#ifdef DEBUG
c573ff67 7704 gemu_log("syscall %d", num);
72f03900 7705#endif
9c15e700 7706 trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
b92c47c1
TS		 7707 if(do_strace)
7708 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
7709
31e31b8a
FB		 7710 switch(num) {
7711 case TARGET_NR_exit:
9b056fcc
AF		 7712 /* In old applications this may be used to implement _exit(2).
7713 However in threaded applictions it is used for thread termination,
7714 and _exit_group is used for application termination.
7715 Do thread termination if we have more then one thread. */
a0995886
TB		 7716
7717 if (block_signals()) {
7718 ret = -TARGET_ERESTARTSYS;
7719 break;
7720 }
7721
dd1f6349
AB		 7722 cpu_list_lock();
7723
bdc44640 7724 if (CPU_NEXT(first_cpu)) {
9b056fcc 7725 TaskState *ts;
9b056fcc 7726
9b056fcc 7727 /* Remove the CPU from the list. */
bdc44640 7728 QTAILQ_REMOVE(&cpus, cpu, node);
dd1f6349 7729
9b056fcc 7730 cpu_list_unlock();
dd1f6349 7731
0429a971 7732 ts = cpu->opaque;
9b056fcc
AF		 7733 if (ts->child_tidptr) {
7734 put_user_u32(0, ts->child_tidptr);
7735 sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
7736 NULL, NULL, 0);
7737 }
a2247f8e 7738 thread_cpu = NULL;
0429a971 7739 object_unref(OBJECT(cpu));
9b056fcc 7740 g_free(ts);
70903763 7741 rcu_unregister_thread();
9b056fcc
AF		 7742 pthread_exit(NULL);
7743 }
dd1f6349
AB		 7744
7745 cpu_list_unlock();
9788c9ca 7746#ifdef TARGET_GPROF
7d13299d
FB		 7747 _mcleanup();
7748#endif
e9009676 7749 gdb_exit(cpu_env, arg1);
c2764719 7750 _exit(arg1);
31e31b8a
FB		 7751 ret = 0; /* avoid warning */
7752 break;
7753 case TARGET_NR_read:
38d840e6
AJ		 7754 if (arg3 == 0)
7755 ret = 0;
7756 else {
7757 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
7758 goto efault;
50afd02b 7759 ret = get_errno(safe_read(arg1, p, arg3));
e36800c9 7760 if (ret >= 0 &&
5d4d3665
LV		 7761 fd_trans_host_to_target_data(arg1)) {
7762 ret = fd_trans_host_to_target_data(arg1)(p, ret);
e36800c9 7763 }
38d840e6
AJ		 7764 unlock_user(p, arg2, ret);
7765 }
31e31b8a
FB		 7766 break;
7767 case TARGET_NR_write:
579a97f7
FB		 7768 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
7769 goto efault;
50afd02b 7770 ret = get_errno(safe_write(arg1, p, arg3));
53a5960a 7771 unlock_user(p, arg2, 0);
31e31b8a 7772 break;
704eff6c 7773#ifdef TARGET_NR_open
31e31b8a 7774 case TARGET_NR_open:
2f619698
FB		 7775 if (!(p = lock_user_string(arg1)))
7776 goto efault;
0b2effd7
RV		 7777 ret = get_errno(do_openat(cpu_env, AT_FDCWD, p,
7778 target_to_host_bitmask(arg2, fcntl_flags_tbl),
7779 arg3));
e36800c9 7780 fd_trans_unregister(ret);
53a5960a 7781 unlock_user(p, arg1, 0);
31e31b8a 7782 break;
704eff6c 7783#endif
82424832 7784 case TARGET_NR_openat:
579a97f7
FB		 7785 if (!(p = lock_user_string(arg2)))
7786 goto efault;
0b2effd7
RV		 7787 ret = get_errno(do_openat(cpu_env, arg1, p,
7788 target_to_host_bitmask(arg3, fcntl_flags_tbl),
7789 arg4));
e36800c9 7790 fd_trans_unregister(ret);
579a97f7 7791 unlock_user(p, arg2, 0);
82424832 7792 break;
0f0426f3
LV		 7793#if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7794 case TARGET_NR_name_to_handle_at:
7795 ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);
7796 break;
7797#endif
7798#if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7799 case TARGET_NR_open_by_handle_at:
7800 ret = do_open_by_handle_at(arg1, arg2, arg3);
e36800c9 7801 fd_trans_unregister(ret);
0f0426f3
LV		 7802 break;
7803#endif
31e31b8a 7804 case TARGET_NR_close:
e36800c9 7805 fd_trans_unregister(arg1);
31e31b8a
FB		 7806 ret = get_errno(close(arg1));
7807 break;
7808 case TARGET_NR_brk:
53a5960a 7809 ret = do_brk(arg1);
31e31b8a 7810 break;
704eff6c 7811#ifdef TARGET_NR_fork
31e31b8a 7812 case TARGET_NR_fork:
7eddb5dd 7813 ret = get_errno(do_fork(cpu_env, TARGET_SIGCHLD, 0, 0, 0, 0));
31e31b8a 7814 break;
704eff6c 7815#endif
e5febef5 7816#ifdef TARGET_NR_waitpid
31e31b8a
FB		 7817 case TARGET_NR_waitpid:
7818 {
53a5960a 7819 int status;
4af80a37 7820 ret = get_errno(safe_wait4(arg1, &status, arg3, 0));
5379557b 7821 if (!is_error(ret) && arg2 && ret
1d9d8b55 7822 && put_user_s32(host_to_target_waitstatus(status), arg2))
2f619698 7823 goto efault;
31e31b8a
FB		 7824 }
7825 break;
e5febef5 7826#endif
f0cbb613
PB		 7827#ifdef TARGET_NR_waitid
7828 case TARGET_NR_waitid:
7829 {
7830 siginfo_t info;
7831 info.si_pid = 0;
4af80a37 7832 ret = get_errno(safe_waitid(arg1, arg2, &info, arg4, NULL));
f0cbb613 7833 if (!is_error(ret) && arg3 && info.si_pid != 0) {
c227f099 7834 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
f0cbb613
PB		 7835 goto efault;
7836 host_to_target_siginfo(p, &info);
c227f099 7837 unlock_user(p, arg3, sizeof(target_siginfo_t));
f0cbb613
PB		 7838 }
7839 }
7840 break;
7841#endif
7a3148a9 7842#ifdef TARGET_NR_creat /* not on alpha */
31e31b8a 7843 case TARGET_NR_creat:
579a97f7
FB		 7844 if (!(p = lock_user_string(arg1)))
7845 goto efault;
53a5960a 7846 ret = get_errno(creat(p, arg2));
e36800c9 7847 fd_trans_unregister(ret);
53a5960a 7848 unlock_user(p, arg1, 0);
31e31b8a 7849 break;
7a3148a9 7850#endif
704eff6c 7851#ifdef TARGET_NR_link
31e31b8a 7852 case TARGET_NR_link:
53a5960a
PB		 7853 {
7854 void * p2;
7855 p = lock_user_string(arg1);
7856 p2 = lock_user_string(arg2);
579a97f7
FB		 7857 if (!p || !p2)
7858 ret = -TARGET_EFAULT;
7859 else
7860 ret = get_errno(link(p, p2));
53a5960a
PB		 7861 unlock_user(p2, arg2, 0);
7862 unlock_user(p, arg1, 0);
7863 }
31e31b8a 7864 break;
704eff6c 7865#endif
c0d472b1 7866#if defined(TARGET_NR_linkat)
64f0ce4c 7867 case TARGET_NR_linkat:
64f0ce4c
TS		 7868 {
7869 void * p2 = NULL;
579a97f7
FB		 7870 if (!arg2 || !arg4)
7871 goto efault;
64f0ce4c
TS		 7872 p = lock_user_string(arg2);
7873 p2 = lock_user_string(arg4);
579a97f7 7874 if (!p || !p2)
0da46a6e 7875 ret = -TARGET_EFAULT;
64f0ce4c 7876 else
c0d472b1 7877 ret = get_errno(linkat(arg1, p, arg3, p2, arg5));
579a97f7
FB		 7878 unlock_user(p, arg2, 0);
7879 unlock_user(p2, arg4, 0);
64f0ce4c
TS		 7880 }
7881 break;
7882#endif
704eff6c 7883#ifdef TARGET_NR_unlink
31e31b8a 7884 case TARGET_NR_unlink:
579a97f7
FB		 7885 if (!(p = lock_user_string(arg1)))
7886 goto efault;
53a5960a
PB		 7887 ret = get_errno(unlink(p));
7888 unlock_user(p, arg1, 0);
31e31b8a 7889 break;
704eff6c 7890#endif
c0d472b1 7891#if defined(TARGET_NR_unlinkat)
8170f56b 7892 case TARGET_NR_unlinkat:
579a97f7
FB		 7893 if (!(p = lock_user_string(arg2)))
7894 goto efault;
c0d472b1 7895 ret = get_errno(unlinkat(arg1, p, arg3));
579a97f7 7896 unlock_user(p, arg2, 0);
ed494d87 7897 break;
b7d35e65 7898#endif
31e31b8a 7899 case TARGET_NR_execve:
7854b056
FB		 7900 {
7901 char **argp, **envp;
f7341ff4 7902 int argc, envc;
992f48a0
BS		 7903 abi_ulong gp;
7904 abi_ulong guest_argp;
7905 abi_ulong guest_envp;
7906 abi_ulong addr;
7854b056 7907 char **q;
a6f79cc9 7908 int total_size = 0;
7854b056 7909
f7341ff4 7910 argc = 0;
53a5960a 7911 guest_argp = arg2;
da94d263 7912 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
03aa1976 7913 if (get_user_ual(addr, gp))
2f619698 7914 goto efault;
03aa1976 7915 if (!addr)
2f619698 7916 break;
7854b056 7917 argc++;
2f619698 7918 }
f7341ff4 7919 envc = 0;
53a5960a 7920 guest_envp = arg3;
da94d263 7921 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
03aa1976 7922 if (get_user_ual(addr, gp))
2f619698 7923 goto efault;
03aa1976 7924 if (!addr)
2f619698 7925 break;
7854b056 7926 envc++;
2f619698 7927 }
7854b056 7928
f7341ff4
FB		 7929 argp = alloca((argc + 1) * sizeof(void *));
7930 envp = alloca((envc + 1) * sizeof(void *));
7854b056 7931
da94d263 7932 for (gp = guest_argp, q = argp; gp;
992f48a0 7933 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7934 if (get_user_ual(addr, gp))
7935 goto execve_efault;
53a5960a
PB		 7936 if (!addr)
7937 break;
2f619698
FB		 7938 if (!(*q = lock_user_string(addr)))
7939 goto execve_efault;
a6f79cc9 7940 total_size += strlen(*q) + 1;
53a5960a 7941 }
f7341ff4
FB		 7942 *q = NULL;
7943
da94d263 7944 for (gp = guest_envp, q = envp; gp;
992f48a0 7945 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7946 if (get_user_ual(addr, gp))
7947 goto execve_efault;
53a5960a
PB		 7948 if (!addr)
7949 break;
2f619698
FB		 7950 if (!(*q = lock_user_string(addr)))
7951 goto execve_efault;
a6f79cc9 7952 total_size += strlen(*q) + 1;
53a5960a 7953 }
f7341ff4 7954 *q = NULL;
7854b056 7955
2f619698
FB		 7956 if (!(p = lock_user_string(arg1)))
7957 goto execve_efault;
ffdcbe22
TB		 7958 /* Although execve() is not an interruptible syscall it is
7959 * a special case where we must use the safe_syscall wrapper:
7960 * if we allow a signal to happen before we make the host
7961 * syscall then we will 'lose' it, because at the point of
7962 * execve the process leaves QEMU's control. So we use the
7963 * safe syscall wrapper to ensure that we either take the
7964 * signal as a guest signal, or else it does not happen
7965 * before the execve completes and makes it the other
7966 * program's problem.
7967 */
7968 ret = get_errno(safe_execve(p, argp, envp));
53a5960a
PB		 7969 unlock_user(p, arg1, 0);
7970
2f619698
FB		 7971 goto execve_end;
7972
7973 execve_efault:
7974 ret = -TARGET_EFAULT;
7975
7976 execve_end:
53a5960a 7977 for (gp = guest_argp, q = argp; *q;
992f48a0 7978 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7979 if (get_user_ual(addr, gp)
7980 || !addr)
7981 break;
53a5960a
PB		 7982 unlock_user(*q, addr, 0);
7983 }
7984 for (gp = guest_envp, q = envp; *q;
992f48a0 7985 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7986 if (get_user_ual(addr, gp)
7987 || !addr)
7988 break;
53a5960a
PB		 7989 unlock_user(*q, addr, 0);
7990 }
7854b056 7991 }
31e31b8a
FB		 7992 break;
7993 case TARGET_NR_chdir:
579a97f7
FB		 7994 if (!(p = lock_user_string(arg1)))
7995 goto efault;
53a5960a
PB		 7996 ret = get_errno(chdir(p));
7997 unlock_user(p, arg1, 0);
31e31b8a 7998 break;
a315a145 7999#ifdef TARGET_NR_time
31e31b8a
FB		 8000 case TARGET_NR_time:
8001 {
53a5960a
PB		 8002 time_t host_time;
8003 ret = get_errno(time(&host_time));
2f619698
FB		 8004 if (!is_error(ret)
8005 && arg1
8006 && put_user_sal(host_time, arg1))
8007 goto efault;
31e31b8a
FB		 8008 }
8009 break;
a315a145 8010#endif
704eff6c 8011#ifdef TARGET_NR_mknod
31e31b8a 8012 case TARGET_NR_mknod:
579a97f7
FB		 8013 if (!(p = lock_user_string(arg1)))
8014 goto efault;
53a5960a
PB		 8015 ret = get_errno(mknod(p, arg2, arg3));
8016 unlock_user(p, arg1, 0);
31e31b8a 8017 break;
704eff6c 8018#endif
c0d472b1 8019#if defined(TARGET_NR_mknodat)
75ac37a0 8020 case TARGET_NR_mknodat:
579a97f7
FB		 8021 if (!(p = lock_user_string(arg2)))
8022 goto efault;
c0d472b1 8023 ret = get_errno(mknodat(arg1, p, arg3, arg4));
579a97f7 8024 unlock_user(p, arg2, 0);
75ac37a0
TS		 8025 break;
8026#endif
704eff6c 8027#ifdef TARGET_NR_chmod
31e31b8a 8028 case TARGET_NR_chmod:
579a97f7
FB		 8029 if (!(p = lock_user_string(arg1)))
8030 goto efault;
53a5960a
PB		 8031 ret = get_errno(chmod(p, arg2));
8032 unlock_user(p, arg1, 0);
31e31b8a 8033 break;
704eff6c 8034#endif
ebc05488 8035#ifdef TARGET_NR_break
31e31b8a
FB		 8036 case TARGET_NR_break:
8037 goto unimplemented;
ebc05488
FB		 8038#endif
8039#ifdef TARGET_NR_oldstat
31e31b8a
FB		 8040 case TARGET_NR_oldstat:
8041 goto unimplemented;
ebc05488 8042#endif
31e31b8a
FB		 8043 case TARGET_NR_lseek:
8044 ret = get_errno(lseek(arg1, arg2, arg3));
8045 break;
9231733a
RH		 8046#if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
8047 /* Alpha specific */
7a3148a9 8048 case TARGET_NR_getxpid:
9231733a
RH		 8049 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
8050 ret = get_errno(getpid());
8051 break;
7a3148a9 8052#endif
9231733a
RH		 8053#ifdef TARGET_NR_getpid
8054 case TARGET_NR_getpid:
31e31b8a
FB		 8055 ret = get_errno(getpid());
8056 break;
9231733a 8057#endif
31e31b8a 8058 case TARGET_NR_mount:
356d771b
PB		 8059 {
8060 /* need to look at the data field */
8061 void *p2, *p3;
8062
8063 if (arg1) {
8064 p = lock_user_string(arg1);
8065 if (!p) {
8066 goto efault;
8067 }
8068 } else {
8069 p = NULL;
8070 }
8071
8072 p2 = lock_user_string(arg2);
8073 if (!p2) {
8074 if (arg1) {
8075 unlock_user(p, arg1, 0);
8076 }
8077 goto efault;
8078 }
8079
8080 if (arg3) {
8081 p3 = lock_user_string(arg3);
8082 if (!p3) {
8083 if (arg1) {
579a97f7 8084 unlock_user(p, arg1, 0);
356d771b
PB		 8085 }
8086 unlock_user(p2, arg2, 0);
8087 goto efault;
8088 }
8089 } else {
8090 p3 = NULL;
8091 }
8092
8093 /* FIXME - arg5 should be locked, but it isn't clear how to
8094 * do that since it's not guaranteed to be a NULL-terminated
8095 * string.
8096 */
8097 if (!arg5) {
8098 ret = mount(p, p2, p3, (unsigned long)arg4, NULL);
8099 } else {
8100 ret = mount(p, p2, p3, (unsigned long)arg4, g2h(arg5));
8101 }
8102 ret = get_errno(ret);
8103
8104 if (arg1) {
8105 unlock_user(p, arg1, 0);
8106 }
8107 unlock_user(p2, arg2, 0);
8108 if (arg3) {
8109 unlock_user(p3, arg3, 0);
8110 }
8111 }
8112 break;
e5febef5 8113#ifdef TARGET_NR_umount
31e31b8a 8114 case TARGET_NR_umount:
579a97f7
FB		 8115 if (!(p = lock_user_string(arg1)))
8116 goto efault;
53a5960a
PB		 8117 ret = get_errno(umount(p));
8118 unlock_user(p, arg1, 0);
31e31b8a 8119 break;
e5febef5 8120#endif
7a3148a9 8121#ifdef TARGET_NR_stime /* not on alpha */
31e31b8a
FB		 8122 case TARGET_NR_stime:
8123 {
53a5960a 8124 time_t host_time;
2f619698
FB		 8125 if (get_user_sal(host_time, arg1))
8126 goto efault;
53a5960a 8127 ret = get_errno(stime(&host_time));
31e31b8a
FB		 8128 }
8129 break;
7a3148a9 8130#endif
31e31b8a
FB		 8131 case TARGET_NR_ptrace:
8132 goto unimplemented;
7a3148a9 8133#ifdef TARGET_NR_alarm /* not on alpha */
31e31b8a
FB		 8134 case TARGET_NR_alarm:
8135 ret = alarm(arg1);
8136 break;
7a3148a9 8137#endif
ebc05488 8138#ifdef TARGET_NR_oldfstat
31e31b8a
FB		 8139 case TARGET_NR_oldfstat:
8140 goto unimplemented;
ebc05488 8141#endif
7a3148a9 8142#ifdef TARGET_NR_pause /* not on alpha */
31e31b8a 8143 case TARGET_NR_pause:
f59ec606
TB		 8144 if (!block_signals()) {
8145 sigsuspend(&((TaskState *)cpu->opaque)->signal_mask);
8146 }
8147 ret = -TARGET_EINTR;
31e31b8a 8148 break;
7a3148a9 8149#endif
e5febef5 8150#ifdef TARGET_NR_utime
31e31b8a 8151 case TARGET_NR_utime:
ebc05488 8152 {
53a5960a
PB		 8153 struct utimbuf tbuf, *host_tbuf;
8154 struct target_utimbuf *target_tbuf;
8155 if (arg2) {
579a97f7
FB		 8156 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
8157 goto efault;
cbb21eed
MB		 8158 tbuf.actime = tswapal(target_tbuf->actime);
8159 tbuf.modtime = tswapal(target_tbuf->modtime);
53a5960a
PB		 8160 unlock_user_struct(target_tbuf, arg2, 0);
8161 host_tbuf = &tbuf;
f72e8ff4 8162 } else {
53a5960a 8163 host_tbuf = NULL;
f72e8ff4 8164 }
579a97f7
FB		 8165 if (!(p = lock_user_string(arg1)))
8166 goto efault;
53a5960a
PB		 8167 ret = get_errno(utime(p, host_tbuf));
8168 unlock_user(p, arg1, 0);
ebc05488
FB		 8169 }
8170 break;
e5febef5 8171#endif
704eff6c 8172#ifdef TARGET_NR_utimes
978a66ff
FB		 8173 case TARGET_NR_utimes:
8174 {
978a66ff 8175 struct timeval *tvp, tv[2];
53a5960a 8176 if (arg2) {
788f5ec4
TS		 8177 if (copy_from_user_timeval(&tv[0], arg2)
8178 || copy_from_user_timeval(&tv[1],
8179 arg2 + sizeof(struct target_timeval)))
8180 goto efault;
978a66ff
FB		 8181 tvp = tv;
8182 } else {
8183 tvp = NULL;
8184 }
579a97f7
FB		 8185 if (!(p = lock_user_string(arg1)))
8186 goto efault;
53a5960a
PB		 8187 ret = get_errno(utimes(p, tvp));
8188 unlock_user(p, arg1, 0);
978a66ff
FB		 8189 }
8190 break;
704eff6c 8191#endif
c0d472b1 8192#if defined(TARGET_NR_futimesat)
ac8a6556
AZ		 8193 case TARGET_NR_futimesat:
8194 {
8195 struct timeval *tvp, tv[2];
8196 if (arg3) {
8197 if (copy_from_user_timeval(&tv[0], arg3)
8198 || copy_from_user_timeval(&tv[1],
8199 arg3 + sizeof(struct target_timeval)))
8200 goto efault;
8201 tvp = tv;
8202 } else {
8203 tvp = NULL;
8204 }
8205 if (!(p = lock_user_string(arg2)))
8206 goto efault;
c0d472b1 8207 ret = get_errno(futimesat(arg1, path(p), tvp));
ac8a6556
AZ		 8208 unlock_user(p, arg2, 0);
8209 }
8210 break;
8211#endif
ebc05488 8212#ifdef TARGET_NR_stty
31e31b8a
FB		 8213 case TARGET_NR_stty:
8214 goto unimplemented;
ebc05488
FB		 8215#endif
8216#ifdef TARGET_NR_gtty
31e31b8a
FB		 8217 case TARGET_NR_gtty:
8218 goto unimplemented;
ebc05488 8219#endif
704eff6c 8220#ifdef TARGET_NR_access
31e31b8a 8221 case TARGET_NR_access:
579a97f7
FB		 8222 if (!(p = lock_user_string(arg1)))
8223 goto efault;
719f908e 8224 ret = get_errno(access(path(p), arg2));
53a5960a 8225 unlock_user(p, arg1, 0);
31e31b8a 8226 break;
704eff6c 8227#endif
92a34c10
TS		 8228#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
8229 case TARGET_NR_faccessat:
579a97f7
FB		 8230 if (!(p = lock_user_string(arg2)))
8231 goto efault;
c0d472b1 8232 ret = get_errno(faccessat(arg1, p, arg3, 0));
579a97f7 8233 unlock_user(p, arg2, 0);
92a34c10
TS		 8234 break;
8235#endif
7a3148a9 8236#ifdef TARGET_NR_nice /* not on alpha */
31e31b8a
FB		 8237 case TARGET_NR_nice:
8238 ret = get_errno(nice(arg1));
8239 break;
7a3148a9 8240#endif
ebc05488 8241#ifdef TARGET_NR_ftime
31e31b8a
FB		 8242 case TARGET_NR_ftime:
8243 goto unimplemented;
ebc05488 8244#endif
31e31b8a 8245 case TARGET_NR_sync:
04369ff2
FB		 8246 sync();
8247 ret = 0;
31e31b8a 8248 break;
5a03cd00
AM		 8249#if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
8250 case TARGET_NR_syncfs:
8251 ret = get_errno(syncfs(arg1));
8252 break;
8253#endif
31e31b8a 8254 case TARGET_NR_kill:
bef653d9 8255 ret = get_errno(safe_kill(arg1, target_to_host_signal(arg2)));
31e31b8a 8256 break;
704eff6c 8257#ifdef TARGET_NR_rename
31e31b8a 8258 case TARGET_NR_rename:
53a5960a
PB		 8259 {
8260 void *p2;
8261 p = lock_user_string(arg1);
8262 p2 = lock_user_string(arg2);
579a97f7
FB		 8263 if (!p || !p2)
8264 ret = -TARGET_EFAULT;
8265 else
8266 ret = get_errno(rename(p, p2));
53a5960a
PB		 8267 unlock_user(p2, arg2, 0);
8268 unlock_user(p, arg1, 0);
8269 }
31e31b8a 8270 break;
704eff6c 8271#endif
c0d472b1 8272#if defined(TARGET_NR_renameat)
722183f6 8273 case TARGET_NR_renameat:
722183f6 8274 {
579a97f7 8275 void *p2;
722183f6
TS		 8276 p = lock_user_string(arg2);
8277 p2 = lock_user_string(arg4);
579a97f7 8278 if (!p || !p2)
0da46a6e 8279 ret = -TARGET_EFAULT;
722183f6 8280 else
c0d472b1 8281 ret = get_errno(renameat(arg1, p, arg3, p2));
579a97f7
FB		 8282 unlock_user(p2, arg4, 0);
8283 unlock_user(p, arg2, 0);
722183f6
TS		 8284 }
8285 break;
8286#endif
704eff6c 8287#ifdef TARGET_NR_mkdir
31e31b8a 8288 case TARGET_NR_mkdir:
579a97f7
FB		 8289 if (!(p = lock_user_string(arg1)))
8290 goto efault;
53a5960a
PB		 8291 ret = get_errno(mkdir(p, arg2));
8292 unlock_user(p, arg1, 0);
31e31b8a 8293 break;
704eff6c 8294#endif
c0d472b1 8295#if defined(TARGET_NR_mkdirat)
4472ad0d 8296 case TARGET_NR_mkdirat:
579a97f7
FB		 8297 if (!(p = lock_user_string(arg2)))
8298 goto efault;
c0d472b1 8299 ret = get_errno(mkdirat(arg1, p, arg3));
579a97f7 8300 unlock_user(p, arg2, 0);
4472ad0d
TS		 8301 break;
8302#endif
704eff6c 8303#ifdef TARGET_NR_rmdir
31e31b8a 8304 case TARGET_NR_rmdir:
579a97f7
FB		 8305 if (!(p = lock_user_string(arg1)))
8306 goto efault;
53a5960a
PB		 8307 ret = get_errno(rmdir(p));
8308 unlock_user(p, arg1, 0);
31e31b8a 8309 break;
704eff6c 8310#endif
31e31b8a
FB		 8311 case TARGET_NR_dup:
8312 ret = get_errno(dup(arg1));
e36800c9
LV		 8313 if (ret >= 0) {
8314 fd_trans_dup(arg1, ret);
8315 }
31e31b8a 8316 break;
704eff6c 8317#ifdef TARGET_NR_pipe
31e31b8a 8318 case TARGET_NR_pipe:
fb41a66e 8319 ret = do_pipe(cpu_env, arg1, 0, 0);
099d6b0f 8320 break;
704eff6c 8321#endif
099d6b0f
RV		 8322#ifdef TARGET_NR_pipe2
8323 case TARGET_NR_pipe2:
e7ea6cbe
RH		 8324 ret = do_pipe(cpu_env, arg1,
8325 target_to_host_bitmask(arg2, fcntl_flags_tbl), 1);
31e31b8a 8326 break;
099d6b0f 8327#endif
31e31b8a 8328 case TARGET_NR_times:
32f36bce 8329 {
53a5960a 8330 struct target_tms *tmsp;
32f36bce
FB		 8331 struct tms tms;
8332 ret = get_errno(times(&tms));
53a5960a 8333 if (arg1) {
579a97f7
FB		 8334 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
8335 if (!tmsp)
8336 goto efault;
cbb21eed
MB		 8337 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime));
8338 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime));
8339 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime));
8340 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime));
32f36bce 8341 }
c596ed17
FB		 8342 if (!is_error(ret))
8343 ret = host_to_target_clock_t(ret);
32f36bce
FB		 8344 }
8345 break;
ebc05488 8346#ifdef TARGET_NR_prof
31e31b8a
FB		 8347 case TARGET_NR_prof:
8348 goto unimplemented;
ebc05488 8349#endif
e5febef5 8350#ifdef TARGET_NR_signal
31e31b8a
FB		 8351 case TARGET_NR_signal:
8352 goto unimplemented;
e5febef5 8353#endif
31e31b8a 8354 case TARGET_NR_acct:
38d840e6
AJ		 8355 if (arg1 == 0) {
8356 ret = get_errno(acct(NULL));
8357 } else {
8358 if (!(p = lock_user_string(arg1)))
8359 goto efault;
8360 ret = get_errno(acct(path(p)));
8361 unlock_user(p, arg1, 0);
8362 }
24836689 8363 break;
8070e7be 8364#ifdef TARGET_NR_umount2
31e31b8a 8365 case TARGET_NR_umount2:
579a97f7
FB		 8366 if (!(p = lock_user_string(arg1)))
8367 goto efault;
53a5960a
PB		 8368 ret = get_errno(umount2(p, arg2));
8369 unlock_user(p, arg1, 0);
31e31b8a 8370 break;
7a3148a9 8371#endif
ebc05488 8372#ifdef TARGET_NR_lock
31e31b8a
FB		 8373 case TARGET_NR_lock:
8374 goto unimplemented;
ebc05488 8375#endif
31e31b8a
FB		 8376 case TARGET_NR_ioctl:
8377 ret = do_ioctl(arg1, arg2, arg3);
8378 break;
8379 case TARGET_NR_fcntl:
9ee1fa2c 8380 ret = do_fcntl(arg1, arg2, arg3);
31e31b8a 8381 break;
ebc05488 8382#ifdef TARGET_NR_mpx
31e31b8a
FB		 8383 case TARGET_NR_mpx:
8384 goto unimplemented;
ebc05488 8385#endif
31e31b8a
FB		 8386 case TARGET_NR_setpgid:
8387 ret = get_errno(setpgid(arg1, arg2));
8388 break;
ebc05488 8389#ifdef TARGET_NR_ulimit
31e31b8a
FB		 8390 case TARGET_NR_ulimit:
8391 goto unimplemented;
ebc05488
FB		 8392#endif
8393#ifdef TARGET_NR_oldolduname
31e31b8a
FB		 8394 case TARGET_NR_oldolduname:
8395 goto unimplemented;
ebc05488 8396#endif
31e31b8a
FB		 8397 case TARGET_NR_umask:
8398 ret = get_errno(umask(arg1));
8399 break;
8400 case TARGET_NR_chroot:
579a97f7
FB		 8401 if (!(p = lock_user_string(arg1)))
8402 goto efault;
53a5960a
PB		 8403 ret = get_errno(chroot(p));
8404 unlock_user(p, arg1, 0);
31e31b8a 8405 break;
704eff6c 8406#ifdef TARGET_NR_ustat
31e31b8a
FB		 8407 case TARGET_NR_ustat:
8408 goto unimplemented;
704eff6c
CG		 8409#endif
8410#ifdef TARGET_NR_dup2
31e31b8a
FB		 8411 case TARGET_NR_dup2:
8412 ret = get_errno(dup2(arg1, arg2));
e36800c9
LV		 8413 if (ret >= 0) {
8414 fd_trans_dup(arg1, arg2);
8415 }
31e31b8a 8416 break;
704eff6c 8417#endif
d0927938
UH		 8418#if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
8419 case TARGET_NR_dup3:
8420 ret = get_errno(dup3(arg1, arg2, arg3));
e36800c9
LV		 8421 if (ret >= 0) {
8422 fd_trans_dup(arg1, arg2);
8423 }
d0927938
UH		 8424 break;
8425#endif
7a3148a9 8426#ifdef TARGET_NR_getppid /* not on alpha */
31e31b8a
FB		 8427 case TARGET_NR_getppid:
8428 ret = get_errno(getppid());
8429 break;
7a3148a9 8430#endif
704eff6c 8431#ifdef TARGET_NR_getpgrp
31e31b8a
FB		 8432 case TARGET_NR_getpgrp:
8433 ret = get_errno(getpgrp());
8434 break;
704eff6c 8435#endif
31e31b8a
FB		 8436 case TARGET_NR_setsid:
8437 ret = get_errno(setsid());
8438 break;
e5febef5 8439#ifdef TARGET_NR_sigaction
31e31b8a 8440 case TARGET_NR_sigaction:
31e31b8a 8441 {
6049f4f8
RH		 8442#if defined(TARGET_ALPHA)
8443 struct target_sigaction act, oact, *pact = 0;
53a5960a 8444 struct target_old_sigaction *old_act;
53a5960a 8445 if (arg2) {
579a97f7
FB		 8446 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8447 goto efault;
66fb9763
FB		 8448 act._sa_handler = old_act->_sa_handler;
8449 target_siginitset(&act.sa_mask, old_act->sa_mask);
8450 act.sa_flags = old_act->sa_flags;
6049f4f8 8451 act.sa_restorer = 0;
53a5960a 8452 unlock_user_struct(old_act, arg2, 0);
66fb9763 8453 pact = &act;
66fb9763
FB		 8454 }
8455 ret = get_errno(do_sigaction(arg1, pact, &oact));
53a5960a 8456 if (!is_error(ret) && arg3) {
579a97f7
FB		 8457 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8458 goto efault;
53a5960a
PB		 8459 old_act->_sa_handler = oact._sa_handler;
8460 old_act->sa_mask = oact.sa_mask.sig[0];
8461 old_act->sa_flags = oact.sa_flags;
53a5960a 8462 unlock_user_struct(old_act, arg3, 1);
66fb9763 8463 }
6049f4f8 8464#elif defined(TARGET_MIPS)
106ec879
FB		 8465 struct target_sigaction act, oact, *pact, *old_act;
8466
8467 if (arg2) {
579a97f7
FB		 8468 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8469 goto efault;
106ec879
FB		 8470 act._sa_handler = old_act->_sa_handler;
8471 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
8472 act.sa_flags = old_act->sa_flags;
8473 unlock_user_struct(old_act, arg2, 0);
8474 pact = &act;
8475 } else {
8476 pact = NULL;
8477 }
8478
8479 ret = get_errno(do_sigaction(arg1, pact, &oact));
8480
8481 if (!is_error(ret) && arg3) {
579a97f7
FB		 8482 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8483 goto efault;
106ec879
FB		 8484 old_act->_sa_handler = oact._sa_handler;
8485 old_act->sa_flags = oact.sa_flags;
8486 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
8487 old_act->sa_mask.sig[1] = 0;
8488 old_act->sa_mask.sig[2] = 0;
8489 old_act->sa_mask.sig[3] = 0;
8490 unlock_user_struct(old_act, arg3, 1);
8491 }
6049f4f8
RH		 8492#else
8493 struct target_old_sigaction *old_act;
8494 struct target_sigaction act, oact, *pact;
8495 if (arg2) {
8496 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8497 goto efault;
8498 act._sa_handler = old_act->_sa_handler;
8499 target_siginitset(&act.sa_mask, old_act->sa_mask);
8500 act.sa_flags = old_act->sa_flags;
8501 act.sa_restorer = old_act->sa_restorer;
8502 unlock_user_struct(old_act, arg2, 0);
8503 pact = &act;
8504 } else {
8505 pact = NULL;
8506 }
8507 ret = get_errno(do_sigaction(arg1, pact, &oact));
8508 if (!is_error(ret) && arg3) {
8509 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8510 goto efault;
8511 old_act->_sa_handler = oact._sa_handler;
8512 old_act->sa_mask = oact.sa_mask.sig[0];
8513 old_act->sa_flags = oact.sa_flags;
8514 old_act->sa_restorer = oact.sa_restorer;
8515 unlock_user_struct(old_act, arg3, 1);
8516 }
388bb21a 8517#endif
31e31b8a
FB		 8518 }
8519 break;
e5febef5 8520#endif
66fb9763 8521 case TARGET_NR_rt_sigaction:
53a5960a 8522 {
6049f4f8
RH		 8523#if defined(TARGET_ALPHA)
8524 struct target_sigaction act, oact, *pact = 0;
8525 struct target_rt_sigaction *rt_act;
c815701e
PM		 8526
8527 if (arg4 != sizeof(target_sigset_t)) {
8528 ret = -TARGET_EINVAL;
8529 break;
8530 }
6049f4f8
RH		 8531 if (arg2) {
8532 if (!lock_user_struct(VERIFY_READ, rt_act, arg2, 1))
8533 goto efault;
8534 act._sa_handler = rt_act->_sa_handler;
8535 act.sa_mask = rt_act->sa_mask;
8536 act.sa_flags = rt_act->sa_flags;
8537 act.sa_restorer = arg5;
8538 unlock_user_struct(rt_act, arg2, 0);
8539 pact = &act;
8540 }
8541 ret = get_errno(do_sigaction(arg1, pact, &oact));
8542 if (!is_error(ret) && arg3) {
8543 if (!lock_user_struct(VERIFY_WRITE, rt_act, arg3, 0))
8544 goto efault;
8545 rt_act->_sa_handler = oact._sa_handler;
8546 rt_act->sa_mask = oact.sa_mask;
8547 rt_act->sa_flags = oact.sa_flags;
8548 unlock_user_struct(rt_act, arg3, 1);
8549 }
8550#else
53a5960a
PB		 8551 struct target_sigaction *act;
8552 struct target_sigaction *oact;
8553
c815701e
PM		 8554 if (arg4 != sizeof(target_sigset_t)) {
8555 ret = -TARGET_EINVAL;
8556 break;
8557 }
579a97f7
FB		 8558 if (arg2) {
8559 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
8560 goto efault;
8561 } else
53a5960a 8562 act = NULL;
579a97f7
FB		 8563 if (arg3) {
8564 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
8565 ret = -TARGET_EFAULT;
8566 goto rt_sigaction_fail;
8567 }
8568 } else
53a5960a
PB		 8569 oact = NULL;
8570 ret = get_errno(do_sigaction(arg1, act, oact));
579a97f7
FB		 8571 rt_sigaction_fail:
8572 if (act)
53a5960a 8573 unlock_user_struct(act, arg2, 0);
579a97f7 8574 if (oact)
53a5960a 8575 unlock_user_struct(oact, arg3, 1);
6049f4f8 8576#endif
53a5960a 8577 }
66fb9763 8578 break;
7a3148a9 8579#ifdef TARGET_NR_sgetmask /* not on alpha */
31e31b8a 8580 case TARGET_NR_sgetmask:
66fb9763
FB		 8581 {
8582 sigset_t cur_set;
992f48a0 8583 abi_ulong target_set;
3d3efba0
PM		 8584 ret = do_sigprocmask(0, NULL, &cur_set);
8585 if (!ret) {
8586 host_to_target_old_sigset(&target_set, &cur_set);
8587 ret = target_set;
8588 }
66fb9763
FB		 8589 }
8590 break;
7a3148a9
JM		 8591#endif
8592#ifdef TARGET_NR_ssetmask /* not on alpha */
31e31b8a 8593 case TARGET_NR_ssetmask:
66fb9763
FB		 8594 {
8595 sigset_t set, oset, cur_set;
992f48a0 8596 abi_ulong target_set = arg1;
3d3efba0
PM		 8597 /* We only have one word of the new mask so we must read
8598 * the rest of it with do_sigprocmask() and OR in this word.
8599 * We are guaranteed that a do_sigprocmask() that only queries
8600 * the signal mask will not fail.
8601 */
8602 ret = do_sigprocmask(0, NULL, &cur_set);
8603 assert(!ret);
66fb9763
FB		 8604 target_to_host_old_sigset(&set, &target_set);
8605 sigorset(&set, &set, &cur_set);
3d3efba0
PM		 8606 ret = do_sigprocmask(SIG_SETMASK, &set, &oset);
8607 if (!ret) {
8608 host_to_target_old_sigset(&target_set, &oset);
8609 ret = target_set;
8610 }
66fb9763
FB		 8611 }
8612 break;
7a3148a9 8613#endif
e5febef5 8614#ifdef TARGET_NR_sigprocmask
66fb9763
FB		 8615 case TARGET_NR_sigprocmask:
8616 {
a5b3b13b
RH		 8617#if defined(TARGET_ALPHA)
8618 sigset_t set, oldset;
8619 abi_ulong mask;
8620 int how;
8621
8622 switch (arg1) {
8623 case TARGET_SIG_BLOCK:
8624 how = SIG_BLOCK;
8625 break;
8626 case TARGET_SIG_UNBLOCK:
8627 how = SIG_UNBLOCK;
8628 break;
8629 case TARGET_SIG_SETMASK:
8630 how = SIG_SETMASK;
8631 break;
8632 default:
8633 ret = -TARGET_EINVAL;
8634 goto fail;
8635 }
8636 mask = arg2;
8637 target_to_host_old_sigset(&set, &mask);
8638
3d3efba0 8639 ret = do_sigprocmask(how, &set, &oldset);
a5b3b13b
RH		 8640 if (!is_error(ret)) {
8641 host_to_target_old_sigset(&mask, &oldset);
8642 ret = mask;
0229f5a3 8643 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */
a5b3b13b
RH		 8644 }
8645#else
66fb9763 8646 sigset_t set, oldset, *set_ptr;
a5b3b13b 8647 int how;
3b46e624 8648
53a5960a 8649 if (arg2) {
a5b3b13b 8650 switch (arg1) {
66fb9763
FB		 8651 case TARGET_SIG_BLOCK:
8652 how = SIG_BLOCK;
8653 break;
8654 case TARGET_SIG_UNBLOCK:
8655 how = SIG_UNBLOCK;
8656 break;
8657 case TARGET_SIG_SETMASK:
8658 how = SIG_SETMASK;
8659 break;
8660 default:
0da46a6e 8661 ret = -TARGET_EINVAL;
66fb9763
FB		 8662 goto fail;
8663 }
c227f099 8664 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
579a97f7 8665 goto efault;
53a5960a
PB		 8666 target_to_host_old_sigset(&set, p);
8667 unlock_user(p, arg2, 0);
66fb9763
FB		 8668 set_ptr = &set;
8669 } else {
8670 how = 0;
8671 set_ptr = NULL;
8672 }
3d3efba0 8673 ret = do_sigprocmask(how, set_ptr, &oldset);
53a5960a 8674 if (!is_error(ret) && arg3) {
c227f099 8675 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
579a97f7 8676 goto efault;
53a5960a 8677 host_to_target_old_sigset(p, &oldset);
c227f099 8678 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763 8679 }
a5b3b13b 8680#endif
66fb9763
FB		 8681 }
8682 break;
e5febef5 8683#endif
66fb9763
FB		 8684 case TARGET_NR_rt_sigprocmask:
8685 {
8686 int how = arg1;
8687 sigset_t set, oldset, *set_ptr;
3b46e624 8688
c815701e
PM		 8689 if (arg4 != sizeof(target_sigset_t)) {
8690 ret = -TARGET_EINVAL;
8691 break;
8692 }
8693
53a5960a 8694 if (arg2) {
66fb9763
FB		 8695 switch(how) {
8696 case TARGET_SIG_BLOCK:
8697 how = SIG_BLOCK;
8698 break;
8699 case TARGET_SIG_UNBLOCK:
8700 how = SIG_UNBLOCK;
8701 break;
8702 case TARGET_SIG_SETMASK:
8703 how = SIG_SETMASK;
8704 break;
8705 default:
0da46a6e 8706 ret = -TARGET_EINVAL;
66fb9763
FB		 8707 goto fail;
8708 }
c227f099 8709 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
579a97f7 8710 goto efault;
53a5960a
PB		 8711 target_to_host_sigset(&set, p);
8712 unlock_user(p, arg2, 0);
66fb9763
FB		 8713 set_ptr = &set;
8714 } else {
8715 how = 0;
8716 set_ptr = NULL;
8717 }
3d3efba0 8718 ret = do_sigprocmask(how, set_ptr, &oldset);
53a5960a 8719 if (!is_error(ret) && arg3) {
c227f099 8720 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
579a97f7 8721 goto efault;
53a5960a 8722 host_to_target_sigset(p, &oldset);
c227f099 8723 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 8724 }
8725 }
8726 break;
e5febef5 8727#ifdef TARGET_NR_sigpending
66fb9763
FB		 8728 case TARGET_NR_sigpending:
8729 {
8730 sigset_t set;
8731 ret = get_errno(sigpending(&set));
8732 if (!is_error(ret)) {
c227f099 8733 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
579a97f7 8734 goto efault;
53a5960a 8735 host_to_target_old_sigset(p, &set);
c227f099 8736 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 8737 }
8738 }
8739 break;
e5febef5 8740#endif
66fb9763
FB		 8741 case TARGET_NR_rt_sigpending:
8742 {
8743 sigset_t set;
c815701e
PM		 8744
8745 /* Yes, this check is >, not != like most. We follow the kernel's
8746 * logic and it does it like this because it implements
8747 * NR_sigpending through the same code path, and in that case
8748 * the old_sigset_t is smaller in size.
8749 */
8750 if (arg2 > sizeof(target_sigset_t)) {
8751 ret = -TARGET_EINVAL;
8752 break;
8753 }
8754
66fb9763
FB		 8755 ret = get_errno(sigpending(&set));
8756 if (!is_error(ret)) {
c227f099 8757 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
579a97f7 8758 goto efault;
53a5960a 8759 host_to_target_sigset(p, &set);
c227f099 8760 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 8761 }
8762 }
8763 break;
e5febef5 8764#ifdef TARGET_NR_sigsuspend
66fb9763
FB		 8765 case TARGET_NR_sigsuspend:
8766 {
3d3efba0 8767 TaskState *ts = cpu->opaque;
f43ce12b
RH		 8768#if defined(TARGET_ALPHA)
8769 abi_ulong mask = arg1;
3d3efba0 8770 target_to_host_old_sigset(&ts->sigsuspend_mask, &mask);
f43ce12b 8771#else
c227f099 8772 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8773 goto efault;
3d3efba0 8774 target_to_host_old_sigset(&ts->sigsuspend_mask, p);
53a5960a 8775 unlock_user(p, arg1, 0);
f43ce12b 8776#endif
3d3efba0
PM		 8777 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
8778 SIGSET_T_SIZE));
8779 if (ret != -TARGET_ERESTARTSYS) {
8780 ts->in_sigsuspend = 1;
8781 }
66fb9763
FB		 8782 }
8783 break;
e5febef5 8784#endif
66fb9763
FB		 8785 case TARGET_NR_rt_sigsuspend:
8786 {
3d3efba0 8787 TaskState *ts = cpu->opaque;
c815701e
PM		 8788
8789 if (arg2 != sizeof(target_sigset_t)) {
8790 ret = -TARGET_EINVAL;
8791 break;
8792 }
c227f099 8793 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8794 goto efault;
3d3efba0 8795 target_to_host_sigset(&ts->sigsuspend_mask, p);
53a5960a 8796 unlock_user(p, arg1, 0);
3d3efba0
PM		 8797 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
8798 SIGSET_T_SIZE));
8799 if (ret != -TARGET_ERESTARTSYS) {
8800 ts->in_sigsuspend = 1;
8801 }
66fb9763
FB		 8802 }
8803 break;
8804 case TARGET_NR_rt_sigtimedwait:
8805 {
66fb9763
FB		 8806 sigset_t set;
8807 struct timespec uts, *puts;
8808 siginfo_t uinfo;
3b46e624 8809
c815701e
PM		 8810 if (arg4 != sizeof(target_sigset_t)) {
8811 ret = -TARGET_EINVAL;
8812 break;
8813 }
8814
c227f099 8815 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8816 goto efault;
53a5960a
PB		 8817 target_to_host_sigset(&set, p);
8818 unlock_user(p, arg1, 0);
8819 if (arg3) {
66fb9763 8820 puts = &uts;
53a5960a 8821 target_to_host_timespec(puts, arg3);
66fb9763
FB		 8822 } else {
8823 puts = NULL;
8824 }
b3f82330
PM		 8825 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
8826 SIGSET_T_SIZE));
974a196d
PJ		 8827 if (!is_error(ret)) {
8828 if (arg2) {
8829 p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t),
8830 0);
8831 if (!p) {
8832 goto efault;
8833 }
8834 host_to_target_siginfo(p, &uinfo);
8835 unlock_user(p, arg2, sizeof(target_siginfo_t));
8836 }
8837 ret = host_to_target_signal(ret);
66fb9763
FB		 8838 }
8839 }
8840 break;
8841 case TARGET_NR_rt_sigqueueinfo:
8842 {
8843 siginfo_t uinfo;
4debae6f
PM		 8844
8845 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
8846 if (!p) {
579a97f7 8847 goto efault;
4debae6f 8848 }
53a5960a
PB		 8849 target_to_host_siginfo(&uinfo, p);
8850 unlock_user(p, arg1, 0);
66fb9763
FB		 8851 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
8852 }
8853 break;
e5febef5 8854#ifdef TARGET_NR_sigreturn
66fb9763 8855 case TARGET_NR_sigreturn:
3d3efba0
PM		 8856 if (block_signals()) {
8857 ret = -TARGET_ERESTARTSYS;
8858 } else {
8859 ret = do_sigreturn(cpu_env);
8860 }
66fb9763 8861 break;
e5febef5 8862#endif
66fb9763 8863 case TARGET_NR_rt_sigreturn:
3d3efba0
PM		 8864 if (block_signals()) {
8865 ret = -TARGET_ERESTARTSYS;
8866 } else {
8867 ret = do_rt_sigreturn(cpu_env);
8868 }
66fb9763 8869 break;
31e31b8a 8870 case TARGET_NR_sethostname:
579a97f7
FB		 8871 if (!(p = lock_user_string(arg1)))
8872 goto efault;
53a5960a
PB		 8873 ret = get_errno(sethostname(p, arg2));
8874 unlock_user(p, arg1, 0);
31e31b8a
FB		 8875 break;
8876 case TARGET_NR_setrlimit:
9de5e440 8877 {
e22b7015 8878 int resource = target_to_host_resource(arg1);
53a5960a 8879 struct target_rlimit *target_rlim;
9de5e440 8880 struct rlimit rlim;
579a97f7
FB		 8881 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
8882 goto efault;
81bbe906
TY		 8883 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
8884 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
53a5960a 8885 unlock_user_struct(target_rlim, arg2, 0);
9de5e440
FB		 8886 ret = get_errno(setrlimit(resource, &rlim));
8887 }
8888 break;
31e31b8a 8889 case TARGET_NR_getrlimit:
9de5e440 8890 {
e22b7015 8891 int resource = target_to_host_resource(arg1);
53a5960a 8892 struct target_rlimit *target_rlim;
9de5e440 8893 struct rlimit rlim;
3b46e624 8894
9de5e440
FB		 8895 ret = get_errno(getrlimit(resource, &rlim));
8896 if (!is_error(ret)) {
579a97f7
FB		 8897 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
8898 goto efault;
81bbe906
TY		 8899 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
8900 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
53a5960a 8901 unlock_user_struct(target_rlim, arg2, 1);
9de5e440
FB		 8902 }
8903 }
8904 break;
31e31b8a 8905 case TARGET_NR_getrusage:
b409186b
FB		 8906 {
8907 struct rusage rusage;
b409186b
FB		 8908 ret = get_errno(getrusage(arg1, &rusage));
8909 if (!is_error(ret)) {
a39fb273 8910 ret = host_to_target_rusage(arg2, &rusage);
b409186b
FB		 8911 }
8912 }
8913 break;
31e31b8a
FB		 8914 case TARGET_NR_gettimeofday:
8915 {
31e31b8a
FB		 8916 struct timeval tv;
8917 ret = get_errno(gettimeofday(&tv, NULL));
8918 if (!is_error(ret)) {
788f5ec4
TS		 8919 if (copy_to_user_timeval(arg1, &tv))
8920 goto efault;
31e31b8a
FB		 8921 }
8922 }
8923 break;
8924 case TARGET_NR_settimeofday:
8925 {
b67d8031 8926 struct timeval tv, *ptv = NULL;
ef4467e9
PB		 8927 struct timezone tz, *ptz = NULL;
8928
b67d8031
PB		 8929 if (arg1) {
8930 if (copy_from_user_timeval(&tv, arg1)) {
8931 goto efault;
8932 }
8933 ptv = &tv;
8934 }
ef4467e9
PB		 8935
8936 if (arg2) {
8937 if (copy_from_user_timezone(&tz, arg2)) {
8938 goto efault;
8939 }
8940 ptz = &tz;
8941 }
8942
b67d8031 8943 ret = get_errno(settimeofday(ptv, ptz));
31e31b8a
FB		 8944 }
8945 break;
9468a5d4 8946#if defined(TARGET_NR_select)
31e31b8a 8947 case TARGET_NR_select:
5457dc9e
LV		 8948#if defined(TARGET_WANT_NI_OLD_SELECT)
8949 /* some architectures used to have old_select here
8950 * but now ENOSYS it.
8951 */
8952 ret = -TARGET_ENOSYS;
8953#elif defined(TARGET_WANT_OLD_SYS_SELECT)
8954 ret = do_old_select(arg1);
9468a5d4 8955#else
5457dc9e 8956 ret = do_select(arg1, arg2, arg3, arg4, arg5);
9468a5d4 8957#endif
f2674e31 8958 break;
9e42382f
RV		 8959#endif
8960#ifdef TARGET_NR_pselect6
8961 case TARGET_NR_pselect6:
055e0906
MF		 8962 {
8963 abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
8964 fd_set rfds, wfds, efds;
8965 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
8966 struct timespec ts, *ts_ptr;
8967
8968 /*
8969 * The 6th arg is actually two args smashed together,
8970 * so we cannot use the C library.
8971 */
8972 sigset_t set;
8973 struct {
8974 sigset_t *set;
8975 size_t size;
8976 } sig, *sig_ptr;
8977
8978 abi_ulong arg_sigset, arg_sigsize, *arg7;
8979 target_sigset_t *target_sigset;
8980
8981 n = arg1;
8982 rfd_addr = arg2;
8983 wfd_addr = arg3;
8984 efd_addr = arg4;
8985 ts_addr = arg5;
8986
8987 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
8988 if (ret) {
8989 goto fail;
8990 }
8991 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
8992 if (ret) {
8993 goto fail;
8994 }
8995 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
8996 if (ret) {
8997 goto fail;
8998 }
8999
9000 /*
9001 * This takes a timespec, and not a timeval, so we cannot
9002 * use the do_select() helper ...
9003 */
9004 if (ts_addr) {
9005 if (target_to_host_timespec(&ts, ts_addr)) {
9006 goto efault;
9007 }
9008 ts_ptr = &ts;
9009 } else {
9010 ts_ptr = NULL;
9011 }
9012
9013 /* Extract the two packed args for the sigset */
9014 if (arg6) {
9015 sig_ptr = &sig;
b28a1f33 9016 sig.size = SIGSET_T_SIZE;
055e0906
MF		 9017
9018 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
9019 if (!arg7) {
9020 goto efault;
9021 }
cbb21eed
MB		 9022 arg_sigset = tswapal(arg7[0]);
9023 arg_sigsize = tswapal(arg7[1]);
055e0906
MF		 9024 unlock_user(arg7, arg6, 0);
9025
9026 if (arg_sigset) {
9027 sig.set = &set;
8f04eeb3
PM		 9028 if (arg_sigsize != sizeof(*target_sigset)) {
9029 /* Like the kernel, we enforce correct size sigsets */
9030 ret = -TARGET_EINVAL;
9031 goto fail;
9032 }
055e0906
MF		 9033 target_sigset = lock_user(VERIFY_READ, arg_sigset,
9034 sizeof(*target_sigset), 1);
9035 if (!target_sigset) {
9036 goto efault;
9037 }
9038 target_to_host_sigset(&set, target_sigset);
9039 unlock_user(target_sigset, arg_sigset, 0);
9040 } else {
9041 sig.set = NULL;
9042 }
9043 } else {
9044 sig_ptr = NULL;
9045 }
9046
6df9d38d
PM		 9047 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
9048 ts_ptr, sig_ptr));
055e0906
MF		 9049
9050 if (!is_error(ret)) {
9051 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
9052 goto efault;
9053 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
9054 goto efault;
9055 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
9056 goto efault;
9057
9058 if (ts_addr && host_to_target_timespec(ts_addr, &ts))
9059 goto efault;
9060 }
9061 }
9062 break;
048f6b4d 9063#endif
704eff6c 9064#ifdef TARGET_NR_symlink
31e31b8a 9065 case TARGET_NR_symlink:
53a5960a
PB		 9066 {
9067 void *p2;
9068 p = lock_user_string(arg1);
9069 p2 = lock_user_string(arg2);
579a97f7
FB		 9070 if (!p || !p2)
9071 ret = -TARGET_EFAULT;
9072 else
9073 ret = get_errno(symlink(p, p2));
53a5960a
PB		 9074 unlock_user(p2, arg2, 0);
9075 unlock_user(p, arg1, 0);
9076 }
31e31b8a 9077 break;
704eff6c 9078#endif
c0d472b1 9079#if defined(TARGET_NR_symlinkat)
f0b6243d 9080 case TARGET_NR_symlinkat:
f0b6243d 9081 {
579a97f7 9082 void *p2;
f0b6243d
TS		 9083 p = lock_user_string(arg1);
9084 p2 = lock_user_string(arg3);
579a97f7 9085 if (!p || !p2)
0da46a6e 9086 ret = -TARGET_EFAULT;
f0b6243d 9087 else
c0d472b1 9088 ret = get_errno(symlinkat(p, arg2, p2));
579a97f7
FB		 9089 unlock_user(p2, arg3, 0);
9090 unlock_user(p, arg1, 0);
f0b6243d
TS		 9091 }
9092 break;
9093#endif
ebc05488 9094#ifdef TARGET_NR_oldlstat
31e31b8a
FB		 9095 case TARGET_NR_oldlstat:
9096 goto unimplemented;
ebc05488 9097#endif
704eff6c 9098#ifdef TARGET_NR_readlink
31e31b8a 9099 case TARGET_NR_readlink:
53a5960a 9100 {
463d8e73 9101 void *p2;
53a5960a 9102 p = lock_user_string(arg1);
579a97f7 9103 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
463d8e73 9104 if (!p || !p2) {
579a97f7 9105 ret = -TARGET_EFAULT;
f17f4989
MF		 9106 } else if (!arg3) {
9107 /* Short circuit this for the magic exe check. */
9108 ret = -TARGET_EINVAL;
463d8e73
AS		 9109 } else if (is_proc_myself((const char *)p, "exe")) {
9110 char real[PATH_MAX], *temp;
9111 temp = realpath(exec_path, real);
f17f4989
MF		 9112 /* Return value is # of bytes that we wrote to the buffer. */
9113 if (temp == NULL) {
9114 ret = get_errno(-1);
9115 } else {
9116 /* Don't worry about sign mismatch as earlier mapping
9117 * logic would have thrown a bad address error. */
9118 ret = MIN(strlen(real), arg3);
9119 /* We cannot NUL terminate the string. */
9120 memcpy(p2, real, ret);
9121 }
463d8e73
AS		 9122 } else {
9123 ret = get_errno(readlink(path(p), p2, arg3));
d088d664 9124 }
53a5960a
PB		 9125 unlock_user(p2, arg2, ret);
9126 unlock_user(p, arg1, 0);
9127 }
31e31b8a 9128 break;
704eff6c 9129#endif
c0d472b1 9130#if defined(TARGET_NR_readlinkat)
5e0ccb18 9131 case TARGET_NR_readlinkat:
5e0ccb18 9132 {
579a97f7 9133 void *p2;
5e0ccb18 9134 p = lock_user_string(arg2);
579a97f7 9135 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
463d8e73
AS		 9136 if (!p || !p2) {
9137 ret = -TARGET_EFAULT;
9138 } else if (is_proc_myself((const char *)p, "exe")) {
9139 char real[PATH_MAX], *temp;
9140 temp = realpath(exec_path, real);
9141 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
9142 snprintf((char *)p2, arg4, "%s", real);
9143 } else {
c0d472b1 9144 ret = get_errno(readlinkat(arg1, path(p), p2, arg4));
463d8e73 9145 }
579a97f7
FB		 9146 unlock_user(p2, arg3, ret);
9147 unlock_user(p, arg2, 0);
5e0ccb18
TS		 9148 }
9149 break;
9150#endif
e5febef5 9151#ifdef TARGET_NR_uselib
31e31b8a
FB		 9152 case TARGET_NR_uselib:
9153 goto unimplemented;
e5febef5
TS		 9154#endif
9155#ifdef TARGET_NR_swapon
31e31b8a 9156 case TARGET_NR_swapon:
579a97f7
FB		 9157 if (!(p = lock_user_string(arg1)))
9158 goto efault;
53a5960a
PB		 9159 ret = get_errno(swapon(p, arg2));
9160 unlock_user(p, arg1, 0);
31e31b8a 9161 break;
e5febef5 9162#endif
31e31b8a 9163 case TARGET_NR_reboot:
c07ecc68
LV		 9164 if (arg3 == LINUX_REBOOT_CMD_RESTART2) {
9165 /* arg4 must be ignored in all other cases */
9166 p = lock_user_string(arg4);
9167 if (!p) {
9168 goto efault;
9169 }
9170 ret = get_errno(reboot(arg1, arg2, arg3, p));
9171 unlock_user(p, arg4, 0);
9172 } else {
9173 ret = get_errno(reboot(arg1, arg2, arg3, NULL));
9174 }
0f6b4d21 9175 break;
e5febef5 9176#ifdef TARGET_NR_readdir
31e31b8a
FB		 9177 case TARGET_NR_readdir:
9178 goto unimplemented;
e5febef5
TS		 9179#endif
9180#ifdef TARGET_NR_mmap
31e31b8a 9181 case TARGET_NR_mmap:
09701199
AG		 9182#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
9183 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
a4c075f1
UH		 9184 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
9185 || defined(TARGET_S390X)
31e31b8a 9186 {
992f48a0
BS		 9187 abi_ulong *v;
9188 abi_ulong v1, v2, v3, v4, v5, v6;
579a97f7
FB		 9189 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
9190 goto efault;
cbb21eed
MB		 9191 v1 = tswapal(v[0]);
9192 v2 = tswapal(v[1]);
9193 v3 = tswapal(v[2]);
9194 v4 = tswapal(v[3]);
9195 v5 = tswapal(v[4]);
9196 v6 = tswapal(v[5]);
53a5960a 9197 unlock_user(v, arg1, 0);
5fafdf24 9198 ret = get_errno(target_mmap(v1, v2, v3,
5286db75
FB		 9199 target_to_host_bitmask(v4, mmap_flags_tbl),
9200 v5, v6));
31e31b8a 9201 }
31e31b8a 9202#else
5fafdf24
TS		 9203 ret = get_errno(target_mmap(arg1, arg2, arg3,
9204 target_to_host_bitmask(arg4, mmap_flags_tbl),
6fb883e8
FB		 9205 arg5,
9206 arg6));
31e31b8a 9207#endif
6fb883e8 9208 break;
e5febef5 9209#endif
a315a145 9210#ifdef TARGET_NR_mmap2
6fb883e8 9211 case TARGET_NR_mmap2:
bb7ec043 9212#ifndef MMAP_SHIFT
c573ff67 9213#define MMAP_SHIFT 12
c573ff67 9214#endif
5fafdf24
TS		 9215 ret = get_errno(target_mmap(arg1, arg2, arg3,
9216 target_to_host_bitmask(arg4, mmap_flags_tbl),
5286db75 9217 arg5,
c573ff67 9218 arg6 << MMAP_SHIFT));
31e31b8a 9219 break;
a315a145 9220#endif
31e31b8a 9221 case TARGET_NR_munmap:
54936004 9222 ret = get_errno(target_munmap(arg1, arg2));
31e31b8a 9223 break;
9de5e440 9224 case TARGET_NR_mprotect:
97374d38 9225 {
0429a971 9226 TaskState *ts = cpu->opaque;
97374d38
PB		 9227 /* Special hack to detect libc making the stack executable. */
9228 if ((arg3 & PROT_GROWSDOWN)
9229 && arg1 >= ts->info->stack_limit
9230 && arg1 <= ts->info->start_stack) {
9231 arg3 &= ~PROT_GROWSDOWN;
9232 arg2 = arg2 + arg1 - ts->info->stack_limit;
9233 arg1 = ts->info->stack_limit;
9234 }
9235 }
54936004 9236 ret = get_errno(target_mprotect(arg1, arg2, arg3));
9de5e440 9237 break;
e5febef5 9238#ifdef TARGET_NR_mremap
9de5e440 9239 case TARGET_NR_mremap:
54936004 9240 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
9de5e440 9241 break;
e5febef5 9242#endif
53a5960a 9243 /* ??? msync/mlock/munlock are broken for softmmu. */
e5febef5 9244#ifdef TARGET_NR_msync
9de5e440 9245 case TARGET_NR_msync:
53a5960a 9246 ret = get_errno(msync(g2h(arg1), arg2, arg3));
9de5e440 9247 break;
e5febef5
TS		 9248#endif
9249#ifdef TARGET_NR_mlock
9de5e440 9250 case TARGET_NR_mlock:
53a5960a 9251 ret = get_errno(mlock(g2h(arg1), arg2));
9de5e440 9252 break;
e5febef5
TS		 9253#endif
9254#ifdef TARGET_NR_munlock
9de5e440 9255 case TARGET_NR_munlock:
53a5960a 9256 ret = get_errno(munlock(g2h(arg1), arg2));
9de5e440 9257 break;
e5febef5
TS		 9258#endif
9259#ifdef TARGET_NR_mlockall
9de5e440 9260 case TARGET_NR_mlockall:
6f6a4032 9261 ret = get_errno(mlockall(target_to_host_mlockall_arg(arg1)));
9de5e440 9262 break;
e5febef5
TS		 9263#endif
9264#ifdef TARGET_NR_munlockall
9de5e440
FB		 9265 case TARGET_NR_munlockall:
9266 ret = get_errno(munlockall());
9267 break;
e5febef5 9268#endif
31e31b8a 9269 case TARGET_NR_truncate:
579a97f7
FB		 9270 if (!(p = lock_user_string(arg1)))
9271 goto efault;
53a5960a
PB		 9272 ret = get_errno(truncate(p, arg2));
9273 unlock_user(p, arg1, 0);
31e31b8a
FB		 9274 break;
9275 case TARGET_NR_ftruncate:
9276 ret = get_errno(ftruncate(arg1, arg2));
9277 break;
9278 case TARGET_NR_fchmod:
9279 ret = get_errno(fchmod(arg1, arg2));
9280 break;
c0d472b1 9281#if defined(TARGET_NR_fchmodat)
814d7977 9282 case TARGET_NR_fchmodat:
579a97f7
FB		 9283 if (!(p = lock_user_string(arg2)))
9284 goto efault;
c0d472b1 9285 ret = get_errno(fchmodat(arg1, p, arg3, 0));
579a97f7 9286 unlock_user(p, arg2, 0);
814d7977
TS		 9287 break;
9288#endif
31e31b8a 9289 case TARGET_NR_getpriority:
95c09828
RH		 9290 /* Note that negative values are valid for getpriority, so we must
9291 differentiate based on errno settings. */
9292 errno = 0;
9293 ret = getpriority(arg1, arg2);
9294 if (ret == -1 && errno != 0) {
9295 ret = -host_to_target_errno(errno);
9296 break;
9297 }
9298#ifdef TARGET_ALPHA
9299 /* Return value is the unbiased priority. Signal no error. */
9300 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0;
9301#else
9302 /* Return value is a biased priority to avoid negative numbers. */
9303 ret = 20 - ret;
9304#endif
31e31b8a
FB		 9305 break;
9306 case TARGET_NR_setpriority:
9307 ret = get_errno(setpriority(arg1, arg2, arg3));
9308 break;
ebc05488 9309#ifdef TARGET_NR_profil
31e31b8a
FB		 9310 case TARGET_NR_profil:
9311 goto unimplemented;
ebc05488 9312#endif
31e31b8a 9313 case TARGET_NR_statfs:
579a97f7
FB		 9314 if (!(p = lock_user_string(arg1)))
9315 goto efault;
53a5960a
PB		 9316 ret = get_errno(statfs(path(p), &stfs));
9317 unlock_user(p, arg1, 0);
31e31b8a
FB		 9318 convert_statfs:
9319 if (!is_error(ret)) {
53a5960a 9320 struct target_statfs *target_stfs;
3b46e624 9321
579a97f7
FB		 9322 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
9323 goto efault;
9324 __put_user(stfs.f_type, &target_stfs->f_type);
9325 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
9326 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
9327 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
9328 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
9329 __put_user(stfs.f_files, &target_stfs->f_files);
9330 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
9331 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
9332 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
9333 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
229d3376
AG		 9334 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
9335 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
53a5960a 9336 unlock_user_struct(target_stfs, arg2, 1);
31e31b8a
FB		 9337 }
9338 break;
9339 case TARGET_NR_fstatfs:
56c8f68f 9340 ret = get_errno(fstatfs(arg1, &stfs));
31e31b8a 9341 goto convert_statfs;
56c8f68f
FB		 9342#ifdef TARGET_NR_statfs64
9343 case TARGET_NR_statfs64:
579a97f7
FB		 9344 if (!(p = lock_user_string(arg1)))
9345 goto efault;
53a5960a
PB		 9346 ret = get_errno(statfs(path(p), &stfs));
9347 unlock_user(p, arg1, 0);
56c8f68f
FB		 9348 convert_statfs64:
9349 if (!is_error(ret)) {
53a5960a 9350 struct target_statfs64 *target_stfs;
3b46e624 9351
579a97f7
FB		 9352 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
9353 goto efault;
9354 __put_user(stfs.f_type, &target_stfs->f_type);
9355 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
9356 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
9357 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
9358 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
9359 __put_user(stfs.f_files, &target_stfs->f_files);
9360 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
9361 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
9362 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
9363 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
229d3376
AG		 9364 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
9365 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
579a97f7 9366 unlock_user_struct(target_stfs, arg3, 1);
56c8f68f
FB		 9367 }
9368 break;
9369 case TARGET_NR_fstatfs64:
9370 ret = get_errno(fstatfs(arg1, &stfs));
9371 goto convert_statfs64;
9372#endif
ebc05488 9373#ifdef TARGET_NR_ioperm
31e31b8a
FB		 9374 case TARGET_NR_ioperm:
9375 goto unimplemented;
ebc05488 9376#endif
e5febef5 9377#ifdef TARGET_NR_socketcall
31e31b8a 9378 case TARGET_NR_socketcall:
53a5960a 9379 ret = do_socketcall(arg1, arg2);
31e31b8a 9380 break;
e5febef5 9381#endif
3532fa74
FB		 9382#ifdef TARGET_NR_accept
9383 case TARGET_NR_accept:
a94b4987
PM		 9384 ret = do_accept4(arg1, arg2, arg3, 0);
9385 break;
9386#endif
9387#ifdef TARGET_NR_accept4
9388 case TARGET_NR_accept4:
a94b4987 9389 ret = do_accept4(arg1, arg2, arg3, arg4);
3532fa74
FB		 9390 break;
9391#endif
9392#ifdef TARGET_NR_bind
9393 case TARGET_NR_bind:
9394 ret = do_bind(arg1, arg2, arg3);
9395 break;
9396#endif
9397#ifdef TARGET_NR_connect
9398 case TARGET_NR_connect:
9399 ret = do_connect(arg1, arg2, arg3);
9400 break;
9401#endif
9402#ifdef TARGET_NR_getpeername
9403 case TARGET_NR_getpeername:
1be9e1dc 9404 ret = do_getpeername(arg1, arg2, arg3);
3532fa74
FB		 9405 break;
9406#endif
9407#ifdef TARGET_NR_getsockname
9408 case TARGET_NR_getsockname:
1be9e1dc 9409 ret = do_getsockname(arg1, arg2, arg3);
3532fa74
FB		 9410 break;
9411#endif
9412#ifdef TARGET_NR_getsockopt
9413 case TARGET_NR_getsockopt:
9414 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
9415 break;
9416#endif
9417#ifdef TARGET_NR_listen
9418 case TARGET_NR_listen:
1be9e1dc 9419 ret = get_errno(listen(arg1, arg2));
3532fa74
FB		 9420 break;
9421#endif
9422#ifdef TARGET_NR_recv
9423 case TARGET_NR_recv:
214201bd 9424 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 9425 break;
9426#endif
9427#ifdef TARGET_NR_recvfrom
9428 case TARGET_NR_recvfrom:
214201bd 9429 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 9430 break;
9431#endif
9432#ifdef TARGET_NR_recvmsg
9433 case TARGET_NR_recvmsg:
9434 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
9435 break;
9436#endif
9437#ifdef TARGET_NR_send
9438 case TARGET_NR_send:
1be9e1dc 9439 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 9440 break;
9441#endif
9442#ifdef TARGET_NR_sendmsg
9443 case TARGET_NR_sendmsg:
9444 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
9445 break;
9446#endif
f19e00d7
AG		 9447#ifdef TARGET_NR_sendmmsg
9448 case TARGET_NR_sendmmsg:
9449 ret = do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1);
9450 break;
9451 case TARGET_NR_recvmmsg:
9452 ret = do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0);
9453 break;
9454#endif
3532fa74
FB		 9455#ifdef TARGET_NR_sendto
9456 case TARGET_NR_sendto:
1be9e1dc 9457 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 9458 break;
9459#endif
9460#ifdef TARGET_NR_shutdown
9461 case TARGET_NR_shutdown:
1be9e1dc 9462 ret = get_errno(shutdown(arg1, arg2));
3532fa74
FB		 9463 break;
9464#endif
f894efd1
LV		 9465#if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
9466 case TARGET_NR_getrandom:
9467 p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
9468 if (!p) {
9469 goto efault;
9470 }
9471 ret = get_errno(getrandom(p, arg2, arg3));
9472 unlock_user(p, arg1, ret);
9473 break;
9474#endif
3532fa74
FB		 9475#ifdef TARGET_NR_socket
9476 case TARGET_NR_socket:
9477 ret = do_socket(arg1, arg2, arg3);
9478 break;
9479#endif
9480#ifdef TARGET_NR_socketpair
9481 case TARGET_NR_socketpair:
1be9e1dc 9482 ret = do_socketpair(arg1, arg2, arg3, arg4);
3532fa74
FB		 9483 break;
9484#endif
9485#ifdef TARGET_NR_setsockopt
9486 case TARGET_NR_setsockopt:
9487 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
9488 break;
9489#endif
da2c8ad7 9490#if defined(TARGET_NR_syslog)
31e31b8a 9491 case TARGET_NR_syslog:
da2c8ad7
AM		 9492 {
9493 int len = arg2;
7494b0f9 9494
da2c8ad7
AM		 9495 switch (arg1) {
9496 case TARGET_SYSLOG_ACTION_CLOSE: /* Close log */
9497 case TARGET_SYSLOG_ACTION_OPEN: /* Open log */
9498 case TARGET_SYSLOG_ACTION_CLEAR: /* Clear ring buffer */
9499 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging */
9500 case TARGET_SYSLOG_ACTION_CONSOLE_ON: /* Enable logging */
9501 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */
9502 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: /* Number of chars */
9503 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: /* Size of the buffer */
9504 {
9505 ret = get_errno(sys_syslog((int)arg1, NULL, (int)arg3));
9506 }
9507 break;
9508 case TARGET_SYSLOG_ACTION_READ: /* Read from log */
9509 case TARGET_SYSLOG_ACTION_READ_CLEAR: /* Read/clear msgs */
9510 case TARGET_SYSLOG_ACTION_READ_ALL: /* Read last messages */
9511 {
9512 ret = -TARGET_EINVAL;
9513 if (len < 0) {
9514 goto fail;
9515 }
9516 ret = 0;
9517 if (len == 0) {
9518 break;
9519 }
9520 p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
9521 if (!p) {
9522 ret = -TARGET_EFAULT;
9523 goto fail;
9524 }
9525 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
9526 unlock_user(p, arg2, arg3);
9527 }
9528 break;
9529 default:
9530 ret = -EINVAL;
9531 break;
9532 }
9533 }
9534 break;
9535#endif
31e31b8a 9536 case TARGET_NR_setitimer:
66fb9763 9537 {
66fb9763
FB		 9538 struct itimerval value, ovalue, *pvalue;
9539
53a5960a 9540 if (arg2) {
66fb9763 9541 pvalue = &value;
788f5ec4
TS		 9542 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
9543 || copy_from_user_timeval(&pvalue->it_value,
9544 arg2 + sizeof(struct target_timeval)))
9545 goto efault;
66fb9763
FB		 9546 } else {
9547 pvalue = NULL;
9548 }
9549 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
53a5960a 9550 if (!is_error(ret) && arg3) {
788f5ec4
TS		 9551 if (copy_to_user_timeval(arg3,
9552 &ovalue.it_interval)
9553 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
9554 &ovalue.it_value))
9555 goto efault;
66fb9763
FB		 9556 }
9557 }
9558 break;
31e31b8a 9559 case TARGET_NR_getitimer:
66fb9763 9560 {
66fb9763 9561 struct itimerval value;
3b46e624 9562
66fb9763 9563 ret = get_errno(getitimer(arg1, &value));
53a5960a 9564 if (!is_error(ret) && arg2) {
788f5ec4
TS		 9565 if (copy_to_user_timeval(arg2,
9566 &value.it_interval)
9567 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
9568 &value.it_value))
9569 goto efault;
66fb9763
FB		 9570 }
9571 }
9572 break;
704eff6c 9573#ifdef TARGET_NR_stat
31e31b8a 9574 case TARGET_NR_stat:
579a97f7
FB		 9575 if (!(p = lock_user_string(arg1)))
9576 goto efault;
53a5960a
PB		 9577 ret = get_errno(stat(path(p), &st));
9578 unlock_user(p, arg1, 0);
31e31b8a 9579 goto do_stat;
704eff6c
CG		 9580#endif
9581#ifdef TARGET_NR_lstat
31e31b8a 9582 case TARGET_NR_lstat:
579a97f7
FB		 9583 if (!(p = lock_user_string(arg1)))
9584 goto efault;
53a5960a
PB		 9585 ret = get_errno(lstat(path(p), &st));
9586 unlock_user(p, arg1, 0);
31e31b8a 9587 goto do_stat;
704eff6c 9588#endif
31e31b8a
FB		 9589 case TARGET_NR_fstat:
9590 {
9591 ret = get_errno(fstat(arg1, &st));
704eff6c 9592#if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
31e31b8a 9593 do_stat:
704eff6c 9594#endif
31e31b8a 9595 if (!is_error(ret)) {
53a5960a 9596 struct target_stat *target_st;
e3584658 9597
579a97f7
FB		 9598 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
9599 goto efault;
12727917 9600 memset(target_st, 0, sizeof(*target_st));
d2fd1af7
FB		 9601 __put_user(st.st_dev, &target_st->st_dev);
9602 __put_user(st.st_ino, &target_st->st_ino);
9603 __put_user(st.st_mode, &target_st->st_mode);
9604 __put_user(st.st_uid, &target_st->st_uid);
9605 __put_user(st.st_gid, &target_st->st_gid);
9606 __put_user(st.st_nlink, &target_st->st_nlink);
9607 __put_user(st.st_rdev, &target_st->st_rdev);
9608 __put_user(st.st_size, &target_st->st_size);
9609 __put_user(st.st_blksize, &target_st->st_blksize);
9610 __put_user(st.st_blocks, &target_st->st_blocks);
9611 __put_user(st.st_atime, &target_st->target_st_atime);
9612 __put_user(st.st_mtime, &target_st->target_st_mtime);
9613 __put_user(st.st_ctime, &target_st->target_st_ctime);
53a5960a 9614 unlock_user_struct(target_st, arg2, 1);
31e31b8a
FB		 9615 }
9616 }
9617 break;
ebc05488 9618#ifdef TARGET_NR_olduname
31e31b8a
FB		 9619 case TARGET_NR_olduname:
9620 goto unimplemented;
ebc05488
FB		 9621#endif
9622#ifdef TARGET_NR_iopl
31e31b8a
FB		 9623 case TARGET_NR_iopl:
9624 goto unimplemented;
ebc05488 9625#endif
31e31b8a
FB		 9626 case TARGET_NR_vhangup:
9627 ret = get_errno(vhangup());
9628 break;
ebc05488 9629#ifdef TARGET_NR_idle
31e31b8a
FB		 9630 case TARGET_NR_idle:
9631 goto unimplemented;
42ad6ae9
FB		 9632#endif
9633#ifdef TARGET_NR_syscall
9634 case TARGET_NR_syscall:
5945cfcb
PM		 9635 ret = do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5,
9636 arg6, arg7, arg8, 0);
9637 break;
ebc05488 9638#endif
31e31b8a
FB		 9639 case TARGET_NR_wait4:
9640 {
9641 int status;
992f48a0 9642 abi_long status_ptr = arg2;
31e31b8a 9643 struct rusage rusage, *rusage_ptr;
992f48a0 9644 abi_ulong target_rusage = arg4;
a39fb273 9645 abi_long rusage_err;
31e31b8a
FB		 9646 if (target_rusage)
9647 rusage_ptr = &rusage;
9648 else
9649 rusage_ptr = NULL;
4af80a37 9650 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr));
31e31b8a 9651 if (!is_error(ret)) {
5379557b 9652 if (status_ptr && ret) {
1d9d8b55 9653 status = host_to_target_waitstatus(status);
2f619698
FB		 9654 if (put_user_s32(status, status_ptr))
9655 goto efault;
31e31b8a 9656 }
a39fb273
PJ		 9657 if (target_rusage) {
9658 rusage_err = host_to_target_rusage(target_rusage, &rusage);
9659 if (rusage_err) {
9660 ret = rusage_err;
9661 }
9662 }
31e31b8a
FB		 9663 }
9664 }
9665 break;
e5febef5 9666#ifdef TARGET_NR_swapoff
31e31b8a 9667 case TARGET_NR_swapoff:
579a97f7
FB		 9668 if (!(p = lock_user_string(arg1)))
9669 goto efault;
53a5960a
PB		 9670 ret = get_errno(swapoff(p));
9671 unlock_user(p, arg1, 0);
31e31b8a 9672 break;
e5febef5 9673#endif
31e31b8a 9674 case TARGET_NR_sysinfo:
a5448a7d 9675 {
53a5960a 9676 struct target_sysinfo *target_value;
a5448a7d
FB		 9677 struct sysinfo value;
9678 ret = get_errno(sysinfo(&value));
53a5960a 9679 if (!is_error(ret) && arg1)
a5448a7d 9680 {
579a97f7
FB		 9681 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
9682 goto efault;
a5448a7d
FB		 9683 __put_user(value.uptime, &target_value->uptime);
9684 __put_user(value.loads[0], &target_value->loads[0]);
9685 __put_user(value.loads[1], &target_value->loads[1]);
9686 __put_user(value.loads[2], &target_value->loads[2]);
9687 __put_user(value.totalram, &target_value->totalram);
9688 __put_user(value.freeram, &target_value->freeram);
9689 __put_user(value.sharedram, &target_value->sharedram);
9690 __put_user(value.bufferram, &target_value->bufferram);
9691 __put_user(value.totalswap, &target_value->totalswap);
9692 __put_user(value.freeswap, &target_value->freeswap);
9693 __put_user(value.procs, &target_value->procs);
9694 __put_user(value.totalhigh, &target_value->totalhigh);
9695 __put_user(value.freehigh, &target_value->freehigh);
9696 __put_user(value.mem_unit, &target_value->mem_unit);
53a5960a 9697 unlock_user_struct(target_value, arg1, 1);
a5448a7d
FB		 9698 }
9699 }
9700 break;
e5febef5 9701#ifdef TARGET_NR_ipc
31e31b8a 9702 case TARGET_NR_ipc:
ee8e7614
PM		 9703 ret = do_ipc(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
9704 break;
e5febef5 9705#endif
e5289087
AJ		 9706#ifdef TARGET_NR_semget
9707 case TARGET_NR_semget:
9708 ret = get_errno(semget(arg1, arg2, arg3));
9709 break;
9710#endif
9711#ifdef TARGET_NR_semop
9712 case TARGET_NR_semop:
c7128c9f 9713 ret = do_semop(arg1, arg2, arg3);
e5289087
AJ		 9714 break;
9715#endif
9716#ifdef TARGET_NR_semctl
9717 case TARGET_NR_semctl:
d1c002b6 9718 ret = do_semctl(arg1, arg2, arg3, arg4);
e5289087
AJ		 9719 break;
9720#endif
eeb438c1
AJ		 9721#ifdef TARGET_NR_msgctl
9722 case TARGET_NR_msgctl:
9723 ret = do_msgctl(arg1, arg2, arg3);
9724 break;
9725#endif
9726#ifdef TARGET_NR_msgget
9727 case TARGET_NR_msgget:
9728 ret = get_errno(msgget(arg1, arg2));
9729 break;
9730#endif
9731#ifdef TARGET_NR_msgrcv
9732 case TARGET_NR_msgrcv:
9733 ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
9734 break;
9735#endif
9736#ifdef TARGET_NR_msgsnd
9737 case TARGET_NR_msgsnd:
9738 ret = do_msgsnd(arg1, arg2, arg3, arg4);
9739 break;
88a8c984
RV		 9740#endif
9741#ifdef TARGET_NR_shmget
9742 case TARGET_NR_shmget:
9743 ret = get_errno(shmget(arg1, arg2, arg3));
9744 break;
9745#endif
9746#ifdef TARGET_NR_shmctl
9747 case TARGET_NR_shmctl:
9748 ret = do_shmctl(arg1, arg2, arg3);
9749 break;
9750#endif
9751#ifdef TARGET_NR_shmat
9752 case TARGET_NR_shmat:
ee8e7614 9753 ret = do_shmat(cpu_env, arg1, arg2, arg3);
88a8c984
RV		 9754 break;
9755#endif
9756#ifdef TARGET_NR_shmdt
9757 case TARGET_NR_shmdt:
9758 ret = do_shmdt(arg1);
9759 break;
eeb438c1 9760#endif
31e31b8a
FB		 9761 case TARGET_NR_fsync:
9762 ret = get_errno(fsync(arg1));
9763 break;
31e31b8a 9764 case TARGET_NR_clone:
4ce6243d
PM		 9765 /* Linux manages to have three different orderings for its
9766 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
9767 * match the kernel's CONFIG_CLONE_* settings.
9768 * Microblaze is further special in that it uses a sixth
9769 * implicit argument to clone for the TLS pointer.
9770 */
9771#if defined(TARGET_MICROBLAZE)
a5b3bdcb 9772 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5));
4ce6243d
PM		 9773#elif defined(TARGET_CLONE_BACKWARDS)
9774 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
9775#elif defined(TARGET_CLONE_BACKWARDS2)
a4c075f1 9776 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
0b6d3ae0 9777#else
4ce6243d 9778 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
0b6d3ae0 9779#endif
1b6b029e 9780 break;
ec86b0fb
FB		 9781#ifdef __NR_exit_group
9782 /* new thread calls */
9783 case TARGET_NR_exit_group:
9788c9ca 9784#ifdef TARGET_GPROF
6d946cda
AJ		 9785 _mcleanup();
9786#endif
e9009676 9787 gdb_exit(cpu_env, arg1);
ec86b0fb
FB		 9788 ret = get_errno(exit_group(arg1));
9789 break;
9790#endif
31e31b8a 9791 case TARGET_NR_setdomainname:
579a97f7
FB		 9792 if (!(p = lock_user_string(arg1)))
9793 goto efault;
53a5960a
PB		 9794 ret = get_errno(setdomainname(p, arg2));
9795 unlock_user(p, arg1, 0);
31e31b8a
FB		 9796 break;
9797 case TARGET_NR_uname:
9798 /* no need to transcode because we use the linux syscall */
29e619b1
FB		 9799 {
9800 struct new_utsname * buf;
3b46e624 9801
579a97f7
FB		 9802 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
9803 goto efault;
29e619b1
FB		 9804 ret = get_errno(sys_uname(buf));
9805 if (!is_error(ret)) {
332c9781 9806 /* Overwrite the native machine name with whatever is being
29e619b1 9807 emulated. */
da79030f 9808 strcpy (buf->machine, cpu_to_uname_machine(cpu_env));
c5937220 9809 /* Allow the user to override the reported release. */
332c9781
PM		 9810 if (qemu_uname_release && *qemu_uname_release) {
9811 g_strlcpy(buf->release, qemu_uname_release,
9812 sizeof(buf->release));
9813 }
29e619b1 9814 }
53a5960a 9815 unlock_user_struct(buf, arg1, 1);
29e619b1 9816 }
31e31b8a 9817 break;
6dbad63e 9818#ifdef TARGET_I386
31e31b8a 9819 case TARGET_NR_modify_ldt:
03acab66 9820 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
5cd4393b 9821 break;
84409ddb 9822#if !defined(TARGET_X86_64)
5cd4393b
FB		 9823 case TARGET_NR_vm86old:
9824 goto unimplemented;
9825 case TARGET_NR_vm86:
53a5960a 9826 ret = do_vm86(cpu_env, arg1, arg2);
6dbad63e 9827 break;
84409ddb 9828#endif
6dbad63e 9829#endif
31e31b8a 9830 case TARGET_NR_adjtimex:
19f59bce
AM		 9831 {
9832 struct timex host_buf;
9833
9834 if (target_to_host_timex(&host_buf, arg1) != 0) {
9835 goto efault;
9836 }
9837 ret = get_errno(adjtimex(&host_buf));
9838 if (!is_error(ret)) {
9839 if (host_to_target_timex(arg1, &host_buf) != 0) {
9840 goto efault;
9841 }
9842 }
9843 }
9844 break;
38860a03
AM		 9845#if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
9846 case TARGET_NR_clock_adjtime:
9847 {
9848 struct timex htx, *phtx = &htx;
9849
9850 if (target_to_host_timex(phtx, arg2) != 0) {
9851 goto efault;
9852 }
9853 ret = get_errno(clock_adjtime(arg1, phtx));
9854 if (!is_error(ret) && phtx) {
9855 if (host_to_target_timex(arg2, phtx) != 0) {
9856 goto efault;
9857 }
9858 }
9859 }
9860 break;
9861#endif
e5febef5 9862#ifdef TARGET_NR_create_module
31e31b8a 9863 case TARGET_NR_create_module:
e5febef5 9864#endif
31e31b8a
FB		 9865 case TARGET_NR_init_module:
9866 case TARGET_NR_delete_module:
e5febef5 9867#ifdef TARGET_NR_get_kernel_syms
31e31b8a 9868 case TARGET_NR_get_kernel_syms:
e5febef5 9869#endif
31e31b8a
FB		 9870 goto unimplemented;
9871 case TARGET_NR_quotactl:
9872 goto unimplemented;
9873 case TARGET_NR_getpgid:
9874 ret = get_errno(getpgid(arg1));
9875 break;
9876 case TARGET_NR_fchdir:
9877 ret = get_errno(fchdir(arg1));
9878 break;
84409ddb 9879#ifdef TARGET_NR_bdflush /* not on x86_64 */
31e31b8a
FB		 9880 case TARGET_NR_bdflush:
9881 goto unimplemented;
84409ddb 9882#endif
e5febef5 9883#ifdef TARGET_NR_sysfs
31e31b8a
FB		 9884 case TARGET_NR_sysfs:
9885 goto unimplemented;
e5febef5 9886#endif
31e31b8a 9887 case TARGET_NR_personality:
1b6b029e 9888 ret = get_errno(personality(arg1));
31e31b8a 9889 break;
e5febef5 9890#ifdef TARGET_NR_afs_syscall
31e31b8a
FB		 9891 case TARGET_NR_afs_syscall:
9892 goto unimplemented;
e5febef5 9893#endif
7a3148a9 9894#ifdef TARGET_NR__llseek /* Not on alpha */
31e31b8a
FB		 9895 case TARGET_NR__llseek:
9896 {
0c1592d9 9897 int64_t res;
d35b261c 9898#if !defined(__NR_llseek)
9fea273c 9899 res = lseek(arg1, ((uint64_t)arg2 << 32) | (abi_ulong)arg3, arg5);
0c1592d9
PM		 9900 if (res == -1) {
9901 ret = get_errno(res);
9902 } else {
9903 ret = 0;
9904 }
4f2ac237 9905#else
31e31b8a 9906 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
4f2ac237 9907#endif
0c1592d9
PM		 9908 if ((ret == 0) && put_user_s64(res, arg4)) {
9909 goto efault;
9910 }
31e31b8a
FB		 9911 }
9912 break;
7a3148a9 9913#endif
704eff6c 9914#ifdef TARGET_NR_getdents
31e31b8a 9915 case TARGET_NR_getdents:
3307e236 9916#ifdef __NR_getdents
d83c8733 9917#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4add45b4 9918 {
53a5960a 9919 struct target_dirent *target_dirp;
6556a833 9920 struct linux_dirent *dirp;
992f48a0 9921 abi_long count = arg3;
4add45b4 9922
0e173b24
HK		 9923 dirp = g_try_malloc(count);
9924 if (!dirp) {
579a97f7 9925 ret = -TARGET_ENOMEM;
0da46a6e
TS		 9926 goto fail;
9927 }
3b46e624 9928
4add45b4
FB		 9929 ret = get_errno(sys_getdents(arg1, dirp, count));
9930 if (!is_error(ret)) {
6556a833 9931 struct linux_dirent *de;
4add45b4
FB		 9932 struct target_dirent *tde;
9933 int len = ret;
9934 int reclen, treclen;
9935 int count1, tnamelen;
9936
9937 count1 = 0;
9938 de = dirp;
579a97f7
FB		 9939 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9940 goto efault;
4add45b4
FB		 9941 tde = target_dirp;
9942 while (len > 0) {
9943 reclen = de->d_reclen;
333858b7
DL		 9944 tnamelen = reclen - offsetof(struct linux_dirent, d_name);
9945 assert(tnamelen >= 0);
9946 treclen = tnamelen + offsetof(struct target_dirent, d_name);
9947 assert(count1 + treclen <= count);
4add45b4 9948 tde->d_reclen = tswap16(treclen);
cbb21eed
MB		 9949 tde->d_ino = tswapal(de->d_ino);
9950 tde->d_off = tswapal(de->d_off);
333858b7 9951 memcpy(tde->d_name, de->d_name, tnamelen);
6556a833 9952 de = (struct linux_dirent *)((char *)de + reclen);
4add45b4 9953 len -= reclen;
1c5bf3bf 9954 tde = (struct target_dirent *)((char *)tde + treclen);
4add45b4
FB		 9955 count1 += treclen;
9956 }
9957 ret = count1;
579a97f7 9958 unlock_user(target_dirp, arg2, ret);
4add45b4 9959 }
0e173b24 9960 g_free(dirp);
4add45b4
FB		 9961 }
9962#else
31e31b8a 9963 {
6556a833 9964 struct linux_dirent *dirp;
992f48a0 9965 abi_long count = arg3;
dab2ed99 9966
579a97f7
FB		 9967 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9968 goto efault;
72f03900 9969 ret = get_errno(sys_getdents(arg1, dirp, count));
31e31b8a 9970 if (!is_error(ret)) {
6556a833 9971 struct linux_dirent *de;
31e31b8a
FB		 9972 int len = ret;
9973 int reclen;
9974 de = dirp;
9975 while (len > 0) {
8083a3e5 9976 reclen = de->d_reclen;
31e31b8a
FB		 9977 if (reclen > len)
9978 break;
8083a3e5 9979 de->d_reclen = tswap16(reclen);
31e31b8a
FB		 9980 tswapls(&de->d_ino);
9981 tswapls(&de->d_off);
6556a833 9982 de = (struct linux_dirent *)((char *)de + reclen);
31e31b8a
FB		 9983 len -= reclen;
9984 }
9985 }
53a5960a 9986 unlock_user(dirp, arg2, ret);
3307e236
PM		 9987 }
9988#endif
9989#else
9990 /* Implement getdents in terms of getdents64 */
9991 {
9992 struct linux_dirent64 *dirp;
9993 abi_long count = arg3;
9994
9995 dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
9996 if (!dirp) {
9997 goto efault;
9998 }
9999 ret = get_errno(sys_getdents64(arg1, dirp, count));
10000 if (!is_error(ret)) {
10001 /* Convert the dirent64 structs to target dirent. We do this
10002 * in-place, since we can guarantee that a target_dirent is no
10003 * larger than a dirent64; however this means we have to be
10004 * careful to read everything before writing in the new format.
10005 */
10006 struct linux_dirent64 *de;
10007 struct target_dirent *tde;
10008 int len = ret;
10009 int tlen = 0;
10010
10011 de = dirp;
10012 tde = (struct target_dirent *)dirp;
10013 while (len > 0) {
10014 int namelen, treclen;
10015 int reclen = de->d_reclen;
10016 uint64_t ino = de->d_ino;
10017 int64_t off = de->d_off;
10018 uint8_t type = de->d_type;
10019
10020 namelen = strlen(de->d_name);
10021 treclen = offsetof(struct target_dirent, d_name)
10022 + namelen + 2;
10023 treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
10024
10025 memmove(tde->d_name, de->d_name, namelen + 1);
10026 tde->d_ino = tswapal(ino);
10027 tde->d_off = tswapal(off);
10028 tde->d_reclen = tswap16(treclen);
10029 /* The target_dirent type is in what was formerly a padding
10030 * byte at the end of the structure:
10031 */
10032 *(((char *)tde) + treclen - 1) = type;
10033
10034 de = (struct linux_dirent64 *)((char *)de + reclen);
10035 tde = (struct target_dirent *)((char *)tde + treclen);
10036 len -= reclen;
10037 tlen += treclen;
10038 }
10039 ret = tlen;
10040 }
10041 unlock_user(dirp, arg2, ret);
31e31b8a 10042 }
4add45b4 10043#endif
31e31b8a 10044 break;
704eff6c 10045#endif /* TARGET_NR_getdents */
3ae43202 10046#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
dab2ed99
FB		 10047 case TARGET_NR_getdents64:
10048 {
6556a833 10049 struct linux_dirent64 *dirp;
992f48a0 10050 abi_long count = arg3;
579a97f7
FB		 10051 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
10052 goto efault;
dab2ed99
FB		 10053 ret = get_errno(sys_getdents64(arg1, dirp, count));
10054 if (!is_error(ret)) {
6556a833 10055 struct linux_dirent64 *de;
dab2ed99
FB		 10056 int len = ret;
10057 int reclen;
10058 de = dirp;
10059 while (len > 0) {
8083a3e5 10060 reclen = de->d_reclen;
dab2ed99
FB		 10061 if (reclen > len)
10062 break;
8083a3e5 10063 de->d_reclen = tswap16(reclen);
8582a53a
FB		 10064 tswap64s((uint64_t *)&de->d_ino);
10065 tswap64s((uint64_t *)&de->d_off);
6556a833 10066 de = (struct linux_dirent64 *)((char *)de + reclen);
dab2ed99
FB		 10067 len -= reclen;
10068 }
10069 }
53a5960a 10070 unlock_user(dirp, arg2, ret);
dab2ed99
FB		 10071 }
10072 break;
a541f297 10073#endif /* TARGET_NR_getdents64 */
9468a5d4 10074#if defined(TARGET_NR__newselect)
31e31b8a 10075 case TARGET_NR__newselect:
53a5960a 10076 ret = do_select(arg1, arg2, arg3, arg4, arg5);
31e31b8a 10077 break;
e5febef5 10078#endif
d8035d4c
MF		 10079#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
10080# ifdef TARGET_NR_poll
9de5e440 10081 case TARGET_NR_poll:
d8035d4c
MF		 10082# endif
10083# ifdef TARGET_NR_ppoll
10084 case TARGET_NR_ppoll:
10085# endif
9de5e440 10086 {
53a5960a 10087 struct target_pollfd *target_pfd;
9de5e440 10088 unsigned int nfds = arg2;
9de5e440 10089 struct pollfd *pfd;
7854b056 10090 unsigned int i;
9de5e440 10091
3e24bb3f
LV		 10092 pfd = NULL;
10093 target_pfd = NULL;
10094 if (nfds) {
ce9c139d
PM		 10095 if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
10096 ret = -TARGET_EINVAL;
10097 break;
10098 }
10099
3e24bb3f
LV		 10100 target_pfd = lock_user(VERIFY_WRITE, arg1,
10101 sizeof(struct target_pollfd) * nfds, 1);
10102 if (!target_pfd) {
10103 goto efault;
10104 }
d8035d4c 10105
3e24bb3f
LV		 10106 pfd = alloca(sizeof(struct pollfd) * nfds);
10107 for (i = 0; i < nfds; i++) {
10108 pfd[i].fd = tswap32(target_pfd[i].fd);
10109 pfd[i].events = tswap16(target_pfd[i].events);
10110 }
9de5e440 10111 }
d8035d4c 10112
a6130237 10113 switch (num) {
d8035d4c 10114# ifdef TARGET_NR_ppoll
a6130237
PM		 10115 case TARGET_NR_ppoll:
10116 {
d8035d4c
MF		 10117 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
10118 target_sigset_t *target_set;
10119 sigset_t _set, *set = &_set;
10120
10121 if (arg3) {
10122 if (target_to_host_timespec(timeout_ts, arg3)) {
10123 unlock_user(target_pfd, arg1, 0);
10124 goto efault;
10125 }
10126 } else {
10127 timeout_ts = NULL;
10128 }
10129
10130 if (arg4) {
c815701e
PM		 10131 if (arg5 != sizeof(target_sigset_t)) {
10132 unlock_user(target_pfd, arg1, 0);
10133 ret = -TARGET_EINVAL;
10134 break;
10135 }
10136
d8035d4c
MF		 10137 target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
10138 if (!target_set) {
10139 unlock_user(target_pfd, arg1, 0);
10140 goto efault;
10141 }
10142 target_to_host_sigset(set, target_set);
10143 } else {
10144 set = NULL;
10145 }
10146
a6130237
PM		 10147 ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
10148 set, SIGSET_T_SIZE));
d8035d4c
MF		 10149
10150 if (!is_error(ret) && arg3) {
10151 host_to_target_timespec(arg3, timeout_ts);
10152 }
10153 if (arg4) {
10154 unlock_user(target_set, arg4, 0);
10155 }
a6130237
PM		 10156 break;
10157 }
d8035d4c 10158# endif
a6130237
PM		 10159# ifdef TARGET_NR_poll
10160 case TARGET_NR_poll:
10161 {
10162 struct timespec ts, *pts;
10163
10164 if (arg3 >= 0) {
10165 /* Convert ms to secs, ns */
10166 ts.tv_sec = arg3 / 1000;
10167 ts.tv_nsec = (arg3 % 1000) * 1000000LL;
10168 pts = &ts;
10169 } else {
10170 /* -ve poll() timeout means "infinite" */
10171 pts = NULL;
10172 }
10173 ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
10174 break;
10175 }
d8035d4c 10176# endif
a6130237
PM		 10177 default:
10178 g_assert_not_reached();
10179 }
d8035d4c 10180
9de5e440
FB		 10181 if (!is_error(ret)) {
10182 for(i = 0; i < nfds; i++) {
5cd4393b 10183 target_pfd[i].revents = tswap16(pfd[i].revents);
9de5e440
FB		 10184 }
10185 }
30cb4cde 10186 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
9de5e440
FB		 10187 }
10188 break;
e5febef5 10189#endif
31e31b8a 10190 case TARGET_NR_flock:
9de5e440
FB		 10191 /* NOTE: the flock constant seems to be the same for every
10192 Linux platform */
2a845989 10193 ret = get_errno(safe_flock(arg1, arg2));
31e31b8a
FB		 10194 break;
10195 case TARGET_NR_readv:
10196 {
f287b2c2
RH		 10197 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10198 if (vec != NULL) {
918c03ed 10199 ret = get_errno(safe_readv(arg1, vec, arg3));
f287b2c2
RH		 10200 unlock_iovec(vec, arg2, arg3, 1);
10201 } else {
10202 ret = -host_to_target_errno(errno);
10203 }
31e31b8a
FB		 10204 }
10205 break;
10206 case TARGET_NR_writev:
10207 {
f287b2c2
RH		 10208 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10209 if (vec != NULL) {
918c03ed 10210 ret = get_errno(safe_writev(arg1, vec, arg3));
f287b2c2
RH		 10211 unlock_iovec(vec, arg2, arg3, 0);
10212 } else {
10213 ret = -host_to_target_errno(errno);
10214 }
31e31b8a
FB		 10215 }
10216 break;
0f26386c
DJ		 10217#if defined(TARGET_NR_preadv)
10218 case TARGET_NR_preadv:
10219 {
10220 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10221 if (vec != NULL) {
10222 ret = get_errno(safe_preadv(arg1, vec, arg3, arg4, arg5));
10223 unlock_iovec(vec, arg2, arg3, 1);
10224 } else {
10225 ret = -host_to_target_errno(errno);
f8d00fba
DJ		 10226 }
10227 }
10228 break;
10229#endif
10230#if defined(TARGET_NR_pwritev)
10231 case TARGET_NR_pwritev:
10232 {
10233 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10234 if (vec != NULL) {
10235 ret = get_errno(safe_pwritev(arg1, vec, arg3, arg4, arg5));
10236 unlock_iovec(vec, arg2, arg3, 0);
10237 } else {
10238 ret = -host_to_target_errno(errno);
0f26386c
DJ		 10239 }
10240 }
10241 break;
10242#endif
31e31b8a
FB		 10243 case TARGET_NR_getsid:
10244 ret = get_errno(getsid(arg1));
10245 break;
7a3148a9 10246#if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
31e31b8a 10247 case TARGET_NR_fdatasync:
5cd4393b
FB		 10248 ret = get_errno(fdatasync(arg1));
10249 break;
7a3148a9 10250#endif
704eff6c 10251#ifdef TARGET_NR__sysctl
31e31b8a 10252 case TARGET_NR__sysctl:
0da46a6e 10253 /* We don't implement this, but ENOTDIR is always a safe
29e619b1 10254 return value. */
0da46a6e
TS		 10255 ret = -TARGET_ENOTDIR;
10256 break;
704eff6c 10257#endif
737de1d1
MF		 10258 case TARGET_NR_sched_getaffinity:
10259 {
10260 unsigned int mask_size;
10261 unsigned long *mask;
10262
10263 /*
10264 * sched_getaffinity needs multiples of ulong, so need to take
10265 * care of mismatches between target ulong and host ulong sizes.
10266 */
10267 if (arg2 & (sizeof(abi_ulong) - 1)) {
10268 ret = -TARGET_EINVAL;
10269 break;
10270 }
10271 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10272
10273 mask = alloca(mask_size);
10274 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
10275
10276 if (!is_error(ret)) {
be3bd286
PM		 10277 if (ret > arg2) {
10278 /* More data returned than the caller's buffer will fit.
10279 * This only happens if sizeof(abi_long) < sizeof(long)
10280 * and the caller passed us a buffer holding an odd number
10281 * of abi_longs. If the host kernel is actually using the
10282 * extra 4 bytes then fail EINVAL; otherwise we can just
10283 * ignore them and only copy the interesting part.
10284 */
10285 int numcpus = sysconf(_SC_NPROCESSORS_CONF);
10286 if (numcpus > arg2 * 8) {
10287 ret = -TARGET_EINVAL;
10288 break;
10289 }
10290 ret = arg2;
10291 }
10292
cd18f05e 10293 if (copy_to_user(arg3, mask, ret)) {
737de1d1
MF		 10294 goto efault;
10295 }
737de1d1
MF		 10296 }
10297 }
10298 break;
10299 case TARGET_NR_sched_setaffinity:
10300 {
10301 unsigned int mask_size;
10302 unsigned long *mask;
10303
10304 /*
10305 * sched_setaffinity needs multiples of ulong, so need to take
10306 * care of mismatches between target ulong and host ulong sizes.
10307 */
10308 if (arg2 & (sizeof(abi_ulong) - 1)) {
10309 ret = -TARGET_EINVAL;
10310 break;
10311 }
10312 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10313
10314 mask = alloca(mask_size);
10315 if (!lock_user_struct(VERIFY_READ, p, arg3, 1)) {
10316 goto efault;
10317 }
10318 memcpy(mask, p, arg2);
10319 unlock_user_struct(p, arg2, 0);
10320
10321 ret = get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
10322 }
10323 break;
31e31b8a 10324 case TARGET_NR_sched_setparam:
5cd4393b 10325 {
53a5960a 10326 struct sched_param *target_schp;
5cd4393b 10327 struct sched_param schp;
53a5960a 10328
a1d5c5b2
TM		 10329 if (arg2 == 0) {
10330 return -TARGET_EINVAL;
10331 }
579a97f7
FB		 10332 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
10333 goto efault;
5cd4393b 10334 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 10335 unlock_user_struct(target_schp, arg2, 0);
5cd4393b
FB		 10336 ret = get_errno(sched_setparam(arg1, &schp));
10337 }
10338 break;
31e31b8a 10339 case TARGET_NR_sched_getparam:
5cd4393b 10340 {
53a5960a 10341 struct sched_param *target_schp;
5cd4393b 10342 struct sched_param schp;
a1d5c5b2
TM		 10343
10344 if (arg2 == 0) {
10345 return -TARGET_EINVAL;
10346 }
5cd4393b
FB		 10347 ret = get_errno(sched_getparam(arg1, &schp));
10348 if (!is_error(ret)) {
579a97f7
FB		 10349 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
10350 goto efault;
5cd4393b 10351 target_schp->sched_priority = tswap32(schp.sched_priority);
53a5960a 10352 unlock_user_struct(target_schp, arg2, 1);
5cd4393b
FB		 10353 }
10354 }
10355 break;
31e31b8a 10356 case TARGET_NR_sched_setscheduler:
5cd4393b 10357 {
53a5960a 10358 struct sched_param *target_schp;
5cd4393b 10359 struct sched_param schp;
a1d5c5b2
TM		 10360 if (arg3 == 0) {
10361 return -TARGET_EINVAL;
10362 }
579a97f7
FB		 10363 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
10364 goto efault;
5cd4393b 10365 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 10366 unlock_user_struct(target_schp, arg3, 0);
5cd4393b
FB		 10367 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
10368 }
10369 break;
31e31b8a 10370 case TARGET_NR_sched_getscheduler:
5cd4393b
FB		 10371 ret = get_errno(sched_getscheduler(arg1));
10372 break;
31e31b8a
FB		 10373 case TARGET_NR_sched_yield:
10374 ret = get_errno(sched_yield());
10375 break;
10376 case TARGET_NR_sched_get_priority_max:
5cd4393b
FB		 10377 ret = get_errno(sched_get_priority_max(arg1));
10378 break;
31e31b8a 10379 case TARGET_NR_sched_get_priority_min:
5cd4393b
FB		 10380 ret = get_errno(sched_get_priority_min(arg1));
10381 break;
31e31b8a 10382 case TARGET_NR_sched_rr_get_interval:
5cd4393b 10383 {
5cd4393b
FB		 10384 struct timespec ts;
10385 ret = get_errno(sched_rr_get_interval(arg1, &ts));
10386 if (!is_error(ret)) {
d4290c40 10387 ret = host_to_target_timespec(arg2, &ts);
5cd4393b
FB		 10388 }
10389 }
10390 break;
31e31b8a 10391 case TARGET_NR_nanosleep:
1b6b029e 10392 {
1b6b029e 10393 struct timespec req, rem;
53a5960a 10394 target_to_host_timespec(&req, arg1);
9e518226 10395 ret = get_errno(safe_nanosleep(&req, &rem));
53a5960a
PB		 10396 if (is_error(ret) && arg2) {
10397 host_to_target_timespec(arg2, &rem);
1b6b029e
FB		 10398 }
10399 }
10400 break;
e5febef5 10401#ifdef TARGET_NR_query_module
31e31b8a 10402 case TARGET_NR_query_module:
5cd4393b 10403 goto unimplemented;
e5febef5
TS		 10404#endif
10405#ifdef TARGET_NR_nfsservctl
31e31b8a 10406 case TARGET_NR_nfsservctl:
5cd4393b 10407 goto unimplemented;
e5febef5 10408#endif
31e31b8a 10409 case TARGET_NR_prctl:
1e6722f8
PM		 10410 switch (arg1) {
10411 case PR_GET_PDEATHSIG:
10412 {
10413 int deathsig;
10414 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
10415 if (!is_error(ret) && arg2
10416 && put_user_ual(deathsig, arg2)) {
10417 goto efault;
e5574487 10418 }
1e6722f8
PM		 10419 break;
10420 }
db9526b1
PM		 10421#ifdef PR_GET_NAME
10422 case PR_GET_NAME:
10423 {
10424 void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
10425 if (!name) {
10426 goto efault;
10427 }
10428 ret = get_errno(prctl(arg1, (unsigned long)name,
10429 arg3, arg4, arg5));
10430 unlock_user(name, arg2, 16);
10431 break;
10432 }
10433 case PR_SET_NAME:
10434 {
10435 void *name = lock_user(VERIFY_READ, arg2, 16, 1);
10436 if (!name) {
10437 goto efault;
10438 }
10439 ret = get_errno(prctl(arg1, (unsigned long)name,
10440 arg3, arg4, arg5));
10441 unlock_user(name, arg2, 0);
10442 break;
10443 }
10444#endif
1e6722f8
PM		 10445 default:
10446 /* Most prctl options have no pointer arguments */
10447 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
10448 break;
10449 }
39b9aae1 10450 break;
d2fd1af7
FB		 10451#ifdef TARGET_NR_arch_prctl
10452 case TARGET_NR_arch_prctl:
10453#if defined(TARGET_I386) && !defined(TARGET_ABI32)
10454 ret = do_arch_prctl(cpu_env, arg1, arg2);
10455 break;
10456#else
10457 goto unimplemented;
10458#endif
10459#endif
f2c7ba15
AJ		 10460#ifdef TARGET_NR_pread64
10461 case TARGET_NR_pread64:
ae017a5b
AG		 10462 if (regpairs_aligned(cpu_env)) {
10463 arg4 = arg5;
10464 arg5 = arg6;
10465 }
f2c7ba15
AJ		 10466 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
10467 goto efault;
10468 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
10469 unlock_user(p, arg2, ret);
10470 break;
10471 case TARGET_NR_pwrite64:
ae017a5b
AG		 10472 if (regpairs_aligned(cpu_env)) {
10473 arg4 = arg5;
10474 arg5 = arg6;
10475 }
f2c7ba15
AJ		 10476 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
10477 goto efault;
10478 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
10479 unlock_user(p, arg2, 0);
10480 break;
67867308 10481#endif
31e31b8a 10482 case TARGET_NR_getcwd:
579a97f7
FB		 10483 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
10484 goto efault;
53a5960a
PB		 10485 ret = get_errno(sys_getcwd1(p, arg2));
10486 unlock_user(p, arg1, ret);
31e31b8a
FB		 10487 break;
10488 case TARGET_NR_capget:
10489 case TARGET_NR_capset:
e0eb210e
PM		 10490 {
10491 struct target_user_cap_header *target_header;
10492 struct target_user_cap_data *target_data = NULL;
10493 struct __user_cap_header_struct header;
10494 struct __user_cap_data_struct data[2];
10495 struct __user_cap_data_struct *dataptr = NULL;
10496 int i, target_datalen;
10497 int data_items = 1;
10498
10499 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
10500 goto efault;
10501 }
10502 header.version = tswap32(target_header->version);
10503 header.pid = tswap32(target_header->pid);
10504
ec864874 10505 if (header.version != _LINUX_CAPABILITY_VERSION) {
e0eb210e
PM		 10506 /* Version 2 and up takes pointer to two user_data structs */
10507 data_items = 2;
10508 }
10509
10510 target_datalen = sizeof(*target_data) * data_items;
10511
10512 if (arg2) {
10513 if (num == TARGET_NR_capget) {
10514 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0);
10515 } else {
10516 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1);
10517 }
10518 if (!target_data) {
10519 unlock_user_struct(target_header, arg1, 0);
10520 goto efault;
10521 }
10522
10523 if (num == TARGET_NR_capset) {
10524 for (i = 0; i < data_items; i++) {
10525 data[i].effective = tswap32(target_data[i].effective);
10526 data[i].permitted = tswap32(target_data[i].permitted);
10527 data[i].inheritable = tswap32(target_data[i].inheritable);
10528 }
10529 }
10530
10531 dataptr = data;
10532 }
10533
10534 if (num == TARGET_NR_capget) {
10535 ret = get_errno(capget(&header, dataptr));
10536 } else {
10537 ret = get_errno(capset(&header, dataptr));
10538 }
10539
10540 /* The kernel always updates version for both capget and capset */
10541 target_header->version = tswap32(header.version);
10542 unlock_user_struct(target_header, arg1, 1);
10543
10544 if (arg2) {
10545 if (num == TARGET_NR_capget) {
10546 for (i = 0; i < data_items; i++) {
10547 target_data[i].effective = tswap32(data[i].effective);
10548 target_data[i].permitted = tswap32(data[i].permitted);
10549 target_data[i].inheritable = tswap32(data[i].inheritable);
10550 }
10551 unlock_user(target_data, arg2, target_datalen);
10552 } else {
10553 unlock_user(target_data, arg2, 0);
10554 }
10555 }
10556 break;
10557 }
31e31b8a 10558 case TARGET_NR_sigaltstack:
9349b4f9 10559 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUArchState *)cpu_env));
a04e134a 10560 break;
a8fd1aba
PM		 10561
10562#ifdef CONFIG_SENDFILE
10563 case TARGET_NR_sendfile:
10564 {
10565 off_t *offp = NULL;
10566 off_t off;
10567 if (arg3) {
10568 ret = get_user_sal(off, arg3);
10569 if (is_error(ret)) {
10570 break;
10571 }
10572 offp = &off;
10573 }
10574 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
10575 if (!is_error(ret) && arg3) {
10576 abi_long ret2 = put_user_sal(off, arg3);
10577 if (is_error(ret2)) {
10578 ret = ret2;
10579 }
10580 }
10581 break;
10582 }
10583#ifdef TARGET_NR_sendfile64
10584 case TARGET_NR_sendfile64:
10585 {
10586 off_t *offp = NULL;
10587 off_t off;
10588 if (arg3) {
10589 ret = get_user_s64(off, arg3);
10590 if (is_error(ret)) {
10591 break;
10592 }
10593 offp = &off;
10594 }
10595 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
10596 if (!is_error(ret) && arg3) {
10597 abi_long ret2 = put_user_s64(off, arg3);
10598 if (is_error(ret2)) {
10599 ret = ret2;
10600 }
10601 }
10602 break;
10603 }
10604#endif
10605#else
31e31b8a 10606 case TARGET_NR_sendfile:
7edd2cf1 10607#ifdef TARGET_NR_sendfile64
a8fd1aba
PM		 10608 case TARGET_NR_sendfile64:
10609#endif
5cd4393b 10610 goto unimplemented;
a8fd1aba
PM		 10611#endif
10612
ebc05488 10613#ifdef TARGET_NR_getpmsg
31e31b8a 10614 case TARGET_NR_getpmsg:
5cd4393b 10615 goto unimplemented;
ebc05488
FB		 10616#endif
10617#ifdef TARGET_NR_putpmsg
31e31b8a 10618 case TARGET_NR_putpmsg:
5cd4393b 10619 goto unimplemented;
ebc05488 10620#endif
048f6b4d 10621#ifdef TARGET_NR_vfork
31e31b8a 10622 case TARGET_NR_vfork:
7eddb5dd
LV		 10623 ret = get_errno(do_fork(cpu_env,
10624 CLONE_VFORK | CLONE_VM | TARGET_SIGCHLD,
d865bab5 10625 0, 0, 0, 0));
31e31b8a 10626 break;
048f6b4d 10627#endif
ebc05488 10628#ifdef TARGET_NR_ugetrlimit
31e31b8a 10629 case TARGET_NR_ugetrlimit:
728584be
FB		 10630 {
10631 struct rlimit rlim;
e22b7015
WT		 10632 int resource = target_to_host_resource(arg1);
10633 ret = get_errno(getrlimit(resource, &rlim));
728584be 10634 if (!is_error(ret)) {
53a5960a 10635 struct target_rlimit *target_rlim;
579a97f7
FB		 10636 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
10637 goto efault;
81bbe906
TY		 10638 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
10639 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
53a5960a 10640 unlock_user_struct(target_rlim, arg2, 1);
728584be
FB		 10641 }
10642 break;
10643 }
ebc05488 10644#endif
a315a145 10645#ifdef TARGET_NR_truncate64
31e31b8a 10646 case TARGET_NR_truncate64:
579a97f7
FB		 10647 if (!(p = lock_user_string(arg1)))
10648 goto efault;
53a5960a
PB		 10649 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
10650 unlock_user(p, arg1, 0);
667f38b1 10651 break;
a315a145
FB		 10652#endif
10653#ifdef TARGET_NR_ftruncate64
31e31b8a 10654 case TARGET_NR_ftruncate64:
ce4defa0 10655 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
667f38b1 10656 break;
a315a145
FB		 10657#endif
10658#ifdef TARGET_NR_stat64
31e31b8a 10659 case TARGET_NR_stat64:
579a97f7
FB		 10660 if (!(p = lock_user_string(arg1)))
10661 goto efault;
53a5960a
PB		 10662 ret = get_errno(stat(path(p), &st));
10663 unlock_user(p, arg1, 0);
6a24a778
AZ		 10664 if (!is_error(ret))
10665 ret = host_to_target_stat64(cpu_env, arg2, &st);
10666 break;
a315a145
FB		 10667#endif
10668#ifdef TARGET_NR_lstat64
31e31b8a 10669 case TARGET_NR_lstat64:
579a97f7
FB		 10670 if (!(p = lock_user_string(arg1)))
10671 goto efault;
53a5960a
PB		 10672 ret = get_errno(lstat(path(p), &st));
10673 unlock_user(p, arg1, 0);
6a24a778
AZ		 10674 if (!is_error(ret))
10675 ret = host_to_target_stat64(cpu_env, arg2, &st);
10676 break;
a315a145
FB		 10677#endif
10678#ifdef TARGET_NR_fstat64
31e31b8a 10679 case TARGET_NR_fstat64:
6a24a778
AZ		 10680 ret = get_errno(fstat(arg1, &st));
10681 if (!is_error(ret))
10682 ret = host_to_target_stat64(cpu_env, arg2, &st);
10683 break;
ce4defa0 10684#endif
c0d472b1 10685#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
9d33b76b 10686#ifdef TARGET_NR_fstatat64
6a24a778 10687 case TARGET_NR_fstatat64:
9d33b76b
AJ		 10688#endif
10689#ifdef TARGET_NR_newfstatat
10690 case TARGET_NR_newfstatat:
10691#endif
6a24a778
AZ		 10692 if (!(p = lock_user_string(arg2)))
10693 goto efault;
c0d472b1 10694 ret = get_errno(fstatat(arg1, path(p), &st, arg4));
6a24a778
AZ		 10695 if (!is_error(ret))
10696 ret = host_to_target_stat64(cpu_env, arg3, &st);
60cd49d5 10697 break;
a315a145 10698#endif
704eff6c 10699#ifdef TARGET_NR_lchown
67867308 10700 case TARGET_NR_lchown:
579a97f7
FB		 10701 if (!(p = lock_user_string(arg1)))
10702 goto efault;
53a5960a
PB		 10703 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
10704 unlock_user(p, arg1, 0);
67867308 10705 break;
704eff6c 10706#endif
0c866a7e 10707#ifdef TARGET_NR_getuid
67867308
FB		 10708 case TARGET_NR_getuid:
10709 ret = get_errno(high2lowuid(getuid()));
10710 break;
0c866a7e
RV		 10711#endif
10712#ifdef TARGET_NR_getgid
67867308
FB		 10713 case TARGET_NR_getgid:
10714 ret = get_errno(high2lowgid(getgid()));
10715 break;
0c866a7e
RV		 10716#endif
10717#ifdef TARGET_NR_geteuid
67867308
FB		 10718 case TARGET_NR_geteuid:
10719 ret = get_errno(high2lowuid(geteuid()));
10720 break;
0c866a7e
RV		 10721#endif
10722#ifdef TARGET_NR_getegid
67867308
FB		 10723 case TARGET_NR_getegid:
10724 ret = get_errno(high2lowgid(getegid()));
10725 break;
0c866a7e 10726#endif
67867308
FB		 10727 case TARGET_NR_setreuid:
10728 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
10729 break;
10730 case TARGET_NR_setregid:
10731 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
10732 break;
10733 case TARGET_NR_getgroups:
10734 {
10735 int gidsetsize = arg1;
0c866a7e 10736 target_id *target_grouplist;
67867308
FB		 10737 gid_t *grouplist;
10738 int i;
10739
10740 grouplist = alloca(gidsetsize * sizeof(gid_t));
10741 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 10742 if (gidsetsize == 0)
10743 break;
67867308 10744 if (!is_error(ret)) {
03903ffc 10745 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
579a97f7
FB		 10746 if (!target_grouplist)
10747 goto efault;
a2155fcc 10748 for(i = 0;i < ret; i++)
0c866a7e 10749 target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
03903ffc 10750 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
67867308
FB		 10751 }
10752 }
10753 break;
10754 case TARGET_NR_setgroups:
10755 {
10756 int gidsetsize = arg1;
0c866a7e 10757 target_id *target_grouplist;
f2b79ce9 10758 gid_t *grouplist = NULL;
67867308 10759 int i;
f2b79ce9
DA		 10760 if (gidsetsize) {
10761 grouplist = alloca(gidsetsize * sizeof(gid_t));
03903ffc 10762 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
f2b79ce9
DA		 10763 if (!target_grouplist) {
10764 ret = -TARGET_EFAULT;
10765 goto fail;
10766 }
10767 for (i = 0; i < gidsetsize; i++) {
10768 grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
10769 }
10770 unlock_user(target_grouplist, arg2, 0);
579a97f7 10771 }
67867308
FB		 10772 ret = get_errno(setgroups(gidsetsize, grouplist));
10773 }
10774 break;
10775 case TARGET_NR_fchown:
10776 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
10777 break;
c0d472b1 10778#if defined(TARGET_NR_fchownat)
ccfa72b7 10779 case TARGET_NR_fchownat:
579a97f7
FB		 10780 if (!(p = lock_user_string(arg2)))
10781 goto efault;
c0d472b1
PM		 10782 ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
10783 low2highgid(arg4), arg5));
579a97f7 10784 unlock_user(p, arg2, 0);
ccfa72b7
TS		 10785 break;
10786#endif
67867308
FB		 10787#ifdef TARGET_NR_setresuid
10788 case TARGET_NR_setresuid:
fd6f7798
PM		 10789 ret = get_errno(sys_setresuid(low2highuid(arg1),
10790 low2highuid(arg2),
10791 low2highuid(arg3)));
67867308
FB		 10792 break;
10793#endif
10794#ifdef TARGET_NR_getresuid
10795 case TARGET_NR_getresuid:
10796 {
53a5960a 10797 uid_t ruid, euid, suid;
67867308
FB		 10798 ret = get_errno(getresuid(&ruid, &euid, &suid));
10799 if (!is_error(ret)) {
76ca310a
PM		 10800 if (put_user_id(high2lowuid(ruid), arg1)
10801 || put_user_id(high2lowuid(euid), arg2)
10802 || put_user_id(high2lowuid(suid), arg3))
2f619698 10803 goto efault;
67867308
FB		 10804 }
10805 }
10806 break;
10807#endif
10808#ifdef TARGET_NR_getresgid
10809 case TARGET_NR_setresgid:
fd6f7798
PM		 10810 ret = get_errno(sys_setresgid(low2highgid(arg1),
10811 low2highgid(arg2),
10812 low2highgid(arg3)));
67867308
FB		 10813 break;
10814#endif
10815#ifdef TARGET_NR_getresgid
10816 case TARGET_NR_getresgid:
10817 {
53a5960a 10818 gid_t rgid, egid, sgid;
67867308
FB		 10819 ret = get_errno(getresgid(&rgid, &egid, &sgid));
10820 if (!is_error(ret)) {
76ca310a
PM		 10821 if (put_user_id(high2lowgid(rgid), arg1)
10822 || put_user_id(high2lowgid(egid), arg2)
10823 || put_user_id(high2lowgid(sgid), arg3))
2f619698 10824 goto efault;
67867308
FB		 10825 }
10826 }
10827 break;
10828#endif
704eff6c 10829#ifdef TARGET_NR_chown
67867308 10830 case TARGET_NR_chown:
579a97f7
FB		 10831 if (!(p = lock_user_string(arg1)))
10832 goto efault;
53a5960a
PB		 10833 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
10834 unlock_user(p, arg1, 0);
67867308 10835 break;
704eff6c 10836#endif
67867308 10837 case TARGET_NR_setuid:
fd6f7798 10838 ret = get_errno(sys_setuid(low2highuid(arg1)));
67867308
FB		 10839 break;
10840 case TARGET_NR_setgid:
fd6f7798 10841 ret = get_errno(sys_setgid(low2highgid(arg1)));
67867308
FB		 10842 break;
10843 case TARGET_NR_setfsuid:
10844 ret = get_errno(setfsuid(arg1));
10845 break;
10846 case TARGET_NR_setfsgid:
10847 ret = get_errno(setfsgid(arg1));
10848 break;
67867308 10849
a315a145 10850#ifdef TARGET_NR_lchown32
31e31b8a 10851 case TARGET_NR_lchown32:
579a97f7
FB		 10852 if (!(p = lock_user_string(arg1)))
10853 goto efault;
53a5960a
PB		 10854 ret = get_errno(lchown(p, arg2, arg3));
10855 unlock_user(p, arg1, 0);
b03c60f3 10856 break;
a315a145
FB		 10857#endif
10858#ifdef TARGET_NR_getuid32
31e31b8a 10859 case TARGET_NR_getuid32:
b03c60f3
FB		 10860 ret = get_errno(getuid());
10861 break;
a315a145 10862#endif
64b4d28c
AJ		 10863
10864#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
10865 /* Alpha specific */
10866 case TARGET_NR_getxuid:
ba0e276d
RH		 10867 {
10868 uid_t euid;
10869 euid=geteuid();
10870 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
10871 }
64b4d28c
AJ		 10872 ret = get_errno(getuid());
10873 break;
10874#endif
10875#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
10876 /* Alpha specific */
10877 case TARGET_NR_getxgid:
ba0e276d
RH		 10878 {
10879 uid_t egid;
10880 egid=getegid();
10881 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
10882 }
64b4d28c
AJ		 10883 ret = get_errno(getgid());
10884 break;
10885#endif
ba0e276d
RH		 10886#if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
10887 /* Alpha specific */
10888 case TARGET_NR_osf_getsysinfo:
10889 ret = -TARGET_EOPNOTSUPP;
10890 switch (arg1) {
10891 case TARGET_GSI_IEEE_FP_CONTROL:
10892 {
10893 uint64_t swcr, fpcr = cpu_alpha_load_fpcr (cpu_env);
10894
10895 /* Copied from linux ieee_fpcr_to_swcr. */
10896 swcr = (fpcr >> 35) & SWCR_STATUS_MASK;
10897 swcr |= (fpcr >> 36) & SWCR_MAP_DMZ;
10898 swcr |= (~fpcr >> 48) & (SWCR_TRAP_ENABLE_INV
10899 | SWCR_TRAP_ENABLE_DZE
10900 | SWCR_TRAP_ENABLE_OVF);
10901 swcr |= (~fpcr >> 57) & (SWCR_TRAP_ENABLE_UNF
10902 | SWCR_TRAP_ENABLE_INE);
10903 swcr |= (fpcr >> 47) & SWCR_MAP_UMZ;
10904 swcr |= (~fpcr >> 41) & SWCR_TRAP_ENABLE_DNO;
10905
10906 if (put_user_u64 (swcr, arg2))
10907 goto efault;
10908 ret = 0;
10909 }
10910 break;
10911
10912 /* case GSI_IEEE_STATE_AT_SIGNAL:
10913 -- Not implemented in linux kernel.
10914 case GSI_UACPROC:
10915 -- Retrieves current unaligned access state; not much used.
10916 case GSI_PROC_TYPE:
10917 -- Retrieves implver information; surely not used.
10918 case GSI_GET_HWRPB:
10919 -- Grabs a copy of the HWRPB; surely not used.
10920 */
10921 }
10922 break;
10923#endif
10924#if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
10925 /* Alpha specific */
10926 case TARGET_NR_osf_setsysinfo:
10927 ret = -TARGET_EOPNOTSUPP;
10928 switch (arg1) {
10929 case TARGET_SSI_IEEE_FP_CONTROL:
ba0e276d
RH		 10930 {
10931 uint64_t swcr, fpcr, orig_fpcr;
10932
6e06d515 10933 if (get_user_u64 (swcr, arg2)) {
ba0e276d 10934 goto efault;
6e06d515
RH		 10935 }
10936 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
ba0e276d
RH		 10937 fpcr = orig_fpcr & FPCR_DYN_MASK;
10938
10939 /* Copied from linux ieee_swcr_to_fpcr. */
10940 fpcr |= (swcr & SWCR_STATUS_MASK) << 35;
10941 fpcr |= (swcr & SWCR_MAP_DMZ) << 36;
10942 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_INV
10943 | SWCR_TRAP_ENABLE_DZE
10944 | SWCR_TRAP_ENABLE_OVF)) << 48;
10945 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_UNF
10946 | SWCR_TRAP_ENABLE_INE)) << 57;
10947 fpcr |= (swcr & SWCR_MAP_UMZ ? FPCR_UNDZ | FPCR_UNFD : 0);
10948 fpcr |= (~swcr & SWCR_TRAP_ENABLE_DNO) << 41;
10949
6e06d515 10950 cpu_alpha_store_fpcr(cpu_env, fpcr);
ba0e276d 10951 ret = 0;
6e06d515
RH		 10952 }
10953 break;
10954
10955 case TARGET_SSI_IEEE_RAISE_EXCEPTION:
10956 {
10957 uint64_t exc, fpcr, orig_fpcr;
10958 int si_code;
10959
10960 if (get_user_u64(exc, arg2)) {
10961 goto efault;
10962 }
ba0e276d 10963
6e06d515 10964 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
ba0e276d 10965
6e06d515
RH		 10966 /* We only add to the exception status here. */
10967 fpcr = orig_fpcr | ((exc & SWCR_STATUS_MASK) << 35);
10968
10969 cpu_alpha_store_fpcr(cpu_env, fpcr);
10970 ret = 0;
10971
10972 /* Old exceptions are not signaled. */
10973 fpcr &= ~(orig_fpcr & FPCR_STATUS_MASK);
10974
10975 /* If any exceptions set by this call,
10976 and are unmasked, send a signal. */
10977 si_code = 0;
10978 if ((fpcr & (FPCR_INE | FPCR_INED)) == FPCR_INE) {
10979 si_code = TARGET_FPE_FLTRES;
10980 }
10981 if ((fpcr & (FPCR_UNF | FPCR_UNFD)) == FPCR_UNF) {
10982 si_code = TARGET_FPE_FLTUND;
10983 }
10984 if ((fpcr & (FPCR_OVF | FPCR_OVFD)) == FPCR_OVF) {
10985 si_code = TARGET_FPE_FLTOVF;
10986 }
10987 if ((fpcr & (FPCR_DZE | FPCR_DZED)) == FPCR_DZE) {
10988 si_code = TARGET_FPE_FLTDIV;
10989 }
10990 if ((fpcr & (FPCR_INV | FPCR_INVD)) == FPCR_INV) {
10991 si_code = TARGET_FPE_FLTINV;
10992 }
10993 if (si_code != 0) {
10994 target_siginfo_t info;
10995 info.si_signo = SIGFPE;
10996 info.si_errno = 0;
10997 info.si_code = si_code;
10998 info._sifields._sigfault._addr
10999 = ((CPUArchState *)cpu_env)->pc;
9d2803f7
PM		 11000 queue_signal((CPUArchState *)cpu_env, info.si_signo,
11001 QEMU_SI_FAULT, &info);
ba0e276d
RH		 11002 }
11003 }
11004 break;
11005
11006 /* case SSI_NVPAIRS:
11007 -- Used with SSIN_UACPROC to enable unaligned accesses.
11008 case SSI_IEEE_STATE_AT_SIGNAL:
11009 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
11010 -- Not implemented in linux kernel
11011 */
11012 }
11013 break;
11014#endif
11015#ifdef TARGET_NR_osf_sigprocmask
11016 /* Alpha specific. */
11017 case TARGET_NR_osf_sigprocmask:
11018 {
11019 abi_ulong mask;
bc088ba1 11020 int how;
ba0e276d
RH		 11021 sigset_t set, oldset;
11022
11023 switch(arg1) {
11024 case TARGET_SIG_BLOCK:
11025 how = SIG_BLOCK;
11026 break;
11027 case TARGET_SIG_UNBLOCK:
11028 how = SIG_UNBLOCK;
11029 break;
11030 case TARGET_SIG_SETMASK:
11031 how = SIG_SETMASK;
11032 break;
11033 default:
11034 ret = -TARGET_EINVAL;
11035 goto fail;
11036 }
11037 mask = arg2;
11038 target_to_host_old_sigset(&set, &mask);
3d3efba0
PM		 11039 ret = do_sigprocmask(how, &set, &oldset);
11040 if (!ret) {
11041 host_to_target_old_sigset(&mask, &oldset);
11042 ret = mask;
11043 }
ba0e276d
RH		 11044 }
11045 break;
11046#endif
64b4d28c 11047
a315a145 11048#ifdef TARGET_NR_getgid32
31e31b8a 11049 case TARGET_NR_getgid32:
b03c60f3
FB		 11050 ret = get_errno(getgid());
11051 break;
a315a145
FB		 11052#endif
11053#ifdef TARGET_NR_geteuid32
31e31b8a 11054 case TARGET_NR_geteuid32:
b03c60f3
FB		 11055 ret = get_errno(geteuid());
11056 break;
a315a145
FB		 11057#endif
11058#ifdef TARGET_NR_getegid32
31e31b8a 11059 case TARGET_NR_getegid32:
b03c60f3
FB		 11060 ret = get_errno(getegid());
11061 break;
a315a145
FB		 11062#endif
11063#ifdef TARGET_NR_setreuid32
31e31b8a 11064 case TARGET_NR_setreuid32:
b03c60f3
FB		 11065 ret = get_errno(setreuid(arg1, arg2));
11066 break;
a315a145
FB		 11067#endif
11068#ifdef TARGET_NR_setregid32
31e31b8a 11069 case TARGET_NR_setregid32:
b03c60f3
FB		 11070 ret = get_errno(setregid(arg1, arg2));
11071 break;
a315a145
FB		 11072#endif
11073#ifdef TARGET_NR_getgroups32
31e31b8a 11074 case TARGET_NR_getgroups32:
99c475ab
FB		 11075 {
11076 int gidsetsize = arg1;
53a5960a 11077 uint32_t *target_grouplist;
99c475ab
FB		 11078 gid_t *grouplist;
11079 int i;
11080
11081 grouplist = alloca(gidsetsize * sizeof(gid_t));
11082 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 11083 if (gidsetsize == 0)
11084 break;
99c475ab 11085 if (!is_error(ret)) {
579a97f7
FB		 11086 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
11087 if (!target_grouplist) {
11088 ret = -TARGET_EFAULT;
11089 goto fail;
11090 }
a2155fcc 11091 for(i = 0;i < ret; i++)
53a5960a
PB		 11092 target_grouplist[i] = tswap32(grouplist[i]);
11093 unlock_user(target_grouplist, arg2, gidsetsize * 4);
99c475ab
FB		 11094 }
11095 }
11096 break;
a315a145
FB		 11097#endif
11098#ifdef TARGET_NR_setgroups32
31e31b8a 11099 case TARGET_NR_setgroups32:
99c475ab
FB		 11100 {
11101 int gidsetsize = arg1;
53a5960a 11102 uint32_t *target_grouplist;
99c475ab
FB		 11103 gid_t *grouplist;
11104 int i;
3b46e624 11105
99c475ab 11106 grouplist = alloca(gidsetsize * sizeof(gid_t));
579a97f7
FB		 11107 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
11108 if (!target_grouplist) {
11109 ret = -TARGET_EFAULT;
11110 goto fail;
11111 }
99c475ab 11112 for(i = 0;i < gidsetsize; i++)
53a5960a
PB		 11113 grouplist[i] = tswap32(target_grouplist[i]);
11114 unlock_user(target_grouplist, arg2, 0);
99c475ab
FB		 11115 ret = get_errno(setgroups(gidsetsize, grouplist));
11116 }
11117 break;
a315a145
FB		 11118#endif
11119#ifdef TARGET_NR_fchown32
31e31b8a 11120 case TARGET_NR_fchown32:
b03c60f3
FB		 11121 ret = get_errno(fchown(arg1, arg2, arg3));
11122 break;
a315a145
FB		 11123#endif
11124#ifdef TARGET_NR_setresuid32
31e31b8a 11125 case TARGET_NR_setresuid32:
fd6f7798 11126 ret = get_errno(sys_setresuid(arg1, arg2, arg3));
b03c60f3 11127 break;
a315a145
FB		 11128#endif
11129#ifdef TARGET_NR_getresuid32
31e31b8a 11130 case TARGET_NR_getresuid32:
b03c60f3 11131 {
53a5960a 11132 uid_t ruid, euid, suid;
b03c60f3
FB		 11133 ret = get_errno(getresuid(&ruid, &euid, &suid));
11134 if (!is_error(ret)) {
2f619698
FB		 11135 if (put_user_u32(ruid, arg1)
11136 || put_user_u32(euid, arg2)
11137 || put_user_u32(suid, arg3))
11138 goto efault;
b03c60f3
FB		 11139 }
11140 }
11141 break;
a315a145
FB		 11142#endif
11143#ifdef TARGET_NR_setresgid32
31e31b8a 11144 case TARGET_NR_setresgid32:
fd6f7798 11145 ret = get_errno(sys_setresgid(arg1, arg2, arg3));
b03c60f3 11146 break;
a315a145
FB		 11147#endif
11148#ifdef TARGET_NR_getresgid32
31e31b8a 11149 case TARGET_NR_getresgid32:
b03c60f3 11150 {
53a5960a 11151 gid_t rgid, egid, sgid;
b03c60f3
FB		 11152 ret = get_errno(getresgid(&rgid, &egid, &sgid));
11153 if (!is_error(ret)) {
2f619698
FB		 11154 if (put_user_u32(rgid, arg1)
11155 || put_user_u32(egid, arg2)
11156 || put_user_u32(sgid, arg3))
11157 goto efault;
b03c60f3
FB		 11158 }
11159 }
11160 break;
a315a145
FB		 11161#endif
11162#ifdef TARGET_NR_chown32
31e31b8a 11163 case TARGET_NR_chown32:
579a97f7
FB		 11164 if (!(p = lock_user_string(arg1)))
11165 goto efault;
53a5960a
PB		 11166 ret = get_errno(chown(p, arg2, arg3));
11167 unlock_user(p, arg1, 0);
b03c60f3 11168 break;
a315a145
FB		 11169#endif
11170#ifdef TARGET_NR_setuid32
31e31b8a 11171 case TARGET_NR_setuid32:
fd6f7798 11172 ret = get_errno(sys_setuid(arg1));
b03c60f3 11173 break;
a315a145
FB		 11174#endif
11175#ifdef TARGET_NR_setgid32
31e31b8a 11176 case TARGET_NR_setgid32:
fd6f7798 11177 ret = get_errno(sys_setgid(arg1));
b03c60f3 11178 break;
a315a145
FB		 11179#endif
11180#ifdef TARGET_NR_setfsuid32
31e31b8a 11181 case TARGET_NR_setfsuid32:
b03c60f3
FB		 11182 ret = get_errno(setfsuid(arg1));
11183 break;
a315a145
FB		 11184#endif
11185#ifdef TARGET_NR_setfsgid32
31e31b8a 11186 case TARGET_NR_setfsgid32:
b03c60f3
FB		 11187 ret = get_errno(setfsgid(arg1));
11188 break;
a315a145 11189#endif
67867308 11190
31e31b8a 11191 case TARGET_NR_pivot_root:
b03c60f3 11192 goto unimplemented;
ffa65c3b 11193#ifdef TARGET_NR_mincore
31e31b8a 11194 case TARGET_NR_mincore:
04bb9ace
AJ		 11195 {
11196 void *a;
98a3331a
FSM		 11197 ret = -TARGET_ENOMEM;
11198 a = lock_user(VERIFY_READ, arg1, arg2, 0);
11199 if (!a) {
11200 goto fail;
11201 }
04bb9ace 11202 ret = -TARGET_EFAULT;
98a3331a
FSM		 11203 p = lock_user_string(arg3);
11204 if (!p) {
04bb9ace 11205 goto mincore_fail;
98a3331a 11206 }
04bb9ace
AJ		 11207 ret = get_errno(mincore(a, arg2, p));
11208 unlock_user(p, arg3, ret);
11209 mincore_fail:
11210 unlock_user(a, arg1, 0);
11211 }
11212 break;
ffa65c3b 11213#endif
408321b6
AJ		 11214#ifdef TARGET_NR_arm_fadvise64_64
11215 case TARGET_NR_arm_fadvise64_64:
e0156a9d
PM		 11216 /* arm_fadvise64_64 looks like fadvise64_64 but
11217 * with different argument order: fd, advice, offset, len
11218 * rather than the usual fd, offset, len, advice.
11219 * Note that offset and len are both 64-bit so appear as
11220 * pairs of 32-bit registers.
11221 */
11222 ret = posix_fadvise(arg1, target_offset64(arg3, arg4),
11223 target_offset64(arg5, arg6), arg2);
11224 ret = -host_to_target_errno(ret);
11225 break;
408321b6 11226#endif
badd3cd8
PM		 11227
11228#if TARGET_ABI_BITS == 32
11229
11230#ifdef TARGET_NR_fadvise64_64
11231 case TARGET_NR_fadvise64_64:
11232 /* 6 args: fd, offset (high, low), len (high, low), advice */
11233 if (regpairs_aligned(cpu_env)) {
11234 /* offset is in (3,4), len in (5,6) and advice in 7 */
11235 arg2 = arg3;
11236 arg3 = arg4;
11237 arg4 = arg5;
11238 arg5 = arg6;
11239 arg6 = arg7;
11240 }
11241 ret = -host_to_target_errno(posix_fadvise(arg1,
11242 target_offset64(arg2, arg3),
11243 target_offset64(arg4, arg5),
11244 arg6));
11245 break;
11246#endif
11247
11248#ifdef TARGET_NR_fadvise64
11249 case TARGET_NR_fadvise64:
11250 /* 5 args: fd, offset (high, low), len, advice */
11251 if (regpairs_aligned(cpu_env)) {
11252 /* offset is in (3,4), len in 5 and advice in 6 */
11253 arg2 = arg3;
11254 arg3 = arg4;
11255 arg4 = arg5;
11256 arg5 = arg6;
11257 }
11258 ret = -host_to_target_errno(posix_fadvise(arg1,
11259 target_offset64(arg2, arg3),
11260 arg4, arg5));
11261 break;
408321b6 11262#endif
badd3cd8
PM		 11263
11264#else /* not a 32-bit ABI */
e0156a9d 11265#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
408321b6
AJ		 11266#ifdef TARGET_NR_fadvise64_64
11267 case TARGET_NR_fadvise64_64:
11268#endif
e72d2cc7
UH		 11269#ifdef TARGET_NR_fadvise64
11270 case TARGET_NR_fadvise64:
11271#endif
11272#ifdef TARGET_S390X
11273 switch (arg4) {
11274 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
11275 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
11276 case 6: arg4 = POSIX_FADV_DONTNEED; break;
11277 case 7: arg4 = POSIX_FADV_NOREUSE; break;
11278 default: break;
11279 }
11280#endif
977d8241
PM		 11281 ret = -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4));
11282 break;
408321b6 11283#endif
badd3cd8
PM		 11284#endif /* end of 64-bit ABI fadvise handling */
11285
ffa65c3b 11286#ifdef TARGET_NR_madvise
31e31b8a 11287 case TARGET_NR_madvise:
24836689 11288 /* A straight passthrough may not be safe because qemu sometimes
d2d6b857 11289 turns private file-backed mappings into anonymous mappings.
24836689
PB		 11290 This will break MADV_DONTNEED.
11291 This is a hint, so ignoring and returning success is ok. */
11292 ret = get_errno(0);
11293 break;
ffa65c3b 11294#endif
992f48a0 11295#if TARGET_ABI_BITS == 32
31e31b8a 11296 case TARGET_NR_fcntl64:
77e4672d 11297 {
b1e341eb 11298 int cmd;
77e4672d 11299 struct flock64 fl;
213d3e9e
PM		 11300 from_flock64_fn *copyfrom = copy_from_user_flock64;
11301 to_flock64_fn *copyto = copy_to_user_flock64;
11302
ce4defa0 11303#ifdef TARGET_ARM
213d3e9e
PM		 11304 if (((CPUARMState *)cpu_env)->eabi) {
11305 copyfrom = copy_from_user_eabi_flock64;
11306 copyto = copy_to_user_eabi_flock64;
11307 }
ce4defa0 11308#endif
77e4672d 11309
5f106811 11310 cmd = target_to_host_fcntl_cmd(arg2);
31b63193
PM		 11311 if (cmd == -TARGET_EINVAL) {
11312 ret = cmd;
11313 break;
11314 }
b1e341eb 11315
60cd49d5 11316 switch(arg2) {
b1e341eb 11317 case TARGET_F_GETLK64:
213d3e9e
PM		 11318 ret = copyfrom(&fl, arg3);
11319 if (ret) {
11320 break;
5813427b 11321 }
b1e341eb 11322 ret = get_errno(fcntl(arg1, cmd, &fl));
213d3e9e
PM		 11323 if (ret == 0) {
11324 ret = copyto(arg3, &fl);
11325 }
77e4672d
FB		 11326 break;
11327
b1e341eb
TS		 11328 case TARGET_F_SETLK64:
11329 case TARGET_F_SETLKW64:
213d3e9e
PM		 11330 ret = copyfrom(&fl, arg3);
11331 if (ret) {
11332 break;
ce4defa0 11333 }
435da5e7 11334 ret = get_errno(safe_fcntl(arg1, cmd, &fl));
77e4672d 11335 break;
60cd49d5 11336 default:
5f106811 11337 ret = do_fcntl(arg1, arg2, arg3);
60cd49d5
FB		 11338 break;
11339 }
77e4672d
FB		 11340 break;
11341 }
60cd49d5 11342#endif
7d600c80
TS		 11343#ifdef TARGET_NR_cacheflush
11344 case TARGET_NR_cacheflush:
11345 /* self-modifying code is handled automatically, so nothing needed */
11346 ret = 0;
11347 break;
11348#endif
ebc05488 11349#ifdef TARGET_NR_security
31e31b8a
FB		 11350 case TARGET_NR_security:
11351 goto unimplemented;
c573ff67
FB		 11352#endif
11353#ifdef TARGET_NR_getpagesize
11354 case TARGET_NR_getpagesize:
11355 ret = TARGET_PAGE_SIZE;
11356 break;
ebc05488 11357#endif
31e31b8a
FB		 11358 case TARGET_NR_gettid:
11359 ret = get_errno(gettid());
11360 break;
e5febef5 11361#ifdef TARGET_NR_readahead
31e31b8a 11362 case TARGET_NR_readahead:
2054ac9b 11363#if TARGET_ABI_BITS == 32
48e515d4 11364 if (regpairs_aligned(cpu_env)) {
2054ac9b
AJ		 11365 arg2 = arg3;
11366 arg3 = arg4;
11367 arg4 = arg5;
11368 }
77c6850f 11369 ret = get_errno(readahead(arg1, target_offset64(arg2, arg3) , arg4));
2054ac9b
AJ		 11370#else
11371 ret = get_errno(readahead(arg1, arg2, arg3));
11372#endif
11373 break;
e5febef5 11374#endif
a790ae38 11375#ifdef CONFIG_ATTR
ebc05488 11376#ifdef TARGET_NR_setxattr
31e31b8a
FB		 11377 case TARGET_NR_listxattr:
11378 case TARGET_NR_llistxattr:
fb5590f7
PM		 11379 {
11380 void *p, *b = 0;
11381 if (arg2) {
11382 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11383 if (!b) {
11384 ret = -TARGET_EFAULT;
11385 break;
11386 }
11387 }
11388 p = lock_user_string(arg1);
11389 if (p) {
11390 if (num == TARGET_NR_listxattr) {
11391 ret = get_errno(listxattr(p, b, arg3));
11392 } else {
11393 ret = get_errno(llistxattr(p, b, arg3));
11394 }
11395 } else {
11396 ret = -TARGET_EFAULT;
11397 }
11398 unlock_user(p, arg1, 0);
11399 unlock_user(b, arg2, arg3);
11400 break;
11401 }
31e31b8a 11402 case TARGET_NR_flistxattr:
fb5590f7
PM		 11403 {
11404 void *b = 0;
11405 if (arg2) {
11406 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11407 if (!b) {
11408 ret = -TARGET_EFAULT;
11409 break;
11410 }
11411 }
11412 ret = get_errno(flistxattr(arg1, b, arg3));
11413 unlock_user(b, arg2, arg3);
6f932f91 11414 break;
fb5590f7 11415 }
a790ae38 11416 case TARGET_NR_setxattr:
30297b55 11417 case TARGET_NR_lsetxattr:
a790ae38 11418 {
e3c33ec6
PM		 11419 void *p, *n, *v = 0;
11420 if (arg3) {
11421 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11422 if (!v) {
11423 ret = -TARGET_EFAULT;
11424 break;
11425 }
11426 }
a790ae38
ACH		 11427 p = lock_user_string(arg1);
11428 n = lock_user_string(arg2);
e3c33ec6 11429 if (p && n) {
30297b55
PM		 11430 if (num == TARGET_NR_setxattr) {
11431 ret = get_errno(setxattr(p, n, v, arg4, arg5));
11432 } else {
11433 ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
11434 }
a790ae38
ACH		 11435 } else {
11436 ret = -TARGET_EFAULT;
11437 }
11438 unlock_user(p, arg1, 0);
11439 unlock_user(n, arg2, 0);
11440 unlock_user(v, arg3, 0);
11441 }
11442 break;
30297b55
PM		 11443 case TARGET_NR_fsetxattr:
11444 {
11445 void *n, *v = 0;
11446 if (arg3) {
11447 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11448 if (!v) {
11449 ret = -TARGET_EFAULT;
11450 break;
11451 }
11452 }
11453 n = lock_user_string(arg2);
11454 if (n) {
11455 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
11456 } else {
11457 ret = -TARGET_EFAULT;
11458 }
11459 unlock_user(n, arg2, 0);
11460 unlock_user(v, arg3, 0);
11461 }
11462 break;
a790ae38 11463 case TARGET_NR_getxattr:
30297b55 11464 case TARGET_NR_lgetxattr:
a790ae38 11465 {
e3c33ec6
PM		 11466 void *p, *n, *v = 0;
11467 if (arg3) {
11468 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
11469 if (!v) {
11470 ret = -TARGET_EFAULT;
11471 break;
11472 }
11473 }
a790ae38
ACH		 11474 p = lock_user_string(arg1);
11475 n = lock_user_string(arg2);
e3c33ec6 11476 if (p && n) {
30297b55
PM		 11477 if (num == TARGET_NR_getxattr) {
11478 ret = get_errno(getxattr(p, n, v, arg4));
11479 } else {
11480 ret = get_errno(lgetxattr(p, n, v, arg4));
11481 }
a790ae38
ACH		 11482 } else {
11483 ret = -TARGET_EFAULT;
11484 }
11485 unlock_user(p, arg1, 0);
11486 unlock_user(n, arg2, 0);
11487 unlock_user(v, arg3, arg4);
11488 }
11489 break;
30297b55
PM		 11490 case TARGET_NR_fgetxattr:
11491 {
11492 void *n, *v = 0;
11493 if (arg3) {
11494 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
11495 if (!v) {
11496 ret = -TARGET_EFAULT;
11497 break;
11498 }
11499 }
11500 n = lock_user_string(arg2);
11501 if (n) {
11502 ret = get_errno(fgetxattr(arg1, n, v, arg4));
11503 } else {
11504 ret = -TARGET_EFAULT;
11505 }
11506 unlock_user(n, arg2, 0);
11507 unlock_user(v, arg3, arg4);
11508 }
11509 break;
a790ae38 11510 case TARGET_NR_removexattr:
30297b55 11511 case TARGET_NR_lremovexattr:
a790ae38
ACH		 11512 {
11513 void *p, *n;
11514 p = lock_user_string(arg1);
11515 n = lock_user_string(arg2);
11516 if (p && n) {
30297b55
PM		 11517 if (num == TARGET_NR_removexattr) {
11518 ret = get_errno(removexattr(p, n));
11519 } else {
11520 ret = get_errno(lremovexattr(p, n));
11521 }
a790ae38
ACH		 11522 } else {
11523 ret = -TARGET_EFAULT;
11524 }
11525 unlock_user(p, arg1, 0);
11526 unlock_user(n, arg2, 0);
11527 }
11528 break;
30297b55
PM		 11529 case TARGET_NR_fremovexattr:
11530 {
11531 void *n;
11532 n = lock_user_string(arg2);
11533 if (n) {
11534 ret = get_errno(fremovexattr(arg1, n));
11535 } else {
11536 ret = -TARGET_EFAULT;
11537 }
11538 unlock_user(n, arg2, 0);
11539 }
11540 break;
ebc05488 11541#endif
a790ae38 11542#endif /* CONFIG_ATTR */
ebc05488 11543#ifdef TARGET_NR_set_thread_area
5cd4393b 11544 case TARGET_NR_set_thread_area:
8d18e893 11545#if defined(TARGET_MIPS)
d279279e 11546 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1;
6f5b89a0
TS		 11547 ret = 0;
11548 break;
ef96779b
EI		 11549#elif defined(TARGET_CRIS)
11550 if (arg1 & 0xff)
11551 ret = -TARGET_EINVAL;
11552 else {
11553 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
11554 ret = 0;
11555 }
11556 break;
8d18e893
FB		 11557#elif defined(TARGET_I386) && defined(TARGET_ABI32)
11558 ret = do_set_thread_area(cpu_env, arg1);
11559 break;
1ccd9374
PM		 11560#elif defined(TARGET_M68K)
11561 {
0429a971 11562 TaskState *ts = cpu->opaque;
1ccd9374 11563 ts->tp_value = arg1;
95c1eb19 11564 ret = 0;
1ccd9374
PM		 11565 break;
11566 }
6f5b89a0
TS		 11567#else
11568 goto unimplemented_nowarn;
11569#endif
11570#endif
11571#ifdef TARGET_NR_get_thread_area
5cd4393b 11572 case TARGET_NR_get_thread_area:
8d18e893
FB		 11573#if defined(TARGET_I386) && defined(TARGET_ABI32)
11574 ret = do_get_thread_area(cpu_env, arg1);
d312bbe1 11575 break;
1ccd9374
PM		 11576#elif defined(TARGET_M68K)
11577 {
0429a971 11578 TaskState *ts = cpu->opaque;
1ccd9374
PM		 11579 ret = ts->tp_value;
11580 break;
11581 }
8d18e893 11582#else
5cd4393b 11583 goto unimplemented_nowarn;
48dc41eb 11584#endif
8d18e893 11585#endif
48dc41eb
FB		 11586#ifdef TARGET_NR_getdomainname
11587 case TARGET_NR_getdomainname:
11588 goto unimplemented_nowarn;
ebc05488 11589#endif
6f5b89a0 11590
b5906f95
TS		 11591#ifdef TARGET_NR_clock_gettime
11592 case TARGET_NR_clock_gettime:
11593 {
11594 struct timespec ts;
11595 ret = get_errno(clock_gettime(arg1, &ts));
11596 if (!is_error(ret)) {
11597 host_to_target_timespec(arg2, &ts);
11598 }
11599 break;
11600 }
11601#endif
11602#ifdef TARGET_NR_clock_getres
11603 case TARGET_NR_clock_getres:
11604 {
11605 struct timespec ts;
11606 ret = get_errno(clock_getres(arg1, &ts));
11607 if (!is_error(ret)) {
11608 host_to_target_timespec(arg2, &ts);
11609 }
11610 break;
11611 }
11612#endif
63d7651b
PB		 11613#ifdef TARGET_NR_clock_nanosleep
11614 case TARGET_NR_clock_nanosleep:
11615 {
11616 struct timespec ts;
11617 target_to_host_timespec(&ts, arg3);
9e518226
PM		 11618 ret = get_errno(safe_clock_nanosleep(arg1, arg2,
11619 &ts, arg4 ? &ts : NULL));
63d7651b
PB		 11620 if (arg4)
11621 host_to_target_timespec(arg4, &ts);
8fbe8fdf
TM		 11622
11623#if defined(TARGET_PPC)
11624 /* clock_nanosleep is odd in that it returns positive errno values.
11625 * On PPC, CR0 bit 3 should be set in such a situation. */
9e518226 11626 if (ret && ret != -TARGET_ERESTARTSYS) {
8fbe8fdf
TM		 11627 ((CPUPPCState *)cpu_env)->crf[0] |= 1;
11628 }
11629#endif
63d7651b
PB		 11630 break;
11631 }
11632#endif
b5906f95 11633
6f5b89a0
TS		 11634#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11635 case TARGET_NR_set_tid_address:
579a97f7
FB		 11636 ret = get_errno(set_tid_address((int *)g2h(arg1)));
11637 break;
6f5b89a0
TS		 11638#endif
11639
4cae1d16 11640 case TARGET_NR_tkill:
bef653d9 11641 ret = get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2)));
4cae1d16 11642 break;
4cae1d16 11643
71455574 11644 case TARGET_NR_tgkill:
bef653d9 11645 ret = get_errno(safe_tgkill((int)arg1, (int)arg2,
4cb05961 11646 target_to_host_signal(arg3)));
bef653d9 11647 break;
71455574 11648
4f2b1fe8
TS		 11649#ifdef TARGET_NR_set_robust_list
11650 case TARGET_NR_set_robust_list:
e9a970a8
PM		 11651 case TARGET_NR_get_robust_list:
11652 /* The ABI for supporting robust futexes has userspace pass
11653 * the kernel a pointer to a linked list which is updated by
11654 * userspace after the syscall; the list is walked by the kernel
11655 * when the thread exits. Since the linked list in QEMU guest
11656 * memory isn't a valid linked list for the host and we have
11657 * no way to reliably intercept the thread-death event, we can't
11658 * support these. Silently return ENOSYS so that guest userspace
11659 * falls back to a non-robust futex implementation (which should
11660 * be OK except in the corner case of the guest crashing while
11661 * holding a mutex that is shared with another process via
11662 * shared memory).
11663 */
11664 goto unimplemented_nowarn;
4f2b1fe8
TS		 11665#endif
11666
1acae9f2 11667#if defined(TARGET_NR_utimensat)
9007f0ef
TS		 11668 case TARGET_NR_utimensat:
11669 {
ebc996f3
RV		 11670 struct timespec *tsp, ts[2];
11671 if (!arg3) {
11672 tsp = NULL;
11673 } else {
11674 target_to_host_timespec(ts, arg3);
11675 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
11676 tsp = ts;
11677 }
9007f0ef 11678 if (!arg2)
ebc996f3 11679 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
9007f0ef 11680 else {
579a97f7 11681 if (!(p = lock_user_string(arg2))) {
0da46a6e 11682 ret = -TARGET_EFAULT;
579a97f7
FB		 11683 goto fail;
11684 }
ebc996f3 11685 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
579a97f7 11686 unlock_user(p, arg2, 0);
9007f0ef
TS		 11687 }
11688 }
11689 break;
11690#endif
bd0c5661
PB		 11691 case TARGET_NR_futex:
11692 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
11693 break;
dbfe4c36 11694#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
39b59763
AJ		 11695 case TARGET_NR_inotify_init:
11696 ret = get_errno(sys_inotify_init());
11697 break;
11698#endif
a1606b0b 11699#ifdef CONFIG_INOTIFY1
c05c7a73
RV		 11700#if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11701 case TARGET_NR_inotify_init1:
fea243e9
LD		 11702 ret = get_errno(sys_inotify_init1(target_to_host_bitmask(arg1,
11703 fcntl_flags_tbl)));
c05c7a73
RV		 11704 break;
11705#endif
a1606b0b 11706#endif
dbfe4c36 11707#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
39b59763
AJ		 11708 case TARGET_NR_inotify_add_watch:
11709 p = lock_user_string(arg2);
11710 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
11711 unlock_user(p, arg2, 0);
11712 break;
11713#endif
dbfe4c36 11714#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
39b59763
AJ		 11715 case TARGET_NR_inotify_rm_watch:
11716 ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
11717 break;
11718#endif
9007f0ef 11719
8ec9cf89 11720#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
24e1003a
AJ		 11721 case TARGET_NR_mq_open:
11722 {
c7536ab6 11723 struct mq_attr posix_mq_attr;
26400775 11724 struct mq_attr *pposix_mq_attr;
c7536ab6 11725 int host_flags;
24e1003a 11726
c7536ab6 11727 host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl);
26400775
LD		 11728 pposix_mq_attr = NULL;
11729 if (arg4) {
11730 if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) {
11731 goto efault;
11732 }
11733 pposix_mq_attr = &posix_mq_attr;
c7536ab6 11734 }
24e1003a 11735 p = lock_user_string(arg1 - 1);
c7536ab6
AM		 11736 if (!p) {
11737 goto efault;
b6ce1f6b 11738 }
26400775 11739 ret = get_errno(mq_open(p, host_flags, arg3, pposix_mq_attr));
24e1003a
AJ		 11740 unlock_user (p, arg1, 0);
11741 }
11742 break;
11743
11744 case TARGET_NR_mq_unlink:
11745 p = lock_user_string(arg1 - 1);
3211215e
PM		 11746 if (!p) {
11747 ret = -TARGET_EFAULT;
11748 break;
11749 }
24e1003a
AJ		 11750 ret = get_errno(mq_unlink(p));
11751 unlock_user (p, arg1, 0);
11752 break;
11753
11754 case TARGET_NR_mq_timedsend:
11755 {
11756 struct timespec ts;
11757
11758 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11759 if (arg5 != 0) {
11760 target_to_host_timespec(&ts, arg5);
d40ecd66 11761 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
24e1003a 11762 host_to_target_timespec(arg5, &ts);
d40ecd66
PM		 11763 } else {
11764 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
24e1003a 11765 }
24e1003a
AJ		 11766 unlock_user (p, arg2, arg3);
11767 }
11768 break;
11769
11770 case TARGET_NR_mq_timedreceive:
11771 {
11772 struct timespec ts;
11773 unsigned int prio;
11774
11775 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11776 if (arg5 != 0) {
11777 target_to_host_timespec(&ts, arg5);
d40ecd66
PM		 11778 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11779 &prio, &ts));
24e1003a 11780 host_to_target_timespec(arg5, &ts);
d40ecd66
PM		 11781 } else {
11782 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11783 &prio, NULL));
24e1003a 11784 }
24e1003a
AJ		 11785 unlock_user (p, arg2, arg3);
11786 if (arg4 != 0)
11787 put_user_u32(prio, arg4);
11788 }
11789 break;
11790
11791 /* Not implemented for now... */
11792/* case TARGET_NR_mq_notify: */
11793/* break; */
11794
11795 case TARGET_NR_mq_getsetattr:
11796 {
11797 struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
11798 ret = 0;
11799 if (arg3 != 0) {
11800 ret = mq_getattr(arg1, &posix_mq_attr_out);
11801 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
11802 }
11803 if (arg2 != 0) {
11804 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
11805 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
11806 }
11807
11808 }
11809 break;
11810#endif
11811
3ce34dfb
VS		 11812#ifdef CONFIG_SPLICE
11813#ifdef TARGET_NR_tee
11814 case TARGET_NR_tee:
11815 {
11816 ret = get_errno(tee(arg1,arg2,arg3,arg4));
11817 }
11818 break;
11819#endif
11820#ifdef TARGET_NR_splice
11821 case TARGET_NR_splice:
11822 {
11823 loff_t loff_in, loff_out;
11824 loff_t *ploff_in = NULL, *ploff_out = NULL;
17644b36
AS		 11825 if (arg2) {
11826 if (get_user_u64(loff_in, arg2)) {
11827 goto efault;
11828 }
3ce34dfb
VS		 11829 ploff_in = &loff_in;
11830 }
17644b36
AS		 11831 if (arg4) {
11832 if (get_user_u64(loff_out, arg4)) {
11833 goto efault;
11834 }
3ce34dfb
VS		 11835 ploff_out = &loff_out;
11836 }
11837 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
17644b36
AS		 11838 if (arg2) {
11839 if (put_user_u64(loff_in, arg2)) {
11840 goto efault;
11841 }
11842 }
11843 if (arg4) {
11844 if (put_user_u64(loff_out, arg4)) {
11845 goto efault;
11846 }
11847 }
3ce34dfb
VS		 11848 }
11849 break;
11850#endif
11851#ifdef TARGET_NR_vmsplice
11852 case TARGET_NR_vmsplice:
11853 {
f287b2c2
RH		 11854 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
11855 if (vec != NULL) {
11856 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
11857 unlock_iovec(vec, arg2, arg3, 0);
11858 } else {
11859 ret = -host_to_target_errno(errno);
11860 }
3ce34dfb
VS		 11861 }
11862 break;
11863#endif
11864#endif /* CONFIG_SPLICE */
c2882b96
RV		 11865#ifdef CONFIG_EVENTFD
11866#if defined(TARGET_NR_eventfd)
11867 case TARGET_NR_eventfd:
11868 ret = get_errno(eventfd(arg1, 0));
e36800c9 11869 fd_trans_unregister(ret);
c2882b96
RV		 11870 break;
11871#endif
11872#if defined(TARGET_NR_eventfd2)
11873 case TARGET_NR_eventfd2:
5947c697
PJ		 11874 {
11875 int host_flags = arg2 & (~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC));
11876 if (arg2 & TARGET_O_NONBLOCK) {
11877 host_flags |= O_NONBLOCK;
11878 }
11879 if (arg2 & TARGET_O_CLOEXEC) {
11880 host_flags |= O_CLOEXEC;
11881 }
11882 ret = get_errno(eventfd(arg1, host_flags));
e36800c9 11883 fd_trans_unregister(ret);
c2882b96 11884 break;
5947c697 11885 }
c2882b96
RV		 11886#endif
11887#endif /* CONFIG_EVENTFD */
d0927938
UH		 11888#if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
11889 case TARGET_NR_fallocate:
20249ae1
AG		 11890#if TARGET_ABI_BITS == 32
11891 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
11892 target_offset64(arg5, arg6)));
11893#else
d0927938 11894 ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
20249ae1 11895#endif
d0927938 11896 break;
c727f47d
PM		 11897#endif
11898#if defined(CONFIG_SYNC_FILE_RANGE)
11899#if defined(TARGET_NR_sync_file_range)
11900 case TARGET_NR_sync_file_range:
11901#if TARGET_ABI_BITS == 32
bfcedc57
RV		 11902#if defined(TARGET_MIPS)
11903 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11904 target_offset64(arg5, arg6), arg7));
11905#else
c727f47d
PM		 11906 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
11907 target_offset64(arg4, arg5), arg6));
bfcedc57 11908#endif /* !TARGET_MIPS */
c727f47d
PM		 11909#else
11910 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
11911#endif
11912 break;
11913#endif
11914#if defined(TARGET_NR_sync_file_range2)
11915 case TARGET_NR_sync_file_range2:
11916 /* This is like sync_file_range but the arguments are reordered */
11917#if TARGET_ABI_BITS == 32
11918 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11919 target_offset64(arg5, arg6), arg2));
11920#else
11921 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
11922#endif
11923 break;
11924#endif
3b6edd16 11925#endif
e36800c9
LV		 11926#if defined(TARGET_NR_signalfd4)
11927 case TARGET_NR_signalfd4:
11928 ret = do_signalfd4(arg1, arg2, arg4);
11929 break;
11930#endif
11931#if defined(TARGET_NR_signalfd)
11932 case TARGET_NR_signalfd:
11933 ret = do_signalfd4(arg1, arg2, 0);
11934 break;
11935#endif
3b6edd16
PM		 11936#if defined(CONFIG_EPOLL)
11937#if defined(TARGET_NR_epoll_create)
11938 case TARGET_NR_epoll_create:
11939 ret = get_errno(epoll_create(arg1));
11940 break;
11941#endif
11942#if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
11943 case TARGET_NR_epoll_create1:
11944 ret = get_errno(epoll_create1(arg1));
11945 break;
11946#endif
11947#if defined(TARGET_NR_epoll_ctl)
11948 case TARGET_NR_epoll_ctl:
11949 {
11950 struct epoll_event ep;
11951 struct epoll_event *epp = 0;
11952 if (arg4) {
11953 struct target_epoll_event *target_ep;
11954 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
11955 goto efault;
11956 }
11957 ep.events = tswap32(target_ep->events);
11958 /* The epoll_data_t union is just opaque data to the kernel,
11959 * so we transfer all 64 bits across and need not worry what
11960 * actual data type it is.
11961 */
11962 ep.data.u64 = tswap64(target_ep->data.u64);
11963 unlock_user_struct(target_ep, arg4, 0);
11964 epp = &ep;
11965 }
11966 ret = get_errno(epoll_ctl(arg1, arg2, arg3, epp));
11967 break;
11968 }
11969#endif
11970
227f0214 11971#if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 11972#if defined(TARGET_NR_epoll_wait)
11973 case TARGET_NR_epoll_wait:
11974#endif
227f0214 11975#if defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 11976 case TARGET_NR_epoll_pwait:
11977#endif
11978 {
11979 struct target_epoll_event *target_ep;
11980 struct epoll_event *ep;
11981 int epfd = arg1;
11982 int maxevents = arg3;
11983 int timeout = arg4;
11984
2ba7fae3
PM		 11985 if (maxevents <= 0 || maxevents > TARGET_EP_MAX_EVENTS) {
11986 ret = -TARGET_EINVAL;
11987 break;
11988 }
11989
3b6edd16
PM		 11990 target_ep = lock_user(VERIFY_WRITE, arg2,
11991 maxevents * sizeof(struct target_epoll_event), 1);
11992 if (!target_ep) {
11993 goto efault;
11994 }
11995
04c95f4d
PM		 11996 ep = g_try_new(struct epoll_event, maxevents);
11997 if (!ep) {
11998 unlock_user(target_ep, arg2, 0);
11999 ret = -TARGET_ENOMEM;
12000 break;
12001 }
3b6edd16
PM		 12002
12003 switch (num) {
227f0214 12004#if defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 12005 case TARGET_NR_epoll_pwait:
12006 {
12007 target_sigset_t *target_set;
12008 sigset_t _set, *set = &_set;
12009
12010 if (arg5) {
c815701e
PM		 12011 if (arg6 != sizeof(target_sigset_t)) {
12012 ret = -TARGET_EINVAL;
12013 break;
12014 }
12015
3b6edd16
PM		 12016 target_set = lock_user(VERIFY_READ, arg5,
12017 sizeof(target_sigset_t), 1);
12018 if (!target_set) {
04c95f4d
PM		 12019 ret = -TARGET_EFAULT;
12020 break;
3b6edd16
PM		 12021 }
12022 target_to_host_sigset(set, target_set);
12023 unlock_user(target_set, arg5, 0);
12024 } else {
12025 set = NULL;
12026 }
12027
227f0214
PM		 12028 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12029 set, SIGSET_T_SIZE));
3b6edd16
PM		 12030 break;
12031 }
12032#endif
12033#if defined(TARGET_NR_epoll_wait)
12034 case TARGET_NR_epoll_wait:
227f0214
PM		 12035 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12036 NULL, 0));
3b6edd16
PM		 12037 break;
12038#endif
12039 default:
12040 ret = -TARGET_ENOSYS;
12041 }
12042 if (!is_error(ret)) {
12043 int i;
12044 for (i = 0; i < ret; i++) {
12045 target_ep[i].events = tswap32(ep[i].events);
12046 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
12047 }
04c95f4d
PM		 12048 unlock_user(target_ep, arg2,
12049 ret * sizeof(struct target_epoll_event));
12050 } else {
12051 unlock_user(target_ep, arg2, 0);
3b6edd16 12052 }
04c95f4d 12053 g_free(ep);
3b6edd16
PM		 12054 break;
12055 }
12056#endif
163a05a8
PM		 12057#endif
12058#ifdef TARGET_NR_prlimit64
12059 case TARGET_NR_prlimit64:
12060 {
12061 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
12062 struct target_rlimit64 *target_rnew, *target_rold;
12063 struct host_rlimit64 rnew, rold, *rnewp = 0;
95018018 12064 int resource = target_to_host_resource(arg2);
163a05a8
PM		 12065 if (arg3) {
12066 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
12067 goto efault;
12068 }
12069 rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
12070 rnew.rlim_max = tswap64(target_rnew->rlim_max);
12071 unlock_user_struct(target_rnew, arg3, 0);
12072 rnewp = &rnew;
12073 }
12074
95018018 12075 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0));
163a05a8
PM		 12076 if (!is_error(ret) && arg4) {
12077 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
12078 goto efault;
12079 }
12080 target_rold->rlim_cur = tswap64(rold.rlim_cur);
12081 target_rold->rlim_max = tswap64(rold.rlim_max);
12082 unlock_user_struct(target_rold, arg4, 1);
12083 }
12084 break;
12085 }
3d21d29c
RH		 12086#endif
12087#ifdef TARGET_NR_gethostname
12088 case TARGET_NR_gethostname:
12089 {
12090 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
12091 if (name) {
12092 ret = get_errno(gethostname(name, arg2));
12093 unlock_user(name, arg1, arg2);
12094 } else {
12095 ret = -TARGET_EFAULT;
12096 }
12097 break;
12098 }
89aaf1a6
RV		 12099#endif
12100#ifdef TARGET_NR_atomic_cmpxchg_32
12101 case TARGET_NR_atomic_cmpxchg_32:
12102 {
12103 /* should use start_exclusive from main.c */
12104 abi_ulong mem_value;
12105 if (get_user_u32(mem_value, arg6)) {
12106 target_siginfo_t info;
12107 info.si_signo = SIGSEGV;
12108 info.si_errno = 0;
12109 info.si_code = TARGET_SEGV_MAPERR;
12110 info._sifields._sigfault._addr = arg6;
9d2803f7
PM		 12111 queue_signal((CPUArchState *)cpu_env, info.si_signo,
12112 QEMU_SI_FAULT, &info);
89aaf1a6
RV		 12113 ret = 0xdeadbeef;
12114
12115 }
12116 if (mem_value == arg2)
12117 put_user_u32(arg1, arg6);
12118 ret = mem_value;
12119 break;
12120 }
12121#endif
12122#ifdef TARGET_NR_atomic_barrier
12123 case TARGET_NR_atomic_barrier:
12124 {
12125 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
3b899ea7 12126 ret = 0;
89aaf1a6
RV		 12127 break;
12128 }
d0927938 12129#endif
f4f1e10a
ECL		 12130
12131#ifdef TARGET_NR_timer_create
12132 case TARGET_NR_timer_create:
12133 {
12134 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
12135
12136 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
f4f1e10a
ECL		 12137
12138 int clkid = arg1;
12139 int timer_index = next_free_host_timer();
12140
12141 if (timer_index < 0) {
12142 ret = -TARGET_EAGAIN;
12143 } else {
12144 timer_t *phtimer = g_posix_timers + timer_index;
12145
12146 if (arg2) {
f4f1e10a 12147 phost_sevp = &host_sevp;
c065976f
PM		 12148 ret = target_to_host_sigevent(phost_sevp, arg2);
12149 if (ret != 0) {
12150 break;
12151 }
f4f1e10a
ECL		 12152 }
12153
12154 ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
12155 if (ret) {
12156 phtimer = NULL;
12157 } else {
aecc8861 12158 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) {
f4f1e10a
ECL		 12159 goto efault;
12160 }
f4f1e10a
ECL		 12161 }
12162 }
12163 break;
12164 }
12165#endif
12166
12167#ifdef TARGET_NR_timer_settime
12168 case TARGET_NR_timer_settime:
12169 {
12170 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
12171 * struct itimerspec * old_value */
aecc8861 12172 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 12173
aecc8861
AG		 12174 if (timerid < 0) {
12175 ret = timerid;
12176 } else if (arg3 == 0) {
f4f1e10a
ECL		 12177 ret = -TARGET_EINVAL;
12178 } else {
e52a99f7 12179 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 12180 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
12181
40c80b5e
MAL		 12182 if (target_to_host_itimerspec(&hspec_new, arg3)) {
12183 goto efault;
12184 }
f4f1e10a
ECL		 12185 ret = get_errno(
12186 timer_settime(htimer, arg2, &hspec_new, &hspec_old));
40c80b5e
MAL		 12187 if (arg4 && host_to_target_itimerspec(arg4, &hspec_old)) {
12188 goto efault;
12189 }
f4f1e10a
ECL		 12190 }
12191 break;
12192 }
12193#endif
12194
12195#ifdef TARGET_NR_timer_gettime
12196 case TARGET_NR_timer_gettime:
12197 {
12198 /* args: timer_t timerid, struct itimerspec *curr_value */
aecc8861 12199 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 12200
aecc8861
AG		 12201 if (timerid < 0) {
12202 ret = timerid;
12203 } else if (!arg2) {
12204 ret = -TARGET_EFAULT;
f4f1e10a 12205 } else {
e52a99f7 12206 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 12207 struct itimerspec hspec;
12208 ret = get_errno(timer_gettime(htimer, &hspec));
12209
12210 if (host_to_target_itimerspec(arg2, &hspec)) {
12211 ret = -TARGET_EFAULT;
12212 }
12213 }
12214 break;
12215 }
12216#endif
12217
12218#ifdef TARGET_NR_timer_getoverrun
12219 case TARGET_NR_timer_getoverrun:
12220 {
12221 /* args: timer_t timerid */
aecc8861 12222 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 12223
aecc8861
AG		 12224 if (timerid < 0) {
12225 ret = timerid;
f4f1e10a 12226 } else {
e52a99f7 12227 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 12228 ret = get_errno(timer_getoverrun(htimer));
12229 }
e36800c9 12230 fd_trans_unregister(ret);
f4f1e10a
ECL		 12231 break;
12232 }
12233#endif
12234
12235#ifdef TARGET_NR_timer_delete
12236 case TARGET_NR_timer_delete:
12237 {
12238 /* args: timer_t timerid */
aecc8861 12239 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 12240
aecc8861
AG		 12241 if (timerid < 0) {
12242 ret = timerid;
f4f1e10a 12243 } else {
e52a99f7 12244 timer_t htimer = g_posix_timers[timerid];
f4f1e10a 12245 ret = get_errno(timer_delete(htimer));
e52a99f7 12246 g_posix_timers[timerid] = 0;
f4f1e10a
ECL		 12247 }
12248 break;
12249 }
12250#endif
12251
51834341
RV		 12252#if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
12253 case TARGET_NR_timerfd_create:
12254 ret = get_errno(timerfd_create(arg1,
12255 target_to_host_bitmask(arg2, fcntl_flags_tbl)));
12256 break;
12257#endif
12258
12259#if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
12260 case TARGET_NR_timerfd_gettime:
12261 {
12262 struct itimerspec its_curr;
12263
12264 ret = get_errno(timerfd_gettime(arg1, &its_curr));
12265
12266 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) {
12267 goto efault;
12268 }
12269 }
12270 break;
12271#endif
12272
12273#if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
12274 case TARGET_NR_timerfd_settime:
12275 {
12276 struct itimerspec its_new, its_old, *p_new;
12277
12278 if (arg3) {
12279 if (target_to_host_itimerspec(&its_new, arg3)) {
12280 goto efault;
12281 }
12282 p_new = &its_new;
12283 } else {
12284 p_new = NULL;
12285 }
12286
12287 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
12288
12289 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) {
12290 goto efault;
12291 }
12292 }
12293 break;
12294#endif
12295
ab31cda3
PB		 12296#if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
12297 case TARGET_NR_ioprio_get:
12298 ret = get_errno(ioprio_get(arg1, arg2));
12299 break;
12300#endif
12301
12302#if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
12303 case TARGET_NR_ioprio_set:
12304 ret = get_errno(ioprio_set(arg1, arg2, arg3));
12305 break;
12306#endif
12307
9af5c906
RV		 12308#if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
12309 case TARGET_NR_setns:
12310 ret = get_errno(setns(arg1, arg2));
12311 break;
12312#endif
12313#if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
12314 case TARGET_NR_unshare:
12315 ret = get_errno(unshare(arg1));
12316 break;
12317#endif
2f14788c
LV		 12318#if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
12319 case TARGET_NR_kcmp:
12320 ret = get_errno(kcmp(arg1, arg2, arg3, arg4, arg5));
12321 break;
12322#endif
9af5c906 12323
31e31b8a
FB		 12324 default:
12325 unimplemented:
5cd4393b 12326 gemu_log("qemu: Unsupported syscall: %d\n", num);
4f2b1fe8 12327#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
5cd4393b 12328 unimplemented_nowarn:
80a9d035 12329#endif
0da46a6e 12330 ret = -TARGET_ENOSYS;
31e31b8a
FB		 12331 break;
12332 }
579a97f7 12333fail:
c573ff67 12334#ifdef DEBUG
0bf9e31a 12335 gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
c573ff67 12336#endif
b92c47c1
TS		 12337 if(do_strace)
12338 print_syscall_ret(num, ret);
9c15e700 12339 trace_guest_user_syscall_ret(cpu, num, ret);
31e31b8a 12340 return ret;
579a97f7
FB		 12341efault:
12342 ret = -TARGET_EFAULT;
12343 goto fail;
31e31b8a 12344}
QEMU mirror