4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 #define _ATFILE_SOURCE
20 #include "qemu/osdep.h"
21 #include "qemu/cutils.h"
22 #include "qemu/path.h"
29 #include <sys/mount.h>
31 #include <sys/fsuid.h>
32 #include <sys/personality.h>
33 #include <sys/prctl.h>
34 #include <sys/resource.h>
36 #include <linux/capability.h>
38 #include <sys/timex.h>
39 #include <sys/socket.h>
43 #include <sys/times.h>
46 #include <sys/statfs.h>
48 #include <sys/sysinfo.h>
49 #include <sys/signalfd.h>
50 //#include <sys/user.h>
51 #include <netinet/ip.h>
52 #include <netinet/tcp.h>
53 #include <linux/wireless.h>
54 #include <linux/icmp.h>
55 #include <linux/icmpv6.h>
56 #include <linux/errqueue.h>
57 #include <linux/random.h>
58 #include "qemu-common.h"
60 #include <sys/timerfd.h>
66 #include <sys/eventfd.h>
69 #include <sys/epoll.h>
72 #include "qemu/xattr.h"
74 #ifdef CONFIG_SENDFILE
75 #include <sys/sendfile.h>
78 #define termios host_termios
79 #define winsize host_winsize
80 #define termio host_termio
81 #define sgttyb host_sgttyb /* same as target */
82 #define tchars host_tchars /* same as target */
83 #define ltchars host_ltchars /* same as target */
85 #include <linux/termios.h>
86 #include <linux/unistd.h>
87 #include <linux/cdrom.h>
88 #include <linux/hdreg.h>
89 #include <linux/soundcard.h>
91 #include <linux/mtio.h>
93 #if defined(CONFIG_FIEMAP)
94 #include <linux/fiemap.h>
98 #include <linux/dm-ioctl.h>
99 #include <linux/reboot.h>
100 #include <linux/route.h>
101 #include <linux/filter.h>
102 #include <linux/blkpg.h>
103 #include <netpacket/packet.h>
104 #include <linux/netlink.h>
105 #ifdef CONFIG_RTNETLINK
106 #include <linux/rtnetlink.h>
107 #include <linux/if_bridge.h>
109 #include <linux/audit.h>
110 #include "linux_loop.h"
116 #define CLONE_IO 0x80000000 /* Clone io context */
119 /* We can't directly call the host clone syscall, because this will
120 * badly confuse libc (breaking mutexes, for example). So we must
121 * divide clone flags into:
122 * * flag combinations that look like pthread_create()
123 * * flag combinations that look like fork()
124 * * flags we can implement within QEMU itself
125 * * flags we can't support and will return an error for
127 /* For thread creation, all these flags must be present; for
128 * fork, none must be present.
130 #define CLONE_THREAD_FLAGS \
131 (CLONE_VM | CLONE_FS | CLONE_FILES | \
132 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
134 /* These flags are ignored:
135 * CLONE_DETACHED is now ignored by the kernel;
136 * CLONE_IO is just an optimisation hint to the I/O scheduler
138 #define CLONE_IGNORED_FLAGS \
139 (CLONE_DETACHED | CLONE_IO)
141 /* Flags for fork which we can implement within QEMU itself */
142 #define CLONE_OPTIONAL_FORK_FLAGS \
143 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
144 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
146 /* Flags for thread creation which we can implement within QEMU itself */
147 #define CLONE_OPTIONAL_THREAD_FLAGS \
148 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
149 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
151 #define CLONE_INVALID_FORK_FLAGS \
152 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
154 #define CLONE_INVALID_THREAD_FLAGS \
155 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
156 CLONE_IGNORED_FLAGS))
158 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
159 * have almost all been allocated. We cannot support any of
160 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
161 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
162 * The checks against the invalid thread masks above will catch these.
163 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
167 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
168 * once. This exercises the codepaths for restart.
170 //#define DEBUG_ERESTARTSYS
172 //#include <linux/msdos_fs.h>
173 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
174 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
184 #define _syscall0(type,name) \
185 static type name (void) \
187 return syscall(__NR_##name); \
190 #define _syscall1(type,name,type1,arg1) \
191 static type name (type1 arg1) \
193 return syscall(__NR_##name, arg1); \
196 #define _syscall2(type,name,type1,arg1,type2,arg2) \
197 static type name (type1 arg1,type2 arg2) \
199 return syscall(__NR_##name, arg1, arg2); \
202 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
203 static type name (type1 arg1,type2 arg2,type3 arg3) \
205 return syscall(__NR_##name, arg1, arg2, arg3); \
208 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
209 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
211 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
214 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
216 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
218 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
222 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
223 type5,arg5,type6,arg6) \
224 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
227 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
231 #define __NR_sys_uname __NR_uname
232 #define __NR_sys_getcwd1 __NR_getcwd
233 #define __NR_sys_getdents __NR_getdents
234 #define __NR_sys_getdents64 __NR_getdents64
235 #define __NR_sys_getpriority __NR_getpriority
236 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
237 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
238 #define __NR_sys_syslog __NR_syslog
239 #define __NR_sys_futex __NR_futex
240 #define __NR_sys_inotify_init __NR_inotify_init
241 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
242 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
244 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
245 #define __NR__llseek __NR_lseek
248 /* Newer kernel ports have llseek() instead of _llseek() */
249 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
250 #define TARGET_NR__llseek TARGET_NR_llseek
254 _syscall0(int, gettid
)
256 /* This is a replacement for the host gettid() and must return a host
258 static int gettid(void) {
263 /* For the 64-bit guest on 32-bit host case we must emulate
264 * getdents using getdents64, because otherwise the host
265 * might hand us back more dirent records than we can fit
266 * into the guest buffer after structure format conversion.
267 * Otherwise we emulate getdents with getdents if the host has it.
269 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
270 #define EMULATE_GETDENTS_WITH_GETDENTS
273 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
274 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
276 #if (defined(TARGET_NR_getdents) && \
277 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
278 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
279 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
281 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
282 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
283 loff_t
*, res
, uint
, wh
);
285 _syscall3(int, sys_rt_sigqueueinfo
, pid_t
, pid
, int, sig
, siginfo_t
*, uinfo
)
286 _syscall4(int, sys_rt_tgsigqueueinfo
, pid_t
, pid
, pid_t
, tid
, int, sig
,
288 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
289 #ifdef __NR_exit_group
290 _syscall1(int,exit_group
,int,error_code
)
292 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
293 _syscall1(int,set_tid_address
,int *,tidptr
)
295 #if defined(TARGET_NR_futex) && defined(__NR_futex)
296 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
297 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
299 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
300 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
301 unsigned long *, user_mask_ptr
);
302 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
303 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
304 unsigned long *, user_mask_ptr
);
305 #define __NR_sys_getcpu __NR_getcpu
306 _syscall3(int, sys_getcpu
, unsigned *, cpu
, unsigned *, node
, void *, tcache
);
307 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
309 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
310 struct __user_cap_data_struct
*, data
);
311 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
312 struct __user_cap_data_struct
*, data
);
313 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
314 _syscall2(int, ioprio_get
, int, which
, int, who
)
316 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
317 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
319 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
320 _syscall3(int, getrandom
, void *, buf
, size_t, buflen
, unsigned int, flags
)
323 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
324 _syscall5(int, kcmp
, pid_t
, pid1
, pid_t
, pid2
, int, type
,
325 unsigned long, idx1
, unsigned long, idx2
)
328 static bitmask_transtbl fcntl_flags_tbl
[] = {
329 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
330 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
331 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
332 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
333 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
334 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
335 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
336 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
337 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
338 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
339 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
340 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
341 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
342 #if defined(O_DIRECT)
343 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
345 #if defined(O_NOATIME)
346 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
348 #if defined(O_CLOEXEC)
349 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
352 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
354 #if defined(O_TMPFILE)
355 { TARGET_O_TMPFILE
, TARGET_O_TMPFILE
, O_TMPFILE
, O_TMPFILE
},
357 /* Don't terminate the list prematurely on 64-bit host+guest. */
358 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
359 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
366 QEMU_IFLA_BR_FORWARD_DELAY
,
367 QEMU_IFLA_BR_HELLO_TIME
,
368 QEMU_IFLA_BR_MAX_AGE
,
369 QEMU_IFLA_BR_AGEING_TIME
,
370 QEMU_IFLA_BR_STP_STATE
,
371 QEMU_IFLA_BR_PRIORITY
,
372 QEMU_IFLA_BR_VLAN_FILTERING
,
373 QEMU_IFLA_BR_VLAN_PROTOCOL
,
374 QEMU_IFLA_BR_GROUP_FWD_MASK
,
375 QEMU_IFLA_BR_ROOT_ID
,
376 QEMU_IFLA_BR_BRIDGE_ID
,
377 QEMU_IFLA_BR_ROOT_PORT
,
378 QEMU_IFLA_BR_ROOT_PATH_COST
,
379 QEMU_IFLA_BR_TOPOLOGY_CHANGE
,
380 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED
,
381 QEMU_IFLA_BR_HELLO_TIMER
,
382 QEMU_IFLA_BR_TCN_TIMER
,
383 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER
,
384 QEMU_IFLA_BR_GC_TIMER
,
385 QEMU_IFLA_BR_GROUP_ADDR
,
386 QEMU_IFLA_BR_FDB_FLUSH
,
387 QEMU_IFLA_BR_MCAST_ROUTER
,
388 QEMU_IFLA_BR_MCAST_SNOOPING
,
389 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR
,
390 QEMU_IFLA_BR_MCAST_QUERIER
,
391 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY
,
392 QEMU_IFLA_BR_MCAST_HASH_MAX
,
393 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT
,
394 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT
,
395 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL
,
396 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL
,
397 QEMU_IFLA_BR_MCAST_QUERIER_INTVL
,
398 QEMU_IFLA_BR_MCAST_QUERY_INTVL
,
399 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL
,
400 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL
,
401 QEMU_IFLA_BR_NF_CALL_IPTABLES
,
402 QEMU_IFLA_BR_NF_CALL_IP6TABLES
,
403 QEMU_IFLA_BR_NF_CALL_ARPTABLES
,
404 QEMU_IFLA_BR_VLAN_DEFAULT_PVID
,
406 QEMU_IFLA_BR_VLAN_STATS_ENABLED
,
407 QEMU_IFLA_BR_MCAST_STATS_ENABLED
,
408 QEMU_IFLA_BR_MCAST_IGMP_VERSION
,
409 QEMU_IFLA_BR_MCAST_MLD_VERSION
,
433 QEMU_IFLA_NET_NS_PID
,
436 QEMU_IFLA_VFINFO_LIST
,
444 QEMU_IFLA_PROMISCUITY
,
445 QEMU_IFLA_NUM_TX_QUEUES
,
446 QEMU_IFLA_NUM_RX_QUEUES
,
448 QEMU_IFLA_PHYS_PORT_ID
,
449 QEMU_IFLA_CARRIER_CHANGES
,
450 QEMU_IFLA_PHYS_SWITCH_ID
,
451 QEMU_IFLA_LINK_NETNSID
,
452 QEMU_IFLA_PHYS_PORT_NAME
,
453 QEMU_IFLA_PROTO_DOWN
,
454 QEMU_IFLA_GSO_MAX_SEGS
,
455 QEMU_IFLA_GSO_MAX_SIZE
,
459 QEMU_IFLA_NEW_NETNSID
,
460 QEMU_IFLA_IF_NETNSID
,
461 QEMU_IFLA_CARRIER_UP_COUNT
,
462 QEMU_IFLA_CARRIER_DOWN_COUNT
,
463 QEMU_IFLA_NEW_IFINDEX
,
468 QEMU_IFLA_BRPORT_UNSPEC
,
469 QEMU_IFLA_BRPORT_STATE
,
470 QEMU_IFLA_BRPORT_PRIORITY
,
471 QEMU_IFLA_BRPORT_COST
,
472 QEMU_IFLA_BRPORT_MODE
,
473 QEMU_IFLA_BRPORT_GUARD
,
474 QEMU_IFLA_BRPORT_PROTECT
,
475 QEMU_IFLA_BRPORT_FAST_LEAVE
,
476 QEMU_IFLA_BRPORT_LEARNING
,
477 QEMU_IFLA_BRPORT_UNICAST_FLOOD
,
478 QEMU_IFLA_BRPORT_PROXYARP
,
479 QEMU_IFLA_BRPORT_LEARNING_SYNC
,
480 QEMU_IFLA_BRPORT_PROXYARP_WIFI
,
481 QEMU_IFLA_BRPORT_ROOT_ID
,
482 QEMU_IFLA_BRPORT_BRIDGE_ID
,
483 QEMU_IFLA_BRPORT_DESIGNATED_PORT
,
484 QEMU_IFLA_BRPORT_DESIGNATED_COST
,
487 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK
,
488 QEMU_IFLA_BRPORT_CONFIG_PENDING
,
489 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER
,
490 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER
,
491 QEMU_IFLA_BRPORT_HOLD_TIMER
,
492 QEMU_IFLA_BRPORT_FLUSH
,
493 QEMU_IFLA_BRPORT_MULTICAST_ROUTER
,
494 QEMU_IFLA_BRPORT_PAD
,
495 QEMU_IFLA_BRPORT_MCAST_FLOOD
,
496 QEMU_IFLA_BRPORT_MCAST_TO_UCAST
,
497 QEMU_IFLA_BRPORT_VLAN_TUNNEL
,
498 QEMU_IFLA_BRPORT_BCAST_FLOOD
,
499 QEMU_IFLA_BRPORT_GROUP_FWD_MASK
,
500 QEMU_IFLA_BRPORT_NEIGH_SUPPRESS
,
501 QEMU___IFLA_BRPORT_MAX
505 QEMU_IFLA_INFO_UNSPEC
,
508 QEMU_IFLA_INFO_XSTATS
,
509 QEMU_IFLA_INFO_SLAVE_KIND
,
510 QEMU_IFLA_INFO_SLAVE_DATA
,
511 QEMU___IFLA_INFO_MAX
,
515 QEMU_IFLA_INET_UNSPEC
,
517 QEMU___IFLA_INET_MAX
,
521 QEMU_IFLA_INET6_UNSPEC
,
522 QEMU_IFLA_INET6_FLAGS
,
523 QEMU_IFLA_INET6_CONF
,
524 QEMU_IFLA_INET6_STATS
,
525 QEMU_IFLA_INET6_MCAST
,
526 QEMU_IFLA_INET6_CACHEINFO
,
527 QEMU_IFLA_INET6_ICMP6STATS
,
528 QEMU_IFLA_INET6_TOKEN
,
529 QEMU_IFLA_INET6_ADDR_GEN_MODE
,
530 QEMU___IFLA_INET6_MAX
534 QEMU_IFLA_XDP_UNSPEC
,
536 QEMU_IFLA_XDP_ATTACHED
,
538 QEMU_IFLA_XDP_PROG_ID
,
542 typedef abi_long (*TargetFdDataFunc
)(void *, size_t);
543 typedef abi_long (*TargetFdAddrFunc
)(void *, abi_ulong
, socklen_t
);
544 typedef struct TargetFdTrans
{
545 TargetFdDataFunc host_to_target_data
;
546 TargetFdDataFunc target_to_host_data
;
547 TargetFdAddrFunc target_to_host_addr
;
550 static TargetFdTrans
**target_fd_trans
;
552 static unsigned int target_fd_max
;
554 static TargetFdDataFunc
fd_trans_target_to_host_data(int fd
)
556 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
557 return target_fd_trans
[fd
]->target_to_host_data
;
562 static TargetFdDataFunc
fd_trans_host_to_target_data(int fd
)
564 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
565 return target_fd_trans
[fd
]->host_to_target_data
;
570 static TargetFdAddrFunc
fd_trans_target_to_host_addr(int fd
)
572 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
573 return target_fd_trans
[fd
]->target_to_host_addr
;
578 static void fd_trans_register(int fd
, TargetFdTrans
*trans
)
582 if (fd
>= target_fd_max
) {
583 oldmax
= target_fd_max
;
584 target_fd_max
= ((fd
>> 6) + 1) << 6; /* by slice of 64 entries */
585 target_fd_trans
= g_renew(TargetFdTrans
*,
586 target_fd_trans
, target_fd_max
);
587 memset((void *)(target_fd_trans
+ oldmax
), 0,
588 (target_fd_max
- oldmax
) * sizeof(TargetFdTrans
*));
590 target_fd_trans
[fd
] = trans
;
593 static void fd_trans_unregister(int fd
)
595 if (fd
>= 0 && fd
< target_fd_max
) {
596 target_fd_trans
[fd
] = NULL
;
600 static void fd_trans_dup(int oldfd
, int newfd
)
602 fd_trans_unregister(newfd
);
603 if (oldfd
< target_fd_max
&& target_fd_trans
[oldfd
]) {
604 fd_trans_register(newfd
, target_fd_trans
[oldfd
]);
608 static int sys_getcwd1(char *buf
, size_t size
)
610 if (getcwd(buf
, size
) == NULL
) {
611 /* getcwd() sets errno */
614 return strlen(buf
)+1;
617 #ifdef TARGET_NR_utimensat
618 #if defined(__NR_utimensat)
619 #define __NR_sys_utimensat __NR_utimensat
620 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
621 const struct timespec
*,tsp
,int,flags
)
623 static int sys_utimensat(int dirfd
, const char *pathname
,
624 const struct timespec times
[2], int flags
)
630 #endif /* TARGET_NR_utimensat */
632 #ifdef TARGET_NR_renameat2
633 #if defined(__NR_renameat2)
634 #define __NR_sys_renameat2 __NR_renameat2
635 _syscall5(int, sys_renameat2
, int, oldfd
, const char *, old
, int, newfd
,
636 const char *, new, unsigned int, flags
)
638 static int sys_renameat2(int oldfd
, const char *old
,
639 int newfd
, const char *new, int flags
)
642 return renameat(oldfd
, old
, newfd
, new);
648 #endif /* TARGET_NR_renameat2 */
650 #ifdef CONFIG_INOTIFY
651 #include <sys/inotify.h>
653 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
654 static int sys_inotify_init(void)
656 return (inotify_init());
659 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
660 static int sys_inotify_add_watch(int fd
,const char *pathname
, int32_t mask
)
662 return (inotify_add_watch(fd
, pathname
, mask
));
665 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
666 static int sys_inotify_rm_watch(int fd
, int32_t wd
)
668 return (inotify_rm_watch(fd
, wd
));
671 #ifdef CONFIG_INOTIFY1
672 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
673 static int sys_inotify_init1(int flags
)
675 return (inotify_init1(flags
));
680 /* Userspace can usually survive runtime without inotify */
681 #undef TARGET_NR_inotify_init
682 #undef TARGET_NR_inotify_init1
683 #undef TARGET_NR_inotify_add_watch
684 #undef TARGET_NR_inotify_rm_watch
685 #endif /* CONFIG_INOTIFY */
687 #if defined(TARGET_NR_prlimit64)
688 #ifndef __NR_prlimit64
689 # define __NR_prlimit64 -1
691 #define __NR_sys_prlimit64 __NR_prlimit64
692 /* The glibc rlimit structure may not be that used by the underlying syscall */
693 struct host_rlimit64
{
697 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
698 const struct host_rlimit64
*, new_limit
,
699 struct host_rlimit64
*, old_limit
)
703 #if defined(TARGET_NR_timer_create)
704 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
705 static timer_t g_posix_timers
[32] = { 0, } ;
707 static inline int next_free_host_timer(void)
710 /* FIXME: Does finding the next free slot require a lock? */
711 for (k
= 0; k
< ARRAY_SIZE(g_posix_timers
); k
++) {
712 if (g_posix_timers
[k
] == 0) {
713 g_posix_timers
[k
] = (timer_t
) 1;
721 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
723 static inline int regpairs_aligned(void *cpu_env
, int num
)
725 return ((((CPUARMState
*)cpu_env
)->eabi
) == 1) ;
727 #elif defined(TARGET_MIPS) && (TARGET_ABI_BITS == 32)
728 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
729 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
730 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
731 * of registers which translates to the same as ARM/MIPS, because we start with
733 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
734 #elif defined(TARGET_SH4)
735 /* SH4 doesn't align register pairs, except for p{read,write}64 */
736 static inline int regpairs_aligned(void *cpu_env
, int num
)
739 case TARGET_NR_pread64
:
740 case TARGET_NR_pwrite64
:
747 #elif defined(TARGET_XTENSA)
748 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
750 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 0; }
753 #define ERRNO_TABLE_SIZE 1200
755 /* target_to_host_errno_table[] is initialized from
756 * host_to_target_errno_table[] in syscall_init(). */
757 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
761 * This list is the union of errno values overridden in asm-<arch>/errno.h
762 * minus the errnos that are not actually generic to all archs.
764 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
765 [EAGAIN
] = TARGET_EAGAIN
,
766 [EIDRM
] = TARGET_EIDRM
,
767 [ECHRNG
] = TARGET_ECHRNG
,
768 [EL2NSYNC
] = TARGET_EL2NSYNC
,
769 [EL3HLT
] = TARGET_EL3HLT
,
770 [EL3RST
] = TARGET_EL3RST
,
771 [ELNRNG
] = TARGET_ELNRNG
,
772 [EUNATCH
] = TARGET_EUNATCH
,
773 [ENOCSI
] = TARGET_ENOCSI
,
774 [EL2HLT
] = TARGET_EL2HLT
,
775 [EDEADLK
] = TARGET_EDEADLK
,
776 [ENOLCK
] = TARGET_ENOLCK
,
777 [EBADE
] = TARGET_EBADE
,
778 [EBADR
] = TARGET_EBADR
,
779 [EXFULL
] = TARGET_EXFULL
,
780 [ENOANO
] = TARGET_ENOANO
,
781 [EBADRQC
] = TARGET_EBADRQC
,
782 [EBADSLT
] = TARGET_EBADSLT
,
783 [EBFONT
] = TARGET_EBFONT
,
784 [ENOSTR
] = TARGET_ENOSTR
,
785 [ENODATA
] = TARGET_ENODATA
,
786 [ETIME
] = TARGET_ETIME
,
787 [ENOSR
] = TARGET_ENOSR
,
788 [ENONET
] = TARGET_ENONET
,
789 [ENOPKG
] = TARGET_ENOPKG
,
790 [EREMOTE
] = TARGET_EREMOTE
,
791 [ENOLINK
] = TARGET_ENOLINK
,
792 [EADV
] = TARGET_EADV
,
793 [ESRMNT
] = TARGET_ESRMNT
,
794 [ECOMM
] = TARGET_ECOMM
,
795 [EPROTO
] = TARGET_EPROTO
,
796 [EDOTDOT
] = TARGET_EDOTDOT
,
797 [EMULTIHOP
] = TARGET_EMULTIHOP
,
798 [EBADMSG
] = TARGET_EBADMSG
,
799 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
800 [EOVERFLOW
] = TARGET_EOVERFLOW
,
801 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
802 [EBADFD
] = TARGET_EBADFD
,
803 [EREMCHG
] = TARGET_EREMCHG
,
804 [ELIBACC
] = TARGET_ELIBACC
,
805 [ELIBBAD
] = TARGET_ELIBBAD
,
806 [ELIBSCN
] = TARGET_ELIBSCN
,
807 [ELIBMAX
] = TARGET_ELIBMAX
,
808 [ELIBEXEC
] = TARGET_ELIBEXEC
,
809 [EILSEQ
] = TARGET_EILSEQ
,
810 [ENOSYS
] = TARGET_ENOSYS
,
811 [ELOOP
] = TARGET_ELOOP
,
812 [ERESTART
] = TARGET_ERESTART
,
813 [ESTRPIPE
] = TARGET_ESTRPIPE
,
814 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
815 [EUSERS
] = TARGET_EUSERS
,
816 [ENOTSOCK
] = TARGET_ENOTSOCK
,
817 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
818 [EMSGSIZE
] = TARGET_EMSGSIZE
,
819 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
820 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
821 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
822 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
823 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
824 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
825 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
826 [EADDRINUSE
] = TARGET_EADDRINUSE
,
827 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
828 [ENETDOWN
] = TARGET_ENETDOWN
,
829 [ENETUNREACH
] = TARGET_ENETUNREACH
,
830 [ENETRESET
] = TARGET_ENETRESET
,
831 [ECONNABORTED
] = TARGET_ECONNABORTED
,
832 [ECONNRESET
] = TARGET_ECONNRESET
,
833 [ENOBUFS
] = TARGET_ENOBUFS
,
834 [EISCONN
] = TARGET_EISCONN
,
835 [ENOTCONN
] = TARGET_ENOTCONN
,
836 [EUCLEAN
] = TARGET_EUCLEAN
,
837 [ENOTNAM
] = TARGET_ENOTNAM
,
838 [ENAVAIL
] = TARGET_ENAVAIL
,
839 [EISNAM
] = TARGET_EISNAM
,
840 [EREMOTEIO
] = TARGET_EREMOTEIO
,
841 [EDQUOT
] = TARGET_EDQUOT
,
842 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
843 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
844 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
845 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
846 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
847 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
848 [EALREADY
] = TARGET_EALREADY
,
849 [EINPROGRESS
] = TARGET_EINPROGRESS
,
850 [ESTALE
] = TARGET_ESTALE
,
851 [ECANCELED
] = TARGET_ECANCELED
,
852 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
853 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
855 [ENOKEY
] = TARGET_ENOKEY
,
858 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
861 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
864 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
867 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
869 #ifdef ENOTRECOVERABLE
870 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
873 [ENOMSG
] = TARGET_ENOMSG
,
876 [ERFKILL
] = TARGET_ERFKILL
,
879 [EHWPOISON
] = TARGET_EHWPOISON
,
883 static inline int host_to_target_errno(int err
)
885 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
886 host_to_target_errno_table
[err
]) {
887 return host_to_target_errno_table
[err
];
892 static inline int target_to_host_errno(int err
)
894 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
895 target_to_host_errno_table
[err
]) {
896 return target_to_host_errno_table
[err
];
901 static inline abi_long
get_errno(abi_long ret
)
904 return -host_to_target_errno(errno
);
909 const char *target_strerror(int err
)
911 if (err
== TARGET_ERESTARTSYS
) {
912 return "To be restarted";
914 if (err
== TARGET_QEMU_ESIGRETURN
) {
915 return "Successful exit from sigreturn";
918 if ((err
>= ERRNO_TABLE_SIZE
) || (err
< 0)) {
921 return strerror(target_to_host_errno(err
));
924 #define safe_syscall0(type, name) \
925 static type safe_##name(void) \
927 return safe_syscall(__NR_##name); \
930 #define safe_syscall1(type, name, type1, arg1) \
931 static type safe_##name(type1 arg1) \
933 return safe_syscall(__NR_##name, arg1); \
936 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
937 static type safe_##name(type1 arg1, type2 arg2) \
939 return safe_syscall(__NR_##name, arg1, arg2); \
942 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
943 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
945 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
948 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
950 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
952 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
955 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
956 type4, arg4, type5, arg5) \
957 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
960 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
963 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
964 type4, arg4, type5, arg5, type6, arg6) \
965 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
966 type5 arg5, type6 arg6) \
968 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
971 safe_syscall3(ssize_t
, read
, int, fd
, void *, buff
, size_t, count
)
972 safe_syscall3(ssize_t
, write
, int, fd
, const void *, buff
, size_t, count
)
973 safe_syscall4(int, openat
, int, dirfd
, const char *, pathname
, \
974 int, flags
, mode_t
, mode
)
975 safe_syscall4(pid_t
, wait4
, pid_t
, pid
, int *, status
, int, options
, \
976 struct rusage
*, rusage
)
977 safe_syscall5(int, waitid
, idtype_t
, idtype
, id_t
, id
, siginfo_t
*, infop
, \
978 int, options
, struct rusage
*, rusage
)
979 safe_syscall3(int, execve
, const char *, filename
, char **, argv
, char **, envp
)
980 safe_syscall6(int, pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
, \
981 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
)
982 safe_syscall5(int, ppoll
, struct pollfd
*, ufds
, unsigned int, nfds
,
983 struct timespec
*, tsp
, const sigset_t
*, sigmask
,
985 safe_syscall6(int, epoll_pwait
, int, epfd
, struct epoll_event
*, events
,
986 int, maxevents
, int, timeout
, const sigset_t
*, sigmask
,
988 safe_syscall6(int,futex
,int *,uaddr
,int,op
,int,val
, \
989 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
990 safe_syscall2(int, rt_sigsuspend
, sigset_t
*, newset
, size_t, sigsetsize
)
991 safe_syscall2(int, kill
, pid_t
, pid
, int, sig
)
992 safe_syscall2(int, tkill
, int, tid
, int, sig
)
993 safe_syscall3(int, tgkill
, int, tgid
, int, pid
, int, sig
)
994 safe_syscall3(ssize_t
, readv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
995 safe_syscall3(ssize_t
, writev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
996 safe_syscall5(ssize_t
, preadv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
997 unsigned long, pos_l
, unsigned long, pos_h
)
998 safe_syscall5(ssize_t
, pwritev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
999 unsigned long, pos_l
, unsigned long, pos_h
)
1000 safe_syscall3(int, connect
, int, fd
, const struct sockaddr
*, addr
,
1002 safe_syscall6(ssize_t
, sendto
, int, fd
, const void *, buf
, size_t, len
,
1003 int, flags
, const struct sockaddr
*, addr
, socklen_t
, addrlen
)
1004 safe_syscall6(ssize_t
, recvfrom
, int, fd
, void *, buf
, size_t, len
,
1005 int, flags
, struct sockaddr
*, addr
, socklen_t
*, addrlen
)
1006 safe_syscall3(ssize_t
, sendmsg
, int, fd
, const struct msghdr
*, msg
, int, flags
)
1007 safe_syscall3(ssize_t
, recvmsg
, int, fd
, struct msghdr
*, msg
, int, flags
)
1008 safe_syscall2(int, flock
, int, fd
, int, operation
)
1009 safe_syscall4(int, rt_sigtimedwait
, const sigset_t
*, these
, siginfo_t
*, uinfo
,
1010 const struct timespec
*, uts
, size_t, sigsetsize
)
1011 safe_syscall4(int, accept4
, int, fd
, struct sockaddr
*, addr
, socklen_t
*, len
,
1013 safe_syscall2(int, nanosleep
, const struct timespec
*, req
,
1014 struct timespec
*, rem
)
1015 #ifdef TARGET_NR_clock_nanosleep
1016 safe_syscall4(int, clock_nanosleep
, const clockid_t
, clock
, int, flags
,
1017 const struct timespec
*, req
, struct timespec
*, rem
)
1020 safe_syscall4(int, msgsnd
, int, msgid
, const void *, msgp
, size_t, sz
,
1022 safe_syscall5(int, msgrcv
, int, msgid
, void *, msgp
, size_t, sz
,
1023 long, msgtype
, int, flags
)
1024 safe_syscall4(int, semtimedop
, int, semid
, struct sembuf
*, tsops
,
1025 unsigned, nsops
, const struct timespec
*, timeout
)
1027 /* This host kernel architecture uses a single ipc syscall; fake up
1028 * wrappers for the sub-operations to hide this implementation detail.
1029 * Annoyingly we can't include linux/ipc.h to get the constant definitions
1030 * for the call parameter because some structs in there conflict with the
1031 * sys/ipc.h ones. So we just define them here, and rely on them being
1032 * the same for all host architectures.
1034 #define Q_SEMTIMEDOP 4
1037 #define Q_IPCCALL(VERSION, OP) ((VERSION) << 16 | (OP))
1039 safe_syscall6(int, ipc
, int, call
, long, first
, long, second
, long, third
,
1040 void *, ptr
, long, fifth
)
1041 static int safe_msgsnd(int msgid
, const void *msgp
, size_t sz
, int flags
)
1043 return safe_ipc(Q_IPCCALL(0, Q_MSGSND
), msgid
, sz
, flags
, (void *)msgp
, 0);
1045 static int safe_msgrcv(int msgid
, void *msgp
, size_t sz
, long type
, int flags
)
1047 return safe_ipc(Q_IPCCALL(1, Q_MSGRCV
), msgid
, sz
, flags
, msgp
, type
);
1049 static int safe_semtimedop(int semid
, struct sembuf
*tsops
, unsigned nsops
,
1050 const struct timespec
*timeout
)
1052 return safe_ipc(Q_IPCCALL(0, Q_SEMTIMEDOP
), semid
, nsops
, 0, tsops
,
1056 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1057 safe_syscall5(int, mq_timedsend
, int, mqdes
, const char *, msg_ptr
,
1058 size_t, len
, unsigned, prio
, const struct timespec
*, timeout
)
1059 safe_syscall5(int, mq_timedreceive
, int, mqdes
, char *, msg_ptr
,
1060 size_t, len
, unsigned *, prio
, const struct timespec
*, timeout
)
1062 /* We do ioctl like this rather than via safe_syscall3 to preserve the
1063 * "third argument might be integer or pointer or not present" behaviour of
1064 * the libc function.
1066 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
1067 /* Similarly for fcntl. Note that callers must always:
1068 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
1069 * use the flock64 struct rather than unsuffixed flock
1070 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
1073 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
1075 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
1078 static inline int host_to_target_sock_type(int host_type
)
1082 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
1084 target_type
= TARGET_SOCK_DGRAM
;
1087 target_type
= TARGET_SOCK_STREAM
;
1090 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
1094 #if defined(SOCK_CLOEXEC)
1095 if (host_type
& SOCK_CLOEXEC
) {
1096 target_type
|= TARGET_SOCK_CLOEXEC
;
1100 #if defined(SOCK_NONBLOCK)
1101 if (host_type
& SOCK_NONBLOCK
) {
1102 target_type
|= TARGET_SOCK_NONBLOCK
;
1109 static abi_ulong target_brk
;
1110 static abi_ulong target_original_brk
;
1111 static abi_ulong brk_page
;
1113 void target_set_brk(abi_ulong new_brk
)
1115 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
1116 brk_page
= HOST_PAGE_ALIGN(target_brk
);
1119 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
1120 #define DEBUGF_BRK(message, args...)
1122 /* do_brk() must return target values and target errnos. */
1123 abi_long
do_brk(abi_ulong new_brk
)
1125 abi_long mapped_addr
;
1126 abi_ulong new_alloc_size
;
1128 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx
") -> ", new_brk
);
1131 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (!new_brk)\n", target_brk
);
1134 if (new_brk
< target_original_brk
) {
1135 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk < target_original_brk)\n",
1140 /* If the new brk is less than the highest page reserved to the
1141 * target heap allocation, set it and we're almost done... */
1142 if (new_brk
<= brk_page
) {
1143 /* Heap contents are initialized to zero, as for anonymous
1145 if (new_brk
> target_brk
) {
1146 memset(g2h(target_brk
), 0, new_brk
- target_brk
);
1148 target_brk
= new_brk
;
1149 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk <= brk_page)\n", target_brk
);
1153 /* We need to allocate more memory after the brk... Note that
1154 * we don't use MAP_FIXED because that will map over the top of
1155 * any existing mapping (like the one with the host libc or qemu
1156 * itself); instead we treat "mapped but at wrong address" as
1157 * a failure and unmap again.
1159 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
);
1160 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
1161 PROT_READ
|PROT_WRITE
,
1162 MAP_ANON
|MAP_PRIVATE
, 0, 0));
1164 if (mapped_addr
== brk_page
) {
1165 /* Heap contents are initialized to zero, as for anonymous
1166 * mapped pages. Technically the new pages are already
1167 * initialized to zero since they *are* anonymous mapped
1168 * pages, however we have to take care with the contents that
1169 * come from the remaining part of the previous page: it may
1170 * contains garbage data due to a previous heap usage (grown
1171 * then shrunken). */
1172 memset(g2h(target_brk
), 0, brk_page
- target_brk
);
1174 target_brk
= new_brk
;
1175 brk_page
= HOST_PAGE_ALIGN(target_brk
);
1176 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr == brk_page)\n",
1179 } else if (mapped_addr
!= -1) {
1180 /* Mapped but at wrong address, meaning there wasn't actually
1181 * enough space for this brk.
1183 target_munmap(mapped_addr
, new_alloc_size
);
1185 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr != -1)\n", target_brk
);
1188 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (otherwise)\n", target_brk
);
1191 #if defined(TARGET_ALPHA)
1192 /* We (partially) emulate OSF/1 on Alpha, which requires we
1193 return a proper errno, not an unchanged brk value. */
1194 return -TARGET_ENOMEM
;
1196 /* For everything else, return the previous break. */
1200 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
1201 abi_ulong target_fds_addr
,
1205 abi_ulong b
, *target_fds
;
1207 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
1208 if (!(target_fds
= lock_user(VERIFY_READ
,
1210 sizeof(abi_ulong
) * nw
,
1212 return -TARGET_EFAULT
;
1216 for (i
= 0; i
< nw
; i
++) {
1217 /* grab the abi_ulong */
1218 __get_user(b
, &target_fds
[i
]);
1219 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1220 /* check the bit inside the abi_ulong */
1227 unlock_user(target_fds
, target_fds_addr
, 0);
1232 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
1233 abi_ulong target_fds_addr
,
1236 if (target_fds_addr
) {
1237 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
1238 return -TARGET_EFAULT
;
1246 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
1252 abi_ulong
*target_fds
;
1254 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
1255 if (!(target_fds
= lock_user(VERIFY_WRITE
,
1257 sizeof(abi_ulong
) * nw
,
1259 return -TARGET_EFAULT
;
1262 for (i
= 0; i
< nw
; i
++) {
1264 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1265 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
1268 __put_user(v
, &target_fds
[i
]);
1271 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
1276 #if defined(__alpha__)
1277 #define HOST_HZ 1024
1282 static inline abi_long
host_to_target_clock_t(long ticks
)
1284 #if HOST_HZ == TARGET_HZ
1287 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
1291 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
1292 const struct rusage
*rusage
)
1294 struct target_rusage
*target_rusage
;
1296 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
1297 return -TARGET_EFAULT
;
1298 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
1299 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
1300 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
1301 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
1302 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
1303 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
1304 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
1305 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
1306 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
1307 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
1308 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
1309 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
1310 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
1311 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
1312 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
1313 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
1314 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
1315 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
1316 unlock_user_struct(target_rusage
, target_addr
, 1);
1321 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
1323 abi_ulong target_rlim_swap
;
1326 target_rlim_swap
= tswapal(target_rlim
);
1327 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
1328 return RLIM_INFINITY
;
1330 result
= target_rlim_swap
;
1331 if (target_rlim_swap
!= (rlim_t
)result
)
1332 return RLIM_INFINITY
;
1337 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
1339 abi_ulong target_rlim_swap
;
1342 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
1343 target_rlim_swap
= TARGET_RLIM_INFINITY
;
1345 target_rlim_swap
= rlim
;
1346 result
= tswapal(target_rlim_swap
);
1351 static inline int target_to_host_resource(int code
)
1354 case TARGET_RLIMIT_AS
:
1356 case TARGET_RLIMIT_CORE
:
1358 case TARGET_RLIMIT_CPU
:
1360 case TARGET_RLIMIT_DATA
:
1362 case TARGET_RLIMIT_FSIZE
:
1363 return RLIMIT_FSIZE
;
1364 case TARGET_RLIMIT_LOCKS
:
1365 return RLIMIT_LOCKS
;
1366 case TARGET_RLIMIT_MEMLOCK
:
1367 return RLIMIT_MEMLOCK
;
1368 case TARGET_RLIMIT_MSGQUEUE
:
1369 return RLIMIT_MSGQUEUE
;
1370 case TARGET_RLIMIT_NICE
:
1372 case TARGET_RLIMIT_NOFILE
:
1373 return RLIMIT_NOFILE
;
1374 case TARGET_RLIMIT_NPROC
:
1375 return RLIMIT_NPROC
;
1376 case TARGET_RLIMIT_RSS
:
1378 case TARGET_RLIMIT_RTPRIO
:
1379 return RLIMIT_RTPRIO
;
1380 case TARGET_RLIMIT_SIGPENDING
:
1381 return RLIMIT_SIGPENDING
;
1382 case TARGET_RLIMIT_STACK
:
1383 return RLIMIT_STACK
;
1389 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
1390 abi_ulong target_tv_addr
)
1392 struct target_timeval
*target_tv
;
1394 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
1395 return -TARGET_EFAULT
;
1397 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1398 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1400 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1405 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
1406 const struct timeval
*tv
)
1408 struct target_timeval
*target_tv
;
1410 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
1411 return -TARGET_EFAULT
;
1413 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1414 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1416 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1421 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
1422 abi_ulong target_tz_addr
)
1424 struct target_timezone
*target_tz
;
1426 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
1427 return -TARGET_EFAULT
;
1430 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1431 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1433 unlock_user_struct(target_tz
, target_tz_addr
, 0);
1438 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1441 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
1442 abi_ulong target_mq_attr_addr
)
1444 struct target_mq_attr
*target_mq_attr
;
1446 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
1447 target_mq_attr_addr
, 1))
1448 return -TARGET_EFAULT
;
1450 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1451 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1452 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1453 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1455 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
1460 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
1461 const struct mq_attr
*attr
)
1463 struct target_mq_attr
*target_mq_attr
;
1465 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
1466 target_mq_attr_addr
, 0))
1467 return -TARGET_EFAULT
;
1469 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1470 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1471 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1472 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1474 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1480 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1481 /* do_select() must return target values and target errnos. */
1482 static abi_long
do_select(int n
,
1483 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1484 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1486 fd_set rfds
, wfds
, efds
;
1487 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1489 struct timespec ts
, *ts_ptr
;
1492 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1496 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1500 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1505 if (target_tv_addr
) {
1506 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1507 return -TARGET_EFAULT
;
1508 ts
.tv_sec
= tv
.tv_sec
;
1509 ts
.tv_nsec
= tv
.tv_usec
* 1000;
1515 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1518 if (!is_error(ret
)) {
1519 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1520 return -TARGET_EFAULT
;
1521 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1522 return -TARGET_EFAULT
;
1523 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1524 return -TARGET_EFAULT
;
1526 if (target_tv_addr
) {
1527 tv
.tv_sec
= ts
.tv_sec
;
1528 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
1529 if (copy_to_user_timeval(target_tv_addr
, &tv
)) {
1530 return -TARGET_EFAULT
;
1538 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1539 static abi_long
do_old_select(abi_ulong arg1
)
1541 struct target_sel_arg_struct
*sel
;
1542 abi_ulong inp
, outp
, exp
, tvp
;
1545 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1)) {
1546 return -TARGET_EFAULT
;
1549 nsel
= tswapal(sel
->n
);
1550 inp
= tswapal(sel
->inp
);
1551 outp
= tswapal(sel
->outp
);
1552 exp
= tswapal(sel
->exp
);
1553 tvp
= tswapal(sel
->tvp
);
1555 unlock_user_struct(sel
, arg1
, 0);
1557 return do_select(nsel
, inp
, outp
, exp
, tvp
);
1562 static abi_long
do_pipe2(int host_pipe
[], int flags
)
1565 return pipe2(host_pipe
, flags
);
1571 static abi_long
do_pipe(void *cpu_env
, abi_ulong pipedes
,
1572 int flags
, int is_pipe2
)
1576 ret
= flags
? do_pipe2(host_pipe
, flags
) : pipe(host_pipe
);
1579 return get_errno(ret
);
1581 /* Several targets have special calling conventions for the original
1582 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1584 #if defined(TARGET_ALPHA)
1585 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = host_pipe
[1];
1586 return host_pipe
[0];
1587 #elif defined(TARGET_MIPS)
1588 ((CPUMIPSState
*)cpu_env
)->active_tc
.gpr
[3] = host_pipe
[1];
1589 return host_pipe
[0];
1590 #elif defined(TARGET_SH4)
1591 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
1592 return host_pipe
[0];
1593 #elif defined(TARGET_SPARC)
1594 ((CPUSPARCState
*)cpu_env
)->regwptr
[1] = host_pipe
[1];
1595 return host_pipe
[0];
1599 if (put_user_s32(host_pipe
[0], pipedes
)
1600 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(host_pipe
[0])))
1601 return -TARGET_EFAULT
;
1602 return get_errno(ret
);
1605 static inline abi_long
target_to_host_ip_mreq(struct ip_mreqn
*mreqn
,
1606 abi_ulong target_addr
,
1609 struct target_ip_mreqn
*target_smreqn
;
1611 target_smreqn
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1613 return -TARGET_EFAULT
;
1614 mreqn
->imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
1615 mreqn
->imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
1616 if (len
== sizeof(struct target_ip_mreqn
))
1617 mreqn
->imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
1618 unlock_user(target_smreqn
, target_addr
, 0);
1623 static inline abi_long
target_to_host_sockaddr(int fd
, struct sockaddr
*addr
,
1624 abi_ulong target_addr
,
1627 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1628 sa_family_t sa_family
;
1629 struct target_sockaddr
*target_saddr
;
1631 if (fd_trans_target_to_host_addr(fd
)) {
1632 return fd_trans_target_to_host_addr(fd
)(addr
, target_addr
, len
);
1635 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1637 return -TARGET_EFAULT
;
1639 sa_family
= tswap16(target_saddr
->sa_family
);
1641 /* Oops. The caller might send a incomplete sun_path; sun_path
1642 * must be terminated by \0 (see the manual page), but
1643 * unfortunately it is quite common to specify sockaddr_un
1644 * length as "strlen(x->sun_path)" while it should be
1645 * "strlen(...) + 1". We'll fix that here if needed.
1646 * Linux kernel has a similar feature.
1649 if (sa_family
== AF_UNIX
) {
1650 if (len
< unix_maxlen
&& len
> 0) {
1651 char *cp
= (char*)target_saddr
;
1653 if ( cp
[len
-1] && !cp
[len
] )
1656 if (len
> unix_maxlen
)
1660 memcpy(addr
, target_saddr
, len
);
1661 addr
->sa_family
= sa_family
;
1662 if (sa_family
== AF_NETLINK
) {
1663 struct sockaddr_nl
*nladdr
;
1665 nladdr
= (struct sockaddr_nl
*)addr
;
1666 nladdr
->nl_pid
= tswap32(nladdr
->nl_pid
);
1667 nladdr
->nl_groups
= tswap32(nladdr
->nl_groups
);
1668 } else if (sa_family
== AF_PACKET
) {
1669 struct target_sockaddr_ll
*lladdr
;
1671 lladdr
= (struct target_sockaddr_ll
*)addr
;
1672 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1673 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1675 unlock_user(target_saddr
, target_addr
, 0);
1680 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1681 struct sockaddr
*addr
,
1684 struct target_sockaddr
*target_saddr
;
1691 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1693 return -TARGET_EFAULT
;
1694 memcpy(target_saddr
, addr
, len
);
1695 if (len
>= offsetof(struct target_sockaddr
, sa_family
) +
1696 sizeof(target_saddr
->sa_family
)) {
1697 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1699 if (addr
->sa_family
== AF_NETLINK
&& len
>= sizeof(struct sockaddr_nl
)) {
1700 struct sockaddr_nl
*target_nl
= (struct sockaddr_nl
*)target_saddr
;
1701 target_nl
->nl_pid
= tswap32(target_nl
->nl_pid
);
1702 target_nl
->nl_groups
= tswap32(target_nl
->nl_groups
);
1703 } else if (addr
->sa_family
== AF_PACKET
) {
1704 struct sockaddr_ll
*target_ll
= (struct sockaddr_ll
*)target_saddr
;
1705 target_ll
->sll_ifindex
= tswap32(target_ll
->sll_ifindex
);
1706 target_ll
->sll_hatype
= tswap16(target_ll
->sll_hatype
);
1707 } else if (addr
->sa_family
== AF_INET6
&&
1708 len
>= sizeof(struct target_sockaddr_in6
)) {
1709 struct target_sockaddr_in6
*target_in6
=
1710 (struct target_sockaddr_in6
*)target_saddr
;
1711 target_in6
->sin6_scope_id
= tswap16(target_in6
->sin6_scope_id
);
1713 unlock_user(target_saddr
, target_addr
, len
);
1718 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1719 struct target_msghdr
*target_msgh
)
1721 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1722 abi_long msg_controllen
;
1723 abi_ulong target_cmsg_addr
;
1724 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1725 socklen_t space
= 0;
1727 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1728 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1730 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1731 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1732 target_cmsg_start
= target_cmsg
;
1734 return -TARGET_EFAULT
;
1736 while (cmsg
&& target_cmsg
) {
1737 void *data
= CMSG_DATA(cmsg
);
1738 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1740 int len
= tswapal(target_cmsg
->cmsg_len
)
1741 - sizeof(struct target_cmsghdr
);
1743 space
+= CMSG_SPACE(len
);
1744 if (space
> msgh
->msg_controllen
) {
1745 space
-= CMSG_SPACE(len
);
1746 /* This is a QEMU bug, since we allocated the payload
1747 * area ourselves (unlike overflow in host-to-target
1748 * conversion, which is just the guest giving us a buffer
1749 * that's too small). It can't happen for the payload types
1750 * we currently support; if it becomes an issue in future
1751 * we would need to improve our allocation strategy to
1752 * something more intelligent than "twice the size of the
1753 * target buffer we're reading from".
1755 gemu_log("Host cmsg overflow\n");
1759 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1760 cmsg
->cmsg_level
= SOL_SOCKET
;
1762 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1764 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1765 cmsg
->cmsg_len
= CMSG_LEN(len
);
1767 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1768 int *fd
= (int *)data
;
1769 int *target_fd
= (int *)target_data
;
1770 int i
, numfds
= len
/ sizeof(int);
1772 for (i
= 0; i
< numfds
; i
++) {
1773 __get_user(fd
[i
], target_fd
+ i
);
1775 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1776 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1777 struct ucred
*cred
= (struct ucred
*)data
;
1778 struct target_ucred
*target_cred
=
1779 (struct target_ucred
*)target_data
;
1781 __get_user(cred
->pid
, &target_cred
->pid
);
1782 __get_user(cred
->uid
, &target_cred
->uid
);
1783 __get_user(cred
->gid
, &target_cred
->gid
);
1785 gemu_log("Unsupported ancillary data: %d/%d\n",
1786 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1787 memcpy(data
, target_data
, len
);
1790 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1791 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1794 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1796 msgh
->msg_controllen
= space
;
1800 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1801 struct msghdr
*msgh
)
1803 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1804 abi_long msg_controllen
;
1805 abi_ulong target_cmsg_addr
;
1806 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1807 socklen_t space
= 0;
1809 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1810 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1812 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1813 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1814 target_cmsg_start
= target_cmsg
;
1816 return -TARGET_EFAULT
;
1818 while (cmsg
&& target_cmsg
) {
1819 void *data
= CMSG_DATA(cmsg
);
1820 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1822 int len
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1823 int tgt_len
, tgt_space
;
1825 /* We never copy a half-header but may copy half-data;
1826 * this is Linux's behaviour in put_cmsg(). Note that
1827 * truncation here is a guest problem (which we report
1828 * to the guest via the CTRUNC bit), unlike truncation
1829 * in target_to_host_cmsg, which is a QEMU bug.
1831 if (msg_controllen
< sizeof(struct target_cmsghdr
)) {
1832 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1836 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1837 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1839 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1841 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1843 /* Payload types which need a different size of payload on
1844 * the target must adjust tgt_len here.
1847 switch (cmsg
->cmsg_level
) {
1849 switch (cmsg
->cmsg_type
) {
1851 tgt_len
= sizeof(struct target_timeval
);
1861 if (msg_controllen
< TARGET_CMSG_LEN(tgt_len
)) {
1862 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1863 tgt_len
= msg_controllen
- sizeof(struct target_cmsghdr
);
1866 /* We must now copy-and-convert len bytes of payload
1867 * into tgt_len bytes of destination space. Bear in mind
1868 * that in both source and destination we may be dealing
1869 * with a truncated value!
1871 switch (cmsg
->cmsg_level
) {
1873 switch (cmsg
->cmsg_type
) {
1876 int *fd
= (int *)data
;
1877 int *target_fd
= (int *)target_data
;
1878 int i
, numfds
= tgt_len
/ sizeof(int);
1880 for (i
= 0; i
< numfds
; i
++) {
1881 __put_user(fd
[i
], target_fd
+ i
);
1887 struct timeval
*tv
= (struct timeval
*)data
;
1888 struct target_timeval
*target_tv
=
1889 (struct target_timeval
*)target_data
;
1891 if (len
!= sizeof(struct timeval
) ||
1892 tgt_len
!= sizeof(struct target_timeval
)) {
1896 /* copy struct timeval to target */
1897 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1898 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1901 case SCM_CREDENTIALS
:
1903 struct ucred
*cred
= (struct ucred
*)data
;
1904 struct target_ucred
*target_cred
=
1905 (struct target_ucred
*)target_data
;
1907 __put_user(cred
->pid
, &target_cred
->pid
);
1908 __put_user(cred
->uid
, &target_cred
->uid
);
1909 __put_user(cred
->gid
, &target_cred
->gid
);
1918 switch (cmsg
->cmsg_type
) {
1921 uint32_t *v
= (uint32_t *)data
;
1922 uint32_t *t_int
= (uint32_t *)target_data
;
1924 if (len
!= sizeof(uint32_t) ||
1925 tgt_len
!= sizeof(uint32_t)) {
1928 __put_user(*v
, t_int
);
1934 struct sock_extended_err ee
;
1935 struct sockaddr_in offender
;
1937 struct errhdr_t
*errh
= (struct errhdr_t
*)data
;
1938 struct errhdr_t
*target_errh
=
1939 (struct errhdr_t
*)target_data
;
1941 if (len
!= sizeof(struct errhdr_t
) ||
1942 tgt_len
!= sizeof(struct errhdr_t
)) {
1945 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1946 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1947 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1948 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1949 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1950 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1951 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1952 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1953 (void *) &errh
->offender
, sizeof(errh
->offender
));
1962 switch (cmsg
->cmsg_type
) {
1965 uint32_t *v
= (uint32_t *)data
;
1966 uint32_t *t_int
= (uint32_t *)target_data
;
1968 if (len
!= sizeof(uint32_t) ||
1969 tgt_len
!= sizeof(uint32_t)) {
1972 __put_user(*v
, t_int
);
1978 struct sock_extended_err ee
;
1979 struct sockaddr_in6 offender
;
1981 struct errhdr6_t
*errh
= (struct errhdr6_t
*)data
;
1982 struct errhdr6_t
*target_errh
=
1983 (struct errhdr6_t
*)target_data
;
1985 if (len
!= sizeof(struct errhdr6_t
) ||
1986 tgt_len
!= sizeof(struct errhdr6_t
)) {
1989 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1990 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1991 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1992 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1993 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1994 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1995 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1996 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1997 (void *) &errh
->offender
, sizeof(errh
->offender
));
2007 gemu_log("Unsupported ancillary data: %d/%d\n",
2008 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
2009 memcpy(target_data
, data
, MIN(len
, tgt_len
));
2010 if (tgt_len
> len
) {
2011 memset(target_data
+ len
, 0, tgt_len
- len
);
2015 target_cmsg
->cmsg_len
= tswapal(TARGET_CMSG_LEN(tgt_len
));
2016 tgt_space
= TARGET_CMSG_SPACE(tgt_len
);
2017 if (msg_controllen
< tgt_space
) {
2018 tgt_space
= msg_controllen
;
2020 msg_controllen
-= tgt_space
;
2022 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
2023 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
2026 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
2028 target_msgh
->msg_controllen
= tswapal(space
);
2032 static void tswap_nlmsghdr(struct nlmsghdr
*nlh
)
2034 nlh
->nlmsg_len
= tswap32(nlh
->nlmsg_len
);
2035 nlh
->nlmsg_type
= tswap16(nlh
->nlmsg_type
);
2036 nlh
->nlmsg_flags
= tswap16(nlh
->nlmsg_flags
);
2037 nlh
->nlmsg_seq
= tswap32(nlh
->nlmsg_seq
);
2038 nlh
->nlmsg_pid
= tswap32(nlh
->nlmsg_pid
);
2041 static abi_long
host_to_target_for_each_nlmsg(struct nlmsghdr
*nlh
,
2043 abi_long (*host_to_target_nlmsg
)
2044 (struct nlmsghdr
*))
2049 while (len
> sizeof(struct nlmsghdr
)) {
2051 nlmsg_len
= nlh
->nlmsg_len
;
2052 if (nlmsg_len
< sizeof(struct nlmsghdr
) ||
2057 switch (nlh
->nlmsg_type
) {
2059 tswap_nlmsghdr(nlh
);
2065 struct nlmsgerr
*e
= NLMSG_DATA(nlh
);
2066 e
->error
= tswap32(e
->error
);
2067 tswap_nlmsghdr(&e
->msg
);
2068 tswap_nlmsghdr(nlh
);
2072 ret
= host_to_target_nlmsg(nlh
);
2074 tswap_nlmsghdr(nlh
);
2079 tswap_nlmsghdr(nlh
);
2080 len
-= NLMSG_ALIGN(nlmsg_len
);
2081 nlh
= (struct nlmsghdr
*)(((char*)nlh
) + NLMSG_ALIGN(nlmsg_len
));
2086 static abi_long
target_to_host_for_each_nlmsg(struct nlmsghdr
*nlh
,
2088 abi_long (*target_to_host_nlmsg
)
2089 (struct nlmsghdr
*))
2093 while (len
> sizeof(struct nlmsghdr
)) {
2094 if (tswap32(nlh
->nlmsg_len
) < sizeof(struct nlmsghdr
) ||
2095 tswap32(nlh
->nlmsg_len
) > len
) {
2098 tswap_nlmsghdr(nlh
);
2099 switch (nlh
->nlmsg_type
) {
2106 struct nlmsgerr
*e
= NLMSG_DATA(nlh
);
2107 e
->error
= tswap32(e
->error
);
2108 tswap_nlmsghdr(&e
->msg
);
2112 ret
= target_to_host_nlmsg(nlh
);
2117 len
-= NLMSG_ALIGN(nlh
->nlmsg_len
);
2118 nlh
= (struct nlmsghdr
*)(((char *)nlh
) + NLMSG_ALIGN(nlh
->nlmsg_len
));
2123 #ifdef CONFIG_RTNETLINK
2124 static abi_long
host_to_target_for_each_nlattr(struct nlattr
*nlattr
,
2125 size_t len
, void *context
,
2126 abi_long (*host_to_target_nlattr
)
2130 unsigned short nla_len
;
2133 while (len
> sizeof(struct nlattr
)) {
2134 nla_len
= nlattr
->nla_len
;
2135 if (nla_len
< sizeof(struct nlattr
) ||
2139 ret
= host_to_target_nlattr(nlattr
, context
);
2140 nlattr
->nla_len
= tswap16(nlattr
->nla_len
);
2141 nlattr
->nla_type
= tswap16(nlattr
->nla_type
);
2145 len
-= NLA_ALIGN(nla_len
);
2146 nlattr
= (struct nlattr
*)(((char *)nlattr
) + NLA_ALIGN(nla_len
));
2151 static abi_long
host_to_target_for_each_rtattr(struct rtattr
*rtattr
,
2153 abi_long (*host_to_target_rtattr
)
2156 unsigned short rta_len
;
2159 while (len
> sizeof(struct rtattr
)) {
2160 rta_len
= rtattr
->rta_len
;
2161 if (rta_len
< sizeof(struct rtattr
) ||
2165 ret
= host_to_target_rtattr(rtattr
);
2166 rtattr
->rta_len
= tswap16(rtattr
->rta_len
);
2167 rtattr
->rta_type
= tswap16(rtattr
->rta_type
);
2171 len
-= RTA_ALIGN(rta_len
);
2172 rtattr
= (struct rtattr
*)(((char *)rtattr
) + RTA_ALIGN(rta_len
));
2177 #define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
2179 static abi_long
host_to_target_data_bridge_nlattr(struct nlattr
*nlattr
,
2186 switch (nlattr
->nla_type
) {
2188 case QEMU_IFLA_BR_FDB_FLUSH
:
2191 case QEMU_IFLA_BR_GROUP_ADDR
:
2194 case QEMU_IFLA_BR_VLAN_FILTERING
:
2195 case QEMU_IFLA_BR_TOPOLOGY_CHANGE
:
2196 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED
:
2197 case QEMU_IFLA_BR_MCAST_ROUTER
:
2198 case QEMU_IFLA_BR_MCAST_SNOOPING
:
2199 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR
:
2200 case QEMU_IFLA_BR_MCAST_QUERIER
:
2201 case QEMU_IFLA_BR_NF_CALL_IPTABLES
:
2202 case QEMU_IFLA_BR_NF_CALL_IP6TABLES
:
2203 case QEMU_IFLA_BR_NF_CALL_ARPTABLES
:
2204 case QEMU_IFLA_BR_VLAN_STATS_ENABLED
:
2205 case QEMU_IFLA_BR_MCAST_STATS_ENABLED
:
2206 case QEMU_IFLA_BR_MCAST_IGMP_VERSION
:
2207 case QEMU_IFLA_BR_MCAST_MLD_VERSION
:
2210 case QEMU_IFLA_BR_PRIORITY
:
2211 case QEMU_IFLA_BR_VLAN_PROTOCOL
:
2212 case QEMU_IFLA_BR_GROUP_FWD_MASK
:
2213 case QEMU_IFLA_BR_ROOT_PORT
:
2214 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID
:
2215 u16
= NLA_DATA(nlattr
);
2216 *u16
= tswap16(*u16
);
2219 case QEMU_IFLA_BR_FORWARD_DELAY
:
2220 case QEMU_IFLA_BR_HELLO_TIME
:
2221 case QEMU_IFLA_BR_MAX_AGE
:
2222 case QEMU_IFLA_BR_AGEING_TIME
:
2223 case QEMU_IFLA_BR_STP_STATE
:
2224 case QEMU_IFLA_BR_ROOT_PATH_COST
:
2225 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY
:
2226 case QEMU_IFLA_BR_MCAST_HASH_MAX
:
2227 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT
:
2228 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT
:
2229 u32
= NLA_DATA(nlattr
);
2230 *u32
= tswap32(*u32
);
2233 case QEMU_IFLA_BR_HELLO_TIMER
:
2234 case QEMU_IFLA_BR_TCN_TIMER
:
2235 case QEMU_IFLA_BR_GC_TIMER
:
2236 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER
:
2237 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL
:
2238 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL
:
2239 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL
:
2240 case QEMU_IFLA_BR_MCAST_QUERY_INTVL
:
2241 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL
:
2242 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL
:
2243 u64
= NLA_DATA(nlattr
);
2244 *u64
= tswap64(*u64
);
2246 /* ifla_bridge_id: uin8_t[] */
2247 case QEMU_IFLA_BR_ROOT_ID
:
2248 case QEMU_IFLA_BR_BRIDGE_ID
:
2251 gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr
->nla_type
);
2257 static abi_long
host_to_target_slave_data_bridge_nlattr(struct nlattr
*nlattr
,
2264 switch (nlattr
->nla_type
) {
2266 case QEMU_IFLA_BRPORT_STATE
:
2267 case QEMU_IFLA_BRPORT_MODE
:
2268 case QEMU_IFLA_BRPORT_GUARD
:
2269 case QEMU_IFLA_BRPORT_PROTECT
:
2270 case QEMU_IFLA_BRPORT_FAST_LEAVE
:
2271 case QEMU_IFLA_BRPORT_LEARNING
:
2272 case QEMU_IFLA_BRPORT_UNICAST_FLOOD
:
2273 case QEMU_IFLA_BRPORT_PROXYARP
:
2274 case QEMU_IFLA_BRPORT_LEARNING_SYNC
:
2275 case QEMU_IFLA_BRPORT_PROXYARP_WIFI
:
2276 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK
:
2277 case QEMU_IFLA_BRPORT_CONFIG_PENDING
:
2278 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER
:
2279 case QEMU_IFLA_BRPORT_MCAST_FLOOD
:
2280 case QEMU_IFLA_BRPORT_MCAST_TO_UCAST
:
2281 case QEMU_IFLA_BRPORT_VLAN_TUNNEL
:
2282 case QEMU_IFLA_BRPORT_BCAST_FLOOD
:
2283 case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS
:
2286 case QEMU_IFLA_BRPORT_PRIORITY
:
2287 case QEMU_IFLA_BRPORT_DESIGNATED_PORT
:
2288 case QEMU_IFLA_BRPORT_DESIGNATED_COST
:
2289 case QEMU_IFLA_BRPORT_ID
:
2290 case QEMU_IFLA_BRPORT_NO
:
2291 case QEMU_IFLA_BRPORT_GROUP_FWD_MASK
:
2292 u16
= NLA_DATA(nlattr
);
2293 *u16
= tswap16(*u16
);
2296 case QEMU_IFLA_BRPORT_COST
:
2297 u32
= NLA_DATA(nlattr
);
2298 *u32
= tswap32(*u32
);
2301 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER
:
2302 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER
:
2303 case QEMU_IFLA_BRPORT_HOLD_TIMER
:
2304 u64
= NLA_DATA(nlattr
);
2305 *u64
= tswap64(*u64
);
2307 /* ifla_bridge_id: uint8_t[] */
2308 case QEMU_IFLA_BRPORT_ROOT_ID
:
2309 case QEMU_IFLA_BRPORT_BRIDGE_ID
:
2312 gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr
->nla_type
);
2318 struct linkinfo_context
{
2325 static abi_long
host_to_target_data_linkinfo_nlattr(struct nlattr
*nlattr
,
2328 struct linkinfo_context
*li_context
= context
;
2330 switch (nlattr
->nla_type
) {
2332 case QEMU_IFLA_INFO_KIND
:
2333 li_context
->name
= NLA_DATA(nlattr
);
2334 li_context
->len
= nlattr
->nla_len
- NLA_HDRLEN
;
2336 case QEMU_IFLA_INFO_SLAVE_KIND
:
2337 li_context
->slave_name
= NLA_DATA(nlattr
);
2338 li_context
->slave_len
= nlattr
->nla_len
- NLA_HDRLEN
;
2341 case QEMU_IFLA_INFO_XSTATS
:
2342 /* FIXME: only used by CAN */
2345 case QEMU_IFLA_INFO_DATA
:
2346 if (strncmp(li_context
->name
, "bridge",
2347 li_context
->len
) == 0) {
2348 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
),
2351 host_to_target_data_bridge_nlattr
);
2353 gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context
->name
);
2356 case QEMU_IFLA_INFO_SLAVE_DATA
:
2357 if (strncmp(li_context
->slave_name
, "bridge",
2358 li_context
->slave_len
) == 0) {
2359 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
),
2362 host_to_target_slave_data_bridge_nlattr
);
2364 gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
2365 li_context
->slave_name
);
2369 gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr
->nla_type
);
2376 static abi_long
host_to_target_data_inet_nlattr(struct nlattr
*nlattr
,
2382 switch (nlattr
->nla_type
) {
2383 case QEMU_IFLA_INET_CONF
:
2384 u32
= NLA_DATA(nlattr
);
2385 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u32
);
2387 u32
[i
] = tswap32(u32
[i
]);
2391 gemu_log("Unknown host AF_INET type: %d\n", nlattr
->nla_type
);
2396 static abi_long
host_to_target_data_inet6_nlattr(struct nlattr
*nlattr
,
2401 struct ifla_cacheinfo
*ci
;
2404 switch (nlattr
->nla_type
) {
2406 case QEMU_IFLA_INET6_TOKEN
:
2409 case QEMU_IFLA_INET6_ADDR_GEN_MODE
:
2412 case QEMU_IFLA_INET6_FLAGS
:
2413 u32
= NLA_DATA(nlattr
);
2414 *u32
= tswap32(*u32
);
2417 case QEMU_IFLA_INET6_CONF
:
2418 u32
= NLA_DATA(nlattr
);
2419 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u32
);
2421 u32
[i
] = tswap32(u32
[i
]);
2424 /* ifla_cacheinfo */
2425 case QEMU_IFLA_INET6_CACHEINFO
:
2426 ci
= NLA_DATA(nlattr
);
2427 ci
->max_reasm_len
= tswap32(ci
->max_reasm_len
);
2428 ci
->tstamp
= tswap32(ci
->tstamp
);
2429 ci
->reachable_time
= tswap32(ci
->reachable_time
);
2430 ci
->retrans_time
= tswap32(ci
->retrans_time
);
2433 case QEMU_IFLA_INET6_STATS
:
2434 case QEMU_IFLA_INET6_ICMP6STATS
:
2435 u64
= NLA_DATA(nlattr
);
2436 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u64
);
2438 u64
[i
] = tswap64(u64
[i
]);
2442 gemu_log("Unknown host AF_INET6 type: %d\n", nlattr
->nla_type
);
2447 static abi_long
host_to_target_data_spec_nlattr(struct nlattr
*nlattr
,
2450 switch (nlattr
->nla_type
) {
2452 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
), nlattr
->nla_len
,
2454 host_to_target_data_inet_nlattr
);
2456 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
), nlattr
->nla_len
,
2458 host_to_target_data_inet6_nlattr
);
2460 gemu_log("Unknown host AF_SPEC type: %d\n", nlattr
->nla_type
);
2466 static abi_long
host_to_target_data_xdp_nlattr(struct nlattr
*nlattr
,
2471 switch (nlattr
->nla_type
) {
2473 case QEMU_IFLA_XDP_ATTACHED
:
2476 case QEMU_IFLA_XDP_PROG_ID
:
2477 u32
= NLA_DATA(nlattr
);
2478 *u32
= tswap32(*u32
);
2481 gemu_log("Unknown host XDP type: %d\n", nlattr
->nla_type
);
2487 static abi_long
host_to_target_data_link_rtattr(struct rtattr
*rtattr
)
2490 struct rtnl_link_stats
*st
;
2491 struct rtnl_link_stats64
*st64
;
2492 struct rtnl_link_ifmap
*map
;
2493 struct linkinfo_context li_context
;
2495 switch (rtattr
->rta_type
) {
2497 case QEMU_IFLA_ADDRESS
:
2498 case QEMU_IFLA_BROADCAST
:
2500 case QEMU_IFLA_IFNAME
:
2501 case QEMU_IFLA_QDISC
:
2504 case QEMU_IFLA_OPERSTATE
:
2505 case QEMU_IFLA_LINKMODE
:
2506 case QEMU_IFLA_CARRIER
:
2507 case QEMU_IFLA_PROTO_DOWN
:
2511 case QEMU_IFLA_LINK
:
2512 case QEMU_IFLA_WEIGHT
:
2513 case QEMU_IFLA_TXQLEN
:
2514 case QEMU_IFLA_CARRIER_CHANGES
:
2515 case QEMU_IFLA_NUM_RX_QUEUES
:
2516 case QEMU_IFLA_NUM_TX_QUEUES
:
2517 case QEMU_IFLA_PROMISCUITY
:
2518 case QEMU_IFLA_EXT_MASK
:
2519 case QEMU_IFLA_LINK_NETNSID
:
2520 case QEMU_IFLA_GROUP
:
2521 case QEMU_IFLA_MASTER
:
2522 case QEMU_IFLA_NUM_VF
:
2523 case QEMU_IFLA_GSO_MAX_SEGS
:
2524 case QEMU_IFLA_GSO_MAX_SIZE
:
2525 case QEMU_IFLA_CARRIER_UP_COUNT
:
2526 case QEMU_IFLA_CARRIER_DOWN_COUNT
:
2527 u32
= RTA_DATA(rtattr
);
2528 *u32
= tswap32(*u32
);
2530 /* struct rtnl_link_stats */
2531 case QEMU_IFLA_STATS
:
2532 st
= RTA_DATA(rtattr
);
2533 st
->rx_packets
= tswap32(st
->rx_packets
);
2534 st
->tx_packets
= tswap32(st
->tx_packets
);
2535 st
->rx_bytes
= tswap32(st
->rx_bytes
);
2536 st
->tx_bytes
= tswap32(st
->tx_bytes
);
2537 st
->rx_errors
= tswap32(st
->rx_errors
);
2538 st
->tx_errors
= tswap32(st
->tx_errors
);
2539 st
->rx_dropped
= tswap32(st
->rx_dropped
);
2540 st
->tx_dropped
= tswap32(st
->tx_dropped
);
2541 st
->multicast
= tswap32(st
->multicast
);
2542 st
->collisions
= tswap32(st
->collisions
);
2544 /* detailed rx_errors: */
2545 st
->rx_length_errors
= tswap32(st
->rx_length_errors
);
2546 st
->rx_over_errors
= tswap32(st
->rx_over_errors
);
2547 st
->rx_crc_errors
= tswap32(st
->rx_crc_errors
);
2548 st
->rx_frame_errors
= tswap32(st
->rx_frame_errors
);
2549 st
->rx_fifo_errors
= tswap32(st
->rx_fifo_errors
);
2550 st
->rx_missed_errors
= tswap32(st
->rx_missed_errors
);
2552 /* detailed tx_errors */
2553 st
->tx_aborted_errors
= tswap32(st
->tx_aborted_errors
);
2554 st
->tx_carrier_errors
= tswap32(st
->tx_carrier_errors
);
2555 st
->tx_fifo_errors
= tswap32(st
->tx_fifo_errors
);
2556 st
->tx_heartbeat_errors
= tswap32(st
->tx_heartbeat_errors
);
2557 st
->tx_window_errors
= tswap32(st
->tx_window_errors
);
2560 st
->rx_compressed
= tswap32(st
->rx_compressed
);
2561 st
->tx_compressed
= tswap32(st
->tx_compressed
);
2563 /* struct rtnl_link_stats64 */
2564 case QEMU_IFLA_STATS64
:
2565 st64
= RTA_DATA(rtattr
);
2566 st64
->rx_packets
= tswap64(st64
->rx_packets
);
2567 st64
->tx_packets
= tswap64(st64
->tx_packets
);
2568 st64
->rx_bytes
= tswap64(st64
->rx_bytes
);
2569 st64
->tx_bytes
= tswap64(st64
->tx_bytes
);
2570 st64
->rx_errors
= tswap64(st64
->rx_errors
);
2571 st64
->tx_errors
= tswap64(st64
->tx_errors
);
2572 st64
->rx_dropped
= tswap64(st64
->rx_dropped
);
2573 st64
->tx_dropped
= tswap64(st64
->tx_dropped
);
2574 st64
->multicast
= tswap64(st64
->multicast
);
2575 st64
->collisions
= tswap64(st64
->collisions
);
2577 /* detailed rx_errors: */
2578 st64
->rx_length_errors
= tswap64(st64
->rx_length_errors
);
2579 st64
->rx_over_errors
= tswap64(st64
->rx_over_errors
);
2580 st64
->rx_crc_errors
= tswap64(st64
->rx_crc_errors
);
2581 st64
->rx_frame_errors
= tswap64(st64
->rx_frame_errors
);
2582 st64
->rx_fifo_errors
= tswap64(st64
->rx_fifo_errors
);
2583 st64
->rx_missed_errors
= tswap64(st64
->rx_missed_errors
);
2585 /* detailed tx_errors */
2586 st64
->tx_aborted_errors
= tswap64(st64
->tx_aborted_errors
);
2587 st64
->tx_carrier_errors
= tswap64(st64
->tx_carrier_errors
);
2588 st64
->tx_fifo_errors
= tswap64(st64
->tx_fifo_errors
);
2589 st64
->tx_heartbeat_errors
= tswap64(st64
->tx_heartbeat_errors
);
2590 st64
->tx_window_errors
= tswap64(st64
->tx_window_errors
);
2593 st64
->rx_compressed
= tswap64(st64
->rx_compressed
);
2594 st64
->tx_compressed
= tswap64(st64
->tx_compressed
);
2596 /* struct rtnl_link_ifmap */
2598 map
= RTA_DATA(rtattr
);
2599 map
->mem_start
= tswap64(map
->mem_start
);
2600 map
->mem_end
= tswap64(map
->mem_end
);
2601 map
->base_addr
= tswap64(map
->base_addr
);
2602 map
->irq
= tswap16(map
->irq
);
2605 case QEMU_IFLA_LINKINFO
:
2606 memset(&li_context
, 0, sizeof(li_context
));
2607 return host_to_target_for_each_nlattr(RTA_DATA(rtattr
), rtattr
->rta_len
,
2609 host_to_target_data_linkinfo_nlattr
);
2610 case QEMU_IFLA_AF_SPEC
:
2611 return host_to_target_for_each_nlattr(RTA_DATA(rtattr
), rtattr
->rta_len
,
2613 host_to_target_data_spec_nlattr
);
2615 return host_to_target_for_each_nlattr(RTA_DATA(rtattr
), rtattr
->rta_len
,
2617 host_to_target_data_xdp_nlattr
);
2619 gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr
->rta_type
);
2625 static abi_long
host_to_target_data_addr_rtattr(struct rtattr
*rtattr
)
2628 struct ifa_cacheinfo
*ci
;
2630 switch (rtattr
->rta_type
) {
2631 /* binary: depends on family type */
2641 u32
= RTA_DATA(rtattr
);
2642 *u32
= tswap32(*u32
);
2644 /* struct ifa_cacheinfo */
2646 ci
= RTA_DATA(rtattr
);
2647 ci
->ifa_prefered
= tswap32(ci
->ifa_prefered
);
2648 ci
->ifa_valid
= tswap32(ci
->ifa_valid
);
2649 ci
->cstamp
= tswap32(ci
->cstamp
);
2650 ci
->tstamp
= tswap32(ci
->tstamp
);
2653 gemu_log("Unknown host IFA type: %d\n", rtattr
->rta_type
);
2659 static abi_long
host_to_target_data_route_rtattr(struct rtattr
*rtattr
)
2662 switch (rtattr
->rta_type
) {
2663 /* binary: depends on family type */
2672 u32
= RTA_DATA(rtattr
);
2673 *u32
= tswap32(*u32
);
2676 gemu_log("Unknown host RTA type: %d\n", rtattr
->rta_type
);
2682 static abi_long
host_to_target_link_rtattr(struct rtattr
*rtattr
,
2683 uint32_t rtattr_len
)
2685 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2686 host_to_target_data_link_rtattr
);
2689 static abi_long
host_to_target_addr_rtattr(struct rtattr
*rtattr
,
2690 uint32_t rtattr_len
)
2692 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2693 host_to_target_data_addr_rtattr
);
2696 static abi_long
host_to_target_route_rtattr(struct rtattr
*rtattr
,
2697 uint32_t rtattr_len
)
2699 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2700 host_to_target_data_route_rtattr
);
2703 static abi_long
host_to_target_data_route(struct nlmsghdr
*nlh
)
2706 struct ifinfomsg
*ifi
;
2707 struct ifaddrmsg
*ifa
;
2710 nlmsg_len
= nlh
->nlmsg_len
;
2711 switch (nlh
->nlmsg_type
) {
2715 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifi
))) {
2716 ifi
= NLMSG_DATA(nlh
);
2717 ifi
->ifi_type
= tswap16(ifi
->ifi_type
);
2718 ifi
->ifi_index
= tswap32(ifi
->ifi_index
);
2719 ifi
->ifi_flags
= tswap32(ifi
->ifi_flags
);
2720 ifi
->ifi_change
= tswap32(ifi
->ifi_change
);
2721 host_to_target_link_rtattr(IFLA_RTA(ifi
),
2722 nlmsg_len
- NLMSG_LENGTH(sizeof(*ifi
)));
2728 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifa
))) {
2729 ifa
= NLMSG_DATA(nlh
);
2730 ifa
->ifa_index
= tswap32(ifa
->ifa_index
);
2731 host_to_target_addr_rtattr(IFA_RTA(ifa
),
2732 nlmsg_len
- NLMSG_LENGTH(sizeof(*ifa
)));
2738 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*rtm
))) {
2739 rtm
= NLMSG_DATA(nlh
);
2740 rtm
->rtm_flags
= tswap32(rtm
->rtm_flags
);
2741 host_to_target_route_rtattr(RTM_RTA(rtm
),
2742 nlmsg_len
- NLMSG_LENGTH(sizeof(*rtm
)));
2746 return -TARGET_EINVAL
;
2751 static inline abi_long
host_to_target_nlmsg_route(struct nlmsghdr
*nlh
,
2754 return host_to_target_for_each_nlmsg(nlh
, len
, host_to_target_data_route
);
2757 static abi_long
target_to_host_for_each_rtattr(struct rtattr
*rtattr
,
2759 abi_long (*target_to_host_rtattr
)
2764 while (len
>= sizeof(struct rtattr
)) {
2765 if (tswap16(rtattr
->rta_len
) < sizeof(struct rtattr
) ||
2766 tswap16(rtattr
->rta_len
) > len
) {
2769 rtattr
->rta_len
= tswap16(rtattr
->rta_len
);
2770 rtattr
->rta_type
= tswap16(rtattr
->rta_type
);
2771 ret
= target_to_host_rtattr(rtattr
);
2775 len
-= RTA_ALIGN(rtattr
->rta_len
);
2776 rtattr
= (struct rtattr
*)(((char *)rtattr
) +
2777 RTA_ALIGN(rtattr
->rta_len
));
2782 static abi_long
target_to_host_data_link_rtattr(struct rtattr
*rtattr
)
2784 switch (rtattr
->rta_type
) {
2786 gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr
->rta_type
);
2792 static abi_long
target_to_host_data_addr_rtattr(struct rtattr
*rtattr
)
2794 switch (rtattr
->rta_type
) {
2795 /* binary: depends on family type */
2800 gemu_log("Unknown target IFA type: %d\n", rtattr
->rta_type
);
2806 static abi_long
target_to_host_data_route_rtattr(struct rtattr
*rtattr
)
2809 switch (rtattr
->rta_type
) {
2810 /* binary: depends on family type */
2818 u32
= RTA_DATA(rtattr
);
2819 *u32
= tswap32(*u32
);
2822 gemu_log("Unknown target RTA type: %d\n", rtattr
->rta_type
);
2828 static void target_to_host_link_rtattr(struct rtattr
*rtattr
,
2829 uint32_t rtattr_len
)
2831 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2832 target_to_host_data_link_rtattr
);
2835 static void target_to_host_addr_rtattr(struct rtattr
*rtattr
,
2836 uint32_t rtattr_len
)
2838 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2839 target_to_host_data_addr_rtattr
);
2842 static void target_to_host_route_rtattr(struct rtattr
*rtattr
,
2843 uint32_t rtattr_len
)
2845 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2846 target_to_host_data_route_rtattr
);
2849 static abi_long
target_to_host_data_route(struct nlmsghdr
*nlh
)
2851 struct ifinfomsg
*ifi
;
2852 struct ifaddrmsg
*ifa
;
2855 switch (nlh
->nlmsg_type
) {
2860 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifi
))) {
2861 ifi
= NLMSG_DATA(nlh
);
2862 ifi
->ifi_type
= tswap16(ifi
->ifi_type
);
2863 ifi
->ifi_index
= tswap32(ifi
->ifi_index
);
2864 ifi
->ifi_flags
= tswap32(ifi
->ifi_flags
);
2865 ifi
->ifi_change
= tswap32(ifi
->ifi_change
);
2866 target_to_host_link_rtattr(IFLA_RTA(ifi
), nlh
->nlmsg_len
-
2867 NLMSG_LENGTH(sizeof(*ifi
)));
2873 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifa
))) {
2874 ifa
= NLMSG_DATA(nlh
);
2875 ifa
->ifa_index
= tswap32(ifa
->ifa_index
);
2876 target_to_host_addr_rtattr(IFA_RTA(ifa
), nlh
->nlmsg_len
-
2877 NLMSG_LENGTH(sizeof(*ifa
)));
2884 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*rtm
))) {
2885 rtm
= NLMSG_DATA(nlh
);
2886 rtm
->rtm_flags
= tswap32(rtm
->rtm_flags
);
2887 target_to_host_route_rtattr(RTM_RTA(rtm
), nlh
->nlmsg_len
-
2888 NLMSG_LENGTH(sizeof(*rtm
)));
2892 return -TARGET_EOPNOTSUPP
;
2897 static abi_long
target_to_host_nlmsg_route(struct nlmsghdr
*nlh
, size_t len
)
2899 return target_to_host_for_each_nlmsg(nlh
, len
, target_to_host_data_route
);
2901 #endif /* CONFIG_RTNETLINK */
2903 static abi_long
host_to_target_data_audit(struct nlmsghdr
*nlh
)
2905 switch (nlh
->nlmsg_type
) {
2907 gemu_log("Unknown host audit message type %d\n",
2909 return -TARGET_EINVAL
;
2914 static inline abi_long
host_to_target_nlmsg_audit(struct nlmsghdr
*nlh
,
2917 return host_to_target_for_each_nlmsg(nlh
, len
, host_to_target_data_audit
);
2920 static abi_long
target_to_host_data_audit(struct nlmsghdr
*nlh
)
2922 switch (nlh
->nlmsg_type
) {
2924 case AUDIT_FIRST_USER_MSG
... AUDIT_LAST_USER_MSG
:
2925 case AUDIT_FIRST_USER_MSG2
... AUDIT_LAST_USER_MSG2
:
2928 gemu_log("Unknown target audit message type %d\n",
2930 return -TARGET_EINVAL
;
2936 static abi_long
target_to_host_nlmsg_audit(struct nlmsghdr
*nlh
, size_t len
)
2938 return target_to_host_for_each_nlmsg(nlh
, len
, target_to_host_data_audit
);
2941 /* do_setsockopt() Must return target values and target errnos. */
2942 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
2943 abi_ulong optval_addr
, socklen_t optlen
)
2947 struct ip_mreqn
*ip_mreq
;
2948 struct ip_mreq_source
*ip_mreq_source
;
2952 /* TCP options all take an 'int' value. */
2953 if (optlen
< sizeof(uint32_t))
2954 return -TARGET_EINVAL
;
2956 if (get_user_u32(val
, optval_addr
))
2957 return -TARGET_EFAULT
;
2958 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2965 case IP_ROUTER_ALERT
:
2969 case IP_MTU_DISCOVER
:
2976 case IP_MULTICAST_TTL
:
2977 case IP_MULTICAST_LOOP
:
2979 if (optlen
>= sizeof(uint32_t)) {
2980 if (get_user_u32(val
, optval_addr
))
2981 return -TARGET_EFAULT
;
2982 } else if (optlen
>= 1) {
2983 if (get_user_u8(val
, optval_addr
))
2984 return -TARGET_EFAULT
;
2986 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2988 case IP_ADD_MEMBERSHIP
:
2989 case IP_DROP_MEMBERSHIP
:
2990 if (optlen
< sizeof (struct target_ip_mreq
) ||
2991 optlen
> sizeof (struct target_ip_mreqn
))
2992 return -TARGET_EINVAL
;
2994 ip_mreq
= (struct ip_mreqn
*) alloca(optlen
);
2995 target_to_host_ip_mreq(ip_mreq
, optval_addr
, optlen
);
2996 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq
, optlen
));
2999 case IP_BLOCK_SOURCE
:
3000 case IP_UNBLOCK_SOURCE
:
3001 case IP_ADD_SOURCE_MEMBERSHIP
:
3002 case IP_DROP_SOURCE_MEMBERSHIP
:
3003 if (optlen
!= sizeof (struct target_ip_mreq_source
))
3004 return -TARGET_EINVAL
;
3006 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
3007 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
3008 unlock_user (ip_mreq_source
, optval_addr
, 0);
3017 case IPV6_MTU_DISCOVER
:
3020 case IPV6_RECVPKTINFO
:
3021 case IPV6_UNICAST_HOPS
:
3022 case IPV6_MULTICAST_HOPS
:
3023 case IPV6_MULTICAST_LOOP
:
3025 case IPV6_RECVHOPLIMIT
:
3026 case IPV6_2292HOPLIMIT
:
3029 if (optlen
< sizeof(uint32_t)) {
3030 return -TARGET_EINVAL
;
3032 if (get_user_u32(val
, optval_addr
)) {
3033 return -TARGET_EFAULT
;
3035 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3036 &val
, sizeof(val
)));
3040 struct in6_pktinfo pki
;
3042 if (optlen
< sizeof(pki
)) {
3043 return -TARGET_EINVAL
;
3046 if (copy_from_user(&pki
, optval_addr
, sizeof(pki
))) {
3047 return -TARGET_EFAULT
;
3050 pki
.ipi6_ifindex
= tswap32(pki
.ipi6_ifindex
);
3052 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3053 &pki
, sizeof(pki
)));
3064 struct icmp6_filter icmp6f
;
3066 if (optlen
> sizeof(icmp6f
)) {
3067 optlen
= sizeof(icmp6f
);
3070 if (copy_from_user(&icmp6f
, optval_addr
, optlen
)) {
3071 return -TARGET_EFAULT
;
3074 for (val
= 0; val
< 8; val
++) {
3075 icmp6f
.data
[val
] = tswap32(icmp6f
.data
[val
]);
3078 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3090 /* those take an u32 value */
3091 if (optlen
< sizeof(uint32_t)) {
3092 return -TARGET_EINVAL
;
3095 if (get_user_u32(val
, optval_addr
)) {
3096 return -TARGET_EFAULT
;
3098 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3099 &val
, sizeof(val
)));
3106 case TARGET_SOL_SOCKET
:
3108 case TARGET_SO_RCVTIMEO
:
3112 optname
= SO_RCVTIMEO
;
3115 if (optlen
!= sizeof(struct target_timeval
)) {
3116 return -TARGET_EINVAL
;
3119 if (copy_from_user_timeval(&tv
, optval_addr
)) {
3120 return -TARGET_EFAULT
;
3123 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
3127 case TARGET_SO_SNDTIMEO
:
3128 optname
= SO_SNDTIMEO
;
3130 case TARGET_SO_ATTACH_FILTER
:
3132 struct target_sock_fprog
*tfprog
;
3133 struct target_sock_filter
*tfilter
;
3134 struct sock_fprog fprog
;
3135 struct sock_filter
*filter
;
3138 if (optlen
!= sizeof(*tfprog
)) {
3139 return -TARGET_EINVAL
;
3141 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
3142 return -TARGET_EFAULT
;
3144 if (!lock_user_struct(VERIFY_READ
, tfilter
,
3145 tswapal(tfprog
->filter
), 0)) {
3146 unlock_user_struct(tfprog
, optval_addr
, 1);
3147 return -TARGET_EFAULT
;
3150 fprog
.len
= tswap16(tfprog
->len
);
3151 filter
= g_try_new(struct sock_filter
, fprog
.len
);
3152 if (filter
== NULL
) {
3153 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
3154 unlock_user_struct(tfprog
, optval_addr
, 1);
3155 return -TARGET_ENOMEM
;
3157 for (i
= 0; i
< fprog
.len
; i
++) {
3158 filter
[i
].code
= tswap16(tfilter
[i
].code
);
3159 filter
[i
].jt
= tfilter
[i
].jt
;
3160 filter
[i
].jf
= tfilter
[i
].jf
;
3161 filter
[i
].k
= tswap32(tfilter
[i
].k
);
3163 fprog
.filter
= filter
;
3165 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
3166 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
3169 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
3170 unlock_user_struct(tfprog
, optval_addr
, 1);
3173 case TARGET_SO_BINDTODEVICE
:
3175 char *dev_ifname
, *addr_ifname
;
3177 if (optlen
> IFNAMSIZ
- 1) {
3178 optlen
= IFNAMSIZ
- 1;
3180 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
3182 return -TARGET_EFAULT
;
3184 optname
= SO_BINDTODEVICE
;
3185 addr_ifname
= alloca(IFNAMSIZ
);
3186 memcpy(addr_ifname
, dev_ifname
, optlen
);
3187 addr_ifname
[optlen
] = 0;
3188 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
3189 addr_ifname
, optlen
));
3190 unlock_user (dev_ifname
, optval_addr
, 0);
3193 /* Options with 'int' argument. */
3194 case TARGET_SO_DEBUG
:
3197 case TARGET_SO_REUSEADDR
:
3198 optname
= SO_REUSEADDR
;
3200 case TARGET_SO_TYPE
:
3203 case TARGET_SO_ERROR
:
3206 case TARGET_SO_DONTROUTE
:
3207 optname
= SO_DONTROUTE
;
3209 case TARGET_SO_BROADCAST
:
3210 optname
= SO_BROADCAST
;
3212 case TARGET_SO_SNDBUF
:
3213 optname
= SO_SNDBUF
;
3215 case TARGET_SO_SNDBUFFORCE
:
3216 optname
= SO_SNDBUFFORCE
;
3218 case TARGET_SO_RCVBUF
:
3219 optname
= SO_RCVBUF
;
3221 case TARGET_SO_RCVBUFFORCE
:
3222 optname
= SO_RCVBUFFORCE
;
3224 case TARGET_SO_KEEPALIVE
:
3225 optname
= SO_KEEPALIVE
;
3227 case TARGET_SO_OOBINLINE
:
3228 optname
= SO_OOBINLINE
;
3230 case TARGET_SO_NO_CHECK
:
3231 optname
= SO_NO_CHECK
;
3233 case TARGET_SO_PRIORITY
:
3234 optname
= SO_PRIORITY
;
3237 case TARGET_SO_BSDCOMPAT
:
3238 optname
= SO_BSDCOMPAT
;
3241 case TARGET_SO_PASSCRED
:
3242 optname
= SO_PASSCRED
;
3244 case TARGET_SO_PASSSEC
:
3245 optname
= SO_PASSSEC
;
3247 case TARGET_SO_TIMESTAMP
:
3248 optname
= SO_TIMESTAMP
;
3250 case TARGET_SO_RCVLOWAT
:
3251 optname
= SO_RCVLOWAT
;
3256 if (optlen
< sizeof(uint32_t))
3257 return -TARGET_EINVAL
;
3259 if (get_user_u32(val
, optval_addr
))
3260 return -TARGET_EFAULT
;
3261 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
3265 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level
, optname
);
3266 ret
= -TARGET_ENOPROTOOPT
;
3271 /* do_getsockopt() Must return target values and target errnos. */
3272 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
3273 abi_ulong optval_addr
, abi_ulong optlen
)
3280 case TARGET_SOL_SOCKET
:
3283 /* These don't just return a single integer */
3284 case TARGET_SO_LINGER
:
3285 case TARGET_SO_RCVTIMEO
:
3286 case TARGET_SO_SNDTIMEO
:
3287 case TARGET_SO_PEERNAME
:
3289 case TARGET_SO_PEERCRED
: {
3292 struct target_ucred
*tcr
;
3294 if (get_user_u32(len
, optlen
)) {
3295 return -TARGET_EFAULT
;
3298 return -TARGET_EINVAL
;
3302 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
3310 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
3311 return -TARGET_EFAULT
;
3313 __put_user(cr
.pid
, &tcr
->pid
);
3314 __put_user(cr
.uid
, &tcr
->uid
);
3315 __put_user(cr
.gid
, &tcr
->gid
);
3316 unlock_user_struct(tcr
, optval_addr
, 1);
3317 if (put_user_u32(len
, optlen
)) {
3318 return -TARGET_EFAULT
;
3322 /* Options with 'int' argument. */
3323 case TARGET_SO_DEBUG
:
3326 case TARGET_SO_REUSEADDR
:
3327 optname
= SO_REUSEADDR
;
3329 case TARGET_SO_TYPE
:
3332 case TARGET_SO_ERROR
:
3335 case TARGET_SO_DONTROUTE
:
3336 optname
= SO_DONTROUTE
;
3338 case TARGET_SO_BROADCAST
:
3339 optname
= SO_BROADCAST
;
3341 case TARGET_SO_SNDBUF
:
3342 optname
= SO_SNDBUF
;
3344 case TARGET_SO_RCVBUF
:
3345 optname
= SO_RCVBUF
;
3347 case TARGET_SO_KEEPALIVE
:
3348 optname
= SO_KEEPALIVE
;
3350 case TARGET_SO_OOBINLINE
:
3351 optname
= SO_OOBINLINE
;
3353 case TARGET_SO_NO_CHECK
:
3354 optname
= SO_NO_CHECK
;
3356 case TARGET_SO_PRIORITY
:
3357 optname
= SO_PRIORITY
;
3360 case TARGET_SO_BSDCOMPAT
:
3361 optname
= SO_BSDCOMPAT
;
3364 case TARGET_SO_PASSCRED
:
3365 optname
= SO_PASSCRED
;
3367 case TARGET_SO_TIMESTAMP
:
3368 optname
= SO_TIMESTAMP
;
3370 case TARGET_SO_RCVLOWAT
:
3371 optname
= SO_RCVLOWAT
;
3373 case TARGET_SO_ACCEPTCONN
:
3374 optname
= SO_ACCEPTCONN
;
3381 /* TCP options all take an 'int' value. */
3383 if (get_user_u32(len
, optlen
))
3384 return -TARGET_EFAULT
;
3386 return -TARGET_EINVAL
;
3388 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
3391 if (optname
== SO_TYPE
) {
3392 val
= host_to_target_sock_type(val
);
3397 if (put_user_u32(val
, optval_addr
))
3398 return -TARGET_EFAULT
;
3400 if (put_user_u8(val
, optval_addr
))
3401 return -TARGET_EFAULT
;
3403 if (put_user_u32(len
, optlen
))
3404 return -TARGET_EFAULT
;
3411 case IP_ROUTER_ALERT
:
3415 case IP_MTU_DISCOVER
:
3421 case IP_MULTICAST_TTL
:
3422 case IP_MULTICAST_LOOP
:
3423 if (get_user_u32(len
, optlen
))
3424 return -TARGET_EFAULT
;
3426 return -TARGET_EINVAL
;
3428 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
3431 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
3433 if (put_user_u32(len
, optlen
)
3434 || put_user_u8(val
, optval_addr
))
3435 return -TARGET_EFAULT
;
3437 if (len
> sizeof(int))
3439 if (put_user_u32(len
, optlen
)
3440 || put_user_u32(val
, optval_addr
))
3441 return -TARGET_EFAULT
;
3445 ret
= -TARGET_ENOPROTOOPT
;
3451 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
3453 ret
= -TARGET_EOPNOTSUPP
;
3459 /* Convert target low/high pair representing file offset into the host
3460 * low/high pair. This function doesn't handle offsets bigger than 64 bits
3461 * as the kernel doesn't handle them either.
3463 static void target_to_host_low_high(abi_ulong tlow
,
3465 unsigned long *hlow
,
3466 unsigned long *hhigh
)
3468 uint64_t off
= tlow
|
3469 ((unsigned long long)thigh
<< TARGET_LONG_BITS
/ 2) <<
3470 TARGET_LONG_BITS
/ 2;
3473 *hhigh
= (off
>> HOST_LONG_BITS
/ 2) >> HOST_LONG_BITS
/ 2;
3476 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
3477 abi_ulong count
, int copy
)
3479 struct target_iovec
*target_vec
;
3481 abi_ulong total_len
, max_len
;
3484 bool bad_address
= false;
3490 if (count
> IOV_MAX
) {
3495 vec
= g_try_new0(struct iovec
, count
);
3501 target_vec
= lock_user(VERIFY_READ
, target_addr
,
3502 count
* sizeof(struct target_iovec
), 1);
3503 if (target_vec
== NULL
) {
3508 /* ??? If host page size > target page size, this will result in a
3509 value larger than what we can actually support. */
3510 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
3513 for (i
= 0; i
< count
; i
++) {
3514 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3515 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3520 } else if (len
== 0) {
3521 /* Zero length pointer is ignored. */
3522 vec
[i
].iov_base
= 0;
3524 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
3525 /* If the first buffer pointer is bad, this is a fault. But
3526 * subsequent bad buffers will result in a partial write; this
3527 * is realized by filling the vector with null pointers and
3529 if (!vec
[i
].iov_base
) {
3540 if (len
> max_len
- total_len
) {
3541 len
= max_len
- total_len
;
3544 vec
[i
].iov_len
= len
;
3548 unlock_user(target_vec
, target_addr
, 0);
3553 if (tswapal(target_vec
[i
].iov_len
) > 0) {
3554 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
3557 unlock_user(target_vec
, target_addr
, 0);
3564 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
3565 abi_ulong count
, int copy
)
3567 struct target_iovec
*target_vec
;
3570 target_vec
= lock_user(VERIFY_READ
, target_addr
,
3571 count
* sizeof(struct target_iovec
), 1);
3573 for (i
= 0; i
< count
; i
++) {
3574 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3575 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3579 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
3581 unlock_user(target_vec
, target_addr
, 0);
3587 static inline int target_to_host_sock_type(int *type
)
3590 int target_type
= *type
;
3592 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
3593 case TARGET_SOCK_DGRAM
:
3594 host_type
= SOCK_DGRAM
;
3596 case TARGET_SOCK_STREAM
:
3597 host_type
= SOCK_STREAM
;
3600 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
3603 if (target_type
& TARGET_SOCK_CLOEXEC
) {
3604 #if defined(SOCK_CLOEXEC)
3605 host_type
|= SOCK_CLOEXEC
;
3607 return -TARGET_EINVAL
;
3610 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3611 #if defined(SOCK_NONBLOCK)
3612 host_type
|= SOCK_NONBLOCK
;
3613 #elif !defined(O_NONBLOCK)
3614 return -TARGET_EINVAL
;
3621 /* Try to emulate socket type flags after socket creation. */
3622 static int sock_flags_fixup(int fd
, int target_type
)
3624 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3625 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3626 int flags
= fcntl(fd
, F_GETFL
);
3627 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
3629 return -TARGET_EINVAL
;
3636 static abi_long
packet_target_to_host_sockaddr(void *host_addr
,
3637 abi_ulong target_addr
,
3640 struct sockaddr
*addr
= host_addr
;
3641 struct target_sockaddr
*target_saddr
;
3643 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
3644 if (!target_saddr
) {
3645 return -TARGET_EFAULT
;
3648 memcpy(addr
, target_saddr
, len
);
3649 addr
->sa_family
= tswap16(target_saddr
->sa_family
);
3650 /* spkt_protocol is big-endian */
3652 unlock_user(target_saddr
, target_addr
, 0);
3656 static TargetFdTrans target_packet_trans
= {
3657 .target_to_host_addr
= packet_target_to_host_sockaddr
,
3660 #ifdef CONFIG_RTNETLINK
3661 static abi_long
netlink_route_target_to_host(void *buf
, size_t len
)
3665 ret
= target_to_host_nlmsg_route(buf
, len
);
3673 static abi_long
netlink_route_host_to_target(void *buf
, size_t len
)
3677 ret
= host_to_target_nlmsg_route(buf
, len
);
3685 static TargetFdTrans target_netlink_route_trans
= {
3686 .target_to_host_data
= netlink_route_target_to_host
,
3687 .host_to_target_data
= netlink_route_host_to_target
,
3689 #endif /* CONFIG_RTNETLINK */
3691 static abi_long
netlink_audit_target_to_host(void *buf
, size_t len
)
3695 ret
= target_to_host_nlmsg_audit(buf
, len
);
3703 static abi_long
netlink_audit_host_to_target(void *buf
, size_t len
)
3707 ret
= host_to_target_nlmsg_audit(buf
, len
);
3715 static TargetFdTrans target_netlink_audit_trans
= {
3716 .target_to_host_data
= netlink_audit_target_to_host
,
3717 .host_to_target_data
= netlink_audit_host_to_target
,
3720 /* do_socket() Must return target values and target errnos. */
3721 static abi_long
do_socket(int domain
, int type
, int protocol
)
3723 int target_type
= type
;
3726 ret
= target_to_host_sock_type(&type
);
3731 if (domain
== PF_NETLINK
&& !(
3732 #ifdef CONFIG_RTNETLINK
3733 protocol
== NETLINK_ROUTE
||
3735 protocol
== NETLINK_KOBJECT_UEVENT
||
3736 protocol
== NETLINK_AUDIT
)) {
3737 return -EPFNOSUPPORT
;
3740 if (domain
== AF_PACKET
||
3741 (domain
== AF_INET
&& type
== SOCK_PACKET
)) {
3742 protocol
= tswap16(protocol
);
3745 ret
= get_errno(socket(domain
, type
, protocol
));
3747 ret
= sock_flags_fixup(ret
, target_type
);
3748 if (type
== SOCK_PACKET
) {
3749 /* Manage an obsolete case :
3750 * if socket type is SOCK_PACKET, bind by name
3752 fd_trans_register(ret
, &target_packet_trans
);
3753 } else if (domain
== PF_NETLINK
) {
3755 #ifdef CONFIG_RTNETLINK
3757 fd_trans_register(ret
, &target_netlink_route_trans
);
3760 case NETLINK_KOBJECT_UEVENT
:
3761 /* nothing to do: messages are strings */
3764 fd_trans_register(ret
, &target_netlink_audit_trans
);
3767 g_assert_not_reached();
3774 /* do_bind() Must return target values and target errnos. */
3775 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
3781 if ((int)addrlen
< 0) {
3782 return -TARGET_EINVAL
;
3785 addr
= alloca(addrlen
+1);
3787 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3791 return get_errno(bind(sockfd
, addr
, addrlen
));
3794 /* do_connect() Must return target values and target errnos. */
3795 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
3801 if ((int)addrlen
< 0) {
3802 return -TARGET_EINVAL
;
3805 addr
= alloca(addrlen
+1);
3807 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3811 return get_errno(safe_connect(sockfd
, addr
, addrlen
));
3814 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
3815 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
3816 int flags
, int send
)
3822 abi_ulong target_vec
;
3824 if (msgp
->msg_name
) {
3825 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
3826 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
3827 ret
= target_to_host_sockaddr(fd
, msg
.msg_name
,
3828 tswapal(msgp
->msg_name
),
3830 if (ret
== -TARGET_EFAULT
) {
3831 /* For connected sockets msg_name and msg_namelen must
3832 * be ignored, so returning EFAULT immediately is wrong.
3833 * Instead, pass a bad msg_name to the host kernel, and
3834 * let it decide whether to return EFAULT or not.
3836 msg
.msg_name
= (void *)-1;
3841 msg
.msg_name
= NULL
;
3842 msg
.msg_namelen
= 0;
3844 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
3845 msg
.msg_control
= alloca(msg
.msg_controllen
);
3846 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
3848 count
= tswapal(msgp
->msg_iovlen
);
3849 target_vec
= tswapal(msgp
->msg_iov
);
3851 if (count
> IOV_MAX
) {
3852 /* sendrcvmsg returns a different errno for this condition than
3853 * readv/writev, so we must catch it here before lock_iovec() does.
3855 ret
= -TARGET_EMSGSIZE
;
3859 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
3860 target_vec
, count
, send
);
3862 ret
= -host_to_target_errno(errno
);
3865 msg
.msg_iovlen
= count
;
3869 if (fd_trans_target_to_host_data(fd
)) {
3872 host_msg
= g_malloc(msg
.msg_iov
->iov_len
);
3873 memcpy(host_msg
, msg
.msg_iov
->iov_base
, msg
.msg_iov
->iov_len
);
3874 ret
= fd_trans_target_to_host_data(fd
)(host_msg
,
3875 msg
.msg_iov
->iov_len
);
3877 msg
.msg_iov
->iov_base
= host_msg
;
3878 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3882 ret
= target_to_host_cmsg(&msg
, msgp
);
3884 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3888 ret
= get_errno(safe_recvmsg(fd
, &msg
, flags
));
3889 if (!is_error(ret
)) {
3891 if (fd_trans_host_to_target_data(fd
)) {
3892 ret
= fd_trans_host_to_target_data(fd
)(msg
.msg_iov
->iov_base
,
3895 ret
= host_to_target_cmsg(msgp
, &msg
);
3897 if (!is_error(ret
)) {
3898 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
3899 if (msg
.msg_name
!= NULL
&& msg
.msg_name
!= (void *)-1) {
3900 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
3901 msg
.msg_name
, msg
.msg_namelen
);
3913 unlock_iovec(vec
, target_vec
, count
, !send
);
3918 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
3919 int flags
, int send
)
3922 struct target_msghdr
*msgp
;
3924 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
3928 return -TARGET_EFAULT
;
3930 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
3931 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
3935 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
3936 * so it might not have this *mmsg-specific flag either.
3938 #ifndef MSG_WAITFORONE
3939 #define MSG_WAITFORONE 0x10000
3942 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
3943 unsigned int vlen
, unsigned int flags
,
3946 struct target_mmsghdr
*mmsgp
;
3950 if (vlen
> UIO_MAXIOV
) {
3954 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
3956 return -TARGET_EFAULT
;
3959 for (i
= 0; i
< vlen
; i
++) {
3960 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
3961 if (is_error(ret
)) {
3964 mmsgp
[i
].msg_len
= tswap32(ret
);
3965 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3966 if (flags
& MSG_WAITFORONE
) {
3967 flags
|= MSG_DONTWAIT
;
3971 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
3973 /* Return number of datagrams sent if we sent any at all;
3974 * otherwise return the error.
3982 /* do_accept4() Must return target values and target errnos. */
3983 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
3984 abi_ulong target_addrlen_addr
, int flags
)
3991 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
3993 if (target_addr
== 0) {
3994 return get_errno(safe_accept4(fd
, NULL
, NULL
, host_flags
));
3997 /* linux returns EINVAL if addrlen pointer is invalid */
3998 if (get_user_u32(addrlen
, target_addrlen_addr
))
3999 return -TARGET_EINVAL
;
4001 if ((int)addrlen
< 0) {
4002 return -TARGET_EINVAL
;
4005 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
4006 return -TARGET_EINVAL
;
4008 addr
= alloca(addrlen
);
4010 ret
= get_errno(safe_accept4(fd
, addr
, &addrlen
, host_flags
));
4011 if (!is_error(ret
)) {
4012 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
4013 if (put_user_u32(addrlen
, target_addrlen_addr
))
4014 ret
= -TARGET_EFAULT
;
4019 /* do_getpeername() Must return target values and target errnos. */
4020 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
4021 abi_ulong target_addrlen_addr
)
4027 if (get_user_u32(addrlen
, target_addrlen_addr
))
4028 return -TARGET_EFAULT
;
4030 if ((int)addrlen
< 0) {
4031 return -TARGET_EINVAL
;
4034 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
4035 return -TARGET_EFAULT
;
4037 addr
= alloca(addrlen
);
4039 ret
= get_errno(getpeername(fd
, addr
, &addrlen
));
4040 if (!is_error(ret
)) {
4041 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
4042 if (put_user_u32(addrlen
, target_addrlen_addr
))
4043 ret
= -TARGET_EFAULT
;
4048 /* do_getsockname() Must return target values and target errnos. */
4049 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
4050 abi_ulong target_addrlen_addr
)
4056 if (get_user_u32(addrlen
, target_addrlen_addr
))
4057 return -TARGET_EFAULT
;
4059 if ((int)addrlen
< 0) {
4060 return -TARGET_EINVAL
;
4063 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
4064 return -TARGET_EFAULT
;
4066 addr
= alloca(addrlen
);
4068 ret
= get_errno(getsockname(fd
, addr
, &addrlen
));
4069 if (!is_error(ret
)) {
4070 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
4071 if (put_user_u32(addrlen
, target_addrlen_addr
))
4072 ret
= -TARGET_EFAULT
;
4077 /* do_socketpair() Must return target values and target errnos. */
4078 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
4079 abi_ulong target_tab_addr
)
4084 target_to_host_sock_type(&type
);
4086 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
4087 if (!is_error(ret
)) {
4088 if (put_user_s32(tab
[0], target_tab_addr
)
4089 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
4090 ret
= -TARGET_EFAULT
;
4095 /* do_sendto() Must return target values and target errnos. */
4096 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
4097 abi_ulong target_addr
, socklen_t addrlen
)
4101 void *copy_msg
= NULL
;
4104 if ((int)addrlen
< 0) {
4105 return -TARGET_EINVAL
;
4108 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
4110 return -TARGET_EFAULT
;
4111 if (fd_trans_target_to_host_data(fd
)) {
4112 copy_msg
= host_msg
;
4113 host_msg
= g_malloc(len
);
4114 memcpy(host_msg
, copy_msg
, len
);
4115 ret
= fd_trans_target_to_host_data(fd
)(host_msg
, len
);
4121 addr
= alloca(addrlen
+1);
4122 ret
= target_to_host_sockaddr(fd
, addr
, target_addr
, addrlen
);
4126 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
4128 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, NULL
, 0));
4133 host_msg
= copy_msg
;
4135 unlock_user(host_msg
, msg
, 0);
4139 /* do_recvfrom() Must return target values and target errnos. */
4140 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
4141 abi_ulong target_addr
,
4142 abi_ulong target_addrlen
)
4149 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
4151 return -TARGET_EFAULT
;
4153 if (get_user_u32(addrlen
, target_addrlen
)) {
4154 ret
= -TARGET_EFAULT
;
4157 if ((int)addrlen
< 0) {
4158 ret
= -TARGET_EINVAL
;
4161 addr
= alloca(addrlen
);
4162 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
,
4165 addr
= NULL
; /* To keep compiler quiet. */
4166 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
, NULL
, 0));
4168 if (!is_error(ret
)) {
4169 if (fd_trans_host_to_target_data(fd
)) {
4170 ret
= fd_trans_host_to_target_data(fd
)(host_msg
, ret
);
4173 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
4174 if (put_user_u32(addrlen
, target_addrlen
)) {
4175 ret
= -TARGET_EFAULT
;
4179 unlock_user(host_msg
, msg
, len
);
4182 unlock_user(host_msg
, msg
, 0);
4187 #ifdef TARGET_NR_socketcall
4188 /* do_socketcall() must return target values and target errnos. */
4189 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
4191 static const unsigned nargs
[] = { /* number of arguments per operation */
4192 [TARGET_SYS_SOCKET
] = 3, /* domain, type, protocol */
4193 [TARGET_SYS_BIND
] = 3, /* fd, addr, addrlen */
4194 [TARGET_SYS_CONNECT
] = 3, /* fd, addr, addrlen */
4195 [TARGET_SYS_LISTEN
] = 2, /* fd, backlog */
4196 [TARGET_SYS_ACCEPT
] = 3, /* fd, addr, addrlen */
4197 [TARGET_SYS_GETSOCKNAME
] = 3, /* fd, addr, addrlen */
4198 [TARGET_SYS_GETPEERNAME
] = 3, /* fd, addr, addrlen */
4199 [TARGET_SYS_SOCKETPAIR
] = 4, /* domain, type, protocol, tab */
4200 [TARGET_SYS_SEND
] = 4, /* fd, msg, len, flags */
4201 [TARGET_SYS_RECV
] = 4, /* fd, msg, len, flags */
4202 [TARGET_SYS_SENDTO
] = 6, /* fd, msg, len, flags, addr, addrlen */
4203 [TARGET_SYS_RECVFROM
] = 6, /* fd, msg, len, flags, addr, addrlen */
4204 [TARGET_SYS_SHUTDOWN
] = 2, /* fd, how */
4205 [TARGET_SYS_SETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
4206 [TARGET_SYS_GETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
4207 [TARGET_SYS_SENDMSG
] = 3, /* fd, msg, flags */
4208 [TARGET_SYS_RECVMSG
] = 3, /* fd, msg, flags */
4209 [TARGET_SYS_ACCEPT4
] = 4, /* fd, addr, addrlen, flags */
4210 [TARGET_SYS_RECVMMSG
] = 4, /* fd, msgvec, vlen, flags */
4211 [TARGET_SYS_SENDMMSG
] = 4, /* fd, msgvec, vlen, flags */
4213 abi_long a
[6]; /* max 6 args */
4216 /* check the range of the first argument num */
4217 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
4218 if (num
< 1 || num
> TARGET_SYS_SENDMMSG
) {
4219 return -TARGET_EINVAL
;
4221 /* ensure we have space for args */
4222 if (nargs
[num
] > ARRAY_SIZE(a
)) {
4223 return -TARGET_EINVAL
;
4225 /* collect the arguments in a[] according to nargs[] */
4226 for (i
= 0; i
< nargs
[num
]; ++i
) {
4227 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
4228 return -TARGET_EFAULT
;
4231 /* now when we have the args, invoke the appropriate underlying function */
4233 case TARGET_SYS_SOCKET
: /* domain, type, protocol */
4234 return do_socket(a
[0], a
[1], a
[2]);
4235 case TARGET_SYS_BIND
: /* sockfd, addr, addrlen */
4236 return do_bind(a
[0], a
[1], a
[2]);
4237 case TARGET_SYS_CONNECT
: /* sockfd, addr, addrlen */
4238 return do_connect(a
[0], a
[1], a
[2]);
4239 case TARGET_SYS_LISTEN
: /* sockfd, backlog */
4240 return get_errno(listen(a
[0], a
[1]));
4241 case TARGET_SYS_ACCEPT
: /* sockfd, addr, addrlen */
4242 return do_accept4(a
[0], a
[1], a
[2], 0);
4243 case TARGET_SYS_GETSOCKNAME
: /* sockfd, addr, addrlen */
4244 return do_getsockname(a
[0], a
[1], a
[2]);
4245 case TARGET_SYS_GETPEERNAME
: /* sockfd, addr, addrlen */
4246 return do_getpeername(a
[0], a
[1], a
[2]);
4247 case TARGET_SYS_SOCKETPAIR
: /* domain, type, protocol, tab */
4248 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
4249 case TARGET_SYS_SEND
: /* sockfd, msg, len, flags */
4250 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
4251 case TARGET_SYS_RECV
: /* sockfd, msg, len, flags */
4252 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
4253 case TARGET_SYS_SENDTO
: /* sockfd, msg, len, flags, addr, addrlen */
4254 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
4255 case TARGET_SYS_RECVFROM
: /* sockfd, msg, len, flags, addr, addrlen */
4256 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
4257 case TARGET_SYS_SHUTDOWN
: /* sockfd, how */
4258 return get_errno(shutdown(a
[0], a
[1]));
4259 case TARGET_SYS_SETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
4260 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
4261 case TARGET_SYS_GETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
4262 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
4263 case TARGET_SYS_SENDMSG
: /* sockfd, msg, flags */
4264 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
4265 case TARGET_SYS_RECVMSG
: /* sockfd, msg, flags */
4266 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
4267 case TARGET_SYS_ACCEPT4
: /* sockfd, addr, addrlen, flags */
4268 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
4269 case TARGET_SYS_RECVMMSG
: /* sockfd, msgvec, vlen, flags */
4270 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 0);
4271 case TARGET_SYS_SENDMMSG
: /* sockfd, msgvec, vlen, flags */
4272 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 1);
4274 gemu_log("Unsupported socketcall: %d\n", num
);
4275 return -TARGET_EINVAL
;
4280 #define N_SHM_REGIONS 32
4282 static struct shm_region
{
4286 } shm_regions
[N_SHM_REGIONS
];
4288 #ifndef TARGET_SEMID64_DS
4289 /* asm-generic version of this struct */
4290 struct target_semid64_ds
4292 struct target_ipc_perm sem_perm
;
4293 abi_ulong sem_otime
;
4294 #if TARGET_ABI_BITS == 32
4295 abi_ulong __unused1
;
4297 abi_ulong sem_ctime
;
4298 #if TARGET_ABI_BITS == 32
4299 abi_ulong __unused2
;
4301 abi_ulong sem_nsems
;
4302 abi_ulong __unused3
;
4303 abi_ulong __unused4
;
4307 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
4308 abi_ulong target_addr
)
4310 struct target_ipc_perm
*target_ip
;
4311 struct target_semid64_ds
*target_sd
;
4313 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4314 return -TARGET_EFAULT
;
4315 target_ip
= &(target_sd
->sem_perm
);
4316 host_ip
->__key
= tswap32(target_ip
->__key
);
4317 host_ip
->uid
= tswap32(target_ip
->uid
);
4318 host_ip
->gid
= tswap32(target_ip
->gid
);
4319 host_ip
->cuid
= tswap32(target_ip
->cuid
);
4320 host_ip
->cgid
= tswap32(target_ip
->cgid
);
4321 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4322 host_ip
->mode
= tswap32(target_ip
->mode
);
4324 host_ip
->mode
= tswap16(target_ip
->mode
);
4326 #if defined(TARGET_PPC)
4327 host_ip
->__seq
= tswap32(target_ip
->__seq
);
4329 host_ip
->__seq
= tswap16(target_ip
->__seq
);
4331 unlock_user_struct(target_sd
, target_addr
, 0);
4335 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
4336 struct ipc_perm
*host_ip
)
4338 struct target_ipc_perm
*target_ip
;
4339 struct target_semid64_ds
*target_sd
;
4341 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4342 return -TARGET_EFAULT
;
4343 target_ip
= &(target_sd
->sem_perm
);
4344 target_ip
->__key
= tswap32(host_ip
->__key
);
4345 target_ip
->uid
= tswap32(host_ip
->uid
);
4346 target_ip
->gid
= tswap32(host_ip
->gid
);
4347 target_ip
->cuid
= tswap32(host_ip
->cuid
);
4348 target_ip
->cgid
= tswap32(host_ip
->cgid
);
4349 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4350 target_ip
->mode
= tswap32(host_ip
->mode
);
4352 target_ip
->mode
= tswap16(host_ip
->mode
);
4354 #if defined(TARGET_PPC)
4355 target_ip
->__seq
= tswap32(host_ip
->__seq
);
4357 target_ip
->__seq
= tswap16(host_ip
->__seq
);
4359 unlock_user_struct(target_sd
, target_addr
, 1);
4363 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
4364 abi_ulong target_addr
)
4366 struct target_semid64_ds
*target_sd
;
4368 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4369 return -TARGET_EFAULT
;
4370 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
4371 return -TARGET_EFAULT
;
4372 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
4373 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
4374 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
4375 unlock_user_struct(target_sd
, target_addr
, 0);
4379 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
4380 struct semid_ds
*host_sd
)
4382 struct target_semid64_ds
*target_sd
;
4384 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4385 return -TARGET_EFAULT
;
4386 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
4387 return -TARGET_EFAULT
;
4388 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
4389 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
4390 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
4391 unlock_user_struct(target_sd
, target_addr
, 1);
4395 struct target_seminfo
{
4408 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
4409 struct seminfo
*host_seminfo
)
4411 struct target_seminfo
*target_seminfo
;
4412 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
4413 return -TARGET_EFAULT
;
4414 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
4415 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
4416 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
4417 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
4418 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
4419 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
4420 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
4421 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
4422 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
4423 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
4424 unlock_user_struct(target_seminfo
, target_addr
, 1);
4430 struct semid_ds
*buf
;
4431 unsigned short *array
;
4432 struct seminfo
*__buf
;
4435 union target_semun
{
4442 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
4443 abi_ulong target_addr
)
4446 unsigned short *array
;
4448 struct semid_ds semid_ds
;
4451 semun
.buf
= &semid_ds
;
4453 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
4455 return get_errno(ret
);
4457 nsems
= semid_ds
.sem_nsems
;
4459 *host_array
= g_try_new(unsigned short, nsems
);
4461 return -TARGET_ENOMEM
;
4463 array
= lock_user(VERIFY_READ
, target_addr
,
4464 nsems
*sizeof(unsigned short), 1);
4466 g_free(*host_array
);
4467 return -TARGET_EFAULT
;
4470 for(i
=0; i
<nsems
; i
++) {
4471 __get_user((*host_array
)[i
], &array
[i
]);
4473 unlock_user(array
, target_addr
, 0);
4478 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
4479 unsigned short **host_array
)
4482 unsigned short *array
;
4484 struct semid_ds semid_ds
;
4487 semun
.buf
= &semid_ds
;
4489 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
4491 return get_errno(ret
);
4493 nsems
= semid_ds
.sem_nsems
;
4495 array
= lock_user(VERIFY_WRITE
, target_addr
,
4496 nsems
*sizeof(unsigned short), 0);
4498 return -TARGET_EFAULT
;
4500 for(i
=0; i
<nsems
; i
++) {
4501 __put_user((*host_array
)[i
], &array
[i
]);
4503 g_free(*host_array
);
4504 unlock_user(array
, target_addr
, 1);
4509 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
4510 abi_ulong target_arg
)
4512 union target_semun target_su
= { .buf
= target_arg
};
4514 struct semid_ds dsarg
;
4515 unsigned short *array
= NULL
;
4516 struct seminfo seminfo
;
4517 abi_long ret
= -TARGET_EINVAL
;
4524 /* In 64 bit cross-endian situations, we will erroneously pick up
4525 * the wrong half of the union for the "val" element. To rectify
4526 * this, the entire 8-byte structure is byteswapped, followed by
4527 * a swap of the 4 byte val field. In other cases, the data is
4528 * already in proper host byte order. */
4529 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
4530 target_su
.buf
= tswapal(target_su
.buf
);
4531 arg
.val
= tswap32(target_su
.val
);
4533 arg
.val
= target_su
.val
;
4535 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4539 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
4543 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4544 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
4551 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
4555 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4556 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
4562 arg
.__buf
= &seminfo
;
4563 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4564 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
4572 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
4579 struct target_sembuf
{
4580 unsigned short sem_num
;
4585 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
4586 abi_ulong target_addr
,
4589 struct target_sembuf
*target_sembuf
;
4592 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
4593 nsops
*sizeof(struct target_sembuf
), 1);
4595 return -TARGET_EFAULT
;
4597 for(i
=0; i
<nsops
; i
++) {
4598 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
4599 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
4600 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
4603 unlock_user(target_sembuf
, target_addr
, 0);
4608 static inline abi_long
do_semop(int semid
, abi_long ptr
, unsigned nsops
)
4610 struct sembuf sops
[nsops
];
4612 if (target_to_host_sembuf(sops
, ptr
, nsops
))
4613 return -TARGET_EFAULT
;
4615 return get_errno(safe_semtimedop(semid
, sops
, nsops
, NULL
));
4618 struct target_msqid_ds
4620 struct target_ipc_perm msg_perm
;
4621 abi_ulong msg_stime
;
4622 #if TARGET_ABI_BITS == 32
4623 abi_ulong __unused1
;
4625 abi_ulong msg_rtime
;
4626 #if TARGET_ABI_BITS == 32
4627 abi_ulong __unused2
;
4629 abi_ulong msg_ctime
;
4630 #if TARGET_ABI_BITS == 32
4631 abi_ulong __unused3
;
4633 abi_ulong __msg_cbytes
;
4635 abi_ulong msg_qbytes
;
4636 abi_ulong msg_lspid
;
4637 abi_ulong msg_lrpid
;
4638 abi_ulong __unused4
;
4639 abi_ulong __unused5
;
4642 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
4643 abi_ulong target_addr
)
4645 struct target_msqid_ds
*target_md
;
4647 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
4648 return -TARGET_EFAULT
;
4649 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
4650 return -TARGET_EFAULT
;
4651 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
4652 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
4653 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
4654 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
4655 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
4656 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
4657 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
4658 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
4659 unlock_user_struct(target_md
, target_addr
, 0);
4663 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
4664 struct msqid_ds
*host_md
)
4666 struct target_msqid_ds
*target_md
;
4668 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
4669 return -TARGET_EFAULT
;
4670 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
4671 return -TARGET_EFAULT
;
4672 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
4673 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
4674 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
4675 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
4676 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
4677 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
4678 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
4679 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
4680 unlock_user_struct(target_md
, target_addr
, 1);
4684 struct target_msginfo
{
4692 unsigned short int msgseg
;
4695 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
4696 struct msginfo
*host_msginfo
)
4698 struct target_msginfo
*target_msginfo
;
4699 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
4700 return -TARGET_EFAULT
;
4701 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
4702 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
4703 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
4704 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
4705 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
4706 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
4707 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
4708 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
4709 unlock_user_struct(target_msginfo
, target_addr
, 1);
4713 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
4715 struct msqid_ds dsarg
;
4716 struct msginfo msginfo
;
4717 abi_long ret
= -TARGET_EINVAL
;
4725 if (target_to_host_msqid_ds(&dsarg
,ptr
))
4726 return -TARGET_EFAULT
;
4727 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
4728 if (host_to_target_msqid_ds(ptr
,&dsarg
))
4729 return -TARGET_EFAULT
;
4732 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
4736 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
4737 if (host_to_target_msginfo(ptr
, &msginfo
))
4738 return -TARGET_EFAULT
;
4745 struct target_msgbuf
{
4750 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
4751 ssize_t msgsz
, int msgflg
)
4753 struct target_msgbuf
*target_mb
;
4754 struct msgbuf
*host_mb
;
4758 return -TARGET_EINVAL
;
4761 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
4762 return -TARGET_EFAULT
;
4763 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4765 unlock_user_struct(target_mb
, msgp
, 0);
4766 return -TARGET_ENOMEM
;
4768 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
4769 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
4770 ret
= get_errno(safe_msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
4772 unlock_user_struct(target_mb
, msgp
, 0);
4777 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
4778 ssize_t msgsz
, abi_long msgtyp
,
4781 struct target_msgbuf
*target_mb
;
4783 struct msgbuf
*host_mb
;
4787 return -TARGET_EINVAL
;
4790 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
4791 return -TARGET_EFAULT
;
4793 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4795 ret
= -TARGET_ENOMEM
;
4798 ret
= get_errno(safe_msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
4801 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
4802 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
4803 if (!target_mtext
) {
4804 ret
= -TARGET_EFAULT
;
4807 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
4808 unlock_user(target_mtext
, target_mtext_addr
, ret
);
4811 target_mb
->mtype
= tswapal(host_mb
->mtype
);
4815 unlock_user_struct(target_mb
, msgp
, 1);
4820 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
4821 abi_ulong target_addr
)
4823 struct target_shmid_ds
*target_sd
;
4825 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4826 return -TARGET_EFAULT
;
4827 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
4828 return -TARGET_EFAULT
;
4829 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4830 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4831 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4832 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4833 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4834 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4835 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4836 unlock_user_struct(target_sd
, target_addr
, 0);
4840 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
4841 struct shmid_ds
*host_sd
)
4843 struct target_shmid_ds
*target_sd
;
4845 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4846 return -TARGET_EFAULT
;
4847 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
4848 return -TARGET_EFAULT
;
4849 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4850 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4851 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4852 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4853 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4854 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4855 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4856 unlock_user_struct(target_sd
, target_addr
, 1);
4860 struct target_shminfo
{
4868 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
4869 struct shminfo
*host_shminfo
)
4871 struct target_shminfo
*target_shminfo
;
4872 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
4873 return -TARGET_EFAULT
;
4874 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
4875 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
4876 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
4877 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
4878 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
4879 unlock_user_struct(target_shminfo
, target_addr
, 1);
4883 struct target_shm_info
{
4888 abi_ulong swap_attempts
;
4889 abi_ulong swap_successes
;
4892 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
4893 struct shm_info
*host_shm_info
)
4895 struct target_shm_info
*target_shm_info
;
4896 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
4897 return -TARGET_EFAULT
;
4898 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
4899 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
4900 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
4901 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
4902 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
4903 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
4904 unlock_user_struct(target_shm_info
, target_addr
, 1);
4908 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
4910 struct shmid_ds dsarg
;
4911 struct shminfo shminfo
;
4912 struct shm_info shm_info
;
4913 abi_long ret
= -TARGET_EINVAL
;
4921 if (target_to_host_shmid_ds(&dsarg
, buf
))
4922 return -TARGET_EFAULT
;
4923 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
4924 if (host_to_target_shmid_ds(buf
, &dsarg
))
4925 return -TARGET_EFAULT
;
4928 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
4929 if (host_to_target_shminfo(buf
, &shminfo
))
4930 return -TARGET_EFAULT
;
4933 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
4934 if (host_to_target_shm_info(buf
, &shm_info
))
4935 return -TARGET_EFAULT
;
4940 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
4947 #ifndef TARGET_FORCE_SHMLBA
4948 /* For most architectures, SHMLBA is the same as the page size;
4949 * some architectures have larger values, in which case they should
4950 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
4951 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
4952 * and defining its own value for SHMLBA.
4954 * The kernel also permits SHMLBA to be set by the architecture to a
4955 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
4956 * this means that addresses are rounded to the large size if
4957 * SHM_RND is set but addresses not aligned to that size are not rejected
4958 * as long as they are at least page-aligned. Since the only architecture
4959 * which uses this is ia64 this code doesn't provide for that oddity.
4961 static inline abi_ulong
target_shmlba(CPUArchState
*cpu_env
)
4963 return TARGET_PAGE_SIZE
;
4967 static inline abi_ulong
do_shmat(CPUArchState
*cpu_env
,
4968 int shmid
, abi_ulong shmaddr
, int shmflg
)
4972 struct shmid_ds shm_info
;
4976 /* find out the length of the shared memory segment */
4977 ret
= get_errno(shmctl(shmid
, IPC_STAT
, &shm_info
));
4978 if (is_error(ret
)) {
4979 /* can't get length, bail out */
4983 shmlba
= target_shmlba(cpu_env
);
4985 if (shmaddr
& (shmlba
- 1)) {
4986 if (shmflg
& SHM_RND
) {
4987 shmaddr
&= ~(shmlba
- 1);
4989 return -TARGET_EINVAL
;
4992 if (!guest_range_valid(shmaddr
, shm_info
.shm_segsz
)) {
4993 return -TARGET_EINVAL
;
4999 host_raddr
= shmat(shmid
, (void *)g2h(shmaddr
), shmflg
);
5001 abi_ulong mmap_start
;
5003 mmap_start
= mmap_find_vma(0, shm_info
.shm_segsz
);
5005 if (mmap_start
== -1) {
5007 host_raddr
= (void *)-1;
5009 host_raddr
= shmat(shmid
, g2h(mmap_start
), shmflg
| SHM_REMAP
);
5012 if (host_raddr
== (void *)-1) {
5014 return get_errno((long)host_raddr
);
5016 raddr
=h2g((unsigned long)host_raddr
);
5018 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
5019 PAGE_VALID
| PAGE_READ
|
5020 ((shmflg
& SHM_RDONLY
)? 0 : PAGE_WRITE
));
5022 for (i
= 0; i
< N_SHM_REGIONS
; i
++) {
5023 if (!shm_regions
[i
].in_use
) {
5024 shm_regions
[i
].in_use
= true;
5025 shm_regions
[i
].start
= raddr
;
5026 shm_regions
[i
].size
= shm_info
.shm_segsz
;
5036 static inline abi_long
do_shmdt(abi_ulong shmaddr
)
5043 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
5044 if (shm_regions
[i
].in_use
&& shm_regions
[i
].start
== shmaddr
) {
5045 shm_regions
[i
].in_use
= false;
5046 page_set_flags(shmaddr
, shmaddr
+ shm_regions
[i
].size
, 0);
5050 rv
= get_errno(shmdt(g2h(shmaddr
)));
5057 #ifdef TARGET_NR_ipc
5058 /* ??? This only works with linear mappings. */
5059 /* do_ipc() must return target values and target errnos. */
5060 static abi_long
do_ipc(CPUArchState
*cpu_env
,
5061 unsigned int call
, abi_long first
,
5062 abi_long second
, abi_long third
,
5063 abi_long ptr
, abi_long fifth
)
5068 version
= call
>> 16;
5073 ret
= do_semop(first
, ptr
, second
);
5077 ret
= get_errno(semget(first
, second
, third
));
5080 case IPCOP_semctl
: {
5081 /* The semun argument to semctl is passed by value, so dereference the
5084 get_user_ual(atptr
, ptr
);
5085 ret
= do_semctl(first
, second
, third
, atptr
);
5090 ret
= get_errno(msgget(first
, second
));
5094 ret
= do_msgsnd(first
, ptr
, second
, third
);
5098 ret
= do_msgctl(first
, second
, ptr
);
5105 struct target_ipc_kludge
{
5110 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
5111 ret
= -TARGET_EFAULT
;
5115 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
5117 unlock_user_struct(tmp
, ptr
, 0);
5121 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
5130 raddr
= do_shmat(cpu_env
, first
, ptr
, second
);
5131 if (is_error(raddr
))
5132 return get_errno(raddr
);
5133 if (put_user_ual(raddr
, third
))
5134 return -TARGET_EFAULT
;
5138 ret
= -TARGET_EINVAL
;
5143 ret
= do_shmdt(ptr
);
5147 /* IPC_* flag values are the same on all linux platforms */
5148 ret
= get_errno(shmget(first
, second
, third
));
5151 /* IPC_* and SHM_* command values are the same on all linux platforms */
5153 ret
= do_shmctl(first
, second
, ptr
);
5156 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
5157 ret
= -TARGET_ENOSYS
;
5164 /* kernel structure types definitions */
5166 #define STRUCT(name, ...) STRUCT_ ## name,
5167 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
5169 #include "syscall_types.h"
5173 #undef STRUCT_SPECIAL
5175 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
5176 #define STRUCT_SPECIAL(name)
5177 #include "syscall_types.h"
5179 #undef STRUCT_SPECIAL
5181 typedef struct IOCTLEntry IOCTLEntry
;
5183 typedef abi_long
do_ioctl_fn(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5184 int fd
, int cmd
, abi_long arg
);
5188 unsigned int host_cmd
;
5191 do_ioctl_fn
*do_ioctl
;
5192 const argtype arg_type
[5];
5195 #define IOC_R 0x0001
5196 #define IOC_W 0x0002
5197 #define IOC_RW (IOC_R | IOC_W)
5199 #define MAX_STRUCT_SIZE 4096
5201 #ifdef CONFIG_FIEMAP
5202 /* So fiemap access checks don't overflow on 32 bit systems.
5203 * This is very slightly smaller than the limit imposed by
5204 * the underlying kernel.
5206 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
5207 / sizeof(struct fiemap_extent))
5209 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5210 int fd
, int cmd
, abi_long arg
)
5212 /* The parameter for this ioctl is a struct fiemap followed
5213 * by an array of struct fiemap_extent whose size is set
5214 * in fiemap->fm_extent_count. The array is filled in by the
5217 int target_size_in
, target_size_out
;
5219 const argtype
*arg_type
= ie
->arg_type
;
5220 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
5223 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
5227 assert(arg_type
[0] == TYPE_PTR
);
5228 assert(ie
->access
== IOC_RW
);
5230 target_size_in
= thunk_type_size(arg_type
, 0);
5231 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
5233 return -TARGET_EFAULT
;
5235 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5236 unlock_user(argptr
, arg
, 0);
5237 fm
= (struct fiemap
*)buf_temp
;
5238 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
5239 return -TARGET_EINVAL
;
5242 outbufsz
= sizeof (*fm
) +
5243 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
5245 if (outbufsz
> MAX_STRUCT_SIZE
) {
5246 /* We can't fit all the extents into the fixed size buffer.
5247 * Allocate one that is large enough and use it instead.
5249 fm
= g_try_malloc(outbufsz
);
5251 return -TARGET_ENOMEM
;
5253 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
5256 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, fm
));
5257 if (!is_error(ret
)) {
5258 target_size_out
= target_size_in
;
5259 /* An extent_count of 0 means we were only counting the extents
5260 * so there are no structs to copy
5262 if (fm
->fm_extent_count
!= 0) {
5263 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
5265 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
5267 ret
= -TARGET_EFAULT
;
5269 /* Convert the struct fiemap */
5270 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
5271 if (fm
->fm_extent_count
!= 0) {
5272 p
= argptr
+ target_size_in
;
5273 /* ...and then all the struct fiemap_extents */
5274 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
5275 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
5280 unlock_user(argptr
, arg
, target_size_out
);
5290 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5291 int fd
, int cmd
, abi_long arg
)
5293 const argtype
*arg_type
= ie
->arg_type
;
5297 struct ifconf
*host_ifconf
;
5299 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
5300 int target_ifreq_size
;
5305 abi_long target_ifc_buf
;
5309 assert(arg_type
[0] == TYPE_PTR
);
5310 assert(ie
->access
== IOC_RW
);
5313 target_size
= thunk_type_size(arg_type
, 0);
5315 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5317 return -TARGET_EFAULT
;
5318 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5319 unlock_user(argptr
, arg
, 0);
5321 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
5322 target_ifc_len
= host_ifconf
->ifc_len
;
5323 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
5325 target_ifreq_size
= thunk_type_size(ifreq_arg_type
, 0);
5326 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
5327 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
5329 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
5330 if (outbufsz
> MAX_STRUCT_SIZE
) {
5331 /* We can't fit all the extents into the fixed size buffer.
5332 * Allocate one that is large enough and use it instead.
5334 host_ifconf
= malloc(outbufsz
);
5336 return -TARGET_ENOMEM
;
5338 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
5341 host_ifc_buf
= (char*)host_ifconf
+ sizeof(*host_ifconf
);
5343 host_ifconf
->ifc_len
= host_ifc_len
;
5344 host_ifconf
->ifc_buf
= host_ifc_buf
;
5346 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_ifconf
));
5347 if (!is_error(ret
)) {
5348 /* convert host ifc_len to target ifc_len */
5350 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
5351 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
5352 host_ifconf
->ifc_len
= target_ifc_len
;
5354 /* restore target ifc_buf */
5356 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
5358 /* copy struct ifconf to target user */
5360 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5362 return -TARGET_EFAULT
;
5363 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
5364 unlock_user(argptr
, arg
, target_size
);
5366 /* copy ifreq[] to target user */
5368 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
5369 for (i
= 0; i
< nb_ifreq
; i
++) {
5370 thunk_convert(argptr
+ i
* target_ifreq_size
,
5371 host_ifc_buf
+ i
* sizeof(struct ifreq
),
5372 ifreq_arg_type
, THUNK_TARGET
);
5374 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
5384 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
5385 int cmd
, abi_long arg
)
5388 struct dm_ioctl
*host_dm
;
5389 abi_long guest_data
;
5390 uint32_t guest_data_size
;
5392 const argtype
*arg_type
= ie
->arg_type
;
5394 void *big_buf
= NULL
;
5398 target_size
= thunk_type_size(arg_type
, 0);
5399 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5401 ret
= -TARGET_EFAULT
;
5404 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5405 unlock_user(argptr
, arg
, 0);
5407 /* buf_temp is too small, so fetch things into a bigger buffer */
5408 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
5409 memcpy(big_buf
, buf_temp
, target_size
);
5413 guest_data
= arg
+ host_dm
->data_start
;
5414 if ((guest_data
- arg
) < 0) {
5415 ret
= -TARGET_EINVAL
;
5418 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5419 host_data
= (char*)host_dm
+ host_dm
->data_start
;
5421 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
5423 ret
= -TARGET_EFAULT
;
5427 switch (ie
->host_cmd
) {
5429 case DM_LIST_DEVICES
:
5432 case DM_DEV_SUSPEND
:
5435 case DM_TABLE_STATUS
:
5436 case DM_TABLE_CLEAR
:
5438 case DM_LIST_VERSIONS
:
5442 case DM_DEV_SET_GEOMETRY
:
5443 /* data contains only strings */
5444 memcpy(host_data
, argptr
, guest_data_size
);
5447 memcpy(host_data
, argptr
, guest_data_size
);
5448 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
5452 void *gspec
= argptr
;
5453 void *cur_data
= host_data
;
5454 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5455 int spec_size
= thunk_type_size(arg_type
, 0);
5458 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5459 struct dm_target_spec
*spec
= cur_data
;
5463 thunk_convert(spec
, gspec
, arg_type
, THUNK_HOST
);
5464 slen
= strlen((char*)gspec
+ spec_size
) + 1;
5466 spec
->next
= sizeof(*spec
) + slen
;
5467 strcpy((char*)&spec
[1], gspec
+ spec_size
);
5469 cur_data
+= spec
->next
;
5474 ret
= -TARGET_EINVAL
;
5475 unlock_user(argptr
, guest_data
, 0);
5478 unlock_user(argptr
, guest_data
, 0);
5480 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5481 if (!is_error(ret
)) {
5482 guest_data
= arg
+ host_dm
->data_start
;
5483 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5484 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
5485 switch (ie
->host_cmd
) {
5490 case DM_DEV_SUSPEND
:
5493 case DM_TABLE_CLEAR
:
5495 case DM_DEV_SET_GEOMETRY
:
5496 /* no return data */
5498 case DM_LIST_DEVICES
:
5500 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
5501 uint32_t remaining_data
= guest_data_size
;
5502 void *cur_data
= argptr
;
5503 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
5504 int nl_size
= 12; /* can't use thunk_size due to alignment */
5507 uint32_t next
= nl
->next
;
5509 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
5511 if (remaining_data
< nl
->next
) {
5512 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5515 thunk_convert(cur_data
, nl
, arg_type
, THUNK_TARGET
);
5516 strcpy(cur_data
+ nl_size
, nl
->name
);
5517 cur_data
+= nl
->next
;
5518 remaining_data
-= nl
->next
;
5522 nl
= (void*)nl
+ next
;
5527 case DM_TABLE_STATUS
:
5529 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
5530 void *cur_data
= argptr
;
5531 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5532 int spec_size
= thunk_type_size(arg_type
, 0);
5535 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5536 uint32_t next
= spec
->next
;
5537 int slen
= strlen((char*)&spec
[1]) + 1;
5538 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
5539 if (guest_data_size
< spec
->next
) {
5540 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5543 thunk_convert(cur_data
, spec
, arg_type
, THUNK_TARGET
);
5544 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
5545 cur_data
= argptr
+ spec
->next
;
5546 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
5552 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
5553 int count
= *(uint32_t*)hdata
;
5554 uint64_t *hdev
= hdata
+ 8;
5555 uint64_t *gdev
= argptr
+ 8;
5558 *(uint32_t*)argptr
= tswap32(count
);
5559 for (i
= 0; i
< count
; i
++) {
5560 *gdev
= tswap64(*hdev
);
5566 case DM_LIST_VERSIONS
:
5568 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
5569 uint32_t remaining_data
= guest_data_size
;
5570 void *cur_data
= argptr
;
5571 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
5572 int vers_size
= thunk_type_size(arg_type
, 0);
5575 uint32_t next
= vers
->next
;
5577 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
5579 if (remaining_data
< vers
->next
) {
5580 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5583 thunk_convert(cur_data
, vers
, arg_type
, THUNK_TARGET
);
5584 strcpy(cur_data
+ vers_size
, vers
->name
);
5585 cur_data
+= vers
->next
;
5586 remaining_data
-= vers
->next
;
5590 vers
= (void*)vers
+ next
;
5595 unlock_user(argptr
, guest_data
, 0);
5596 ret
= -TARGET_EINVAL
;
5599 unlock_user(argptr
, guest_data
, guest_data_size
);
5601 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5603 ret
= -TARGET_EFAULT
;
5606 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5607 unlock_user(argptr
, arg
, target_size
);
5614 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
5615 int cmd
, abi_long arg
)
5619 const argtype
*arg_type
= ie
->arg_type
;
5620 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
5623 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
5624 struct blkpg_partition host_part
;
5626 /* Read and convert blkpg */
5628 target_size
= thunk_type_size(arg_type
, 0);
5629 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5631 ret
= -TARGET_EFAULT
;
5634 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5635 unlock_user(argptr
, arg
, 0);
5637 switch (host_blkpg
->op
) {
5638 case BLKPG_ADD_PARTITION
:
5639 case BLKPG_DEL_PARTITION
:
5640 /* payload is struct blkpg_partition */
5643 /* Unknown opcode */
5644 ret
= -TARGET_EINVAL
;
5648 /* Read and convert blkpg->data */
5649 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
5650 target_size
= thunk_type_size(part_arg_type
, 0);
5651 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5653 ret
= -TARGET_EFAULT
;
5656 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
5657 unlock_user(argptr
, arg
, 0);
5659 /* Swizzle the data pointer to our local copy and call! */
5660 host_blkpg
->data
= &host_part
;
5661 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_blkpg
));
5667 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5668 int fd
, int cmd
, abi_long arg
)
5670 const argtype
*arg_type
= ie
->arg_type
;
5671 const StructEntry
*se
;
5672 const argtype
*field_types
;
5673 const int *dst_offsets
, *src_offsets
;
5676 abi_ulong
*target_rt_dev_ptr
;
5677 unsigned long *host_rt_dev_ptr
;
5681 assert(ie
->access
== IOC_W
);
5682 assert(*arg_type
== TYPE_PTR
);
5684 assert(*arg_type
== TYPE_STRUCT
);
5685 target_size
= thunk_type_size(arg_type
, 0);
5686 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5688 return -TARGET_EFAULT
;
5691 assert(*arg_type
== (int)STRUCT_rtentry
);
5692 se
= struct_entries
+ *arg_type
++;
5693 assert(se
->convert
[0] == NULL
);
5694 /* convert struct here to be able to catch rt_dev string */
5695 field_types
= se
->field_types
;
5696 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
5697 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
5698 for (i
= 0; i
< se
->nb_fields
; i
++) {
5699 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
5700 assert(*field_types
== TYPE_PTRVOID
);
5701 target_rt_dev_ptr
= (abi_ulong
*)(argptr
+ src_offsets
[i
]);
5702 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
5703 if (*target_rt_dev_ptr
!= 0) {
5704 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
5705 tswapal(*target_rt_dev_ptr
));
5706 if (!*host_rt_dev_ptr
) {
5707 unlock_user(argptr
, arg
, 0);
5708 return -TARGET_EFAULT
;
5711 *host_rt_dev_ptr
= 0;
5716 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
5717 argptr
+ src_offsets
[i
],
5718 field_types
, THUNK_HOST
);
5720 unlock_user(argptr
, arg
, 0);
5722 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5723 if (*host_rt_dev_ptr
!= 0) {
5724 unlock_user((void *)*host_rt_dev_ptr
,
5725 *target_rt_dev_ptr
, 0);
5730 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5731 int fd
, int cmd
, abi_long arg
)
5733 int sig
= target_to_host_signal(arg
);
5734 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, sig
));
5738 static abi_long
do_ioctl_tiocgptpeer(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5739 int fd
, int cmd
, abi_long arg
)
5741 int flags
= target_to_host_bitmask(arg
, fcntl_flags_tbl
);
5742 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, flags
));
5746 static IOCTLEntry ioctl_entries
[] = {
5747 #define IOCTL(cmd, access, ...) \
5748 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5749 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5750 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
5751 #define IOCTL_IGNORE(cmd) \
5752 { TARGET_ ## cmd, 0, #cmd },
5757 /* ??? Implement proper locking for ioctls. */
5758 /* do_ioctl() Must return target values and target errnos. */
5759 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
5761 const IOCTLEntry
*ie
;
5762 const argtype
*arg_type
;
5764 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
5770 if (ie
->target_cmd
== 0) {
5771 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
5772 return -TARGET_ENOSYS
;
5774 if (ie
->target_cmd
== cmd
)
5778 arg_type
= ie
->arg_type
;
5780 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd
, ie
->name
);
5783 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
5784 } else if (!ie
->host_cmd
) {
5785 /* Some architectures define BSD ioctls in their headers
5786 that are not implemented in Linux. */
5787 return -TARGET_ENOSYS
;
5790 switch(arg_type
[0]) {
5793 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
));
5797 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, arg
));
5801 target_size
= thunk_type_size(arg_type
, 0);
5802 switch(ie
->access
) {
5804 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5805 if (!is_error(ret
)) {
5806 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5808 return -TARGET_EFAULT
;
5809 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5810 unlock_user(argptr
, arg
, target_size
);
5814 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5816 return -TARGET_EFAULT
;
5817 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5818 unlock_user(argptr
, arg
, 0);
5819 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5823 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5825 return -TARGET_EFAULT
;
5826 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5827 unlock_user(argptr
, arg
, 0);
5828 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5829 if (!is_error(ret
)) {
5830 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5832 return -TARGET_EFAULT
;
5833 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5834 unlock_user(argptr
, arg
, target_size
);
5840 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5841 (long)cmd
, arg_type
[0]);
5842 ret
= -TARGET_ENOSYS
;
5848 static const bitmask_transtbl iflag_tbl
[] = {
5849 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
5850 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
5851 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
5852 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
5853 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
5854 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
5855 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
5856 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
5857 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
5858 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
5859 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
5860 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
5861 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
5862 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
5866 static const bitmask_transtbl oflag_tbl
[] = {
5867 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
5868 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
5869 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
5870 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
5871 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
5872 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
5873 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
5874 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
5875 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
5876 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
5877 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
5878 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
5879 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
5880 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
5881 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
5882 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
5883 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
5884 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
5885 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
5886 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
5887 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
5888 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
5889 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
5890 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
5894 static const bitmask_transtbl cflag_tbl
[] = {
5895 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
5896 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
5897 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
5898 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
5899 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
5900 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
5901 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
5902 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
5903 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
5904 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
5905 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
5906 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
5907 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
5908 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
5909 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
5910 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
5911 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
5912 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
5913 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
5914 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
5915 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
5916 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
5917 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
5918 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
5919 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
5920 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
5921 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
5922 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
5923 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
5924 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
5925 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
5929 static const bitmask_transtbl lflag_tbl
[] = {
5930 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
5931 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
5932 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
5933 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
5934 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
5935 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
5936 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
5937 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
5938 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
5939 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
5940 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
5941 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
5942 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
5943 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
5944 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
5948 static void target_to_host_termios (void *dst
, const void *src
)
5950 struct host_termios
*host
= dst
;
5951 const struct target_termios
*target
= src
;
5954 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
5956 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
5958 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
5960 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
5961 host
->c_line
= target
->c_line
;
5963 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
5964 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
5965 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
5966 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
5967 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
5968 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
5969 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
5970 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
5971 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
5972 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
5973 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
5974 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
5975 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
5976 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
5977 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
5978 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
5979 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
5980 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
5983 static void host_to_target_termios (void *dst
, const void *src
)
5985 struct target_termios
*target
= dst
;
5986 const struct host_termios
*host
= src
;
5989 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
5991 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
5993 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
5995 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
5996 target
->c_line
= host
->c_line
;
5998 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
5999 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
6000 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
6001 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
6002 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
6003 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
6004 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
6005 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
6006 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
6007 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
6008 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
6009 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
6010 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
6011 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
6012 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
6013 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
6014 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
6015 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
6018 static const StructEntry struct_termios_def
= {
6019 .convert
= { host_to_target_termios
, target_to_host_termios
},
6020 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
6021 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
6024 static bitmask_transtbl mmap_flags_tbl
[] = {
6025 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
6026 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
6027 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
6028 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
,
6029 MAP_ANONYMOUS
, MAP_ANONYMOUS
},
6030 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
,
6031 MAP_GROWSDOWN
, MAP_GROWSDOWN
},
6032 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
,
6033 MAP_DENYWRITE
, MAP_DENYWRITE
},
6034 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
,
6035 MAP_EXECUTABLE
, MAP_EXECUTABLE
},
6036 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
6037 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
,
6038 MAP_NORESERVE
, MAP_NORESERVE
},
6039 { TARGET_MAP_HUGETLB
, TARGET_MAP_HUGETLB
, MAP_HUGETLB
, MAP_HUGETLB
},
6040 /* MAP_STACK had been ignored by the kernel for quite some time.
6041 Recognize it for the target insofar as we do not want to pass
6042 it through to the host. */
6043 { TARGET_MAP_STACK
, TARGET_MAP_STACK
, 0, 0 },
6047 #if defined(TARGET_I386)
6049 /* NOTE: there is really one LDT for all the threads */
6050 static uint8_t *ldt_table
;
6052 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
6059 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
6060 if (size
> bytecount
)
6062 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
6064 return -TARGET_EFAULT
;
6065 /* ??? Should this by byteswapped? */
6066 memcpy(p
, ldt_table
, size
);
6067 unlock_user(p
, ptr
, size
);
6071 /* XXX: add locking support */
6072 static abi_long
write_ldt(CPUX86State
*env
,
6073 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
6075 struct target_modify_ldt_ldt_s ldt_info
;
6076 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6077 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
6078 int seg_not_present
, useable
, lm
;
6079 uint32_t *lp
, entry_1
, entry_2
;
6081 if (bytecount
!= sizeof(ldt_info
))
6082 return -TARGET_EINVAL
;
6083 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
6084 return -TARGET_EFAULT
;
6085 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
6086 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
6087 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
6088 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
6089 unlock_user_struct(target_ldt_info
, ptr
, 0);
6091 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
6092 return -TARGET_EINVAL
;
6093 seg_32bit
= ldt_info
.flags
& 1;
6094 contents
= (ldt_info
.flags
>> 1) & 3;
6095 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
6096 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
6097 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
6098 useable
= (ldt_info
.flags
>> 6) & 1;
6102 lm
= (ldt_info
.flags
>> 7) & 1;
6104 if (contents
== 3) {
6106 return -TARGET_EINVAL
;
6107 if (seg_not_present
== 0)
6108 return -TARGET_EINVAL
;
6110 /* allocate the LDT */
6112 env
->ldt
.base
= target_mmap(0,
6113 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
6114 PROT_READ
|PROT_WRITE
,
6115 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
6116 if (env
->ldt
.base
== -1)
6117 return -TARGET_ENOMEM
;
6118 memset(g2h(env
->ldt
.base
), 0,
6119 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
6120 env
->ldt
.limit
= 0xffff;
6121 ldt_table
= g2h(env
->ldt
.base
);
6124 /* NOTE: same code as Linux kernel */
6125 /* Allow LDTs to be cleared by the user. */
6126 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6129 read_exec_only
== 1 &&
6131 limit_in_pages
== 0 &&
6132 seg_not_present
== 1 &&
6140 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6141 (ldt_info
.limit
& 0x0ffff);
6142 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6143 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6144 (ldt_info
.limit
& 0xf0000) |
6145 ((read_exec_only
^ 1) << 9) |
6147 ((seg_not_present
^ 1) << 15) |
6149 (limit_in_pages
<< 23) |
6153 entry_2
|= (useable
<< 20);
6155 /* Install the new entry ... */
6157 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
6158 lp
[0] = tswap32(entry_1
);
6159 lp
[1] = tswap32(entry_2
);
6163 /* specific and weird i386 syscalls */
6164 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
6165 unsigned long bytecount
)
6171 ret
= read_ldt(ptr
, bytecount
);
6174 ret
= write_ldt(env
, ptr
, bytecount
, 1);
6177 ret
= write_ldt(env
, ptr
, bytecount
, 0);
6180 ret
= -TARGET_ENOSYS
;
6186 #if defined(TARGET_I386) && defined(TARGET_ABI32)
6187 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6189 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
6190 struct target_modify_ldt_ldt_s ldt_info
;
6191 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6192 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
6193 int seg_not_present
, useable
, lm
;
6194 uint32_t *lp
, entry_1
, entry_2
;
6197 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6198 if (!target_ldt_info
)
6199 return -TARGET_EFAULT
;
6200 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
6201 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
6202 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
6203 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
6204 if (ldt_info
.entry_number
== -1) {
6205 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
6206 if (gdt_table
[i
] == 0) {
6207 ldt_info
.entry_number
= i
;
6208 target_ldt_info
->entry_number
= tswap32(i
);
6213 unlock_user_struct(target_ldt_info
, ptr
, 1);
6215 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
6216 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
6217 return -TARGET_EINVAL
;
6218 seg_32bit
= ldt_info
.flags
& 1;
6219 contents
= (ldt_info
.flags
>> 1) & 3;
6220 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
6221 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
6222 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
6223 useable
= (ldt_info
.flags
>> 6) & 1;
6227 lm
= (ldt_info
.flags
>> 7) & 1;
6230 if (contents
== 3) {
6231 if (seg_not_present
== 0)
6232 return -TARGET_EINVAL
;
6235 /* NOTE: same code as Linux kernel */
6236 /* Allow LDTs to be cleared by the user. */
6237 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6238 if ((contents
== 0 &&
6239 read_exec_only
== 1 &&
6241 limit_in_pages
== 0 &&
6242 seg_not_present
== 1 &&
6250 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6251 (ldt_info
.limit
& 0x0ffff);
6252 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6253 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6254 (ldt_info
.limit
& 0xf0000) |
6255 ((read_exec_only
^ 1) << 9) |
6257 ((seg_not_present
^ 1) << 15) |
6259 (limit_in_pages
<< 23) |
6264 /* Install the new entry ... */
6266 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
6267 lp
[0] = tswap32(entry_1
);
6268 lp
[1] = tswap32(entry_2
);
6272 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6274 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6275 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
6276 uint32_t base_addr
, limit
, flags
;
6277 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
6278 int seg_not_present
, useable
, lm
;
6279 uint32_t *lp
, entry_1
, entry_2
;
6281 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6282 if (!target_ldt_info
)
6283 return -TARGET_EFAULT
;
6284 idx
= tswap32(target_ldt_info
->entry_number
);
6285 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
6286 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
6287 unlock_user_struct(target_ldt_info
, ptr
, 1);
6288 return -TARGET_EINVAL
;
6290 lp
= (uint32_t *)(gdt_table
+ idx
);
6291 entry_1
= tswap32(lp
[0]);
6292 entry_2
= tswap32(lp
[1]);
6294 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
6295 contents
= (entry_2
>> 10) & 3;
6296 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
6297 seg_32bit
= (entry_2
>> 22) & 1;
6298 limit_in_pages
= (entry_2
>> 23) & 1;
6299 useable
= (entry_2
>> 20) & 1;
6303 lm
= (entry_2
>> 21) & 1;
6305 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
6306 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
6307 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
6308 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
6309 base_addr
= (entry_1
>> 16) |
6310 (entry_2
& 0xff000000) |
6311 ((entry_2
& 0xff) << 16);
6312 target_ldt_info
->base_addr
= tswapal(base_addr
);
6313 target_ldt_info
->limit
= tswap32(limit
);
6314 target_ldt_info
->flags
= tswap32(flags
);
6315 unlock_user_struct(target_ldt_info
, ptr
, 1);
6318 #endif /* TARGET_I386 && TARGET_ABI32 */
6320 #ifndef TARGET_ABI32
6321 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
6328 case TARGET_ARCH_SET_GS
:
6329 case TARGET_ARCH_SET_FS
:
6330 if (code
== TARGET_ARCH_SET_GS
)
6334 cpu_x86_load_seg(env
, idx
, 0);
6335 env
->segs
[idx
].base
= addr
;
6337 case TARGET_ARCH_GET_GS
:
6338 case TARGET_ARCH_GET_FS
:
6339 if (code
== TARGET_ARCH_GET_GS
)
6343 val
= env
->segs
[idx
].base
;
6344 if (put_user(val
, addr
, abi_ulong
))
6345 ret
= -TARGET_EFAULT
;
6348 ret
= -TARGET_EINVAL
;
6355 #endif /* defined(TARGET_I386) */
6357 #define NEW_STACK_SIZE 0x40000
6360 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
6363 pthread_mutex_t mutex
;
6364 pthread_cond_t cond
;
6367 abi_ulong child_tidptr
;
6368 abi_ulong parent_tidptr
;
6372 static void *clone_func(void *arg
)
6374 new_thread_info
*info
= arg
;
6379 rcu_register_thread();
6380 tcg_register_thread();
6382 cpu
= ENV_GET_CPU(env
);
6384 ts
= (TaskState
*)cpu
->opaque
;
6385 info
->tid
= gettid();
6387 if (info
->child_tidptr
)
6388 put_user_u32(info
->tid
, info
->child_tidptr
);
6389 if (info
->parent_tidptr
)
6390 put_user_u32(info
->tid
, info
->parent_tidptr
);
6391 /* Enable signals. */
6392 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
6393 /* Signal to the parent that we're ready. */
6394 pthread_mutex_lock(&info
->mutex
);
6395 pthread_cond_broadcast(&info
->cond
);
6396 pthread_mutex_unlock(&info
->mutex
);
6397 /* Wait until the parent has finished initializing the tls state. */
6398 pthread_mutex_lock(&clone_lock
);
6399 pthread_mutex_unlock(&clone_lock
);
6405 /* do_fork() Must return host values and target errnos (unlike most
6406 do_*() functions). */
6407 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
6408 abi_ulong parent_tidptr
, target_ulong newtls
,
6409 abi_ulong child_tidptr
)
6411 CPUState
*cpu
= ENV_GET_CPU(env
);
6415 CPUArchState
*new_env
;
6418 flags
&= ~CLONE_IGNORED_FLAGS
;
6420 /* Emulate vfork() with fork() */
6421 if (flags
& CLONE_VFORK
)
6422 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
6424 if (flags
& CLONE_VM
) {
6425 TaskState
*parent_ts
= (TaskState
*)cpu
->opaque
;
6426 new_thread_info info
;
6427 pthread_attr_t attr
;
6429 if (((flags
& CLONE_THREAD_FLAGS
) != CLONE_THREAD_FLAGS
) ||
6430 (flags
& CLONE_INVALID_THREAD_FLAGS
)) {
6431 return -TARGET_EINVAL
;
6434 ts
= g_new0(TaskState
, 1);
6435 init_task_state(ts
);
6437 /* Grab a mutex so that thread setup appears atomic. */
6438 pthread_mutex_lock(&clone_lock
);
6440 /* we create a new CPU instance. */
6441 new_env
= cpu_copy(env
);
6442 /* Init regs that differ from the parent. */
6443 cpu_clone_regs(new_env
, newsp
);
6444 new_cpu
= ENV_GET_CPU(new_env
);
6445 new_cpu
->opaque
= ts
;
6446 ts
->bprm
= parent_ts
->bprm
;
6447 ts
->info
= parent_ts
->info
;
6448 ts
->signal_mask
= parent_ts
->signal_mask
;
6450 if (flags
& CLONE_CHILD_CLEARTID
) {
6451 ts
->child_tidptr
= child_tidptr
;
6454 if (flags
& CLONE_SETTLS
) {
6455 cpu_set_tls (new_env
, newtls
);
6458 memset(&info
, 0, sizeof(info
));
6459 pthread_mutex_init(&info
.mutex
, NULL
);
6460 pthread_mutex_lock(&info
.mutex
);
6461 pthread_cond_init(&info
.cond
, NULL
);
6463 if (flags
& CLONE_CHILD_SETTID
) {
6464 info
.child_tidptr
= child_tidptr
;
6466 if (flags
& CLONE_PARENT_SETTID
) {
6467 info
.parent_tidptr
= parent_tidptr
;
6470 ret
= pthread_attr_init(&attr
);
6471 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
6472 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
6473 /* It is not safe to deliver signals until the child has finished
6474 initializing, so temporarily block all signals. */
6475 sigfillset(&sigmask
);
6476 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
6478 /* If this is our first additional thread, we need to ensure we
6479 * generate code for parallel execution and flush old translations.
6481 if (!parallel_cpus
) {
6482 parallel_cpus
= true;
6486 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
6487 /* TODO: Free new CPU state if thread creation failed. */
6489 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
6490 pthread_attr_destroy(&attr
);
6492 /* Wait for the child to initialize. */
6493 pthread_cond_wait(&info
.cond
, &info
.mutex
);
6498 pthread_mutex_unlock(&info
.mutex
);
6499 pthread_cond_destroy(&info
.cond
);
6500 pthread_mutex_destroy(&info
.mutex
);
6501 pthread_mutex_unlock(&clone_lock
);
6503 /* if no CLONE_VM, we consider it is a fork */
6504 if (flags
& CLONE_INVALID_FORK_FLAGS
) {
6505 return -TARGET_EINVAL
;
6508 /* We can't support custom termination signals */
6509 if ((flags
& CSIGNAL
) != TARGET_SIGCHLD
) {
6510 return -TARGET_EINVAL
;
6513 if (block_signals()) {
6514 return -TARGET_ERESTARTSYS
;
6520 /* Child Process. */
6521 cpu_clone_regs(env
, newsp
);
6523 /* There is a race condition here. The parent process could
6524 theoretically read the TID in the child process before the child
6525 tid is set. This would require using either ptrace
6526 (not implemented) or having *_tidptr to point at a shared memory
6527 mapping. We can't repeat the spinlock hack used above because
6528 the child process gets its own copy of the lock. */
6529 if (flags
& CLONE_CHILD_SETTID
)
6530 put_user_u32(gettid(), child_tidptr
);
6531 if (flags
& CLONE_PARENT_SETTID
)
6532 put_user_u32(gettid(), parent_tidptr
);
6533 ts
= (TaskState
*)cpu
->opaque
;
6534 if (flags
& CLONE_SETTLS
)
6535 cpu_set_tls (env
, newtls
);
6536 if (flags
& CLONE_CHILD_CLEARTID
)
6537 ts
->child_tidptr
= child_tidptr
;
6545 /* warning : doesn't handle linux specific flags... */
6546 static int target_to_host_fcntl_cmd(int cmd
)
6549 case TARGET_F_DUPFD
:
6550 case TARGET_F_GETFD
:
6551 case TARGET_F_SETFD
:
6552 case TARGET_F_GETFL
:
6553 case TARGET_F_SETFL
:
6555 case TARGET_F_GETLK
:
6557 case TARGET_F_SETLK
:
6559 case TARGET_F_SETLKW
:
6561 case TARGET_F_GETOWN
:
6563 case TARGET_F_SETOWN
:
6565 case TARGET_F_GETSIG
:
6567 case TARGET_F_SETSIG
:
6569 #if TARGET_ABI_BITS == 32
6570 case TARGET_F_GETLK64
:
6572 case TARGET_F_SETLK64
:
6574 case TARGET_F_SETLKW64
:
6577 case TARGET_F_SETLEASE
:
6579 case TARGET_F_GETLEASE
:
6581 #ifdef F_DUPFD_CLOEXEC
6582 case TARGET_F_DUPFD_CLOEXEC
:
6583 return F_DUPFD_CLOEXEC
;
6585 case TARGET_F_NOTIFY
:
6588 case TARGET_F_GETOWN_EX
:
6592 case TARGET_F_SETOWN_EX
:
6596 case TARGET_F_SETPIPE_SZ
:
6597 return F_SETPIPE_SZ
;
6598 case TARGET_F_GETPIPE_SZ
:
6599 return F_GETPIPE_SZ
;
6602 return -TARGET_EINVAL
;
6604 return -TARGET_EINVAL
;
6607 #define FLOCK_TRANSTBL \
6609 TRANSTBL_CONVERT(F_RDLCK); \
6610 TRANSTBL_CONVERT(F_WRLCK); \
6611 TRANSTBL_CONVERT(F_UNLCK); \
6612 TRANSTBL_CONVERT(F_EXLCK); \
6613 TRANSTBL_CONVERT(F_SHLCK); \
6616 static int target_to_host_flock(int type
)
6618 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
6620 #undef TRANSTBL_CONVERT
6621 return -TARGET_EINVAL
;
6624 static int host_to_target_flock(int type
)
6626 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
6628 #undef TRANSTBL_CONVERT
6629 /* if we don't know how to convert the value coming
6630 * from the host we copy to the target field as-is
6635 static inline abi_long
copy_from_user_flock(struct flock64
*fl
,
6636 abi_ulong target_flock_addr
)
6638 struct target_flock
*target_fl
;
6641 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6642 return -TARGET_EFAULT
;
6645 __get_user(l_type
, &target_fl
->l_type
);
6646 l_type
= target_to_host_flock(l_type
);
6650 fl
->l_type
= l_type
;
6651 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6652 __get_user(fl
->l_start
, &target_fl
->l_start
);
6653 __get_user(fl
->l_len
, &target_fl
->l_len
);
6654 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6655 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6659 static inline abi_long
copy_to_user_flock(abi_ulong target_flock_addr
,
6660 const struct flock64
*fl
)
6662 struct target_flock
*target_fl
;
6665 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6666 return -TARGET_EFAULT
;
6669 l_type
= host_to_target_flock(fl
->l_type
);
6670 __put_user(l_type
, &target_fl
->l_type
);
6671 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6672 __put_user(fl
->l_start
, &target_fl
->l_start
);
6673 __put_user(fl
->l_len
, &target_fl
->l_len
);
6674 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6675 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6679 typedef abi_long
from_flock64_fn(struct flock64
*fl
, abi_ulong target_addr
);
6680 typedef abi_long
to_flock64_fn(abi_ulong target_addr
, const struct flock64
*fl
);
6682 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6683 static inline abi_long
copy_from_user_oabi_flock64(struct flock64
*fl
,
6684 abi_ulong target_flock_addr
)
6686 struct target_oabi_flock64
*target_fl
;
6689 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6690 return -TARGET_EFAULT
;
6693 __get_user(l_type
, &target_fl
->l_type
);
6694 l_type
= target_to_host_flock(l_type
);
6698 fl
->l_type
= l_type
;
6699 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6700 __get_user(fl
->l_start
, &target_fl
->l_start
);
6701 __get_user(fl
->l_len
, &target_fl
->l_len
);
6702 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6703 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6707 static inline abi_long
copy_to_user_oabi_flock64(abi_ulong target_flock_addr
,
6708 const struct flock64
*fl
)
6710 struct target_oabi_flock64
*target_fl
;
6713 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6714 return -TARGET_EFAULT
;
6717 l_type
= host_to_target_flock(fl
->l_type
);
6718 __put_user(l_type
, &target_fl
->l_type
);
6719 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6720 __put_user(fl
->l_start
, &target_fl
->l_start
);
6721 __put_user(fl
->l_len
, &target_fl
->l_len
);
6722 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6723 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6728 static inline abi_long
copy_from_user_flock64(struct flock64
*fl
,
6729 abi_ulong target_flock_addr
)
6731 struct target_flock64
*target_fl
;
6734 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6735 return -TARGET_EFAULT
;
6738 __get_user(l_type
, &target_fl
->l_type
);
6739 l_type
= target_to_host_flock(l_type
);
6743 fl
->l_type
= l_type
;
6744 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6745 __get_user(fl
->l_start
, &target_fl
->l_start
);
6746 __get_user(fl
->l_len
, &target_fl
->l_len
);
6747 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6748 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6752 static inline abi_long
copy_to_user_flock64(abi_ulong target_flock_addr
,
6753 const struct flock64
*fl
)
6755 struct target_flock64
*target_fl
;
6758 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6759 return -TARGET_EFAULT
;
6762 l_type
= host_to_target_flock(fl
->l_type
);
6763 __put_user(l_type
, &target_fl
->l_type
);
6764 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6765 __put_user(fl
->l_start
, &target_fl
->l_start
);
6766 __put_user(fl
->l_len
, &target_fl
->l_len
);
6767 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6768 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6772 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
6774 struct flock64 fl64
;
6776 struct f_owner_ex fox
;
6777 struct target_f_owner_ex
*target_fox
;
6780 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
6782 if (host_cmd
== -TARGET_EINVAL
)
6786 case TARGET_F_GETLK
:
6787 ret
= copy_from_user_flock(&fl64
, arg
);
6791 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6793 ret
= copy_to_user_flock(arg
, &fl64
);
6797 case TARGET_F_SETLK
:
6798 case TARGET_F_SETLKW
:
6799 ret
= copy_from_user_flock(&fl64
, arg
);
6803 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6806 case TARGET_F_GETLK64
:
6807 ret
= copy_from_user_flock64(&fl64
, arg
);
6811 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6813 ret
= copy_to_user_flock64(arg
, &fl64
);
6816 case TARGET_F_SETLK64
:
6817 case TARGET_F_SETLKW64
:
6818 ret
= copy_from_user_flock64(&fl64
, arg
);
6822 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6825 case TARGET_F_GETFL
:
6826 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6828 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
6832 case TARGET_F_SETFL
:
6833 ret
= get_errno(safe_fcntl(fd
, host_cmd
,
6834 target_to_host_bitmask(arg
,
6839 case TARGET_F_GETOWN_EX
:
6840 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6842 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
6843 return -TARGET_EFAULT
;
6844 target_fox
->type
= tswap32(fox
.type
);
6845 target_fox
->pid
= tswap32(fox
.pid
);
6846 unlock_user_struct(target_fox
, arg
, 1);
6852 case TARGET_F_SETOWN_EX
:
6853 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
6854 return -TARGET_EFAULT
;
6855 fox
.type
= tswap32(target_fox
->type
);
6856 fox
.pid
= tswap32(target_fox
->pid
);
6857 unlock_user_struct(target_fox
, arg
, 0);
6858 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6862 case TARGET_F_SETOWN
:
6863 case TARGET_F_GETOWN
:
6864 case TARGET_F_SETSIG
:
6865 case TARGET_F_GETSIG
:
6866 case TARGET_F_SETLEASE
:
6867 case TARGET_F_GETLEASE
:
6868 case TARGET_F_SETPIPE_SZ
:
6869 case TARGET_F_GETPIPE_SZ
:
6870 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6874 ret
= get_errno(safe_fcntl(fd
, cmd
, arg
));
6882 static inline int high2lowuid(int uid
)
6890 static inline int high2lowgid(int gid
)
6898 static inline int low2highuid(int uid
)
6900 if ((int16_t)uid
== -1)
6906 static inline int low2highgid(int gid
)
6908 if ((int16_t)gid
== -1)
6913 static inline int tswapid(int id
)
6918 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6920 #else /* !USE_UID16 */
6921 static inline int high2lowuid(int uid
)
6925 static inline int high2lowgid(int gid
)
6929 static inline int low2highuid(int uid
)
6933 static inline int low2highgid(int gid
)
6937 static inline int tswapid(int id
)
6942 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6944 #endif /* USE_UID16 */
6946 /* We must do direct syscalls for setting UID/GID, because we want to
6947 * implement the Linux system call semantics of "change only for this thread",
6948 * not the libc/POSIX semantics of "change for all threads in process".
6949 * (See http://ewontfix.com/17/ for more details.)
6950 * We use the 32-bit version of the syscalls if present; if it is not
6951 * then either the host architecture supports 32-bit UIDs natively with
6952 * the standard syscall, or the 16-bit UID is the best we can do.
6954 #ifdef __NR_setuid32
6955 #define __NR_sys_setuid __NR_setuid32
6957 #define __NR_sys_setuid __NR_setuid
6959 #ifdef __NR_setgid32
6960 #define __NR_sys_setgid __NR_setgid32
6962 #define __NR_sys_setgid __NR_setgid
6964 #ifdef __NR_setresuid32
6965 #define __NR_sys_setresuid __NR_setresuid32
6967 #define __NR_sys_setresuid __NR_setresuid
6969 #ifdef __NR_setresgid32
6970 #define __NR_sys_setresgid __NR_setresgid32
6972 #define __NR_sys_setresgid __NR_setresgid
6975 _syscall1(int, sys_setuid
, uid_t
, uid
)
6976 _syscall1(int, sys_setgid
, gid_t
, gid
)
6977 _syscall3(int, sys_setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
6978 _syscall3(int, sys_setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
6980 void syscall_init(void)
6983 const argtype
*arg_type
;
6987 thunk_init(STRUCT_MAX
);
6989 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
6990 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
6991 #include "syscall_types.h"
6993 #undef STRUCT_SPECIAL
6995 /* Build target_to_host_errno_table[] table from
6996 * host_to_target_errno_table[]. */
6997 for (i
= 0; i
< ERRNO_TABLE_SIZE
; i
++) {
6998 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
7001 /* we patch the ioctl size if necessary. We rely on the fact that
7002 no ioctl has all the bits at '1' in the size field */
7004 while (ie
->target_cmd
!= 0) {
7005 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
7006 TARGET_IOC_SIZEMASK
) {
7007 arg_type
= ie
->arg_type
;
7008 if (arg_type
[0] != TYPE_PTR
) {
7009 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
7014 size
= thunk_type_size(arg_type
, 0);
7015 ie
->target_cmd
= (ie
->target_cmd
&
7016 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
7017 (size
<< TARGET_IOC_SIZESHIFT
);
7020 /* automatic consistency check if same arch */
7021 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
7022 (defined(__x86_64__) && defined(TARGET_X86_64))
7023 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
7024 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
7025 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
7032 #if TARGET_ABI_BITS == 32
7033 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
7035 #ifdef TARGET_WORDS_BIGENDIAN
7036 return ((uint64_t)word0
<< 32) | word1
;
7038 return ((uint64_t)word1
<< 32) | word0
;
7041 #else /* TARGET_ABI_BITS == 32 */
7042 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
7046 #endif /* TARGET_ABI_BITS != 32 */
7048 #ifdef TARGET_NR_truncate64
7049 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
7054 if (regpairs_aligned(cpu_env
, TARGET_NR_truncate64
)) {
7058 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
7062 #ifdef TARGET_NR_ftruncate64
7063 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
7068 if (regpairs_aligned(cpu_env
, TARGET_NR_ftruncate64
)) {
7072 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
7076 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
7077 abi_ulong target_addr
)
7079 struct target_timespec
*target_ts
;
7081 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
7082 return -TARGET_EFAULT
;
7083 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
7084 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
7085 unlock_user_struct(target_ts
, target_addr
, 0);
7089 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
7090 struct timespec
*host_ts
)
7092 struct target_timespec
*target_ts
;
7094 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
7095 return -TARGET_EFAULT
;
7096 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
7097 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
7098 unlock_user_struct(target_ts
, target_addr
, 1);
7102 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_itspec
,
7103 abi_ulong target_addr
)
7105 struct target_itimerspec
*target_itspec
;
7107 if (!lock_user_struct(VERIFY_READ
, target_itspec
, target_addr
, 1)) {
7108 return -TARGET_EFAULT
;
7111 host_itspec
->it_interval
.tv_sec
=
7112 tswapal(target_itspec
->it_interval
.tv_sec
);
7113 host_itspec
->it_interval
.tv_nsec
=
7114 tswapal(target_itspec
->it_interval
.tv_nsec
);
7115 host_itspec
->it_value
.tv_sec
= tswapal(target_itspec
->it_value
.tv_sec
);
7116 host_itspec
->it_value
.tv_nsec
= tswapal(target_itspec
->it_value
.tv_nsec
);
7118 unlock_user_struct(target_itspec
, target_addr
, 1);
7122 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
7123 struct itimerspec
*host_its
)
7125 struct target_itimerspec
*target_itspec
;
7127 if (!lock_user_struct(VERIFY_WRITE
, target_itspec
, target_addr
, 0)) {
7128 return -TARGET_EFAULT
;
7131 target_itspec
->it_interval
.tv_sec
= tswapal(host_its
->it_interval
.tv_sec
);
7132 target_itspec
->it_interval
.tv_nsec
= tswapal(host_its
->it_interval
.tv_nsec
);
7134 target_itspec
->it_value
.tv_sec
= tswapal(host_its
->it_value
.tv_sec
);
7135 target_itspec
->it_value
.tv_nsec
= tswapal(host_its
->it_value
.tv_nsec
);
7137 unlock_user_struct(target_itspec
, target_addr
, 0);
7141 static inline abi_long
target_to_host_timex(struct timex
*host_tx
,
7142 abi_long target_addr
)
7144 struct target_timex
*target_tx
;
7146 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
7147 return -TARGET_EFAULT
;
7150 __get_user(host_tx
->modes
, &target_tx
->modes
);
7151 __get_user(host_tx
->offset
, &target_tx
->offset
);
7152 __get_user(host_tx
->freq
, &target_tx
->freq
);
7153 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7154 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
7155 __get_user(host_tx
->status
, &target_tx
->status
);
7156 __get_user(host_tx
->constant
, &target_tx
->constant
);
7157 __get_user(host_tx
->precision
, &target_tx
->precision
);
7158 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7159 __get_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7160 __get_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7161 __get_user(host_tx
->tick
, &target_tx
->tick
);
7162 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7163 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
7164 __get_user(host_tx
->shift
, &target_tx
->shift
);
7165 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
7166 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7167 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7168 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7169 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7170 __get_user(host_tx
->tai
, &target_tx
->tai
);
7172 unlock_user_struct(target_tx
, target_addr
, 0);
7176 static inline abi_long
host_to_target_timex(abi_long target_addr
,
7177 struct timex
*host_tx
)
7179 struct target_timex
*target_tx
;
7181 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
7182 return -TARGET_EFAULT
;
7185 __put_user(host_tx
->modes
, &target_tx
->modes
);
7186 __put_user(host_tx
->offset
, &target_tx
->offset
);
7187 __put_user(host_tx
->freq
, &target_tx
->freq
);
7188 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7189 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
7190 __put_user(host_tx
->status
, &target_tx
->status
);
7191 __put_user(host_tx
->constant
, &target_tx
->constant
);
7192 __put_user(host_tx
->precision
, &target_tx
->precision
);
7193 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7194 __put_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7195 __put_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7196 __put_user(host_tx
->tick
, &target_tx
->tick
);
7197 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7198 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
7199 __put_user(host_tx
->shift
, &target_tx
->shift
);
7200 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
7201 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7202 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7203 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7204 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7205 __put_user(host_tx
->tai
, &target_tx
->tai
);
7207 unlock_user_struct(target_tx
, target_addr
, 1);
7212 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
7213 abi_ulong target_addr
)
7215 struct target_sigevent
*target_sevp
;
7217 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
7218 return -TARGET_EFAULT
;
7221 /* This union is awkward on 64 bit systems because it has a 32 bit
7222 * integer and a pointer in it; we follow the conversion approach
7223 * used for handling sigval types in signal.c so the guest should get
7224 * the correct value back even if we did a 64 bit byteswap and it's
7225 * using the 32 bit integer.
7227 host_sevp
->sigev_value
.sival_ptr
=
7228 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
7229 host_sevp
->sigev_signo
=
7230 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
7231 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
7232 host_sevp
->_sigev_un
._tid
= tswap32(target_sevp
->_sigev_un
._tid
);
7234 unlock_user_struct(target_sevp
, target_addr
, 1);
7238 #if defined(TARGET_NR_mlockall)
7239 static inline int target_to_host_mlockall_arg(int arg
)
7243 if (arg
& TARGET_MLOCKALL_MCL_CURRENT
) {
7244 result
|= MCL_CURRENT
;
7246 if (arg
& TARGET_MLOCKALL_MCL_FUTURE
) {
7247 result
|= MCL_FUTURE
;
7253 static inline abi_long
host_to_target_stat64(void *cpu_env
,
7254 abi_ulong target_addr
,
7255 struct stat
*host_st
)
7257 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
7258 if (((CPUARMState
*)cpu_env
)->eabi
) {
7259 struct target_eabi_stat64
*target_st
;
7261 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7262 return -TARGET_EFAULT
;
7263 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
7264 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7265 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7266 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7267 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7269 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7270 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7271 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7272 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7273 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7274 __put_user(host_st
->st_size
, &target_st
->st_size
);
7275 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7276 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7277 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7278 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7279 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7280 unlock_user_struct(target_st
, target_addr
, 1);
7284 #if defined(TARGET_HAS_STRUCT_STAT64)
7285 struct target_stat64
*target_st
;
7287 struct target_stat
*target_st
;
7290 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7291 return -TARGET_EFAULT
;
7292 memset(target_st
, 0, sizeof(*target_st
));
7293 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7294 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7295 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7296 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7298 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7299 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7300 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7301 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7302 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7303 /* XXX: better use of kernel struct */
7304 __put_user(host_st
->st_size
, &target_st
->st_size
);
7305 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7306 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7307 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7308 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7309 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7310 unlock_user_struct(target_st
, target_addr
, 1);
7316 /* ??? Using host futex calls even when target atomic operations
7317 are not really atomic probably breaks things. However implementing
7318 futexes locally would make futexes shared between multiple processes
7319 tricky. However they're probably useless because guest atomic
7320 operations won't work either. */
7321 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
7322 target_ulong uaddr2
, int val3
)
7324 struct timespec ts
, *pts
;
7327 /* ??? We assume FUTEX_* constants are the same on both host
7329 #ifdef FUTEX_CMD_MASK
7330 base_op
= op
& FUTEX_CMD_MASK
;
7336 case FUTEX_WAIT_BITSET
:
7339 target_to_host_timespec(pts
, timeout
);
7343 return get_errno(safe_futex(g2h(uaddr
), op
, tswap32(val
),
7346 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
7348 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
7350 case FUTEX_CMP_REQUEUE
:
7352 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7353 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7354 But the prototype takes a `struct timespec *'; insert casts
7355 to satisfy the compiler. We do not need to tswap TIMEOUT
7356 since it's not compared to guest memory. */
7357 pts
= (struct timespec
*)(uintptr_t) timeout
;
7358 return get_errno(safe_futex(g2h(uaddr
), op
, val
, pts
,
7360 (base_op
== FUTEX_CMP_REQUEUE
7364 return -TARGET_ENOSYS
;
7367 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7368 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
7369 abi_long handle
, abi_long mount_id
,
7372 struct file_handle
*target_fh
;
7373 struct file_handle
*fh
;
7377 unsigned int size
, total_size
;
7379 if (get_user_s32(size
, handle
)) {
7380 return -TARGET_EFAULT
;
7383 name
= lock_user_string(pathname
);
7385 return -TARGET_EFAULT
;
7388 total_size
= sizeof(struct file_handle
) + size
;
7389 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
7391 unlock_user(name
, pathname
, 0);
7392 return -TARGET_EFAULT
;
7395 fh
= g_malloc0(total_size
);
7396 fh
->handle_bytes
= size
;
7398 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
7399 unlock_user(name
, pathname
, 0);
7401 /* man name_to_handle_at(2):
7402 * Other than the use of the handle_bytes field, the caller should treat
7403 * the file_handle structure as an opaque data type
7406 memcpy(target_fh
, fh
, total_size
);
7407 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
7408 target_fh
->handle_type
= tswap32(fh
->handle_type
);
7410 unlock_user(target_fh
, handle
, total_size
);
7412 if (put_user_s32(mid
, mount_id
)) {
7413 return -TARGET_EFAULT
;
7421 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7422 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
7425 struct file_handle
*target_fh
;
7426 struct file_handle
*fh
;
7427 unsigned int size
, total_size
;
7430 if (get_user_s32(size
, handle
)) {
7431 return -TARGET_EFAULT
;
7434 total_size
= sizeof(struct file_handle
) + size
;
7435 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
7437 return -TARGET_EFAULT
;
7440 fh
= g_memdup(target_fh
, total_size
);
7441 fh
->handle_bytes
= size
;
7442 fh
->handle_type
= tswap32(target_fh
->handle_type
);
7444 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
7445 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
7449 unlock_user(target_fh
, handle
, total_size
);
7455 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7457 /* signalfd siginfo conversion */
7460 host_to_target_signalfd_siginfo(struct signalfd_siginfo
*tinfo
,
7461 const struct signalfd_siginfo
*info
)
7463 int sig
= host_to_target_signal(info
->ssi_signo
);
7465 /* linux/signalfd.h defines a ssi_addr_lsb
7466 * not defined in sys/signalfd.h but used by some kernels
7469 #ifdef BUS_MCEERR_AO
7470 if (tinfo
->ssi_signo
== SIGBUS
&&
7471 (tinfo
->ssi_code
== BUS_MCEERR_AR
||
7472 tinfo
->ssi_code
== BUS_MCEERR_AO
)) {
7473 uint16_t *ssi_addr_lsb
= (uint16_t *)(&info
->ssi_addr
+ 1);
7474 uint16_t *tssi_addr_lsb
= (uint16_t *)(&tinfo
->ssi_addr
+ 1);
7475 *tssi_addr_lsb
= tswap16(*ssi_addr_lsb
);
7479 tinfo
->ssi_signo
= tswap32(sig
);
7480 tinfo
->ssi_errno
= tswap32(tinfo
->ssi_errno
);
7481 tinfo
->ssi_code
= tswap32(info
->ssi_code
);
7482 tinfo
->ssi_pid
= tswap32(info
->ssi_pid
);
7483 tinfo
->ssi_uid
= tswap32(info
->ssi_uid
);
7484 tinfo
->ssi_fd
= tswap32(info
->ssi_fd
);
7485 tinfo
->ssi_tid
= tswap32(info
->ssi_tid
);
7486 tinfo
->ssi_band
= tswap32(info
->ssi_band
);
7487 tinfo
->ssi_overrun
= tswap32(info
->ssi_overrun
);
7488 tinfo
->ssi_trapno
= tswap32(info
->ssi_trapno
);
7489 tinfo
->ssi_status
= tswap32(info
->ssi_status
);
7490 tinfo
->ssi_int
= tswap32(info
->ssi_int
);
7491 tinfo
->ssi_ptr
= tswap64(info
->ssi_ptr
);
7492 tinfo
->ssi_utime
= tswap64(info
->ssi_utime
);
7493 tinfo
->ssi_stime
= tswap64(info
->ssi_stime
);
7494 tinfo
->ssi_addr
= tswap64(info
->ssi_addr
);
7497 static abi_long
host_to_target_data_signalfd(void *buf
, size_t len
)
7501 for (i
= 0; i
< len
; i
+= sizeof(struct signalfd_siginfo
)) {
7502 host_to_target_signalfd_siginfo(buf
+ i
, buf
+ i
);
7508 static TargetFdTrans target_signalfd_trans
= {
7509 .host_to_target_data
= host_to_target_data_signalfd
,
7512 static abi_long
do_signalfd4(int fd
, abi_long mask
, int flags
)
7515 target_sigset_t
*target_mask
;
7519 if (flags
& ~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
)) {
7520 return -TARGET_EINVAL
;
7522 if (!lock_user_struct(VERIFY_READ
, target_mask
, mask
, 1)) {
7523 return -TARGET_EFAULT
;
7526 target_to_host_sigset(&host_mask
, target_mask
);
7528 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
7530 ret
= get_errno(signalfd(fd
, &host_mask
, host_flags
));
7532 fd_trans_register(ret
, &target_signalfd_trans
);
7535 unlock_user_struct(target_mask
, mask
, 0);
7541 /* Map host to target signal numbers for the wait family of syscalls.
7542 Assume all other status bits are the same. */
7543 int host_to_target_waitstatus(int status
)
7545 if (WIFSIGNALED(status
)) {
7546 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
7548 if (WIFSTOPPED(status
)) {
7549 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
7555 static int open_self_cmdline(void *cpu_env
, int fd
)
7557 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7558 struct linux_binprm
*bprm
= ((TaskState
*)cpu
->opaque
)->bprm
;
7561 for (i
= 0; i
< bprm
->argc
; i
++) {
7562 size_t len
= strlen(bprm
->argv
[i
]) + 1;
7564 if (write(fd
, bprm
->argv
[i
], len
) != len
) {
7572 static int open_self_maps(void *cpu_env
, int fd
)
7574 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7575 TaskState
*ts
= cpu
->opaque
;
7581 fp
= fopen("/proc/self/maps", "r");
7586 while ((read
= getline(&line
, &len
, fp
)) != -1) {
7587 int fields
, dev_maj
, dev_min
, inode
;
7588 uint64_t min
, max
, offset
;
7589 char flag_r
, flag_w
, flag_x
, flag_p
;
7590 char path
[512] = "";
7591 fields
= sscanf(line
, "%"PRIx64
"-%"PRIx64
" %c%c%c%c %"PRIx64
" %x:%x %d"
7592 " %512s", &min
, &max
, &flag_r
, &flag_w
, &flag_x
,
7593 &flag_p
, &offset
, &dev_maj
, &dev_min
, &inode
, path
);
7595 if ((fields
< 10) || (fields
> 11)) {
7598 if (h2g_valid(min
)) {
7599 int flags
= page_get_flags(h2g(min
));
7600 max
= h2g_valid(max
- 1) ? max
: (uintptr_t)g2h(GUEST_ADDR_MAX
) + 1;
7601 if (page_check_range(h2g(min
), max
- min
, flags
) == -1) {
7604 if (h2g(min
) == ts
->info
->stack_limit
) {
7605 pstrcpy(path
, sizeof(path
), " [stack]");
7607 dprintf(fd
, TARGET_ABI_FMT_lx
"-" TARGET_ABI_FMT_lx
7608 " %c%c%c%c %08" PRIx64
" %02x:%02x %d %s%s\n",
7609 h2g(min
), h2g(max
- 1) + 1, flag_r
, flag_w
,
7610 flag_x
, flag_p
, offset
, dev_maj
, dev_min
, inode
,
7611 path
[0] ? " " : "", path
);
7621 static int open_self_stat(void *cpu_env
, int fd
)
7623 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7624 TaskState
*ts
= cpu
->opaque
;
7625 abi_ulong start_stack
= ts
->info
->start_stack
;
7628 for (i
= 0; i
< 44; i
++) {
7636 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
7637 } else if (i
== 1) {
7639 snprintf(buf
, sizeof(buf
), "(%s) ", ts
->bprm
->argv
[0]);
7640 } else if (i
== 27) {
7643 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
7645 /* for the rest, there is MasterCard */
7646 snprintf(buf
, sizeof(buf
), "0%c", i
== 43 ? '\n' : ' ');
7650 if (write(fd
, buf
, len
) != len
) {
7658 static int open_self_auxv(void *cpu_env
, int fd
)
7660 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7661 TaskState
*ts
= cpu
->opaque
;
7662 abi_ulong auxv
= ts
->info
->saved_auxv
;
7663 abi_ulong len
= ts
->info
->auxv_len
;
7667 * Auxiliary vector is stored in target process stack.
7668 * read in whole auxv vector and copy it to file
7670 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
7674 r
= write(fd
, ptr
, len
);
7681 lseek(fd
, 0, SEEK_SET
);
7682 unlock_user(ptr
, auxv
, len
);
7688 static int is_proc_myself(const char *filename
, const char *entry
)
7690 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
7691 filename
+= strlen("/proc/");
7692 if (!strncmp(filename
, "self/", strlen("self/"))) {
7693 filename
+= strlen("self/");
7694 } else if (*filename
>= '1' && *filename
<= '9') {
7696 snprintf(myself
, sizeof(myself
), "%d/", getpid());
7697 if (!strncmp(filename
, myself
, strlen(myself
))) {
7698 filename
+= strlen(myself
);
7705 if (!strcmp(filename
, entry
)) {
7712 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7713 static int is_proc(const char *filename
, const char *entry
)
7715 return strcmp(filename
, entry
) == 0;
7718 static int open_net_route(void *cpu_env
, int fd
)
7725 fp
= fopen("/proc/net/route", "r");
7732 read
= getline(&line
, &len
, fp
);
7733 dprintf(fd
, "%s", line
);
7737 while ((read
= getline(&line
, &len
, fp
)) != -1) {
7739 uint32_t dest
, gw
, mask
;
7740 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
7741 sscanf(line
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7742 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
7743 &mask
, &mtu
, &window
, &irtt
);
7744 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7745 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
7746 metric
, tswap32(mask
), mtu
, window
, irtt
);
7756 static int do_openat(void *cpu_env
, int dirfd
, const char *pathname
, int flags
, mode_t mode
)
7759 const char *filename
;
7760 int (*fill
)(void *cpu_env
, int fd
);
7761 int (*cmp
)(const char *s1
, const char *s2
);
7763 const struct fake_open
*fake_open
;
7764 static const struct fake_open fakes
[] = {
7765 { "maps", open_self_maps
, is_proc_myself
},
7766 { "stat", open_self_stat
, is_proc_myself
},
7767 { "auxv", open_self_auxv
, is_proc_myself
},
7768 { "cmdline", open_self_cmdline
, is_proc_myself
},
7769 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7770 { "/proc/net/route", open_net_route
, is_proc
},
7772 { NULL
, NULL
, NULL
}
7775 if (is_proc_myself(pathname
, "exe")) {
7776 int execfd
= qemu_getauxval(AT_EXECFD
);
7777 return execfd
? execfd
: safe_openat(dirfd
, exec_path
, flags
, mode
);
7780 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
7781 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
7786 if (fake_open
->filename
) {
7788 char filename
[PATH_MAX
];
7791 /* create temporary file to map stat to */
7792 tmpdir
= getenv("TMPDIR");
7795 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
7796 fd
= mkstemp(filename
);
7802 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
7808 lseek(fd
, 0, SEEK_SET
);
7813 return safe_openat(dirfd
, path(pathname
), flags
, mode
);
7816 #define TIMER_MAGIC 0x0caf0000
7817 #define TIMER_MAGIC_MASK 0xffff0000
7819 /* Convert QEMU provided timer ID back to internal 16bit index format */
7820 static target_timer_t
get_timer_id(abi_long arg
)
7822 target_timer_t timerid
= arg
;
7824 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
7825 return -TARGET_EINVAL
;
7830 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
7831 return -TARGET_EINVAL
;
7837 static abi_long
swap_data_eventfd(void *buf
, size_t len
)
7839 uint64_t *counter
= buf
;
7842 if (len
< sizeof(uint64_t)) {
7846 for (i
= 0; i
< len
; i
+= sizeof(uint64_t)) {
7847 *counter
= tswap64(*counter
);
7854 static TargetFdTrans target_eventfd_trans
= {
7855 .host_to_target_data
= swap_data_eventfd
,
7856 .target_to_host_data
= swap_data_eventfd
,
7859 #if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
7860 (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
7861 defined(__NR_inotify_init1))
7862 static abi_long
host_to_target_data_inotify(void *buf
, size_t len
)
7864 struct inotify_event
*ev
;
7868 for (i
= 0; i
< len
; i
+= sizeof(struct inotify_event
) + name_len
) {
7869 ev
= (struct inotify_event
*)((char *)buf
+ i
);
7872 ev
->wd
= tswap32(ev
->wd
);
7873 ev
->mask
= tswap32(ev
->mask
);
7874 ev
->cookie
= tswap32(ev
->cookie
);
7875 ev
->len
= tswap32(name_len
);
7881 static TargetFdTrans target_inotify_trans
= {
7882 .host_to_target_data
= host_to_target_data_inotify
,
7886 static int target_to_host_cpu_mask(unsigned long *host_mask
,
7888 abi_ulong target_addr
,
7891 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7892 unsigned host_bits
= sizeof(*host_mask
) * 8;
7893 abi_ulong
*target_mask
;
7896 assert(host_size
>= target_size
);
7898 target_mask
= lock_user(VERIFY_READ
, target_addr
, target_size
, 1);
7900 return -TARGET_EFAULT
;
7902 memset(host_mask
, 0, host_size
);
7904 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7905 unsigned bit
= i
* target_bits
;
7908 __get_user(val
, &target_mask
[i
]);
7909 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7910 if (val
& (1UL << j
)) {
7911 host_mask
[bit
/ host_bits
] |= 1UL << (bit
% host_bits
);
7916 unlock_user(target_mask
, target_addr
, 0);
7920 static int host_to_target_cpu_mask(const unsigned long *host_mask
,
7922 abi_ulong target_addr
,
7925 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7926 unsigned host_bits
= sizeof(*host_mask
) * 8;
7927 abi_ulong
*target_mask
;
7930 assert(host_size
>= target_size
);
7932 target_mask
= lock_user(VERIFY_WRITE
, target_addr
, target_size
, 0);
7934 return -TARGET_EFAULT
;
7937 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7938 unsigned bit
= i
* target_bits
;
7941 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7942 if (host_mask
[bit
/ host_bits
] & (1UL << (bit
% host_bits
))) {
7946 __put_user(val
, &target_mask
[i
]);
7949 unlock_user(target_mask
, target_addr
, target_size
);
7953 /* do_syscall() should always have a single exit point at the end so
7954 that actions, such as logging of syscall results, can be performed.
7955 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
7956 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
7957 abi_long arg2
, abi_long arg3
, abi_long arg4
,
7958 abi_long arg5
, abi_long arg6
, abi_long arg7
,
7961 CPUState
*cpu
= ENV_GET_CPU(cpu_env
);
7967 #if defined(DEBUG_ERESTARTSYS)
7968 /* Debug-only code for exercising the syscall-restart code paths
7969 * in the per-architecture cpu main loops: restart every syscall
7970 * the guest makes once before letting it through.
7977 return -TARGET_ERESTARTSYS
;
7983 gemu_log("syscall %d", num
);
7985 trace_guest_user_syscall(cpu
, num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
);
7987 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
7990 case TARGET_NR_exit
:
7991 /* In old applications this may be used to implement _exit(2).
7992 However in threaded applictions it is used for thread termination,
7993 and _exit_group is used for application termination.
7994 Do thread termination if we have more then one thread. */
7996 if (block_signals()) {
7997 ret
= -TARGET_ERESTARTSYS
;
8003 if (CPU_NEXT(first_cpu
)) {
8006 /* Remove the CPU from the list. */
8007 QTAILQ_REMOVE(&cpus
, cpu
, node
);
8012 if (ts
->child_tidptr
) {
8013 put_user_u32(0, ts
->child_tidptr
);
8014 sys_futex(g2h(ts
->child_tidptr
), FUTEX_WAKE
, INT_MAX
,
8018 object_unref(OBJECT(cpu
));
8020 rcu_unregister_thread();
8025 preexit_cleanup(cpu_env
, arg1
);
8027 ret
= 0; /* avoid warning */
8029 case TARGET_NR_read
:
8033 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
8035 ret
= get_errno(safe_read(arg1
, p
, arg3
));
8037 fd_trans_host_to_target_data(arg1
)) {
8038 ret
= fd_trans_host_to_target_data(arg1
)(p
, ret
);
8040 unlock_user(p
, arg2
, ret
);
8043 case TARGET_NR_write
:
8044 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
8046 if (fd_trans_target_to_host_data(arg1
)) {
8047 void *copy
= g_malloc(arg3
);
8048 memcpy(copy
, p
, arg3
);
8049 ret
= fd_trans_target_to_host_data(arg1
)(copy
, arg3
);
8051 ret
= get_errno(safe_write(arg1
, copy
, ret
));
8055 ret
= get_errno(safe_write(arg1
, p
, arg3
));
8057 unlock_user(p
, arg2
, 0);
8059 #ifdef TARGET_NR_open
8060 case TARGET_NR_open
:
8061 if (!(p
= lock_user_string(arg1
)))
8063 ret
= get_errno(do_openat(cpu_env
, AT_FDCWD
, p
,
8064 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
8066 fd_trans_unregister(ret
);
8067 unlock_user(p
, arg1
, 0);
8070 case TARGET_NR_openat
:
8071 if (!(p
= lock_user_string(arg2
)))
8073 ret
= get_errno(do_openat(cpu_env
, arg1
, p
,
8074 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
8076 fd_trans_unregister(ret
);
8077 unlock_user(p
, arg2
, 0);
8079 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8080 case TARGET_NR_name_to_handle_at
:
8081 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
8084 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8085 case TARGET_NR_open_by_handle_at
:
8086 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
8087 fd_trans_unregister(ret
);
8090 case TARGET_NR_close
:
8091 fd_trans_unregister(arg1
);
8092 ret
= get_errno(close(arg1
));
8097 #ifdef TARGET_NR_fork
8098 case TARGET_NR_fork
:
8099 ret
= get_errno(do_fork(cpu_env
, TARGET_SIGCHLD
, 0, 0, 0, 0));
8102 #ifdef TARGET_NR_waitpid
8103 case TARGET_NR_waitpid
:
8106 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, 0));
8107 if (!is_error(ret
) && arg2
&& ret
8108 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
8113 #ifdef TARGET_NR_waitid
8114 case TARGET_NR_waitid
:
8118 ret
= get_errno(safe_waitid(arg1
, arg2
, &info
, arg4
, NULL
));
8119 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
8120 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
8122 host_to_target_siginfo(p
, &info
);
8123 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
8128 #ifdef TARGET_NR_creat /* not on alpha */
8129 case TARGET_NR_creat
:
8130 if (!(p
= lock_user_string(arg1
)))
8132 ret
= get_errno(creat(p
, arg2
));
8133 fd_trans_unregister(ret
);
8134 unlock_user(p
, arg1
, 0);
8137 #ifdef TARGET_NR_link
8138 case TARGET_NR_link
:
8141 p
= lock_user_string(arg1
);
8142 p2
= lock_user_string(arg2
);
8144 ret
= -TARGET_EFAULT
;
8146 ret
= get_errno(link(p
, p2
));
8147 unlock_user(p2
, arg2
, 0);
8148 unlock_user(p
, arg1
, 0);
8152 #if defined(TARGET_NR_linkat)
8153 case TARGET_NR_linkat
:
8158 p
= lock_user_string(arg2
);
8159 p2
= lock_user_string(arg4
);
8161 ret
= -TARGET_EFAULT
;
8163 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
8164 unlock_user(p
, arg2
, 0);
8165 unlock_user(p2
, arg4
, 0);
8169 #ifdef TARGET_NR_unlink
8170 case TARGET_NR_unlink
:
8171 if (!(p
= lock_user_string(arg1
)))
8173 ret
= get_errno(unlink(p
));
8174 unlock_user(p
, arg1
, 0);
8177 #if defined(TARGET_NR_unlinkat)
8178 case TARGET_NR_unlinkat
:
8179 if (!(p
= lock_user_string(arg2
)))
8181 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
8182 unlock_user(p
, arg2
, 0);
8185 case TARGET_NR_execve
:
8187 char **argp
, **envp
;
8190 abi_ulong guest_argp
;
8191 abi_ulong guest_envp
;
8198 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
8199 if (get_user_ual(addr
, gp
))
8207 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
8208 if (get_user_ual(addr
, gp
))
8215 argp
= g_new0(char *, argc
+ 1);
8216 envp
= g_new0(char *, envc
+ 1);
8218 for (gp
= guest_argp
, q
= argp
; gp
;
8219 gp
+= sizeof(abi_ulong
), q
++) {
8220 if (get_user_ual(addr
, gp
))
8224 if (!(*q
= lock_user_string(addr
)))
8226 total_size
+= strlen(*q
) + 1;
8230 for (gp
= guest_envp
, q
= envp
; gp
;
8231 gp
+= sizeof(abi_ulong
), q
++) {
8232 if (get_user_ual(addr
, gp
))
8236 if (!(*q
= lock_user_string(addr
)))
8238 total_size
+= strlen(*q
) + 1;
8242 if (!(p
= lock_user_string(arg1
)))
8244 /* Although execve() is not an interruptible syscall it is
8245 * a special case where we must use the safe_syscall wrapper:
8246 * if we allow a signal to happen before we make the host
8247 * syscall then we will 'lose' it, because at the point of
8248 * execve the process leaves QEMU's control. So we use the
8249 * safe syscall wrapper to ensure that we either take the
8250 * signal as a guest signal, or else it does not happen
8251 * before the execve completes and makes it the other
8252 * program's problem.
8254 ret
= get_errno(safe_execve(p
, argp
, envp
));
8255 unlock_user(p
, arg1
, 0);
8260 ret
= -TARGET_EFAULT
;
8263 for (gp
= guest_argp
, q
= argp
; *q
;
8264 gp
+= sizeof(abi_ulong
), q
++) {
8265 if (get_user_ual(addr
, gp
)
8268 unlock_user(*q
, addr
, 0);
8270 for (gp
= guest_envp
, q
= envp
; *q
;
8271 gp
+= sizeof(abi_ulong
), q
++) {
8272 if (get_user_ual(addr
, gp
)
8275 unlock_user(*q
, addr
, 0);
8282 case TARGET_NR_chdir
:
8283 if (!(p
= lock_user_string(arg1
)))
8285 ret
= get_errno(chdir(p
));
8286 unlock_user(p
, arg1
, 0);
8288 #ifdef TARGET_NR_time
8289 case TARGET_NR_time
:
8292 ret
= get_errno(time(&host_time
));
8295 && put_user_sal(host_time
, arg1
))
8300 #ifdef TARGET_NR_mknod
8301 case TARGET_NR_mknod
:
8302 if (!(p
= lock_user_string(arg1
)))
8304 ret
= get_errno(mknod(p
, arg2
, arg3
));
8305 unlock_user(p
, arg1
, 0);
8308 #if defined(TARGET_NR_mknodat)
8309 case TARGET_NR_mknodat
:
8310 if (!(p
= lock_user_string(arg2
)))
8312 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
8313 unlock_user(p
, arg2
, 0);
8316 #ifdef TARGET_NR_chmod
8317 case TARGET_NR_chmod
:
8318 if (!(p
= lock_user_string(arg1
)))
8320 ret
= get_errno(chmod(p
, arg2
));
8321 unlock_user(p
, arg1
, 0);
8324 #ifdef TARGET_NR_break
8325 case TARGET_NR_break
:
8328 #ifdef TARGET_NR_oldstat
8329 case TARGET_NR_oldstat
:
8332 case TARGET_NR_lseek
:
8333 ret
= get_errno(lseek(arg1
, arg2
, arg3
));
8335 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
8336 /* Alpha specific */
8337 case TARGET_NR_getxpid
:
8338 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = getppid();
8339 ret
= get_errno(getpid());
8342 #ifdef TARGET_NR_getpid
8343 case TARGET_NR_getpid
:
8344 ret
= get_errno(getpid());
8347 case TARGET_NR_mount
:
8349 /* need to look at the data field */
8353 p
= lock_user_string(arg1
);
8361 p2
= lock_user_string(arg2
);
8364 unlock_user(p
, arg1
, 0);
8370 p3
= lock_user_string(arg3
);
8373 unlock_user(p
, arg1
, 0);
8375 unlock_user(p2
, arg2
, 0);
8382 /* FIXME - arg5 should be locked, but it isn't clear how to
8383 * do that since it's not guaranteed to be a NULL-terminated
8387 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
8389 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
));
8391 ret
= get_errno(ret
);
8394 unlock_user(p
, arg1
, 0);
8396 unlock_user(p2
, arg2
, 0);
8398 unlock_user(p3
, arg3
, 0);
8402 #ifdef TARGET_NR_umount
8403 case TARGET_NR_umount
:
8404 if (!(p
= lock_user_string(arg1
)))
8406 ret
= get_errno(umount(p
));
8407 unlock_user(p
, arg1
, 0);
8410 #ifdef TARGET_NR_stime /* not on alpha */
8411 case TARGET_NR_stime
:
8414 if (get_user_sal(host_time
, arg1
))
8416 ret
= get_errno(stime(&host_time
));
8420 case TARGET_NR_ptrace
:
8422 #ifdef TARGET_NR_alarm /* not on alpha */
8423 case TARGET_NR_alarm
:
8427 #ifdef TARGET_NR_oldfstat
8428 case TARGET_NR_oldfstat
:
8431 #ifdef TARGET_NR_pause /* not on alpha */
8432 case TARGET_NR_pause
:
8433 if (!block_signals()) {
8434 sigsuspend(&((TaskState
*)cpu
->opaque
)->signal_mask
);
8436 ret
= -TARGET_EINTR
;
8439 #ifdef TARGET_NR_utime
8440 case TARGET_NR_utime
:
8442 struct utimbuf tbuf
, *host_tbuf
;
8443 struct target_utimbuf
*target_tbuf
;
8445 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
8447 tbuf
.actime
= tswapal(target_tbuf
->actime
);
8448 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
8449 unlock_user_struct(target_tbuf
, arg2
, 0);
8454 if (!(p
= lock_user_string(arg1
)))
8456 ret
= get_errno(utime(p
, host_tbuf
));
8457 unlock_user(p
, arg1
, 0);
8461 #ifdef TARGET_NR_utimes
8462 case TARGET_NR_utimes
:
8464 struct timeval
*tvp
, tv
[2];
8466 if (copy_from_user_timeval(&tv
[0], arg2
)
8467 || copy_from_user_timeval(&tv
[1],
8468 arg2
+ sizeof(struct target_timeval
)))
8474 if (!(p
= lock_user_string(arg1
)))
8476 ret
= get_errno(utimes(p
, tvp
));
8477 unlock_user(p
, arg1
, 0);
8481 #if defined(TARGET_NR_futimesat)
8482 case TARGET_NR_futimesat
:
8484 struct timeval
*tvp
, tv
[2];
8486 if (copy_from_user_timeval(&tv
[0], arg3
)
8487 || copy_from_user_timeval(&tv
[1],
8488 arg3
+ sizeof(struct target_timeval
)))
8494 if (!(p
= lock_user_string(arg2
)))
8496 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
8497 unlock_user(p
, arg2
, 0);
8501 #ifdef TARGET_NR_stty
8502 case TARGET_NR_stty
:
8505 #ifdef TARGET_NR_gtty
8506 case TARGET_NR_gtty
:
8509 #ifdef TARGET_NR_access
8510 case TARGET_NR_access
:
8511 if (!(p
= lock_user_string(arg1
)))
8513 ret
= get_errno(access(path(p
), arg2
));
8514 unlock_user(p
, arg1
, 0);
8517 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
8518 case TARGET_NR_faccessat
:
8519 if (!(p
= lock_user_string(arg2
)))
8521 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
8522 unlock_user(p
, arg2
, 0);
8525 #ifdef TARGET_NR_nice /* not on alpha */
8526 case TARGET_NR_nice
:
8527 ret
= get_errno(nice(arg1
));
8530 #ifdef TARGET_NR_ftime
8531 case TARGET_NR_ftime
:
8534 case TARGET_NR_sync
:
8538 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
8539 case TARGET_NR_syncfs
:
8540 ret
= get_errno(syncfs(arg1
));
8543 case TARGET_NR_kill
:
8544 ret
= get_errno(safe_kill(arg1
, target_to_host_signal(arg2
)));
8546 #ifdef TARGET_NR_rename
8547 case TARGET_NR_rename
:
8550 p
= lock_user_string(arg1
);
8551 p2
= lock_user_string(arg2
);
8553 ret
= -TARGET_EFAULT
;
8555 ret
= get_errno(rename(p
, p2
));
8556 unlock_user(p2
, arg2
, 0);
8557 unlock_user(p
, arg1
, 0);
8561 #if defined(TARGET_NR_renameat)
8562 case TARGET_NR_renameat
:
8565 p
= lock_user_string(arg2
);
8566 p2
= lock_user_string(arg4
);
8568 ret
= -TARGET_EFAULT
;
8570 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
8571 unlock_user(p2
, arg4
, 0);
8572 unlock_user(p
, arg2
, 0);
8576 #if defined(TARGET_NR_renameat2)
8577 case TARGET_NR_renameat2
:
8580 p
= lock_user_string(arg2
);
8581 p2
= lock_user_string(arg4
);
8583 ret
= -TARGET_EFAULT
;
8585 ret
= get_errno(sys_renameat2(arg1
, p
, arg3
, p2
, arg5
));
8587 unlock_user(p2
, arg4
, 0);
8588 unlock_user(p
, arg2
, 0);
8592 #ifdef TARGET_NR_mkdir
8593 case TARGET_NR_mkdir
:
8594 if (!(p
= lock_user_string(arg1
)))
8596 ret
= get_errno(mkdir(p
, arg2
));
8597 unlock_user(p
, arg1
, 0);
8600 #if defined(TARGET_NR_mkdirat)
8601 case TARGET_NR_mkdirat
:
8602 if (!(p
= lock_user_string(arg2
)))
8604 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
8605 unlock_user(p
, arg2
, 0);
8608 #ifdef TARGET_NR_rmdir
8609 case TARGET_NR_rmdir
:
8610 if (!(p
= lock_user_string(arg1
)))
8612 ret
= get_errno(rmdir(p
));
8613 unlock_user(p
, arg1
, 0);
8617 ret
= get_errno(dup(arg1
));
8619 fd_trans_dup(arg1
, ret
);
8622 #ifdef TARGET_NR_pipe
8623 case TARGET_NR_pipe
:
8624 ret
= do_pipe(cpu_env
, arg1
, 0, 0);
8627 #ifdef TARGET_NR_pipe2
8628 case TARGET_NR_pipe2
:
8629 ret
= do_pipe(cpu_env
, arg1
,
8630 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
8633 case TARGET_NR_times
:
8635 struct target_tms
*tmsp
;
8637 ret
= get_errno(times(&tms
));
8639 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
8642 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
8643 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
8644 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
8645 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
8648 ret
= host_to_target_clock_t(ret
);
8651 #ifdef TARGET_NR_prof
8652 case TARGET_NR_prof
:
8655 #ifdef TARGET_NR_signal
8656 case TARGET_NR_signal
:
8659 case TARGET_NR_acct
:
8661 ret
= get_errno(acct(NULL
));
8663 if (!(p
= lock_user_string(arg1
)))
8665 ret
= get_errno(acct(path(p
)));
8666 unlock_user(p
, arg1
, 0);
8669 #ifdef TARGET_NR_umount2
8670 case TARGET_NR_umount2
:
8671 if (!(p
= lock_user_string(arg1
)))
8673 ret
= get_errno(umount2(p
, arg2
));
8674 unlock_user(p
, arg1
, 0);
8677 #ifdef TARGET_NR_lock
8678 case TARGET_NR_lock
:
8681 case TARGET_NR_ioctl
:
8682 ret
= do_ioctl(arg1
, arg2
, arg3
);
8684 #ifdef TARGET_NR_fcntl
8685 case TARGET_NR_fcntl
:
8686 ret
= do_fcntl(arg1
, arg2
, arg3
);
8689 #ifdef TARGET_NR_mpx
8693 case TARGET_NR_setpgid
:
8694 ret
= get_errno(setpgid(arg1
, arg2
));
8696 #ifdef TARGET_NR_ulimit
8697 case TARGET_NR_ulimit
:
8700 #ifdef TARGET_NR_oldolduname
8701 case TARGET_NR_oldolduname
:
8704 case TARGET_NR_umask
:
8705 ret
= get_errno(umask(arg1
));
8707 case TARGET_NR_chroot
:
8708 if (!(p
= lock_user_string(arg1
)))
8710 ret
= get_errno(chroot(p
));
8711 unlock_user(p
, arg1
, 0);
8713 #ifdef TARGET_NR_ustat
8714 case TARGET_NR_ustat
:
8717 #ifdef TARGET_NR_dup2
8718 case TARGET_NR_dup2
:
8719 ret
= get_errno(dup2(arg1
, arg2
));
8721 fd_trans_dup(arg1
, arg2
);
8725 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
8726 case TARGET_NR_dup3
:
8730 if ((arg3
& ~TARGET_O_CLOEXEC
) != 0) {
8733 host_flags
= target_to_host_bitmask(arg3
, fcntl_flags_tbl
);
8734 ret
= get_errno(dup3(arg1
, arg2
, host_flags
));
8736 fd_trans_dup(arg1
, arg2
);
8741 #ifdef TARGET_NR_getppid /* not on alpha */
8742 case TARGET_NR_getppid
:
8743 ret
= get_errno(getppid());
8746 #ifdef TARGET_NR_getpgrp
8747 case TARGET_NR_getpgrp
:
8748 ret
= get_errno(getpgrp());
8751 case TARGET_NR_setsid
:
8752 ret
= get_errno(setsid());
8754 #ifdef TARGET_NR_sigaction
8755 case TARGET_NR_sigaction
:
8757 #if defined(TARGET_ALPHA)
8758 struct target_sigaction act
, oact
, *pact
= 0;
8759 struct target_old_sigaction
*old_act
;
8761 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8763 act
._sa_handler
= old_act
->_sa_handler
;
8764 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
8765 act
.sa_flags
= old_act
->sa_flags
;
8766 act
.sa_restorer
= 0;
8767 unlock_user_struct(old_act
, arg2
, 0);
8770 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8771 if (!is_error(ret
) && arg3
) {
8772 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8774 old_act
->_sa_handler
= oact
._sa_handler
;
8775 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
8776 old_act
->sa_flags
= oact
.sa_flags
;
8777 unlock_user_struct(old_act
, arg3
, 1);
8779 #elif defined(TARGET_MIPS)
8780 struct target_sigaction act
, oact
, *pact
, *old_act
;
8783 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8785 act
._sa_handler
= old_act
->_sa_handler
;
8786 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
8787 act
.sa_flags
= old_act
->sa_flags
;
8788 unlock_user_struct(old_act
, arg2
, 0);
8794 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8796 if (!is_error(ret
) && arg3
) {
8797 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8799 old_act
->_sa_handler
= oact
._sa_handler
;
8800 old_act
->sa_flags
= oact
.sa_flags
;
8801 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
8802 old_act
->sa_mask
.sig
[1] = 0;
8803 old_act
->sa_mask
.sig
[2] = 0;
8804 old_act
->sa_mask
.sig
[3] = 0;
8805 unlock_user_struct(old_act
, arg3
, 1);
8808 struct target_old_sigaction
*old_act
;
8809 struct target_sigaction act
, oact
, *pact
;
8811 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8813 act
._sa_handler
= old_act
->_sa_handler
;
8814 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
8815 act
.sa_flags
= old_act
->sa_flags
;
8816 act
.sa_restorer
= old_act
->sa_restorer
;
8817 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8818 act
.ka_restorer
= 0;
8820 unlock_user_struct(old_act
, arg2
, 0);
8825 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8826 if (!is_error(ret
) && arg3
) {
8827 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8829 old_act
->_sa_handler
= oact
._sa_handler
;
8830 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
8831 old_act
->sa_flags
= oact
.sa_flags
;
8832 old_act
->sa_restorer
= oact
.sa_restorer
;
8833 unlock_user_struct(old_act
, arg3
, 1);
8839 case TARGET_NR_rt_sigaction
:
8841 #if defined(TARGET_ALPHA)
8842 /* For Alpha and SPARC this is a 5 argument syscall, with
8843 * a 'restorer' parameter which must be copied into the
8844 * sa_restorer field of the sigaction struct.
8845 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
8846 * and arg5 is the sigsetsize.
8847 * Alpha also has a separate rt_sigaction struct that it uses
8848 * here; SPARC uses the usual sigaction struct.
8850 struct target_rt_sigaction
*rt_act
;
8851 struct target_sigaction act
, oact
, *pact
= 0;
8853 if (arg4
!= sizeof(target_sigset_t
)) {
8854 ret
= -TARGET_EINVAL
;
8858 if (!lock_user_struct(VERIFY_READ
, rt_act
, arg2
, 1))
8860 act
._sa_handler
= rt_act
->_sa_handler
;
8861 act
.sa_mask
= rt_act
->sa_mask
;
8862 act
.sa_flags
= rt_act
->sa_flags
;
8863 act
.sa_restorer
= arg5
;
8864 unlock_user_struct(rt_act
, arg2
, 0);
8867 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8868 if (!is_error(ret
) && arg3
) {
8869 if (!lock_user_struct(VERIFY_WRITE
, rt_act
, arg3
, 0))
8871 rt_act
->_sa_handler
= oact
._sa_handler
;
8872 rt_act
->sa_mask
= oact
.sa_mask
;
8873 rt_act
->sa_flags
= oact
.sa_flags
;
8874 unlock_user_struct(rt_act
, arg3
, 1);
8878 target_ulong restorer
= arg4
;
8879 target_ulong sigsetsize
= arg5
;
8881 target_ulong sigsetsize
= arg4
;
8883 struct target_sigaction
*act
;
8884 struct target_sigaction
*oact
;
8886 if (sigsetsize
!= sizeof(target_sigset_t
)) {
8887 ret
= -TARGET_EINVAL
;
8891 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1)) {
8894 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8895 act
->ka_restorer
= restorer
;
8901 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
8902 ret
= -TARGET_EFAULT
;
8903 goto rt_sigaction_fail
;
8907 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
8910 unlock_user_struct(act
, arg2
, 0);
8912 unlock_user_struct(oact
, arg3
, 1);
8916 #ifdef TARGET_NR_sgetmask /* not on alpha */
8917 case TARGET_NR_sgetmask
:
8920 abi_ulong target_set
;
8921 ret
= do_sigprocmask(0, NULL
, &cur_set
);
8923 host_to_target_old_sigset(&target_set
, &cur_set
);
8929 #ifdef TARGET_NR_ssetmask /* not on alpha */
8930 case TARGET_NR_ssetmask
:
8933 abi_ulong target_set
= arg1
;
8934 target_to_host_old_sigset(&set
, &target_set
);
8935 ret
= do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
8937 host_to_target_old_sigset(&target_set
, &oset
);
8943 #ifdef TARGET_NR_sigprocmask
8944 case TARGET_NR_sigprocmask
:
8946 #if defined(TARGET_ALPHA)
8947 sigset_t set
, oldset
;
8952 case TARGET_SIG_BLOCK
:
8955 case TARGET_SIG_UNBLOCK
:
8958 case TARGET_SIG_SETMASK
:
8962 ret
= -TARGET_EINVAL
;
8966 target_to_host_old_sigset(&set
, &mask
);
8968 ret
= do_sigprocmask(how
, &set
, &oldset
);
8969 if (!is_error(ret
)) {
8970 host_to_target_old_sigset(&mask
, &oldset
);
8972 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0; /* force no error */
8975 sigset_t set
, oldset
, *set_ptr
;
8980 case TARGET_SIG_BLOCK
:
8983 case TARGET_SIG_UNBLOCK
:
8986 case TARGET_SIG_SETMASK
:
8990 ret
= -TARGET_EINVAL
;
8993 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8995 target_to_host_old_sigset(&set
, p
);
8996 unlock_user(p
, arg2
, 0);
9002 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
9003 if (!is_error(ret
) && arg3
) {
9004 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
9006 host_to_target_old_sigset(p
, &oldset
);
9007 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
9013 case TARGET_NR_rt_sigprocmask
:
9016 sigset_t set
, oldset
, *set_ptr
;
9018 if (arg4
!= sizeof(target_sigset_t
)) {
9019 ret
= -TARGET_EINVAL
;
9025 case TARGET_SIG_BLOCK
:
9028 case TARGET_SIG_UNBLOCK
:
9031 case TARGET_SIG_SETMASK
:
9035 ret
= -TARGET_EINVAL
;
9038 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
9040 target_to_host_sigset(&set
, p
);
9041 unlock_user(p
, arg2
, 0);
9047 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
9048 if (!is_error(ret
) && arg3
) {
9049 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
9051 host_to_target_sigset(p
, &oldset
);
9052 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
9056 #ifdef TARGET_NR_sigpending
9057 case TARGET_NR_sigpending
:
9060 ret
= get_errno(sigpending(&set
));
9061 if (!is_error(ret
)) {
9062 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
9064 host_to_target_old_sigset(p
, &set
);
9065 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
9070 case TARGET_NR_rt_sigpending
:
9074 /* Yes, this check is >, not != like most. We follow the kernel's
9075 * logic and it does it like this because it implements
9076 * NR_sigpending through the same code path, and in that case
9077 * the old_sigset_t is smaller in size.
9079 if (arg2
> sizeof(target_sigset_t
)) {
9080 ret
= -TARGET_EINVAL
;
9084 ret
= get_errno(sigpending(&set
));
9085 if (!is_error(ret
)) {
9086 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
9088 host_to_target_sigset(p
, &set
);
9089 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
9093 #ifdef TARGET_NR_sigsuspend
9094 case TARGET_NR_sigsuspend
:
9096 TaskState
*ts
= cpu
->opaque
;
9097 #if defined(TARGET_ALPHA)
9098 abi_ulong mask
= arg1
;
9099 target_to_host_old_sigset(&ts
->sigsuspend_mask
, &mask
);
9101 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
9103 target_to_host_old_sigset(&ts
->sigsuspend_mask
, p
);
9104 unlock_user(p
, arg1
, 0);
9106 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
9108 if (ret
!= -TARGET_ERESTARTSYS
) {
9109 ts
->in_sigsuspend
= 1;
9114 case TARGET_NR_rt_sigsuspend
:
9116 TaskState
*ts
= cpu
->opaque
;
9118 if (arg2
!= sizeof(target_sigset_t
)) {
9119 ret
= -TARGET_EINVAL
;
9122 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
9124 target_to_host_sigset(&ts
->sigsuspend_mask
, p
);
9125 unlock_user(p
, arg1
, 0);
9126 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
9128 if (ret
!= -TARGET_ERESTARTSYS
) {
9129 ts
->in_sigsuspend
= 1;
9133 case TARGET_NR_rt_sigtimedwait
:
9136 struct timespec uts
, *puts
;
9139 if (arg4
!= sizeof(target_sigset_t
)) {
9140 ret
= -TARGET_EINVAL
;
9144 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
9146 target_to_host_sigset(&set
, p
);
9147 unlock_user(p
, arg1
, 0);
9150 target_to_host_timespec(puts
, arg3
);
9154 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
9156 if (!is_error(ret
)) {
9158 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
9163 host_to_target_siginfo(p
, &uinfo
);
9164 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
9166 ret
= host_to_target_signal(ret
);
9170 case TARGET_NR_rt_sigqueueinfo
:
9174 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
9178 target_to_host_siginfo(&uinfo
, p
);
9179 unlock_user(p
, arg3
, 0);
9180 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
9183 case TARGET_NR_rt_tgsigqueueinfo
:
9187 p
= lock_user(VERIFY_READ
, arg4
, sizeof(target_siginfo_t
), 1);
9191 target_to_host_siginfo(&uinfo
, p
);
9192 unlock_user(p
, arg4
, 0);
9193 ret
= get_errno(sys_rt_tgsigqueueinfo(arg1
, arg2
, arg3
, &uinfo
));
9196 #ifdef TARGET_NR_sigreturn
9197 case TARGET_NR_sigreturn
:
9198 if (block_signals()) {
9199 ret
= -TARGET_ERESTARTSYS
;
9201 ret
= do_sigreturn(cpu_env
);
9205 case TARGET_NR_rt_sigreturn
:
9206 if (block_signals()) {
9207 ret
= -TARGET_ERESTARTSYS
;
9209 ret
= do_rt_sigreturn(cpu_env
);
9212 case TARGET_NR_sethostname
:
9213 if (!(p
= lock_user_string(arg1
)))
9215 ret
= get_errno(sethostname(p
, arg2
));
9216 unlock_user(p
, arg1
, 0);
9218 case TARGET_NR_setrlimit
:
9220 int resource
= target_to_host_resource(arg1
);
9221 struct target_rlimit
*target_rlim
;
9223 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
9225 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
9226 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
9227 unlock_user_struct(target_rlim
, arg2
, 0);
9228 ret
= get_errno(setrlimit(resource
, &rlim
));
9231 case TARGET_NR_getrlimit
:
9233 int resource
= target_to_host_resource(arg1
);
9234 struct target_rlimit
*target_rlim
;
9237 ret
= get_errno(getrlimit(resource
, &rlim
));
9238 if (!is_error(ret
)) {
9239 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
9241 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
9242 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
9243 unlock_user_struct(target_rlim
, arg2
, 1);
9247 case TARGET_NR_getrusage
:
9249 struct rusage rusage
;
9250 ret
= get_errno(getrusage(arg1
, &rusage
));
9251 if (!is_error(ret
)) {
9252 ret
= host_to_target_rusage(arg2
, &rusage
);
9256 case TARGET_NR_gettimeofday
:
9259 ret
= get_errno(gettimeofday(&tv
, NULL
));
9260 if (!is_error(ret
)) {
9261 if (copy_to_user_timeval(arg1
, &tv
))
9266 case TARGET_NR_settimeofday
:
9268 struct timeval tv
, *ptv
= NULL
;
9269 struct timezone tz
, *ptz
= NULL
;
9272 if (copy_from_user_timeval(&tv
, arg1
)) {
9279 if (copy_from_user_timezone(&tz
, arg2
)) {
9285 ret
= get_errno(settimeofday(ptv
, ptz
));
9288 #if defined(TARGET_NR_select)
9289 case TARGET_NR_select
:
9290 #if defined(TARGET_WANT_NI_OLD_SELECT)
9291 /* some architectures used to have old_select here
9292 * but now ENOSYS it.
9294 ret
= -TARGET_ENOSYS
;
9295 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
9296 ret
= do_old_select(arg1
);
9298 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
9302 #ifdef TARGET_NR_pselect6
9303 case TARGET_NR_pselect6
:
9305 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
9306 fd_set rfds
, wfds
, efds
;
9307 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
9308 struct timespec ts
, *ts_ptr
;
9311 * The 6th arg is actually two args smashed together,
9312 * so we cannot use the C library.
9320 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
9321 target_sigset_t
*target_sigset
;
9329 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
9333 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
9337 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
9343 * This takes a timespec, and not a timeval, so we cannot
9344 * use the do_select() helper ...
9347 if (target_to_host_timespec(&ts
, ts_addr
)) {
9355 /* Extract the two packed args for the sigset */
9358 sig
.size
= SIGSET_T_SIZE
;
9360 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
9364 arg_sigset
= tswapal(arg7
[0]);
9365 arg_sigsize
= tswapal(arg7
[1]);
9366 unlock_user(arg7
, arg6
, 0);
9370 if (arg_sigsize
!= sizeof(*target_sigset
)) {
9371 /* Like the kernel, we enforce correct size sigsets */
9372 ret
= -TARGET_EINVAL
;
9375 target_sigset
= lock_user(VERIFY_READ
, arg_sigset
,
9376 sizeof(*target_sigset
), 1);
9377 if (!target_sigset
) {
9380 target_to_host_sigset(&set
, target_sigset
);
9381 unlock_user(target_sigset
, arg_sigset
, 0);
9389 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
9392 if (!is_error(ret
)) {
9393 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
9395 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
9397 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
9400 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
))
9406 #ifdef TARGET_NR_symlink
9407 case TARGET_NR_symlink
:
9410 p
= lock_user_string(arg1
);
9411 p2
= lock_user_string(arg2
);
9413 ret
= -TARGET_EFAULT
;
9415 ret
= get_errno(symlink(p
, p2
));
9416 unlock_user(p2
, arg2
, 0);
9417 unlock_user(p
, arg1
, 0);
9421 #if defined(TARGET_NR_symlinkat)
9422 case TARGET_NR_symlinkat
:
9425 p
= lock_user_string(arg1
);
9426 p2
= lock_user_string(arg3
);
9428 ret
= -TARGET_EFAULT
;
9430 ret
= get_errno(symlinkat(p
, arg2
, p2
));
9431 unlock_user(p2
, arg3
, 0);
9432 unlock_user(p
, arg1
, 0);
9436 #ifdef TARGET_NR_oldlstat
9437 case TARGET_NR_oldlstat
:
9440 #ifdef TARGET_NR_readlink
9441 case TARGET_NR_readlink
:
9444 p
= lock_user_string(arg1
);
9445 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9447 ret
= -TARGET_EFAULT
;
9449 /* Short circuit this for the magic exe check. */
9450 ret
= -TARGET_EINVAL
;
9451 } else if (is_proc_myself((const char *)p
, "exe")) {
9452 char real
[PATH_MAX
], *temp
;
9453 temp
= realpath(exec_path
, real
);
9454 /* Return value is # of bytes that we wrote to the buffer. */
9456 ret
= get_errno(-1);
9458 /* Don't worry about sign mismatch as earlier mapping
9459 * logic would have thrown a bad address error. */
9460 ret
= MIN(strlen(real
), arg3
);
9461 /* We cannot NUL terminate the string. */
9462 memcpy(p2
, real
, ret
);
9465 ret
= get_errno(readlink(path(p
), p2
, arg3
));
9467 unlock_user(p2
, arg2
, ret
);
9468 unlock_user(p
, arg1
, 0);
9472 #if defined(TARGET_NR_readlinkat)
9473 case TARGET_NR_readlinkat
:
9476 p
= lock_user_string(arg2
);
9477 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
9479 ret
= -TARGET_EFAULT
;
9480 } else if (is_proc_myself((const char *)p
, "exe")) {
9481 char real
[PATH_MAX
], *temp
;
9482 temp
= realpath(exec_path
, real
);
9483 ret
= temp
== NULL
? get_errno(-1) : strlen(real
) ;
9484 snprintf((char *)p2
, arg4
, "%s", real
);
9486 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
9488 unlock_user(p2
, arg3
, ret
);
9489 unlock_user(p
, arg2
, 0);
9493 #ifdef TARGET_NR_uselib
9494 case TARGET_NR_uselib
:
9497 #ifdef TARGET_NR_swapon
9498 case TARGET_NR_swapon
:
9499 if (!(p
= lock_user_string(arg1
)))
9501 ret
= get_errno(swapon(p
, arg2
));
9502 unlock_user(p
, arg1
, 0);
9505 case TARGET_NR_reboot
:
9506 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
9507 /* arg4 must be ignored in all other cases */
9508 p
= lock_user_string(arg4
);
9512 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
9513 unlock_user(p
, arg4
, 0);
9515 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
9518 #ifdef TARGET_NR_readdir
9519 case TARGET_NR_readdir
:
9522 #ifdef TARGET_NR_mmap
9523 case TARGET_NR_mmap
:
9524 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
9525 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
9526 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
9527 || defined(TARGET_S390X)
9530 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
9531 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
9539 unlock_user(v
, arg1
, 0);
9540 ret
= get_errno(target_mmap(v1
, v2
, v3
,
9541 target_to_host_bitmask(v4
, mmap_flags_tbl
),
9545 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
9546 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
9552 #ifdef TARGET_NR_mmap2
9553 case TARGET_NR_mmap2
:
9555 #define MMAP_SHIFT 12
9557 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
9558 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
9560 arg6
<< MMAP_SHIFT
));
9563 case TARGET_NR_munmap
:
9564 ret
= get_errno(target_munmap(arg1
, arg2
));
9566 case TARGET_NR_mprotect
:
9568 TaskState
*ts
= cpu
->opaque
;
9569 /* Special hack to detect libc making the stack executable. */
9570 if ((arg3
& PROT_GROWSDOWN
)
9571 && arg1
>= ts
->info
->stack_limit
9572 && arg1
<= ts
->info
->start_stack
) {
9573 arg3
&= ~PROT_GROWSDOWN
;
9574 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
9575 arg1
= ts
->info
->stack_limit
;
9578 ret
= get_errno(target_mprotect(arg1
, arg2
, arg3
));
9580 #ifdef TARGET_NR_mremap
9581 case TARGET_NR_mremap
:
9582 ret
= get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
9585 /* ??? msync/mlock/munlock are broken for softmmu. */
9586 #ifdef TARGET_NR_msync
9587 case TARGET_NR_msync
:
9588 ret
= get_errno(msync(g2h(arg1
), arg2
, arg3
));
9591 #ifdef TARGET_NR_mlock
9592 case TARGET_NR_mlock
:
9593 ret
= get_errno(mlock(g2h(arg1
), arg2
));
9596 #ifdef TARGET_NR_munlock
9597 case TARGET_NR_munlock
:
9598 ret
= get_errno(munlock(g2h(arg1
), arg2
));
9601 #ifdef TARGET_NR_mlockall
9602 case TARGET_NR_mlockall
:
9603 ret
= get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
9606 #ifdef TARGET_NR_munlockall
9607 case TARGET_NR_munlockall
:
9608 ret
= get_errno(munlockall());
9611 case TARGET_NR_truncate
:
9612 if (!(p
= lock_user_string(arg1
)))
9614 ret
= get_errno(truncate(p
, arg2
));
9615 unlock_user(p
, arg1
, 0);
9617 case TARGET_NR_ftruncate
:
9618 ret
= get_errno(ftruncate(arg1
, arg2
));
9620 case TARGET_NR_fchmod
:
9621 ret
= get_errno(fchmod(arg1
, arg2
));
9623 #if defined(TARGET_NR_fchmodat)
9624 case TARGET_NR_fchmodat
:
9625 if (!(p
= lock_user_string(arg2
)))
9627 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
9628 unlock_user(p
, arg2
, 0);
9631 case TARGET_NR_getpriority
:
9632 /* Note that negative values are valid for getpriority, so we must
9633 differentiate based on errno settings. */
9635 ret
= getpriority(arg1
, arg2
);
9636 if (ret
== -1 && errno
!= 0) {
9637 ret
= -host_to_target_errno(errno
);
9641 /* Return value is the unbiased priority. Signal no error. */
9642 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0;
9644 /* Return value is a biased priority to avoid negative numbers. */
9648 case TARGET_NR_setpriority
:
9649 ret
= get_errno(setpriority(arg1
, arg2
, arg3
));
9651 #ifdef TARGET_NR_profil
9652 case TARGET_NR_profil
:
9655 case TARGET_NR_statfs
:
9656 if (!(p
= lock_user_string(arg1
)))
9658 ret
= get_errno(statfs(path(p
), &stfs
));
9659 unlock_user(p
, arg1
, 0);
9661 if (!is_error(ret
)) {
9662 struct target_statfs
*target_stfs
;
9664 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
9666 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
9667 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
9668 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
9669 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
9670 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
9671 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
9672 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
9673 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
9674 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
9675 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
9676 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
9677 #ifdef _STATFS_F_FLAGS
9678 __put_user(stfs
.f_flags
, &target_stfs
->f_flags
);
9680 __put_user(0, &target_stfs
->f_flags
);
9682 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
9683 unlock_user_struct(target_stfs
, arg2
, 1);
9686 case TARGET_NR_fstatfs
:
9687 ret
= get_errno(fstatfs(arg1
, &stfs
));
9688 goto convert_statfs
;
9689 #ifdef TARGET_NR_statfs64
9690 case TARGET_NR_statfs64
:
9691 if (!(p
= lock_user_string(arg1
)))
9693 ret
= get_errno(statfs(path(p
), &stfs
));
9694 unlock_user(p
, arg1
, 0);
9696 if (!is_error(ret
)) {
9697 struct target_statfs64
*target_stfs
;
9699 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
9701 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
9702 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
9703 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
9704 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
9705 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
9706 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
9707 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
9708 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
9709 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
9710 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
9711 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
9712 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
9713 unlock_user_struct(target_stfs
, arg3
, 1);
9716 case TARGET_NR_fstatfs64
:
9717 ret
= get_errno(fstatfs(arg1
, &stfs
));
9718 goto convert_statfs64
;
9720 #ifdef TARGET_NR_ioperm
9721 case TARGET_NR_ioperm
:
9724 #ifdef TARGET_NR_socketcall
9725 case TARGET_NR_socketcall
:
9726 ret
= do_socketcall(arg1
, arg2
);
9729 #ifdef TARGET_NR_accept
9730 case TARGET_NR_accept
:
9731 ret
= do_accept4(arg1
, arg2
, arg3
, 0);
9734 #ifdef TARGET_NR_accept4
9735 case TARGET_NR_accept4
:
9736 ret
= do_accept4(arg1
, arg2
, arg3
, arg4
);
9739 #ifdef TARGET_NR_bind
9740 case TARGET_NR_bind
:
9741 ret
= do_bind(arg1
, arg2
, arg3
);
9744 #ifdef TARGET_NR_connect
9745 case TARGET_NR_connect
:
9746 ret
= do_connect(arg1
, arg2
, arg3
);
9749 #ifdef TARGET_NR_getpeername
9750 case TARGET_NR_getpeername
:
9751 ret
= do_getpeername(arg1
, arg2
, arg3
);
9754 #ifdef TARGET_NR_getsockname
9755 case TARGET_NR_getsockname
:
9756 ret
= do_getsockname(arg1
, arg2
, arg3
);
9759 #ifdef TARGET_NR_getsockopt
9760 case TARGET_NR_getsockopt
:
9761 ret
= do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
9764 #ifdef TARGET_NR_listen
9765 case TARGET_NR_listen
:
9766 ret
= get_errno(listen(arg1
, arg2
));
9769 #ifdef TARGET_NR_recv
9770 case TARGET_NR_recv
:
9771 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
9774 #ifdef TARGET_NR_recvfrom
9775 case TARGET_NR_recvfrom
:
9776 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9779 #ifdef TARGET_NR_recvmsg
9780 case TARGET_NR_recvmsg
:
9781 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
9784 #ifdef TARGET_NR_send
9785 case TARGET_NR_send
:
9786 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
9789 #ifdef TARGET_NR_sendmsg
9790 case TARGET_NR_sendmsg
:
9791 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
9794 #ifdef TARGET_NR_sendmmsg
9795 case TARGET_NR_sendmmsg
:
9796 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
9798 case TARGET_NR_recvmmsg
:
9799 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
9802 #ifdef TARGET_NR_sendto
9803 case TARGET_NR_sendto
:
9804 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9807 #ifdef TARGET_NR_shutdown
9808 case TARGET_NR_shutdown
:
9809 ret
= get_errno(shutdown(arg1
, arg2
));
9812 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
9813 case TARGET_NR_getrandom
:
9814 p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
9818 ret
= get_errno(getrandom(p
, arg2
, arg3
));
9819 unlock_user(p
, arg1
, ret
);
9822 #ifdef TARGET_NR_socket
9823 case TARGET_NR_socket
:
9824 ret
= do_socket(arg1
, arg2
, arg3
);
9827 #ifdef TARGET_NR_socketpair
9828 case TARGET_NR_socketpair
:
9829 ret
= do_socketpair(arg1
, arg2
, arg3
, arg4
);
9832 #ifdef TARGET_NR_setsockopt
9833 case TARGET_NR_setsockopt
:
9834 ret
= do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
9837 #if defined(TARGET_NR_syslog)
9838 case TARGET_NR_syslog
:
9843 case TARGET_SYSLOG_ACTION_CLOSE
: /* Close log */
9844 case TARGET_SYSLOG_ACTION_OPEN
: /* Open log */
9845 case TARGET_SYSLOG_ACTION_CLEAR
: /* Clear ring buffer */
9846 case TARGET_SYSLOG_ACTION_CONSOLE_OFF
: /* Disable logging */
9847 case TARGET_SYSLOG_ACTION_CONSOLE_ON
: /* Enable logging */
9848 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL
: /* Set messages level */
9849 case TARGET_SYSLOG_ACTION_SIZE_UNREAD
: /* Number of chars */
9850 case TARGET_SYSLOG_ACTION_SIZE_BUFFER
: /* Size of the buffer */
9852 ret
= get_errno(sys_syslog((int)arg1
, NULL
, (int)arg3
));
9855 case TARGET_SYSLOG_ACTION_READ
: /* Read from log */
9856 case TARGET_SYSLOG_ACTION_READ_CLEAR
: /* Read/clear msgs */
9857 case TARGET_SYSLOG_ACTION_READ_ALL
: /* Read last messages */
9859 ret
= -TARGET_EINVAL
;
9867 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9869 ret
= -TARGET_EFAULT
;
9872 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
9873 unlock_user(p
, arg2
, arg3
);
9883 case TARGET_NR_setitimer
:
9885 struct itimerval value
, ovalue
, *pvalue
;
9889 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
9890 || copy_from_user_timeval(&pvalue
->it_value
,
9891 arg2
+ sizeof(struct target_timeval
)))
9896 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
9897 if (!is_error(ret
) && arg3
) {
9898 if (copy_to_user_timeval(arg3
,
9899 &ovalue
.it_interval
)
9900 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
9906 case TARGET_NR_getitimer
:
9908 struct itimerval value
;
9910 ret
= get_errno(getitimer(arg1
, &value
));
9911 if (!is_error(ret
) && arg2
) {
9912 if (copy_to_user_timeval(arg2
,
9914 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
9920 #ifdef TARGET_NR_stat
9921 case TARGET_NR_stat
:
9922 if (!(p
= lock_user_string(arg1
)))
9924 ret
= get_errno(stat(path(p
), &st
));
9925 unlock_user(p
, arg1
, 0);
9928 #ifdef TARGET_NR_lstat
9929 case TARGET_NR_lstat
:
9930 if (!(p
= lock_user_string(arg1
)))
9932 ret
= get_errno(lstat(path(p
), &st
));
9933 unlock_user(p
, arg1
, 0);
9936 case TARGET_NR_fstat
:
9938 ret
= get_errno(fstat(arg1
, &st
));
9939 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
9942 if (!is_error(ret
)) {
9943 struct target_stat
*target_st
;
9945 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
9947 memset(target_st
, 0, sizeof(*target_st
));
9948 __put_user(st
.st_dev
, &target_st
->st_dev
);
9949 __put_user(st
.st_ino
, &target_st
->st_ino
);
9950 __put_user(st
.st_mode
, &target_st
->st_mode
);
9951 __put_user(st
.st_uid
, &target_st
->st_uid
);
9952 __put_user(st
.st_gid
, &target_st
->st_gid
);
9953 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
9954 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
9955 __put_user(st
.st_size
, &target_st
->st_size
);
9956 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
9957 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
9958 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
9959 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
9960 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
9961 unlock_user_struct(target_st
, arg2
, 1);
9965 #ifdef TARGET_NR_olduname
9966 case TARGET_NR_olduname
:
9969 #ifdef TARGET_NR_iopl
9970 case TARGET_NR_iopl
:
9973 case TARGET_NR_vhangup
:
9974 ret
= get_errno(vhangup());
9976 #ifdef TARGET_NR_idle
9977 case TARGET_NR_idle
:
9980 #ifdef TARGET_NR_syscall
9981 case TARGET_NR_syscall
:
9982 ret
= do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
9983 arg6
, arg7
, arg8
, 0);
9986 case TARGET_NR_wait4
:
9989 abi_long status_ptr
= arg2
;
9990 struct rusage rusage
, *rusage_ptr
;
9991 abi_ulong target_rusage
= arg4
;
9992 abi_long rusage_err
;
9994 rusage_ptr
= &rusage
;
9997 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, rusage_ptr
));
9998 if (!is_error(ret
)) {
9999 if (status_ptr
&& ret
) {
10000 status
= host_to_target_waitstatus(status
);
10001 if (put_user_s32(status
, status_ptr
))
10004 if (target_rusage
) {
10005 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
10013 #ifdef TARGET_NR_swapoff
10014 case TARGET_NR_swapoff
:
10015 if (!(p
= lock_user_string(arg1
)))
10017 ret
= get_errno(swapoff(p
));
10018 unlock_user(p
, arg1
, 0);
10021 case TARGET_NR_sysinfo
:
10023 struct target_sysinfo
*target_value
;
10024 struct sysinfo value
;
10025 ret
= get_errno(sysinfo(&value
));
10026 if (!is_error(ret
) && arg1
)
10028 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
10030 __put_user(value
.uptime
, &target_value
->uptime
);
10031 __put_user(value
.loads
[0], &target_value
->loads
[0]);
10032 __put_user(value
.loads
[1], &target_value
->loads
[1]);
10033 __put_user(value
.loads
[2], &target_value
->loads
[2]);
10034 __put_user(value
.totalram
, &target_value
->totalram
);
10035 __put_user(value
.freeram
, &target_value
->freeram
);
10036 __put_user(value
.sharedram
, &target_value
->sharedram
);
10037 __put_user(value
.bufferram
, &target_value
->bufferram
);
10038 __put_user(value
.totalswap
, &target_value
->totalswap
);
10039 __put_user(value
.freeswap
, &target_value
->freeswap
);
10040 __put_user(value
.procs
, &target_value
->procs
);
10041 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
10042 __put_user(value
.freehigh
, &target_value
->freehigh
);
10043 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
10044 unlock_user_struct(target_value
, arg1
, 1);
10048 #ifdef TARGET_NR_ipc
10049 case TARGET_NR_ipc
:
10050 ret
= do_ipc(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
10053 #ifdef TARGET_NR_semget
10054 case TARGET_NR_semget
:
10055 ret
= get_errno(semget(arg1
, arg2
, arg3
));
10058 #ifdef TARGET_NR_semop
10059 case TARGET_NR_semop
:
10060 ret
= do_semop(arg1
, arg2
, arg3
);
10063 #ifdef TARGET_NR_semctl
10064 case TARGET_NR_semctl
:
10065 ret
= do_semctl(arg1
, arg2
, arg3
, arg4
);
10068 #ifdef TARGET_NR_msgctl
10069 case TARGET_NR_msgctl
:
10070 ret
= do_msgctl(arg1
, arg2
, arg3
);
10073 #ifdef TARGET_NR_msgget
10074 case TARGET_NR_msgget
:
10075 ret
= get_errno(msgget(arg1
, arg2
));
10078 #ifdef TARGET_NR_msgrcv
10079 case TARGET_NR_msgrcv
:
10080 ret
= do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
10083 #ifdef TARGET_NR_msgsnd
10084 case TARGET_NR_msgsnd
:
10085 ret
= do_msgsnd(arg1
, arg2
, arg3
, arg4
);
10088 #ifdef TARGET_NR_shmget
10089 case TARGET_NR_shmget
:
10090 ret
= get_errno(shmget(arg1
, arg2
, arg3
));
10093 #ifdef TARGET_NR_shmctl
10094 case TARGET_NR_shmctl
:
10095 ret
= do_shmctl(arg1
, arg2
, arg3
);
10098 #ifdef TARGET_NR_shmat
10099 case TARGET_NR_shmat
:
10100 ret
= do_shmat(cpu_env
, arg1
, arg2
, arg3
);
10103 #ifdef TARGET_NR_shmdt
10104 case TARGET_NR_shmdt
:
10105 ret
= do_shmdt(arg1
);
10108 case TARGET_NR_fsync
:
10109 ret
= get_errno(fsync(arg1
));
10111 case TARGET_NR_clone
:
10112 /* Linux manages to have three different orderings for its
10113 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
10114 * match the kernel's CONFIG_CLONE_* settings.
10115 * Microblaze is further special in that it uses a sixth
10116 * implicit argument to clone for the TLS pointer.
10118 #if defined(TARGET_MICROBLAZE)
10119 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
10120 #elif defined(TARGET_CLONE_BACKWARDS)
10121 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
10122 #elif defined(TARGET_CLONE_BACKWARDS2)
10123 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
10125 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
10128 #ifdef __NR_exit_group
10129 /* new thread calls */
10130 case TARGET_NR_exit_group
:
10131 preexit_cleanup(cpu_env
, arg1
);
10132 ret
= get_errno(exit_group(arg1
));
10135 case TARGET_NR_setdomainname
:
10136 if (!(p
= lock_user_string(arg1
)))
10138 ret
= get_errno(setdomainname(p
, arg2
));
10139 unlock_user(p
, arg1
, 0);
10141 case TARGET_NR_uname
:
10142 /* no need to transcode because we use the linux syscall */
10144 struct new_utsname
* buf
;
10146 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
10148 ret
= get_errno(sys_uname(buf
));
10149 if (!is_error(ret
)) {
10150 /* Overwrite the native machine name with whatever is being
10152 g_strlcpy(buf
->machine
, cpu_to_uname_machine(cpu_env
),
10153 sizeof(buf
->machine
));
10154 /* Allow the user to override the reported release. */
10155 if (qemu_uname_release
&& *qemu_uname_release
) {
10156 g_strlcpy(buf
->release
, qemu_uname_release
,
10157 sizeof(buf
->release
));
10160 unlock_user_struct(buf
, arg1
, 1);
10164 case TARGET_NR_modify_ldt
:
10165 ret
= do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
10167 #if !defined(TARGET_X86_64)
10168 case TARGET_NR_vm86old
:
10169 goto unimplemented
;
10170 case TARGET_NR_vm86
:
10171 ret
= do_vm86(cpu_env
, arg1
, arg2
);
10175 case TARGET_NR_adjtimex
:
10177 struct timex host_buf
;
10179 if (target_to_host_timex(&host_buf
, arg1
) != 0) {
10182 ret
= get_errno(adjtimex(&host_buf
));
10183 if (!is_error(ret
)) {
10184 if (host_to_target_timex(arg1
, &host_buf
) != 0) {
10190 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
10191 case TARGET_NR_clock_adjtime
:
10193 struct timex htx
, *phtx
= &htx
;
10195 if (target_to_host_timex(phtx
, arg2
) != 0) {
10198 ret
= get_errno(clock_adjtime(arg1
, phtx
));
10199 if (!is_error(ret
) && phtx
) {
10200 if (host_to_target_timex(arg2
, phtx
) != 0) {
10207 #ifdef TARGET_NR_create_module
10208 case TARGET_NR_create_module
:
10210 case TARGET_NR_init_module
:
10211 case TARGET_NR_delete_module
:
10212 #ifdef TARGET_NR_get_kernel_syms
10213 case TARGET_NR_get_kernel_syms
:
10215 goto unimplemented
;
10216 case TARGET_NR_quotactl
:
10217 goto unimplemented
;
10218 case TARGET_NR_getpgid
:
10219 ret
= get_errno(getpgid(arg1
));
10221 case TARGET_NR_fchdir
:
10222 ret
= get_errno(fchdir(arg1
));
10224 #ifdef TARGET_NR_bdflush /* not on x86_64 */
10225 case TARGET_NR_bdflush
:
10226 goto unimplemented
;
10228 #ifdef TARGET_NR_sysfs
10229 case TARGET_NR_sysfs
:
10230 goto unimplemented
;
10232 case TARGET_NR_personality
:
10233 ret
= get_errno(personality(arg1
));
10235 #ifdef TARGET_NR_afs_syscall
10236 case TARGET_NR_afs_syscall
:
10237 goto unimplemented
;
10239 #ifdef TARGET_NR__llseek /* Not on alpha */
10240 case TARGET_NR__llseek
:
10243 #if !defined(__NR_llseek)
10244 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | (abi_ulong
)arg3
, arg5
);
10246 ret
= get_errno(res
);
10251 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
10253 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
10259 #ifdef TARGET_NR_getdents
10260 case TARGET_NR_getdents
:
10261 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
10262 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
10264 struct target_dirent
*target_dirp
;
10265 struct linux_dirent
*dirp
;
10266 abi_long count
= arg3
;
10268 dirp
= g_try_malloc(count
);
10270 ret
= -TARGET_ENOMEM
;
10274 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
10275 if (!is_error(ret
)) {
10276 struct linux_dirent
*de
;
10277 struct target_dirent
*tde
;
10279 int reclen
, treclen
;
10280 int count1
, tnamelen
;
10284 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10288 reclen
= de
->d_reclen
;
10289 tnamelen
= reclen
- offsetof(struct linux_dirent
, d_name
);
10290 assert(tnamelen
>= 0);
10291 treclen
= tnamelen
+ offsetof(struct target_dirent
, d_name
);
10292 assert(count1
+ treclen
<= count
);
10293 tde
->d_reclen
= tswap16(treclen
);
10294 tde
->d_ino
= tswapal(de
->d_ino
);
10295 tde
->d_off
= tswapal(de
->d_off
);
10296 memcpy(tde
->d_name
, de
->d_name
, tnamelen
);
10297 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
10299 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
10303 unlock_user(target_dirp
, arg2
, ret
);
10309 struct linux_dirent
*dirp
;
10310 abi_long count
= arg3
;
10312 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10314 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
10315 if (!is_error(ret
)) {
10316 struct linux_dirent
*de
;
10321 reclen
= de
->d_reclen
;
10324 de
->d_reclen
= tswap16(reclen
);
10325 tswapls(&de
->d_ino
);
10326 tswapls(&de
->d_off
);
10327 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
10331 unlock_user(dirp
, arg2
, ret
);
10335 /* Implement getdents in terms of getdents64 */
10337 struct linux_dirent64
*dirp
;
10338 abi_long count
= arg3
;
10340 dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
10344 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
10345 if (!is_error(ret
)) {
10346 /* Convert the dirent64 structs to target dirent. We do this
10347 * in-place, since we can guarantee that a target_dirent is no
10348 * larger than a dirent64; however this means we have to be
10349 * careful to read everything before writing in the new format.
10351 struct linux_dirent64
*de
;
10352 struct target_dirent
*tde
;
10357 tde
= (struct target_dirent
*)dirp
;
10359 int namelen
, treclen
;
10360 int reclen
= de
->d_reclen
;
10361 uint64_t ino
= de
->d_ino
;
10362 int64_t off
= de
->d_off
;
10363 uint8_t type
= de
->d_type
;
10365 namelen
= strlen(de
->d_name
);
10366 treclen
= offsetof(struct target_dirent
, d_name
)
10368 treclen
= QEMU_ALIGN_UP(treclen
, sizeof(abi_long
));
10370 memmove(tde
->d_name
, de
->d_name
, namelen
+ 1);
10371 tde
->d_ino
= tswapal(ino
);
10372 tde
->d_off
= tswapal(off
);
10373 tde
->d_reclen
= tswap16(treclen
);
10374 /* The target_dirent type is in what was formerly a padding
10375 * byte at the end of the structure:
10377 *(((char *)tde
) + treclen
- 1) = type
;
10379 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
10380 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
10386 unlock_user(dirp
, arg2
, ret
);
10390 #endif /* TARGET_NR_getdents */
10391 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
10392 case TARGET_NR_getdents64
:
10394 struct linux_dirent64
*dirp
;
10395 abi_long count
= arg3
;
10396 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10398 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
10399 if (!is_error(ret
)) {
10400 struct linux_dirent64
*de
;
10405 reclen
= de
->d_reclen
;
10408 de
->d_reclen
= tswap16(reclen
);
10409 tswap64s((uint64_t *)&de
->d_ino
);
10410 tswap64s((uint64_t *)&de
->d_off
);
10411 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
10415 unlock_user(dirp
, arg2
, ret
);
10418 #endif /* TARGET_NR_getdents64 */
10419 #if defined(TARGET_NR__newselect)
10420 case TARGET_NR__newselect
:
10421 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
10424 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
10425 # ifdef TARGET_NR_poll
10426 case TARGET_NR_poll
:
10428 # ifdef TARGET_NR_ppoll
10429 case TARGET_NR_ppoll
:
10432 struct target_pollfd
*target_pfd
;
10433 unsigned int nfds
= arg2
;
10434 struct pollfd
*pfd
;
10440 if (nfds
> (INT_MAX
/ sizeof(struct target_pollfd
))) {
10441 ret
= -TARGET_EINVAL
;
10445 target_pfd
= lock_user(VERIFY_WRITE
, arg1
,
10446 sizeof(struct target_pollfd
) * nfds
, 1);
10451 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
10452 for (i
= 0; i
< nfds
; i
++) {
10453 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
10454 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
10459 # ifdef TARGET_NR_ppoll
10460 case TARGET_NR_ppoll
:
10462 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
10463 target_sigset_t
*target_set
;
10464 sigset_t _set
, *set
= &_set
;
10467 if (target_to_host_timespec(timeout_ts
, arg3
)) {
10468 unlock_user(target_pfd
, arg1
, 0);
10476 if (arg5
!= sizeof(target_sigset_t
)) {
10477 unlock_user(target_pfd
, arg1
, 0);
10478 ret
= -TARGET_EINVAL
;
10482 target_set
= lock_user(VERIFY_READ
, arg4
, sizeof(target_sigset_t
), 1);
10484 unlock_user(target_pfd
, arg1
, 0);
10487 target_to_host_sigset(set
, target_set
);
10492 ret
= get_errno(safe_ppoll(pfd
, nfds
, timeout_ts
,
10493 set
, SIGSET_T_SIZE
));
10495 if (!is_error(ret
) && arg3
) {
10496 host_to_target_timespec(arg3
, timeout_ts
);
10499 unlock_user(target_set
, arg4
, 0);
10504 # ifdef TARGET_NR_poll
10505 case TARGET_NR_poll
:
10507 struct timespec ts
, *pts
;
10510 /* Convert ms to secs, ns */
10511 ts
.tv_sec
= arg3
/ 1000;
10512 ts
.tv_nsec
= (arg3
% 1000) * 1000000LL;
10515 /* -ve poll() timeout means "infinite" */
10518 ret
= get_errno(safe_ppoll(pfd
, nfds
, pts
, NULL
, 0));
10523 g_assert_not_reached();
10526 if (!is_error(ret
)) {
10527 for(i
= 0; i
< nfds
; i
++) {
10528 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
10531 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
10535 case TARGET_NR_flock
:
10536 /* NOTE: the flock constant seems to be the same for every
10538 ret
= get_errno(safe_flock(arg1
, arg2
));
10540 case TARGET_NR_readv
:
10542 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
10544 ret
= get_errno(safe_readv(arg1
, vec
, arg3
));
10545 unlock_iovec(vec
, arg2
, arg3
, 1);
10547 ret
= -host_to_target_errno(errno
);
10551 case TARGET_NR_writev
:
10553 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
10555 ret
= get_errno(safe_writev(arg1
, vec
, arg3
));
10556 unlock_iovec(vec
, arg2
, arg3
, 0);
10558 ret
= -host_to_target_errno(errno
);
10562 #if defined(TARGET_NR_preadv)
10563 case TARGET_NR_preadv
:
10565 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
10567 unsigned long low
, high
;
10569 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
10570 ret
= get_errno(safe_preadv(arg1
, vec
, arg3
, low
, high
));
10571 unlock_iovec(vec
, arg2
, arg3
, 1);
10573 ret
= -host_to_target_errno(errno
);
10578 #if defined(TARGET_NR_pwritev)
10579 case TARGET_NR_pwritev
:
10581 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
10583 unsigned long low
, high
;
10585 target_to_host_low_high(arg4
, arg5
, &low
, &high
);
10586 ret
= get_errno(safe_pwritev(arg1
, vec
, arg3
, low
, high
));
10587 unlock_iovec(vec
, arg2
, arg3
, 0);
10589 ret
= -host_to_target_errno(errno
);
10594 case TARGET_NR_getsid
:
10595 ret
= get_errno(getsid(arg1
));
10597 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
10598 case TARGET_NR_fdatasync
:
10599 ret
= get_errno(fdatasync(arg1
));
10602 #ifdef TARGET_NR__sysctl
10603 case TARGET_NR__sysctl
:
10604 /* We don't implement this, but ENOTDIR is always a safe
10606 ret
= -TARGET_ENOTDIR
;
10609 case TARGET_NR_sched_getaffinity
:
10611 unsigned int mask_size
;
10612 unsigned long *mask
;
10615 * sched_getaffinity needs multiples of ulong, so need to take
10616 * care of mismatches between target ulong and host ulong sizes.
10618 if (arg2
& (sizeof(abi_ulong
) - 1)) {
10619 ret
= -TARGET_EINVAL
;
10622 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
10624 mask
= alloca(mask_size
);
10625 memset(mask
, 0, mask_size
);
10626 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
10628 if (!is_error(ret
)) {
10630 /* More data returned than the caller's buffer will fit.
10631 * This only happens if sizeof(abi_long) < sizeof(long)
10632 * and the caller passed us a buffer holding an odd number
10633 * of abi_longs. If the host kernel is actually using the
10634 * extra 4 bytes then fail EINVAL; otherwise we can just
10635 * ignore them and only copy the interesting part.
10637 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
10638 if (numcpus
> arg2
* 8) {
10639 ret
= -TARGET_EINVAL
;
10645 if (host_to_target_cpu_mask(mask
, mask_size
, arg3
, ret
)) {
10651 case TARGET_NR_sched_setaffinity
:
10653 unsigned int mask_size
;
10654 unsigned long *mask
;
10657 * sched_setaffinity needs multiples of ulong, so need to take
10658 * care of mismatches between target ulong and host ulong sizes.
10660 if (arg2
& (sizeof(abi_ulong
) - 1)) {
10661 ret
= -TARGET_EINVAL
;
10664 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
10665 mask
= alloca(mask_size
);
10667 ret
= target_to_host_cpu_mask(mask
, mask_size
, arg3
, arg2
);
10672 ret
= get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
10675 case TARGET_NR_getcpu
:
10677 unsigned cpu
, node
;
10678 ret
= get_errno(sys_getcpu(arg1
? &cpu
: NULL
,
10679 arg2
? &node
: NULL
,
10681 if (is_error(ret
)) {
10684 if (arg1
&& put_user_u32(cpu
, arg1
)) {
10687 if (arg2
&& put_user_u32(node
, arg2
)) {
10692 case TARGET_NR_sched_setparam
:
10694 struct sched_param
*target_schp
;
10695 struct sched_param schp
;
10698 return -TARGET_EINVAL
;
10700 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
10702 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
10703 unlock_user_struct(target_schp
, arg2
, 0);
10704 ret
= get_errno(sched_setparam(arg1
, &schp
));
10707 case TARGET_NR_sched_getparam
:
10709 struct sched_param
*target_schp
;
10710 struct sched_param schp
;
10713 return -TARGET_EINVAL
;
10715 ret
= get_errno(sched_getparam(arg1
, &schp
));
10716 if (!is_error(ret
)) {
10717 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
10719 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
10720 unlock_user_struct(target_schp
, arg2
, 1);
10724 case TARGET_NR_sched_setscheduler
:
10726 struct sched_param
*target_schp
;
10727 struct sched_param schp
;
10729 return -TARGET_EINVAL
;
10731 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
10733 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
10734 unlock_user_struct(target_schp
, arg3
, 0);
10735 ret
= get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
10738 case TARGET_NR_sched_getscheduler
:
10739 ret
= get_errno(sched_getscheduler(arg1
));
10741 case TARGET_NR_sched_yield
:
10742 ret
= get_errno(sched_yield());
10744 case TARGET_NR_sched_get_priority_max
:
10745 ret
= get_errno(sched_get_priority_max(arg1
));
10747 case TARGET_NR_sched_get_priority_min
:
10748 ret
= get_errno(sched_get_priority_min(arg1
));
10750 case TARGET_NR_sched_rr_get_interval
:
10752 struct timespec ts
;
10753 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
10754 if (!is_error(ret
)) {
10755 ret
= host_to_target_timespec(arg2
, &ts
);
10759 case TARGET_NR_nanosleep
:
10761 struct timespec req
, rem
;
10762 target_to_host_timespec(&req
, arg1
);
10763 ret
= get_errno(safe_nanosleep(&req
, &rem
));
10764 if (is_error(ret
) && arg2
) {
10765 host_to_target_timespec(arg2
, &rem
);
10769 #ifdef TARGET_NR_query_module
10770 case TARGET_NR_query_module
:
10771 goto unimplemented
;
10773 #ifdef TARGET_NR_nfsservctl
10774 case TARGET_NR_nfsservctl
:
10775 goto unimplemented
;
10777 case TARGET_NR_prctl
:
10779 case PR_GET_PDEATHSIG
:
10782 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
10783 if (!is_error(ret
) && arg2
10784 && put_user_ual(deathsig
, arg2
)) {
10792 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
10796 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
10797 arg3
, arg4
, arg5
));
10798 unlock_user(name
, arg2
, 16);
10803 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
10807 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
10808 arg3
, arg4
, arg5
));
10809 unlock_user(name
, arg2
, 0);
10813 #ifdef TARGET_AARCH64
10814 case TARGET_PR_SVE_SET_VL
:
10815 /* We cannot support either PR_SVE_SET_VL_ONEXEC
10816 or PR_SVE_VL_INHERIT. Therefore, anything above
10817 ARM_MAX_VQ results in EINVAL. */
10818 ret
= -TARGET_EINVAL
;
10819 if (arm_feature(cpu_env
, ARM_FEATURE_SVE
)
10820 && arg2
>= 0 && arg2
<= ARM_MAX_VQ
* 16 && !(arg2
& 15)) {
10821 CPUARMState
*env
= cpu_env
;
10822 int old_vq
= (env
->vfp
.zcr_el
[1] & 0xf) + 1;
10823 int vq
= MAX(arg2
/ 16, 1);
10826 aarch64_sve_narrow_vq(env
, vq
);
10828 env
->vfp
.zcr_el
[1] = vq
- 1;
10832 case TARGET_PR_SVE_GET_VL
:
10833 ret
= -TARGET_EINVAL
;
10834 if (arm_feature(cpu_env
, ARM_FEATURE_SVE
)) {
10835 CPUARMState
*env
= cpu_env
;
10836 ret
= ((env
->vfp
.zcr_el
[1] & 0xf) + 1) * 16;
10839 #endif /* AARCH64 */
10840 case PR_GET_SECCOMP
:
10841 case PR_SET_SECCOMP
:
10842 /* Disable seccomp to prevent the target disabling syscalls we
10844 ret
= -TARGET_EINVAL
;
10847 /* Most prctl options have no pointer arguments */
10848 ret
= get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
10852 #ifdef TARGET_NR_arch_prctl
10853 case TARGET_NR_arch_prctl
:
10854 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
10855 ret
= do_arch_prctl(cpu_env
, arg1
, arg2
);
10858 goto unimplemented
;
10861 #ifdef TARGET_NR_pread64
10862 case TARGET_NR_pread64
:
10863 if (regpairs_aligned(cpu_env
, num
)) {
10867 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
10869 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10870 unlock_user(p
, arg2
, ret
);
10872 case TARGET_NR_pwrite64
:
10873 if (regpairs_aligned(cpu_env
, num
)) {
10877 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
10879 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10880 unlock_user(p
, arg2
, 0);
10883 case TARGET_NR_getcwd
:
10884 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
10886 ret
= get_errno(sys_getcwd1(p
, arg2
));
10887 unlock_user(p
, arg1
, ret
);
10889 case TARGET_NR_capget
:
10890 case TARGET_NR_capset
:
10892 struct target_user_cap_header
*target_header
;
10893 struct target_user_cap_data
*target_data
= NULL
;
10894 struct __user_cap_header_struct header
;
10895 struct __user_cap_data_struct data
[2];
10896 struct __user_cap_data_struct
*dataptr
= NULL
;
10897 int i
, target_datalen
;
10898 int data_items
= 1;
10900 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
10903 header
.version
= tswap32(target_header
->version
);
10904 header
.pid
= tswap32(target_header
->pid
);
10906 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
10907 /* Version 2 and up takes pointer to two user_data structs */
10911 target_datalen
= sizeof(*target_data
) * data_items
;
10914 if (num
== TARGET_NR_capget
) {
10915 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
10917 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
10919 if (!target_data
) {
10920 unlock_user_struct(target_header
, arg1
, 0);
10924 if (num
== TARGET_NR_capset
) {
10925 for (i
= 0; i
< data_items
; i
++) {
10926 data
[i
].effective
= tswap32(target_data
[i
].effective
);
10927 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
10928 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
10935 if (num
== TARGET_NR_capget
) {
10936 ret
= get_errno(capget(&header
, dataptr
));
10938 ret
= get_errno(capset(&header
, dataptr
));
10941 /* The kernel always updates version for both capget and capset */
10942 target_header
->version
= tswap32(header
.version
);
10943 unlock_user_struct(target_header
, arg1
, 1);
10946 if (num
== TARGET_NR_capget
) {
10947 for (i
= 0; i
< data_items
; i
++) {
10948 target_data
[i
].effective
= tswap32(data
[i
].effective
);
10949 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
10950 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
10952 unlock_user(target_data
, arg2
, target_datalen
);
10954 unlock_user(target_data
, arg2
, 0);
10959 case TARGET_NR_sigaltstack
:
10960 ret
= do_sigaltstack(arg1
, arg2
, get_sp_from_cpustate((CPUArchState
*)cpu_env
));
10963 #ifdef CONFIG_SENDFILE
10964 case TARGET_NR_sendfile
:
10966 off_t
*offp
= NULL
;
10969 ret
= get_user_sal(off
, arg3
);
10970 if (is_error(ret
)) {
10975 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10976 if (!is_error(ret
) && arg3
) {
10977 abi_long ret2
= put_user_sal(off
, arg3
);
10978 if (is_error(ret2
)) {
10984 #ifdef TARGET_NR_sendfile64
10985 case TARGET_NR_sendfile64
:
10987 off_t
*offp
= NULL
;
10990 ret
= get_user_s64(off
, arg3
);
10991 if (is_error(ret
)) {
10996 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10997 if (!is_error(ret
) && arg3
) {
10998 abi_long ret2
= put_user_s64(off
, arg3
);
10999 if (is_error(ret2
)) {
11007 case TARGET_NR_sendfile
:
11008 #ifdef TARGET_NR_sendfile64
11009 case TARGET_NR_sendfile64
:
11011 goto unimplemented
;
11014 #ifdef TARGET_NR_getpmsg
11015 case TARGET_NR_getpmsg
:
11016 goto unimplemented
;
11018 #ifdef TARGET_NR_putpmsg
11019 case TARGET_NR_putpmsg
:
11020 goto unimplemented
;
11022 #ifdef TARGET_NR_vfork
11023 case TARGET_NR_vfork
:
11024 ret
= get_errno(do_fork(cpu_env
,
11025 CLONE_VFORK
| CLONE_VM
| TARGET_SIGCHLD
,
11029 #ifdef TARGET_NR_ugetrlimit
11030 case TARGET_NR_ugetrlimit
:
11032 struct rlimit rlim
;
11033 int resource
= target_to_host_resource(arg1
);
11034 ret
= get_errno(getrlimit(resource
, &rlim
));
11035 if (!is_error(ret
)) {
11036 struct target_rlimit
*target_rlim
;
11037 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
11039 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
11040 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
11041 unlock_user_struct(target_rlim
, arg2
, 1);
11046 #ifdef TARGET_NR_truncate64
11047 case TARGET_NR_truncate64
:
11048 if (!(p
= lock_user_string(arg1
)))
11050 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
11051 unlock_user(p
, arg1
, 0);
11054 #ifdef TARGET_NR_ftruncate64
11055 case TARGET_NR_ftruncate64
:
11056 ret
= target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
11059 #ifdef TARGET_NR_stat64
11060 case TARGET_NR_stat64
:
11061 if (!(p
= lock_user_string(arg1
)))
11063 ret
= get_errno(stat(path(p
), &st
));
11064 unlock_user(p
, arg1
, 0);
11065 if (!is_error(ret
))
11066 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11069 #ifdef TARGET_NR_lstat64
11070 case TARGET_NR_lstat64
:
11071 if (!(p
= lock_user_string(arg1
)))
11073 ret
= get_errno(lstat(path(p
), &st
));
11074 unlock_user(p
, arg1
, 0);
11075 if (!is_error(ret
))
11076 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11079 #ifdef TARGET_NR_fstat64
11080 case TARGET_NR_fstat64
:
11081 ret
= get_errno(fstat(arg1
, &st
));
11082 if (!is_error(ret
))
11083 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
11086 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
11087 #ifdef TARGET_NR_fstatat64
11088 case TARGET_NR_fstatat64
:
11090 #ifdef TARGET_NR_newfstatat
11091 case TARGET_NR_newfstatat
:
11093 if (!(p
= lock_user_string(arg2
)))
11095 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
11096 if (!is_error(ret
))
11097 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
11100 #ifdef TARGET_NR_lchown
11101 case TARGET_NR_lchown
:
11102 if (!(p
= lock_user_string(arg1
)))
11104 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
11105 unlock_user(p
, arg1
, 0);
11108 #ifdef TARGET_NR_getuid
11109 case TARGET_NR_getuid
:
11110 ret
= get_errno(high2lowuid(getuid()));
11113 #ifdef TARGET_NR_getgid
11114 case TARGET_NR_getgid
:
11115 ret
= get_errno(high2lowgid(getgid()));
11118 #ifdef TARGET_NR_geteuid
11119 case TARGET_NR_geteuid
:
11120 ret
= get_errno(high2lowuid(geteuid()));
11123 #ifdef TARGET_NR_getegid
11124 case TARGET_NR_getegid
:
11125 ret
= get_errno(high2lowgid(getegid()));
11128 case TARGET_NR_setreuid
:
11129 ret
= get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
11131 case TARGET_NR_setregid
:
11132 ret
= get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
11134 case TARGET_NR_getgroups
:
11136 int gidsetsize
= arg1
;
11137 target_id
*target_grouplist
;
11141 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11142 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
11143 if (gidsetsize
== 0)
11145 if (!is_error(ret
)) {
11146 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* sizeof(target_id
), 0);
11147 if (!target_grouplist
)
11149 for(i
= 0;i
< ret
; i
++)
11150 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
11151 unlock_user(target_grouplist
, arg2
, gidsetsize
* sizeof(target_id
));
11155 case TARGET_NR_setgroups
:
11157 int gidsetsize
= arg1
;
11158 target_id
*target_grouplist
;
11159 gid_t
*grouplist
= NULL
;
11162 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11163 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* sizeof(target_id
), 1);
11164 if (!target_grouplist
) {
11165 ret
= -TARGET_EFAULT
;
11168 for (i
= 0; i
< gidsetsize
; i
++) {
11169 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
11171 unlock_user(target_grouplist
, arg2
, 0);
11173 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
11176 case TARGET_NR_fchown
:
11177 ret
= get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
11179 #if defined(TARGET_NR_fchownat)
11180 case TARGET_NR_fchownat
:
11181 if (!(p
= lock_user_string(arg2
)))
11183 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
11184 low2highgid(arg4
), arg5
));
11185 unlock_user(p
, arg2
, 0);
11188 #ifdef TARGET_NR_setresuid
11189 case TARGET_NR_setresuid
:
11190 ret
= get_errno(sys_setresuid(low2highuid(arg1
),
11192 low2highuid(arg3
)));
11195 #ifdef TARGET_NR_getresuid
11196 case TARGET_NR_getresuid
:
11198 uid_t ruid
, euid
, suid
;
11199 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
11200 if (!is_error(ret
)) {
11201 if (put_user_id(high2lowuid(ruid
), arg1
)
11202 || put_user_id(high2lowuid(euid
), arg2
)
11203 || put_user_id(high2lowuid(suid
), arg3
))
11209 #ifdef TARGET_NR_getresgid
11210 case TARGET_NR_setresgid
:
11211 ret
= get_errno(sys_setresgid(low2highgid(arg1
),
11213 low2highgid(arg3
)));
11216 #ifdef TARGET_NR_getresgid
11217 case TARGET_NR_getresgid
:
11219 gid_t rgid
, egid
, sgid
;
11220 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
11221 if (!is_error(ret
)) {
11222 if (put_user_id(high2lowgid(rgid
), arg1
)
11223 || put_user_id(high2lowgid(egid
), arg2
)
11224 || put_user_id(high2lowgid(sgid
), arg3
))
11230 #ifdef TARGET_NR_chown
11231 case TARGET_NR_chown
:
11232 if (!(p
= lock_user_string(arg1
)))
11234 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
11235 unlock_user(p
, arg1
, 0);
11238 case TARGET_NR_setuid
:
11239 ret
= get_errno(sys_setuid(low2highuid(arg1
)));
11241 case TARGET_NR_setgid
:
11242 ret
= get_errno(sys_setgid(low2highgid(arg1
)));
11244 case TARGET_NR_setfsuid
:
11245 ret
= get_errno(setfsuid(arg1
));
11247 case TARGET_NR_setfsgid
:
11248 ret
= get_errno(setfsgid(arg1
));
11251 #ifdef TARGET_NR_lchown32
11252 case TARGET_NR_lchown32
:
11253 if (!(p
= lock_user_string(arg1
)))
11255 ret
= get_errno(lchown(p
, arg2
, arg3
));
11256 unlock_user(p
, arg1
, 0);
11259 #ifdef TARGET_NR_getuid32
11260 case TARGET_NR_getuid32
:
11261 ret
= get_errno(getuid());
11265 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
11266 /* Alpha specific */
11267 case TARGET_NR_getxuid
:
11271 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=euid
;
11273 ret
= get_errno(getuid());
11276 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
11277 /* Alpha specific */
11278 case TARGET_NR_getxgid
:
11282 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=egid
;
11284 ret
= get_errno(getgid());
11287 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
11288 /* Alpha specific */
11289 case TARGET_NR_osf_getsysinfo
:
11290 ret
= -TARGET_EOPNOTSUPP
;
11292 case TARGET_GSI_IEEE_FP_CONTROL
:
11294 uint64_t swcr
, fpcr
= cpu_alpha_load_fpcr (cpu_env
);
11296 /* Copied from linux ieee_fpcr_to_swcr. */
11297 swcr
= (fpcr
>> 35) & SWCR_STATUS_MASK
;
11298 swcr
|= (fpcr
>> 36) & SWCR_MAP_DMZ
;
11299 swcr
|= (~fpcr
>> 48) & (SWCR_TRAP_ENABLE_INV
11300 | SWCR_TRAP_ENABLE_DZE
11301 | SWCR_TRAP_ENABLE_OVF
);
11302 swcr
|= (~fpcr
>> 57) & (SWCR_TRAP_ENABLE_UNF
11303 | SWCR_TRAP_ENABLE_INE
);
11304 swcr
|= (fpcr
>> 47) & SWCR_MAP_UMZ
;
11305 swcr
|= (~fpcr
>> 41) & SWCR_TRAP_ENABLE_DNO
;
11307 if (put_user_u64 (swcr
, arg2
))
11313 /* case GSI_IEEE_STATE_AT_SIGNAL:
11314 -- Not implemented in linux kernel.
11316 -- Retrieves current unaligned access state; not much used.
11317 case GSI_PROC_TYPE:
11318 -- Retrieves implver information; surely not used.
11319 case GSI_GET_HWRPB:
11320 -- Grabs a copy of the HWRPB; surely not used.
11325 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
11326 /* Alpha specific */
11327 case TARGET_NR_osf_setsysinfo
:
11328 ret
= -TARGET_EOPNOTSUPP
;
11330 case TARGET_SSI_IEEE_FP_CONTROL
:
11332 uint64_t swcr
, fpcr
, orig_fpcr
;
11334 if (get_user_u64 (swcr
, arg2
)) {
11337 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
11338 fpcr
= orig_fpcr
& FPCR_DYN_MASK
;
11340 /* Copied from linux ieee_swcr_to_fpcr. */
11341 fpcr
|= (swcr
& SWCR_STATUS_MASK
) << 35;
11342 fpcr
|= (swcr
& SWCR_MAP_DMZ
) << 36;
11343 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_INV
11344 | SWCR_TRAP_ENABLE_DZE
11345 | SWCR_TRAP_ENABLE_OVF
)) << 48;
11346 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_UNF
11347 | SWCR_TRAP_ENABLE_INE
)) << 57;
11348 fpcr
|= (swcr
& SWCR_MAP_UMZ
? FPCR_UNDZ
| FPCR_UNFD
: 0);
11349 fpcr
|= (~swcr
& SWCR_TRAP_ENABLE_DNO
) << 41;
11351 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
11356 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
11358 uint64_t exc
, fpcr
, orig_fpcr
;
11361 if (get_user_u64(exc
, arg2
)) {
11365 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
11367 /* We only add to the exception status here. */
11368 fpcr
= orig_fpcr
| ((exc
& SWCR_STATUS_MASK
) << 35);
11370 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
11373 /* Old exceptions are not signaled. */
11374 fpcr
&= ~(orig_fpcr
& FPCR_STATUS_MASK
);
11376 /* If any exceptions set by this call,
11377 and are unmasked, send a signal. */
11379 if ((fpcr
& (FPCR_INE
| FPCR_INED
)) == FPCR_INE
) {
11380 si_code
= TARGET_FPE_FLTRES
;
11382 if ((fpcr
& (FPCR_UNF
| FPCR_UNFD
)) == FPCR_UNF
) {
11383 si_code
= TARGET_FPE_FLTUND
;
11385 if ((fpcr
& (FPCR_OVF
| FPCR_OVFD
)) == FPCR_OVF
) {
11386 si_code
= TARGET_FPE_FLTOVF
;
11388 if ((fpcr
& (FPCR_DZE
| FPCR_DZED
)) == FPCR_DZE
) {
11389 si_code
= TARGET_FPE_FLTDIV
;
11391 if ((fpcr
& (FPCR_INV
| FPCR_INVD
)) == FPCR_INV
) {
11392 si_code
= TARGET_FPE_FLTINV
;
11394 if (si_code
!= 0) {
11395 target_siginfo_t info
;
11396 info
.si_signo
= SIGFPE
;
11398 info
.si_code
= si_code
;
11399 info
._sifields
._sigfault
._addr
11400 = ((CPUArchState
*)cpu_env
)->pc
;
11401 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
11402 QEMU_SI_FAULT
, &info
);
11407 /* case SSI_NVPAIRS:
11408 -- Used with SSIN_UACPROC to enable unaligned accesses.
11409 case SSI_IEEE_STATE_AT_SIGNAL:
11410 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
11411 -- Not implemented in linux kernel
11416 #ifdef TARGET_NR_osf_sigprocmask
11417 /* Alpha specific. */
11418 case TARGET_NR_osf_sigprocmask
:
11422 sigset_t set
, oldset
;
11425 case TARGET_SIG_BLOCK
:
11428 case TARGET_SIG_UNBLOCK
:
11431 case TARGET_SIG_SETMASK
:
11435 ret
= -TARGET_EINVAL
;
11439 target_to_host_old_sigset(&set
, &mask
);
11440 ret
= do_sigprocmask(how
, &set
, &oldset
);
11442 host_to_target_old_sigset(&mask
, &oldset
);
11449 #ifdef TARGET_NR_getgid32
11450 case TARGET_NR_getgid32
:
11451 ret
= get_errno(getgid());
11454 #ifdef TARGET_NR_geteuid32
11455 case TARGET_NR_geteuid32
:
11456 ret
= get_errno(geteuid());
11459 #ifdef TARGET_NR_getegid32
11460 case TARGET_NR_getegid32
:
11461 ret
= get_errno(getegid());
11464 #ifdef TARGET_NR_setreuid32
11465 case TARGET_NR_setreuid32
:
11466 ret
= get_errno(setreuid(arg1
, arg2
));
11469 #ifdef TARGET_NR_setregid32
11470 case TARGET_NR_setregid32
:
11471 ret
= get_errno(setregid(arg1
, arg2
));
11474 #ifdef TARGET_NR_getgroups32
11475 case TARGET_NR_getgroups32
:
11477 int gidsetsize
= arg1
;
11478 uint32_t *target_grouplist
;
11482 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11483 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
11484 if (gidsetsize
== 0)
11486 if (!is_error(ret
)) {
11487 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
11488 if (!target_grouplist
) {
11489 ret
= -TARGET_EFAULT
;
11492 for(i
= 0;i
< ret
; i
++)
11493 target_grouplist
[i
] = tswap32(grouplist
[i
]);
11494 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
11499 #ifdef TARGET_NR_setgroups32
11500 case TARGET_NR_setgroups32
:
11502 int gidsetsize
= arg1
;
11503 uint32_t *target_grouplist
;
11507 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11508 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
11509 if (!target_grouplist
) {
11510 ret
= -TARGET_EFAULT
;
11513 for(i
= 0;i
< gidsetsize
; i
++)
11514 grouplist
[i
] = tswap32(target_grouplist
[i
]);
11515 unlock_user(target_grouplist
, arg2
, 0);
11516 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
11520 #ifdef TARGET_NR_fchown32
11521 case TARGET_NR_fchown32
:
11522 ret
= get_errno(fchown(arg1
, arg2
, arg3
));
11525 #ifdef TARGET_NR_setresuid32
11526 case TARGET_NR_setresuid32
:
11527 ret
= get_errno(sys_setresuid(arg1
, arg2
, arg3
));
11530 #ifdef TARGET_NR_getresuid32
11531 case TARGET_NR_getresuid32
:
11533 uid_t ruid
, euid
, suid
;
11534 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
11535 if (!is_error(ret
)) {
11536 if (put_user_u32(ruid
, arg1
)
11537 || put_user_u32(euid
, arg2
)
11538 || put_user_u32(suid
, arg3
))
11544 #ifdef TARGET_NR_setresgid32
11545 case TARGET_NR_setresgid32
:
11546 ret
= get_errno(sys_setresgid(arg1
, arg2
, arg3
));
11549 #ifdef TARGET_NR_getresgid32
11550 case TARGET_NR_getresgid32
:
11552 gid_t rgid
, egid
, sgid
;
11553 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
11554 if (!is_error(ret
)) {
11555 if (put_user_u32(rgid
, arg1
)
11556 || put_user_u32(egid
, arg2
)
11557 || put_user_u32(sgid
, arg3
))
11563 #ifdef TARGET_NR_chown32
11564 case TARGET_NR_chown32
:
11565 if (!(p
= lock_user_string(arg1
)))
11567 ret
= get_errno(chown(p
, arg2
, arg3
));
11568 unlock_user(p
, arg1
, 0);
11571 #ifdef TARGET_NR_setuid32
11572 case TARGET_NR_setuid32
:
11573 ret
= get_errno(sys_setuid(arg1
));
11576 #ifdef TARGET_NR_setgid32
11577 case TARGET_NR_setgid32
:
11578 ret
= get_errno(sys_setgid(arg1
));
11581 #ifdef TARGET_NR_setfsuid32
11582 case TARGET_NR_setfsuid32
:
11583 ret
= get_errno(setfsuid(arg1
));
11586 #ifdef TARGET_NR_setfsgid32
11587 case TARGET_NR_setfsgid32
:
11588 ret
= get_errno(setfsgid(arg1
));
11592 case TARGET_NR_pivot_root
:
11593 goto unimplemented
;
11594 #ifdef TARGET_NR_mincore
11595 case TARGET_NR_mincore
:
11598 ret
= -TARGET_ENOMEM
;
11599 a
= lock_user(VERIFY_READ
, arg1
, arg2
, 0);
11603 ret
= -TARGET_EFAULT
;
11604 p
= lock_user_string(arg3
);
11608 ret
= get_errno(mincore(a
, arg2
, p
));
11609 unlock_user(p
, arg3
, ret
);
11611 unlock_user(a
, arg1
, 0);
11615 #ifdef TARGET_NR_arm_fadvise64_64
11616 case TARGET_NR_arm_fadvise64_64
:
11617 /* arm_fadvise64_64 looks like fadvise64_64 but
11618 * with different argument order: fd, advice, offset, len
11619 * rather than the usual fd, offset, len, advice.
11620 * Note that offset and len are both 64-bit so appear as
11621 * pairs of 32-bit registers.
11623 ret
= posix_fadvise(arg1
, target_offset64(arg3
, arg4
),
11624 target_offset64(arg5
, arg6
), arg2
);
11625 ret
= -host_to_target_errno(ret
);
11629 #if TARGET_ABI_BITS == 32
11631 #ifdef TARGET_NR_fadvise64_64
11632 case TARGET_NR_fadvise64_64
:
11633 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
11634 /* 6 args: fd, advice, offset (high, low), len (high, low) */
11642 /* 6 args: fd, offset (high, low), len (high, low), advice */
11643 if (regpairs_aligned(cpu_env
, num
)) {
11644 /* offset is in (3,4), len in (5,6) and advice in 7 */
11652 ret
= -host_to_target_errno(posix_fadvise(arg1
,
11653 target_offset64(arg2
, arg3
),
11654 target_offset64(arg4
, arg5
),
11659 #ifdef TARGET_NR_fadvise64
11660 case TARGET_NR_fadvise64
:
11661 /* 5 args: fd, offset (high, low), len, advice */
11662 if (regpairs_aligned(cpu_env
, num
)) {
11663 /* offset is in (3,4), len in 5 and advice in 6 */
11669 ret
= -host_to_target_errno(posix_fadvise(arg1
,
11670 target_offset64(arg2
, arg3
),
11675 #else /* not a 32-bit ABI */
11676 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
11677 #ifdef TARGET_NR_fadvise64_64
11678 case TARGET_NR_fadvise64_64
:
11680 #ifdef TARGET_NR_fadvise64
11681 case TARGET_NR_fadvise64
:
11683 #ifdef TARGET_S390X
11685 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
11686 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
11687 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
11688 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
11692 ret
= -host_to_target_errno(posix_fadvise(arg1
, arg2
, arg3
, arg4
));
11695 #endif /* end of 64-bit ABI fadvise handling */
11697 #ifdef TARGET_NR_madvise
11698 case TARGET_NR_madvise
:
11699 /* A straight passthrough may not be safe because qemu sometimes
11700 turns private file-backed mappings into anonymous mappings.
11701 This will break MADV_DONTNEED.
11702 This is a hint, so ignoring and returning success is ok. */
11703 ret
= get_errno(0);
11706 #if TARGET_ABI_BITS == 32
11707 case TARGET_NR_fcntl64
:
11711 from_flock64_fn
*copyfrom
= copy_from_user_flock64
;
11712 to_flock64_fn
*copyto
= copy_to_user_flock64
;
11715 if (!((CPUARMState
*)cpu_env
)->eabi
) {
11716 copyfrom
= copy_from_user_oabi_flock64
;
11717 copyto
= copy_to_user_oabi_flock64
;
11721 cmd
= target_to_host_fcntl_cmd(arg2
);
11722 if (cmd
== -TARGET_EINVAL
) {
11728 case TARGET_F_GETLK64
:
11729 ret
= copyfrom(&fl
, arg3
);
11733 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
11735 ret
= copyto(arg3
, &fl
);
11739 case TARGET_F_SETLK64
:
11740 case TARGET_F_SETLKW64
:
11741 ret
= copyfrom(&fl
, arg3
);
11745 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
11748 ret
= do_fcntl(arg1
, arg2
, arg3
);
11754 #ifdef TARGET_NR_cacheflush
11755 case TARGET_NR_cacheflush
:
11756 /* self-modifying code is handled automatically, so nothing needed */
11760 #ifdef TARGET_NR_security
11761 case TARGET_NR_security
:
11762 goto unimplemented
;
11764 #ifdef TARGET_NR_getpagesize
11765 case TARGET_NR_getpagesize
:
11766 ret
= TARGET_PAGE_SIZE
;
11769 case TARGET_NR_gettid
:
11770 ret
= get_errno(gettid());
11772 #ifdef TARGET_NR_readahead
11773 case TARGET_NR_readahead
:
11774 #if TARGET_ABI_BITS == 32
11775 if (regpairs_aligned(cpu_env
, num
)) {
11780 ret
= get_errno(readahead(arg1
, target_offset64(arg2
, arg3
) , arg4
));
11782 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
11787 #ifdef TARGET_NR_setxattr
11788 case TARGET_NR_listxattr
:
11789 case TARGET_NR_llistxattr
:
11793 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11795 ret
= -TARGET_EFAULT
;
11799 p
= lock_user_string(arg1
);
11801 if (num
== TARGET_NR_listxattr
) {
11802 ret
= get_errno(listxattr(p
, b
, arg3
));
11804 ret
= get_errno(llistxattr(p
, b
, arg3
));
11807 ret
= -TARGET_EFAULT
;
11809 unlock_user(p
, arg1
, 0);
11810 unlock_user(b
, arg2
, arg3
);
11813 case TARGET_NR_flistxattr
:
11817 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11819 ret
= -TARGET_EFAULT
;
11823 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
11824 unlock_user(b
, arg2
, arg3
);
11827 case TARGET_NR_setxattr
:
11828 case TARGET_NR_lsetxattr
:
11830 void *p
, *n
, *v
= 0;
11832 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11834 ret
= -TARGET_EFAULT
;
11838 p
= lock_user_string(arg1
);
11839 n
= lock_user_string(arg2
);
11841 if (num
== TARGET_NR_setxattr
) {
11842 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
11844 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
11847 ret
= -TARGET_EFAULT
;
11849 unlock_user(p
, arg1
, 0);
11850 unlock_user(n
, arg2
, 0);
11851 unlock_user(v
, arg3
, 0);
11854 case TARGET_NR_fsetxattr
:
11858 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11860 ret
= -TARGET_EFAULT
;
11864 n
= lock_user_string(arg2
);
11866 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
11868 ret
= -TARGET_EFAULT
;
11870 unlock_user(n
, arg2
, 0);
11871 unlock_user(v
, arg3
, 0);
11874 case TARGET_NR_getxattr
:
11875 case TARGET_NR_lgetxattr
:
11877 void *p
, *n
, *v
= 0;
11879 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11881 ret
= -TARGET_EFAULT
;
11885 p
= lock_user_string(arg1
);
11886 n
= lock_user_string(arg2
);
11888 if (num
== TARGET_NR_getxattr
) {
11889 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
11891 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
11894 ret
= -TARGET_EFAULT
;
11896 unlock_user(p
, arg1
, 0);
11897 unlock_user(n
, arg2
, 0);
11898 unlock_user(v
, arg3
, arg4
);
11901 case TARGET_NR_fgetxattr
:
11905 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11907 ret
= -TARGET_EFAULT
;
11911 n
= lock_user_string(arg2
);
11913 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
11915 ret
= -TARGET_EFAULT
;
11917 unlock_user(n
, arg2
, 0);
11918 unlock_user(v
, arg3
, arg4
);
11921 case TARGET_NR_removexattr
:
11922 case TARGET_NR_lremovexattr
:
11925 p
= lock_user_string(arg1
);
11926 n
= lock_user_string(arg2
);
11928 if (num
== TARGET_NR_removexattr
) {
11929 ret
= get_errno(removexattr(p
, n
));
11931 ret
= get_errno(lremovexattr(p
, n
));
11934 ret
= -TARGET_EFAULT
;
11936 unlock_user(p
, arg1
, 0);
11937 unlock_user(n
, arg2
, 0);
11940 case TARGET_NR_fremovexattr
:
11943 n
= lock_user_string(arg2
);
11945 ret
= get_errno(fremovexattr(arg1
, n
));
11947 ret
= -TARGET_EFAULT
;
11949 unlock_user(n
, arg2
, 0);
11953 #endif /* CONFIG_ATTR */
11954 #ifdef TARGET_NR_set_thread_area
11955 case TARGET_NR_set_thread_area
:
11956 #if defined(TARGET_MIPS)
11957 ((CPUMIPSState
*) cpu_env
)->active_tc
.CP0_UserLocal
= arg1
;
11960 #elif defined(TARGET_CRIS)
11962 ret
= -TARGET_EINVAL
;
11964 ((CPUCRISState
*) cpu_env
)->pregs
[PR_PID
] = arg1
;
11968 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
11969 ret
= do_set_thread_area(cpu_env
, arg1
);
11971 #elif defined(TARGET_M68K)
11973 TaskState
*ts
= cpu
->opaque
;
11974 ts
->tp_value
= arg1
;
11979 goto unimplemented_nowarn
;
11982 #ifdef TARGET_NR_get_thread_area
11983 case TARGET_NR_get_thread_area
:
11984 #if defined(TARGET_I386) && defined(TARGET_ABI32)
11985 ret
= do_get_thread_area(cpu_env
, arg1
);
11987 #elif defined(TARGET_M68K)
11989 TaskState
*ts
= cpu
->opaque
;
11990 ret
= ts
->tp_value
;
11994 goto unimplemented_nowarn
;
11997 #ifdef TARGET_NR_getdomainname
11998 case TARGET_NR_getdomainname
:
11999 goto unimplemented_nowarn
;
12002 #ifdef TARGET_NR_clock_settime
12003 case TARGET_NR_clock_settime
:
12005 struct timespec ts
;
12007 ret
= target_to_host_timespec(&ts
, arg2
);
12008 if (!is_error(ret
)) {
12009 ret
= get_errno(clock_settime(arg1
, &ts
));
12014 #ifdef TARGET_NR_clock_gettime
12015 case TARGET_NR_clock_gettime
:
12017 struct timespec ts
;
12018 ret
= get_errno(clock_gettime(arg1
, &ts
));
12019 if (!is_error(ret
)) {
12020 ret
= host_to_target_timespec(arg2
, &ts
);
12025 #ifdef TARGET_NR_clock_getres
12026 case TARGET_NR_clock_getres
:
12028 struct timespec ts
;
12029 ret
= get_errno(clock_getres(arg1
, &ts
));
12030 if (!is_error(ret
)) {
12031 host_to_target_timespec(arg2
, &ts
);
12036 #ifdef TARGET_NR_clock_nanosleep
12037 case TARGET_NR_clock_nanosleep
:
12039 struct timespec ts
;
12040 target_to_host_timespec(&ts
, arg3
);
12041 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
12042 &ts
, arg4
? &ts
: NULL
));
12044 host_to_target_timespec(arg4
, &ts
);
12046 #if defined(TARGET_PPC)
12047 /* clock_nanosleep is odd in that it returns positive errno values.
12048 * On PPC, CR0 bit 3 should be set in such a situation. */
12049 if (ret
&& ret
!= -TARGET_ERESTARTSYS
) {
12050 ((CPUPPCState
*)cpu_env
)->crf
[0] |= 1;
12057 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
12058 case TARGET_NR_set_tid_address
:
12059 ret
= get_errno(set_tid_address((int *)g2h(arg1
)));
12063 case TARGET_NR_tkill
:
12064 ret
= get_errno(safe_tkill((int)arg1
, target_to_host_signal(arg2
)));
12067 case TARGET_NR_tgkill
:
12068 ret
= get_errno(safe_tgkill((int)arg1
, (int)arg2
,
12069 target_to_host_signal(arg3
)));
12072 #ifdef TARGET_NR_set_robust_list
12073 case TARGET_NR_set_robust_list
:
12074 case TARGET_NR_get_robust_list
:
12075 /* The ABI for supporting robust futexes has userspace pass
12076 * the kernel a pointer to a linked list which is updated by
12077 * userspace after the syscall; the list is walked by the kernel
12078 * when the thread exits. Since the linked list in QEMU guest
12079 * memory isn't a valid linked list for the host and we have
12080 * no way to reliably intercept the thread-death event, we can't
12081 * support these. Silently return ENOSYS so that guest userspace
12082 * falls back to a non-robust futex implementation (which should
12083 * be OK except in the corner case of the guest crashing while
12084 * holding a mutex that is shared with another process via
12087 goto unimplemented_nowarn
;
12090 #if defined(TARGET_NR_utimensat)
12091 case TARGET_NR_utimensat
:
12093 struct timespec
*tsp
, ts
[2];
12097 target_to_host_timespec(ts
, arg3
);
12098 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
12102 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
12104 if (!(p
= lock_user_string(arg2
))) {
12105 ret
= -TARGET_EFAULT
;
12108 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
12109 unlock_user(p
, arg2
, 0);
12114 case TARGET_NR_futex
:
12115 ret
= do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
12117 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
12118 case TARGET_NR_inotify_init
:
12119 ret
= get_errno(sys_inotify_init());
12121 fd_trans_register(ret
, &target_inotify_trans
);
12125 #ifdef CONFIG_INOTIFY1
12126 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
12127 case TARGET_NR_inotify_init1
:
12128 ret
= get_errno(sys_inotify_init1(target_to_host_bitmask(arg1
,
12129 fcntl_flags_tbl
)));
12131 fd_trans_register(ret
, &target_inotify_trans
);
12136 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
12137 case TARGET_NR_inotify_add_watch
:
12138 p
= lock_user_string(arg2
);
12139 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
12140 unlock_user(p
, arg2
, 0);
12143 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
12144 case TARGET_NR_inotify_rm_watch
:
12145 ret
= get_errno(sys_inotify_rm_watch(arg1
, arg2
));
12149 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
12150 case TARGET_NR_mq_open
:
12152 struct mq_attr posix_mq_attr
;
12153 struct mq_attr
*pposix_mq_attr
;
12156 host_flags
= target_to_host_bitmask(arg2
, fcntl_flags_tbl
);
12157 pposix_mq_attr
= NULL
;
12159 if (copy_from_user_mq_attr(&posix_mq_attr
, arg4
) != 0) {
12162 pposix_mq_attr
= &posix_mq_attr
;
12164 p
= lock_user_string(arg1
- 1);
12168 ret
= get_errno(mq_open(p
, host_flags
, arg3
, pposix_mq_attr
));
12169 unlock_user (p
, arg1
, 0);
12173 case TARGET_NR_mq_unlink
:
12174 p
= lock_user_string(arg1
- 1);
12176 ret
= -TARGET_EFAULT
;
12179 ret
= get_errno(mq_unlink(p
));
12180 unlock_user (p
, arg1
, 0);
12183 case TARGET_NR_mq_timedsend
:
12185 struct timespec ts
;
12187 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
12189 target_to_host_timespec(&ts
, arg5
);
12190 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
12191 host_to_target_timespec(arg5
, &ts
);
12193 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
12195 unlock_user (p
, arg2
, arg3
);
12199 case TARGET_NR_mq_timedreceive
:
12201 struct timespec ts
;
12204 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
12206 target_to_host_timespec(&ts
, arg5
);
12207 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
12209 host_to_target_timespec(arg5
, &ts
);
12211 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
12214 unlock_user (p
, arg2
, arg3
);
12216 put_user_u32(prio
, arg4
);
12220 /* Not implemented for now... */
12221 /* case TARGET_NR_mq_notify: */
12224 case TARGET_NR_mq_getsetattr
:
12226 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
12229 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
12230 ret
= get_errno(mq_setattr(arg1
, &posix_mq_attr_in
,
12231 &posix_mq_attr_out
));
12232 } else if (arg3
!= 0) {
12233 ret
= get_errno(mq_getattr(arg1
, &posix_mq_attr_out
));
12235 if (ret
== 0 && arg3
!= 0) {
12236 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
12242 #ifdef CONFIG_SPLICE
12243 #ifdef TARGET_NR_tee
12244 case TARGET_NR_tee
:
12246 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
12250 #ifdef TARGET_NR_splice
12251 case TARGET_NR_splice
:
12253 loff_t loff_in
, loff_out
;
12254 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
12256 if (get_user_u64(loff_in
, arg2
)) {
12259 ploff_in
= &loff_in
;
12262 if (get_user_u64(loff_out
, arg4
)) {
12265 ploff_out
= &loff_out
;
12267 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
12269 if (put_user_u64(loff_in
, arg2
)) {
12274 if (put_user_u64(loff_out
, arg4
)) {
12281 #ifdef TARGET_NR_vmsplice
12282 case TARGET_NR_vmsplice
:
12284 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
12286 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
12287 unlock_iovec(vec
, arg2
, arg3
, 0);
12289 ret
= -host_to_target_errno(errno
);
12294 #endif /* CONFIG_SPLICE */
12295 #ifdef CONFIG_EVENTFD
12296 #if defined(TARGET_NR_eventfd)
12297 case TARGET_NR_eventfd
:
12298 ret
= get_errno(eventfd(arg1
, 0));
12300 fd_trans_register(ret
, &target_eventfd_trans
);
12304 #if defined(TARGET_NR_eventfd2)
12305 case TARGET_NR_eventfd2
:
12307 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
));
12308 if (arg2
& TARGET_O_NONBLOCK
) {
12309 host_flags
|= O_NONBLOCK
;
12311 if (arg2
& TARGET_O_CLOEXEC
) {
12312 host_flags
|= O_CLOEXEC
;
12314 ret
= get_errno(eventfd(arg1
, host_flags
));
12316 fd_trans_register(ret
, &target_eventfd_trans
);
12321 #endif /* CONFIG_EVENTFD */
12322 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
12323 case TARGET_NR_fallocate
:
12324 #if TARGET_ABI_BITS == 32
12325 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
12326 target_offset64(arg5
, arg6
)));
12328 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
12332 #if defined(CONFIG_SYNC_FILE_RANGE)
12333 #if defined(TARGET_NR_sync_file_range)
12334 case TARGET_NR_sync_file_range
:
12335 #if TARGET_ABI_BITS == 32
12336 #if defined(TARGET_MIPS)
12337 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
12338 target_offset64(arg5
, arg6
), arg7
));
12340 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
12341 target_offset64(arg4
, arg5
), arg6
));
12342 #endif /* !TARGET_MIPS */
12344 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
12348 #if defined(TARGET_NR_sync_file_range2)
12349 case TARGET_NR_sync_file_range2
:
12350 /* This is like sync_file_range but the arguments are reordered */
12351 #if TARGET_ABI_BITS == 32
12352 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
12353 target_offset64(arg5
, arg6
), arg2
));
12355 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
12360 #if defined(TARGET_NR_signalfd4)
12361 case TARGET_NR_signalfd4
:
12362 ret
= do_signalfd4(arg1
, arg2
, arg4
);
12365 #if defined(TARGET_NR_signalfd)
12366 case TARGET_NR_signalfd
:
12367 ret
= do_signalfd4(arg1
, arg2
, 0);
12370 #if defined(CONFIG_EPOLL)
12371 #if defined(TARGET_NR_epoll_create)
12372 case TARGET_NR_epoll_create
:
12373 ret
= get_errno(epoll_create(arg1
));
12376 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
12377 case TARGET_NR_epoll_create1
:
12378 ret
= get_errno(epoll_create1(arg1
));
12381 #if defined(TARGET_NR_epoll_ctl)
12382 case TARGET_NR_epoll_ctl
:
12384 struct epoll_event ep
;
12385 struct epoll_event
*epp
= 0;
12387 struct target_epoll_event
*target_ep
;
12388 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
12391 ep
.events
= tswap32(target_ep
->events
);
12392 /* The epoll_data_t union is just opaque data to the kernel,
12393 * so we transfer all 64 bits across and need not worry what
12394 * actual data type it is.
12396 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
12397 unlock_user_struct(target_ep
, arg4
, 0);
12400 ret
= get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
12405 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
12406 #if defined(TARGET_NR_epoll_wait)
12407 case TARGET_NR_epoll_wait
:
12409 #if defined(TARGET_NR_epoll_pwait)
12410 case TARGET_NR_epoll_pwait
:
12413 struct target_epoll_event
*target_ep
;
12414 struct epoll_event
*ep
;
12416 int maxevents
= arg3
;
12417 int timeout
= arg4
;
12419 if (maxevents
<= 0 || maxevents
> TARGET_EP_MAX_EVENTS
) {
12420 ret
= -TARGET_EINVAL
;
12424 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
12425 maxevents
* sizeof(struct target_epoll_event
), 1);
12430 ep
= g_try_new(struct epoll_event
, maxevents
);
12432 unlock_user(target_ep
, arg2
, 0);
12433 ret
= -TARGET_ENOMEM
;
12438 #if defined(TARGET_NR_epoll_pwait)
12439 case TARGET_NR_epoll_pwait
:
12441 target_sigset_t
*target_set
;
12442 sigset_t _set
, *set
= &_set
;
12445 if (arg6
!= sizeof(target_sigset_t
)) {
12446 ret
= -TARGET_EINVAL
;
12450 target_set
= lock_user(VERIFY_READ
, arg5
,
12451 sizeof(target_sigset_t
), 1);
12453 ret
= -TARGET_EFAULT
;
12456 target_to_host_sigset(set
, target_set
);
12457 unlock_user(target_set
, arg5
, 0);
12462 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
12463 set
, SIGSET_T_SIZE
));
12467 #if defined(TARGET_NR_epoll_wait)
12468 case TARGET_NR_epoll_wait
:
12469 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
12474 ret
= -TARGET_ENOSYS
;
12476 if (!is_error(ret
)) {
12478 for (i
= 0; i
< ret
; i
++) {
12479 target_ep
[i
].events
= tswap32(ep
[i
].events
);
12480 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
12482 unlock_user(target_ep
, arg2
,
12483 ret
* sizeof(struct target_epoll_event
));
12485 unlock_user(target_ep
, arg2
, 0);
12492 #ifdef TARGET_NR_prlimit64
12493 case TARGET_NR_prlimit64
:
12495 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
12496 struct target_rlimit64
*target_rnew
, *target_rold
;
12497 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
12498 int resource
= target_to_host_resource(arg2
);
12500 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
12503 rnew
.rlim_cur
= tswap64(target_rnew
->rlim_cur
);
12504 rnew
.rlim_max
= tswap64(target_rnew
->rlim_max
);
12505 unlock_user_struct(target_rnew
, arg3
, 0);
12509 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
12510 if (!is_error(ret
) && arg4
) {
12511 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
12514 target_rold
->rlim_cur
= tswap64(rold
.rlim_cur
);
12515 target_rold
->rlim_max
= tswap64(rold
.rlim_max
);
12516 unlock_user_struct(target_rold
, arg4
, 1);
12521 #ifdef TARGET_NR_gethostname
12522 case TARGET_NR_gethostname
:
12524 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
12526 ret
= get_errno(gethostname(name
, arg2
));
12527 unlock_user(name
, arg1
, arg2
);
12529 ret
= -TARGET_EFAULT
;
12534 #ifdef TARGET_NR_atomic_cmpxchg_32
12535 case TARGET_NR_atomic_cmpxchg_32
:
12537 /* should use start_exclusive from main.c */
12538 abi_ulong mem_value
;
12539 if (get_user_u32(mem_value
, arg6
)) {
12540 target_siginfo_t info
;
12541 info
.si_signo
= SIGSEGV
;
12543 info
.si_code
= TARGET_SEGV_MAPERR
;
12544 info
._sifields
._sigfault
._addr
= arg6
;
12545 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
12546 QEMU_SI_FAULT
, &info
);
12550 if (mem_value
== arg2
)
12551 put_user_u32(arg1
, arg6
);
12556 #ifdef TARGET_NR_atomic_barrier
12557 case TARGET_NR_atomic_barrier
:
12559 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
12565 #ifdef TARGET_NR_timer_create
12566 case TARGET_NR_timer_create
:
12568 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
12570 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
12573 int timer_index
= next_free_host_timer();
12575 if (timer_index
< 0) {
12576 ret
= -TARGET_EAGAIN
;
12578 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
12581 phost_sevp
= &host_sevp
;
12582 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
12588 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
12592 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
12601 #ifdef TARGET_NR_timer_settime
12602 case TARGET_NR_timer_settime
:
12604 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
12605 * struct itimerspec * old_value */
12606 target_timer_t timerid
= get_timer_id(arg1
);
12610 } else if (arg3
== 0) {
12611 ret
= -TARGET_EINVAL
;
12613 timer_t htimer
= g_posix_timers
[timerid
];
12614 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
12616 if (target_to_host_itimerspec(&hspec_new
, arg3
)) {
12620 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
12621 if (arg4
&& host_to_target_itimerspec(arg4
, &hspec_old
)) {
12629 #ifdef TARGET_NR_timer_gettime
12630 case TARGET_NR_timer_gettime
:
12632 /* args: timer_t timerid, struct itimerspec *curr_value */
12633 target_timer_t timerid
= get_timer_id(arg1
);
12637 } else if (!arg2
) {
12638 ret
= -TARGET_EFAULT
;
12640 timer_t htimer
= g_posix_timers
[timerid
];
12641 struct itimerspec hspec
;
12642 ret
= get_errno(timer_gettime(htimer
, &hspec
));
12644 if (host_to_target_itimerspec(arg2
, &hspec
)) {
12645 ret
= -TARGET_EFAULT
;
12652 #ifdef TARGET_NR_timer_getoverrun
12653 case TARGET_NR_timer_getoverrun
:
12655 /* args: timer_t timerid */
12656 target_timer_t timerid
= get_timer_id(arg1
);
12661 timer_t htimer
= g_posix_timers
[timerid
];
12662 ret
= get_errno(timer_getoverrun(htimer
));
12664 fd_trans_unregister(ret
);
12669 #ifdef TARGET_NR_timer_delete
12670 case TARGET_NR_timer_delete
:
12672 /* args: timer_t timerid */
12673 target_timer_t timerid
= get_timer_id(arg1
);
12678 timer_t htimer
= g_posix_timers
[timerid
];
12679 ret
= get_errno(timer_delete(htimer
));
12680 g_posix_timers
[timerid
] = 0;
12686 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
12687 case TARGET_NR_timerfd_create
:
12688 ret
= get_errno(timerfd_create(arg1
,
12689 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
12693 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
12694 case TARGET_NR_timerfd_gettime
:
12696 struct itimerspec its_curr
;
12698 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
12700 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
12707 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
12708 case TARGET_NR_timerfd_settime
:
12710 struct itimerspec its_new
, its_old
, *p_new
;
12713 if (target_to_host_itimerspec(&its_new
, arg3
)) {
12721 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
12723 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
12730 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
12731 case TARGET_NR_ioprio_get
:
12732 ret
= get_errno(ioprio_get(arg1
, arg2
));
12736 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
12737 case TARGET_NR_ioprio_set
:
12738 ret
= get_errno(ioprio_set(arg1
, arg2
, arg3
));
12742 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
12743 case TARGET_NR_setns
:
12744 ret
= get_errno(setns(arg1
, arg2
));
12747 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
12748 case TARGET_NR_unshare
:
12749 ret
= get_errno(unshare(arg1
));
12752 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
12753 case TARGET_NR_kcmp
:
12754 ret
= get_errno(kcmp(arg1
, arg2
, arg3
, arg4
, arg5
));
12760 qemu_log_mask(LOG_UNIMP
, "Unsupported syscall: %d\n", num
);
12761 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
12762 unimplemented_nowarn
:
12764 ret
= -TARGET_ENOSYS
;
12769 gemu_log(" = " TARGET_ABI_FMT_ld
"\n", ret
);
12772 print_syscall_ret(num
, ret
);
12773 trace_guest_user_syscall_ret(cpu
, num
, ret
);
12776 ret
= -TARGET_EFAULT
;