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) {
262 #if defined(TARGET_NR_getdents) && defined(__NR_getdents)
263 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
265 #if !defined(__NR_getdents) || \
266 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
267 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
269 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
270 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
271 loff_t
*, res
, uint
, wh
);
273 _syscall3(int, sys_rt_sigqueueinfo
, pid_t
, pid
, int, sig
, siginfo_t
*, uinfo
)
274 _syscall4(int, sys_rt_tgsigqueueinfo
, pid_t
, pid
, pid_t
, tid
, int, sig
,
276 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
277 #ifdef __NR_exit_group
278 _syscall1(int,exit_group
,int,error_code
)
280 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
281 _syscall1(int,set_tid_address
,int *,tidptr
)
283 #if defined(TARGET_NR_futex) && defined(__NR_futex)
284 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
285 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
287 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
288 _syscall3(int, sys_sched_getaffinity
, pid_t
, pid
, unsigned int, len
,
289 unsigned long *, user_mask_ptr
);
290 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
291 _syscall3(int, sys_sched_setaffinity
, pid_t
, pid
, unsigned int, len
,
292 unsigned long *, user_mask_ptr
);
293 #define __NR_sys_getcpu __NR_getcpu
294 _syscall3(int, sys_getcpu
, unsigned *, cpu
, unsigned *, node
, void *, tcache
);
295 _syscall4(int, reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
297 _syscall2(int, capget
, struct __user_cap_header_struct
*, header
,
298 struct __user_cap_data_struct
*, data
);
299 _syscall2(int, capset
, struct __user_cap_header_struct
*, header
,
300 struct __user_cap_data_struct
*, data
);
301 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
302 _syscall2(int, ioprio_get
, int, which
, int, who
)
304 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
305 _syscall3(int, ioprio_set
, int, which
, int, who
, int, ioprio
)
307 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
308 _syscall3(int, getrandom
, void *, buf
, size_t, buflen
, unsigned int, flags
)
311 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
312 _syscall5(int, kcmp
, pid_t
, pid1
, pid_t
, pid2
, int, type
,
313 unsigned long, idx1
, unsigned long, idx2
)
316 static bitmask_transtbl fcntl_flags_tbl
[] = {
317 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
318 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
319 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
320 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
321 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
322 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
323 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
324 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
325 { TARGET_O_SYNC
, TARGET_O_DSYNC
, O_SYNC
, O_DSYNC
, },
326 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
327 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
328 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
329 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
330 #if defined(O_DIRECT)
331 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
333 #if defined(O_NOATIME)
334 { TARGET_O_NOATIME
, TARGET_O_NOATIME
, O_NOATIME
, O_NOATIME
},
336 #if defined(O_CLOEXEC)
337 { TARGET_O_CLOEXEC
, TARGET_O_CLOEXEC
, O_CLOEXEC
, O_CLOEXEC
},
340 { TARGET_O_PATH
, TARGET_O_PATH
, O_PATH
, O_PATH
},
342 #if defined(O_TMPFILE)
343 { TARGET_O_TMPFILE
, TARGET_O_TMPFILE
, O_TMPFILE
, O_TMPFILE
},
345 /* Don't terminate the list prematurely on 64-bit host+guest. */
346 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
347 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
354 QEMU_IFLA_BR_FORWARD_DELAY
,
355 QEMU_IFLA_BR_HELLO_TIME
,
356 QEMU_IFLA_BR_MAX_AGE
,
357 QEMU_IFLA_BR_AGEING_TIME
,
358 QEMU_IFLA_BR_STP_STATE
,
359 QEMU_IFLA_BR_PRIORITY
,
360 QEMU_IFLA_BR_VLAN_FILTERING
,
361 QEMU_IFLA_BR_VLAN_PROTOCOL
,
362 QEMU_IFLA_BR_GROUP_FWD_MASK
,
363 QEMU_IFLA_BR_ROOT_ID
,
364 QEMU_IFLA_BR_BRIDGE_ID
,
365 QEMU_IFLA_BR_ROOT_PORT
,
366 QEMU_IFLA_BR_ROOT_PATH_COST
,
367 QEMU_IFLA_BR_TOPOLOGY_CHANGE
,
368 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED
,
369 QEMU_IFLA_BR_HELLO_TIMER
,
370 QEMU_IFLA_BR_TCN_TIMER
,
371 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER
,
372 QEMU_IFLA_BR_GC_TIMER
,
373 QEMU_IFLA_BR_GROUP_ADDR
,
374 QEMU_IFLA_BR_FDB_FLUSH
,
375 QEMU_IFLA_BR_MCAST_ROUTER
,
376 QEMU_IFLA_BR_MCAST_SNOOPING
,
377 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR
,
378 QEMU_IFLA_BR_MCAST_QUERIER
,
379 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY
,
380 QEMU_IFLA_BR_MCAST_HASH_MAX
,
381 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT
,
382 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT
,
383 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL
,
384 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL
,
385 QEMU_IFLA_BR_MCAST_QUERIER_INTVL
,
386 QEMU_IFLA_BR_MCAST_QUERY_INTVL
,
387 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL
,
388 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL
,
389 QEMU_IFLA_BR_NF_CALL_IPTABLES
,
390 QEMU_IFLA_BR_NF_CALL_IP6TABLES
,
391 QEMU_IFLA_BR_NF_CALL_ARPTABLES
,
392 QEMU_IFLA_BR_VLAN_DEFAULT_PVID
,
394 QEMU_IFLA_BR_VLAN_STATS_ENABLED
,
395 QEMU_IFLA_BR_MCAST_STATS_ENABLED
,
419 QEMU_IFLA_NET_NS_PID
,
422 QEMU_IFLA_VFINFO_LIST
,
430 QEMU_IFLA_PROMISCUITY
,
431 QEMU_IFLA_NUM_TX_QUEUES
,
432 QEMU_IFLA_NUM_RX_QUEUES
,
434 QEMU_IFLA_PHYS_PORT_ID
,
435 QEMU_IFLA_CARRIER_CHANGES
,
436 QEMU_IFLA_PHYS_SWITCH_ID
,
437 QEMU_IFLA_LINK_NETNSID
,
438 QEMU_IFLA_PHYS_PORT_NAME
,
439 QEMU_IFLA_PROTO_DOWN
,
440 QEMU_IFLA_GSO_MAX_SEGS
,
441 QEMU_IFLA_GSO_MAX_SIZE
,
448 QEMU_IFLA_BRPORT_UNSPEC
,
449 QEMU_IFLA_BRPORT_STATE
,
450 QEMU_IFLA_BRPORT_PRIORITY
,
451 QEMU_IFLA_BRPORT_COST
,
452 QEMU_IFLA_BRPORT_MODE
,
453 QEMU_IFLA_BRPORT_GUARD
,
454 QEMU_IFLA_BRPORT_PROTECT
,
455 QEMU_IFLA_BRPORT_FAST_LEAVE
,
456 QEMU_IFLA_BRPORT_LEARNING
,
457 QEMU_IFLA_BRPORT_UNICAST_FLOOD
,
458 QEMU_IFLA_BRPORT_PROXYARP
,
459 QEMU_IFLA_BRPORT_LEARNING_SYNC
,
460 QEMU_IFLA_BRPORT_PROXYARP_WIFI
,
461 QEMU_IFLA_BRPORT_ROOT_ID
,
462 QEMU_IFLA_BRPORT_BRIDGE_ID
,
463 QEMU_IFLA_BRPORT_DESIGNATED_PORT
,
464 QEMU_IFLA_BRPORT_DESIGNATED_COST
,
467 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK
,
468 QEMU_IFLA_BRPORT_CONFIG_PENDING
,
469 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER
,
470 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER
,
471 QEMU_IFLA_BRPORT_HOLD_TIMER
,
472 QEMU_IFLA_BRPORT_FLUSH
,
473 QEMU_IFLA_BRPORT_MULTICAST_ROUTER
,
474 QEMU_IFLA_BRPORT_PAD
,
475 QEMU___IFLA_BRPORT_MAX
479 QEMU_IFLA_INFO_UNSPEC
,
482 QEMU_IFLA_INFO_XSTATS
,
483 QEMU_IFLA_INFO_SLAVE_KIND
,
484 QEMU_IFLA_INFO_SLAVE_DATA
,
485 QEMU___IFLA_INFO_MAX
,
489 QEMU_IFLA_INET_UNSPEC
,
491 QEMU___IFLA_INET_MAX
,
495 QEMU_IFLA_INET6_UNSPEC
,
496 QEMU_IFLA_INET6_FLAGS
,
497 QEMU_IFLA_INET6_CONF
,
498 QEMU_IFLA_INET6_STATS
,
499 QEMU_IFLA_INET6_MCAST
,
500 QEMU_IFLA_INET6_CACHEINFO
,
501 QEMU_IFLA_INET6_ICMP6STATS
,
502 QEMU_IFLA_INET6_TOKEN
,
503 QEMU_IFLA_INET6_ADDR_GEN_MODE
,
504 QEMU___IFLA_INET6_MAX
507 typedef abi_long (*TargetFdDataFunc
)(void *, size_t);
508 typedef abi_long (*TargetFdAddrFunc
)(void *, abi_ulong
, socklen_t
);
509 typedef struct TargetFdTrans
{
510 TargetFdDataFunc host_to_target_data
;
511 TargetFdDataFunc target_to_host_data
;
512 TargetFdAddrFunc target_to_host_addr
;
515 static TargetFdTrans
**target_fd_trans
;
517 static unsigned int target_fd_max
;
519 static TargetFdDataFunc
fd_trans_target_to_host_data(int fd
)
521 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
522 return target_fd_trans
[fd
]->target_to_host_data
;
527 static TargetFdDataFunc
fd_trans_host_to_target_data(int fd
)
529 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
530 return target_fd_trans
[fd
]->host_to_target_data
;
535 static TargetFdAddrFunc
fd_trans_target_to_host_addr(int fd
)
537 if (fd
>= 0 && fd
< target_fd_max
&& target_fd_trans
[fd
]) {
538 return target_fd_trans
[fd
]->target_to_host_addr
;
543 static void fd_trans_register(int fd
, TargetFdTrans
*trans
)
547 if (fd
>= target_fd_max
) {
548 oldmax
= target_fd_max
;
549 target_fd_max
= ((fd
>> 6) + 1) << 6; /* by slice of 64 entries */
550 target_fd_trans
= g_renew(TargetFdTrans
*,
551 target_fd_trans
, target_fd_max
);
552 memset((void *)(target_fd_trans
+ oldmax
), 0,
553 (target_fd_max
- oldmax
) * sizeof(TargetFdTrans
*));
555 target_fd_trans
[fd
] = trans
;
558 static void fd_trans_unregister(int fd
)
560 if (fd
>= 0 && fd
< target_fd_max
) {
561 target_fd_trans
[fd
] = NULL
;
565 static void fd_trans_dup(int oldfd
, int newfd
)
567 fd_trans_unregister(newfd
);
568 if (oldfd
< target_fd_max
&& target_fd_trans
[oldfd
]) {
569 fd_trans_register(newfd
, target_fd_trans
[oldfd
]);
573 static int sys_getcwd1(char *buf
, size_t size
)
575 if (getcwd(buf
, size
) == NULL
) {
576 /* getcwd() sets errno */
579 return strlen(buf
)+1;
582 #ifdef TARGET_NR_utimensat
583 #if defined(__NR_utimensat)
584 #define __NR_sys_utimensat __NR_utimensat
585 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
586 const struct timespec
*,tsp
,int,flags
)
588 static int sys_utimensat(int dirfd
, const char *pathname
,
589 const struct timespec times
[2], int flags
)
595 #endif /* TARGET_NR_utimensat */
597 #ifdef TARGET_NR_renameat2
598 #if defined(__NR_renameat2)
599 #define __NR_sys_renameat2 __NR_renameat2
600 _syscall5(int, sys_renameat2
, int, oldfd
, const char *, old
, int, newfd
,
601 const char *, new, unsigned int, flags
)
603 static int sys_renameat2(int oldfd
, const char *old
,
604 int newfd
, const char *new, int flags
)
607 return renameat(oldfd
, old
, newfd
, new);
613 #endif /* TARGET_NR_renameat2 */
615 #ifdef CONFIG_INOTIFY
616 #include <sys/inotify.h>
618 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
619 static int sys_inotify_init(void)
621 return (inotify_init());
624 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
625 static int sys_inotify_add_watch(int fd
,const char *pathname
, int32_t mask
)
627 return (inotify_add_watch(fd
, pathname
, mask
));
630 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
631 static int sys_inotify_rm_watch(int fd
, int32_t wd
)
633 return (inotify_rm_watch(fd
, wd
));
636 #ifdef CONFIG_INOTIFY1
637 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
638 static int sys_inotify_init1(int flags
)
640 return (inotify_init1(flags
));
645 /* Userspace can usually survive runtime without inotify */
646 #undef TARGET_NR_inotify_init
647 #undef TARGET_NR_inotify_init1
648 #undef TARGET_NR_inotify_add_watch
649 #undef TARGET_NR_inotify_rm_watch
650 #endif /* CONFIG_INOTIFY */
652 #if defined(TARGET_NR_prlimit64)
653 #ifndef __NR_prlimit64
654 # define __NR_prlimit64 -1
656 #define __NR_sys_prlimit64 __NR_prlimit64
657 /* The glibc rlimit structure may not be that used by the underlying syscall */
658 struct host_rlimit64
{
662 _syscall4(int, sys_prlimit64
, pid_t
, pid
, int, resource
,
663 const struct host_rlimit64
*, new_limit
,
664 struct host_rlimit64
*, old_limit
)
668 #if defined(TARGET_NR_timer_create)
669 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
670 static timer_t g_posix_timers
[32] = { 0, } ;
672 static inline int next_free_host_timer(void)
675 /* FIXME: Does finding the next free slot require a lock? */
676 for (k
= 0; k
< ARRAY_SIZE(g_posix_timers
); k
++) {
677 if (g_posix_timers
[k
] == 0) {
678 g_posix_timers
[k
] = (timer_t
) 1;
686 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
688 static inline int regpairs_aligned(void *cpu_env
, int num
)
690 return ((((CPUARMState
*)cpu_env
)->eabi
) == 1) ;
692 #elif defined(TARGET_MIPS) && (TARGET_ABI_BITS == 32)
693 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
694 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
695 /* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
696 * of registers which translates to the same as ARM/MIPS, because we start with
698 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 1; }
699 #elif defined(TARGET_SH4)
700 /* SH4 doesn't align register pairs, except for p{read,write}64 */
701 static inline int regpairs_aligned(void *cpu_env
, int num
)
704 case TARGET_NR_pread64
:
705 case TARGET_NR_pwrite64
:
713 static inline int regpairs_aligned(void *cpu_env
, int num
) { return 0; }
716 #define ERRNO_TABLE_SIZE 1200
718 /* target_to_host_errno_table[] is initialized from
719 * host_to_target_errno_table[] in syscall_init(). */
720 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
724 * This list is the union of errno values overridden in asm-<arch>/errno.h
725 * minus the errnos that are not actually generic to all archs.
727 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
728 [EAGAIN
] = TARGET_EAGAIN
,
729 [EIDRM
] = TARGET_EIDRM
,
730 [ECHRNG
] = TARGET_ECHRNG
,
731 [EL2NSYNC
] = TARGET_EL2NSYNC
,
732 [EL3HLT
] = TARGET_EL3HLT
,
733 [EL3RST
] = TARGET_EL3RST
,
734 [ELNRNG
] = TARGET_ELNRNG
,
735 [EUNATCH
] = TARGET_EUNATCH
,
736 [ENOCSI
] = TARGET_ENOCSI
,
737 [EL2HLT
] = TARGET_EL2HLT
,
738 [EDEADLK
] = TARGET_EDEADLK
,
739 [ENOLCK
] = TARGET_ENOLCK
,
740 [EBADE
] = TARGET_EBADE
,
741 [EBADR
] = TARGET_EBADR
,
742 [EXFULL
] = TARGET_EXFULL
,
743 [ENOANO
] = TARGET_ENOANO
,
744 [EBADRQC
] = TARGET_EBADRQC
,
745 [EBADSLT
] = TARGET_EBADSLT
,
746 [EBFONT
] = TARGET_EBFONT
,
747 [ENOSTR
] = TARGET_ENOSTR
,
748 [ENODATA
] = TARGET_ENODATA
,
749 [ETIME
] = TARGET_ETIME
,
750 [ENOSR
] = TARGET_ENOSR
,
751 [ENONET
] = TARGET_ENONET
,
752 [ENOPKG
] = TARGET_ENOPKG
,
753 [EREMOTE
] = TARGET_EREMOTE
,
754 [ENOLINK
] = TARGET_ENOLINK
,
755 [EADV
] = TARGET_EADV
,
756 [ESRMNT
] = TARGET_ESRMNT
,
757 [ECOMM
] = TARGET_ECOMM
,
758 [EPROTO
] = TARGET_EPROTO
,
759 [EDOTDOT
] = TARGET_EDOTDOT
,
760 [EMULTIHOP
] = TARGET_EMULTIHOP
,
761 [EBADMSG
] = TARGET_EBADMSG
,
762 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
763 [EOVERFLOW
] = TARGET_EOVERFLOW
,
764 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
765 [EBADFD
] = TARGET_EBADFD
,
766 [EREMCHG
] = TARGET_EREMCHG
,
767 [ELIBACC
] = TARGET_ELIBACC
,
768 [ELIBBAD
] = TARGET_ELIBBAD
,
769 [ELIBSCN
] = TARGET_ELIBSCN
,
770 [ELIBMAX
] = TARGET_ELIBMAX
,
771 [ELIBEXEC
] = TARGET_ELIBEXEC
,
772 [EILSEQ
] = TARGET_EILSEQ
,
773 [ENOSYS
] = TARGET_ENOSYS
,
774 [ELOOP
] = TARGET_ELOOP
,
775 [ERESTART
] = TARGET_ERESTART
,
776 [ESTRPIPE
] = TARGET_ESTRPIPE
,
777 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
778 [EUSERS
] = TARGET_EUSERS
,
779 [ENOTSOCK
] = TARGET_ENOTSOCK
,
780 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
781 [EMSGSIZE
] = TARGET_EMSGSIZE
,
782 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
783 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
784 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
785 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
786 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
787 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
788 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
789 [EADDRINUSE
] = TARGET_EADDRINUSE
,
790 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
791 [ENETDOWN
] = TARGET_ENETDOWN
,
792 [ENETUNREACH
] = TARGET_ENETUNREACH
,
793 [ENETRESET
] = TARGET_ENETRESET
,
794 [ECONNABORTED
] = TARGET_ECONNABORTED
,
795 [ECONNRESET
] = TARGET_ECONNRESET
,
796 [ENOBUFS
] = TARGET_ENOBUFS
,
797 [EISCONN
] = TARGET_EISCONN
,
798 [ENOTCONN
] = TARGET_ENOTCONN
,
799 [EUCLEAN
] = TARGET_EUCLEAN
,
800 [ENOTNAM
] = TARGET_ENOTNAM
,
801 [ENAVAIL
] = TARGET_ENAVAIL
,
802 [EISNAM
] = TARGET_EISNAM
,
803 [EREMOTEIO
] = TARGET_EREMOTEIO
,
804 [EDQUOT
] = TARGET_EDQUOT
,
805 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
806 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
807 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
808 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
809 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
810 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
811 [EALREADY
] = TARGET_EALREADY
,
812 [EINPROGRESS
] = TARGET_EINPROGRESS
,
813 [ESTALE
] = TARGET_ESTALE
,
814 [ECANCELED
] = TARGET_ECANCELED
,
815 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
816 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
818 [ENOKEY
] = TARGET_ENOKEY
,
821 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
824 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
827 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
830 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
832 #ifdef ENOTRECOVERABLE
833 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
836 [ENOMSG
] = TARGET_ENOMSG
,
839 [ERFKILL
] = TARGET_ERFKILL
,
842 [EHWPOISON
] = TARGET_EHWPOISON
,
846 static inline int host_to_target_errno(int err
)
848 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
849 host_to_target_errno_table
[err
]) {
850 return host_to_target_errno_table
[err
];
855 static inline int target_to_host_errno(int err
)
857 if (err
>= 0 && err
< ERRNO_TABLE_SIZE
&&
858 target_to_host_errno_table
[err
]) {
859 return target_to_host_errno_table
[err
];
864 static inline abi_long
get_errno(abi_long ret
)
867 return -host_to_target_errno(errno
);
872 static inline int is_error(abi_long ret
)
874 return (abi_ulong
)ret
>= (abi_ulong
)(-4096);
877 const char *target_strerror(int err
)
879 if (err
== TARGET_ERESTARTSYS
) {
880 return "To be restarted";
882 if (err
== TARGET_QEMU_ESIGRETURN
) {
883 return "Successful exit from sigreturn";
886 if ((err
>= ERRNO_TABLE_SIZE
) || (err
< 0)) {
889 return strerror(target_to_host_errno(err
));
892 #define safe_syscall0(type, name) \
893 static type safe_##name(void) \
895 return safe_syscall(__NR_##name); \
898 #define safe_syscall1(type, name, type1, arg1) \
899 static type safe_##name(type1 arg1) \
901 return safe_syscall(__NR_##name, arg1); \
904 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
905 static type safe_##name(type1 arg1, type2 arg2) \
907 return safe_syscall(__NR_##name, arg1, arg2); \
910 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
911 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
913 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
916 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
918 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
920 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
923 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
924 type4, arg4, type5, arg5) \
925 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
928 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
931 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
932 type4, arg4, type5, arg5, type6, arg6) \
933 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
934 type5 arg5, type6 arg6) \
936 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
939 safe_syscall3(ssize_t
, read
, int, fd
, void *, buff
, size_t, count
)
940 safe_syscall3(ssize_t
, write
, int, fd
, const void *, buff
, size_t, count
)
941 safe_syscall4(int, openat
, int, dirfd
, const char *, pathname
, \
942 int, flags
, mode_t
, mode
)
943 safe_syscall4(pid_t
, wait4
, pid_t
, pid
, int *, status
, int, options
, \
944 struct rusage
*, rusage
)
945 safe_syscall5(int, waitid
, idtype_t
, idtype
, id_t
, id
, siginfo_t
*, infop
, \
946 int, options
, struct rusage
*, rusage
)
947 safe_syscall3(int, execve
, const char *, filename
, char **, argv
, char **, envp
)
948 safe_syscall6(int, pselect6
, int, nfds
, fd_set
*, readfds
, fd_set
*, writefds
, \
949 fd_set
*, exceptfds
, struct timespec
*, timeout
, void *, sig
)
950 safe_syscall5(int, ppoll
, struct pollfd
*, ufds
, unsigned int, nfds
,
951 struct timespec
*, tsp
, const sigset_t
*, sigmask
,
953 safe_syscall6(int, epoll_pwait
, int, epfd
, struct epoll_event
*, events
,
954 int, maxevents
, int, timeout
, const sigset_t
*, sigmask
,
956 safe_syscall6(int,futex
,int *,uaddr
,int,op
,int,val
, \
957 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
958 safe_syscall2(int, rt_sigsuspend
, sigset_t
*, newset
, size_t, sigsetsize
)
959 safe_syscall2(int, kill
, pid_t
, pid
, int, sig
)
960 safe_syscall2(int, tkill
, int, tid
, int, sig
)
961 safe_syscall3(int, tgkill
, int, tgid
, int, pid
, int, sig
)
962 safe_syscall3(ssize_t
, readv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
963 safe_syscall3(ssize_t
, writev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
)
964 safe_syscall5(ssize_t
, preadv
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
965 unsigned long, pos_l
, unsigned long, pos_h
)
966 safe_syscall5(ssize_t
, pwritev
, int, fd
, const struct iovec
*, iov
, int, iovcnt
,
967 unsigned long, pos_l
, unsigned long, pos_h
)
968 safe_syscall3(int, connect
, int, fd
, const struct sockaddr
*, addr
,
970 safe_syscall6(ssize_t
, sendto
, int, fd
, const void *, buf
, size_t, len
,
971 int, flags
, const struct sockaddr
*, addr
, socklen_t
, addrlen
)
972 safe_syscall6(ssize_t
, recvfrom
, int, fd
, void *, buf
, size_t, len
,
973 int, flags
, struct sockaddr
*, addr
, socklen_t
*, addrlen
)
974 safe_syscall3(ssize_t
, sendmsg
, int, fd
, const struct msghdr
*, msg
, int, flags
)
975 safe_syscall3(ssize_t
, recvmsg
, int, fd
, struct msghdr
*, msg
, int, flags
)
976 safe_syscall2(int, flock
, int, fd
, int, operation
)
977 safe_syscall4(int, rt_sigtimedwait
, const sigset_t
*, these
, siginfo_t
*, uinfo
,
978 const struct timespec
*, uts
, size_t, sigsetsize
)
979 safe_syscall4(int, accept4
, int, fd
, struct sockaddr
*, addr
, socklen_t
*, len
,
981 safe_syscall2(int, nanosleep
, const struct timespec
*, req
,
982 struct timespec
*, rem
)
983 #ifdef TARGET_NR_clock_nanosleep
984 safe_syscall4(int, clock_nanosleep
, const clockid_t
, clock
, int, flags
,
985 const struct timespec
*, req
, struct timespec
*, rem
)
988 safe_syscall4(int, msgsnd
, int, msgid
, const void *, msgp
, size_t, sz
,
990 safe_syscall5(int, msgrcv
, int, msgid
, void *, msgp
, size_t, sz
,
991 long, msgtype
, int, flags
)
992 safe_syscall4(int, semtimedop
, int, semid
, struct sembuf
*, tsops
,
993 unsigned, nsops
, const struct timespec
*, timeout
)
995 /* This host kernel architecture uses a single ipc syscall; fake up
996 * wrappers for the sub-operations to hide this implementation detail.
997 * Annoyingly we can't include linux/ipc.h to get the constant definitions
998 * for the call parameter because some structs in there conflict with the
999 * sys/ipc.h ones. So we just define them here, and rely on them being
1000 * the same for all host architectures.
1002 #define Q_SEMTIMEDOP 4
1005 #define Q_IPCCALL(VERSION, OP) ((VERSION) << 16 | (OP))
1007 safe_syscall6(int, ipc
, int, call
, long, first
, long, second
, long, third
,
1008 void *, ptr
, long, fifth
)
1009 static int safe_msgsnd(int msgid
, const void *msgp
, size_t sz
, int flags
)
1011 return safe_ipc(Q_IPCCALL(0, Q_MSGSND
), msgid
, sz
, flags
, (void *)msgp
, 0);
1013 static int safe_msgrcv(int msgid
, void *msgp
, size_t sz
, long type
, int flags
)
1015 return safe_ipc(Q_IPCCALL(1, Q_MSGRCV
), msgid
, sz
, flags
, msgp
, type
);
1017 static int safe_semtimedop(int semid
, struct sembuf
*tsops
, unsigned nsops
,
1018 const struct timespec
*timeout
)
1020 return safe_ipc(Q_IPCCALL(0, Q_SEMTIMEDOP
), semid
, nsops
, 0, tsops
,
1024 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1025 safe_syscall5(int, mq_timedsend
, int, mqdes
, const char *, msg_ptr
,
1026 size_t, len
, unsigned, prio
, const struct timespec
*, timeout
)
1027 safe_syscall5(int, mq_timedreceive
, int, mqdes
, char *, msg_ptr
,
1028 size_t, len
, unsigned *, prio
, const struct timespec
*, timeout
)
1030 /* We do ioctl like this rather than via safe_syscall3 to preserve the
1031 * "third argument might be integer or pointer or not present" behaviour of
1032 * the libc function.
1034 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
1035 /* Similarly for fcntl. Note that callers must always:
1036 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
1037 * use the flock64 struct rather than unsuffixed flock
1038 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
1041 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
1043 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
1046 static inline int host_to_target_sock_type(int host_type
)
1050 switch (host_type
& 0xf /* SOCK_TYPE_MASK */) {
1052 target_type
= TARGET_SOCK_DGRAM
;
1055 target_type
= TARGET_SOCK_STREAM
;
1058 target_type
= host_type
& 0xf /* SOCK_TYPE_MASK */;
1062 #if defined(SOCK_CLOEXEC)
1063 if (host_type
& SOCK_CLOEXEC
) {
1064 target_type
|= TARGET_SOCK_CLOEXEC
;
1068 #if defined(SOCK_NONBLOCK)
1069 if (host_type
& SOCK_NONBLOCK
) {
1070 target_type
|= TARGET_SOCK_NONBLOCK
;
1077 static abi_ulong target_brk
;
1078 static abi_ulong target_original_brk
;
1079 static abi_ulong brk_page
;
1081 void target_set_brk(abi_ulong new_brk
)
1083 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
1084 brk_page
= HOST_PAGE_ALIGN(target_brk
);
1087 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
1088 #define DEBUGF_BRK(message, args...)
1090 /* do_brk() must return target values and target errnos. */
1091 abi_long
do_brk(abi_ulong new_brk
)
1093 abi_long mapped_addr
;
1094 abi_ulong new_alloc_size
;
1096 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx
") -> ", new_brk
);
1099 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (!new_brk)\n", target_brk
);
1102 if (new_brk
< target_original_brk
) {
1103 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk < target_original_brk)\n",
1108 /* If the new brk is less than the highest page reserved to the
1109 * target heap allocation, set it and we're almost done... */
1110 if (new_brk
<= brk_page
) {
1111 /* Heap contents are initialized to zero, as for anonymous
1113 if (new_brk
> target_brk
) {
1114 memset(g2h(target_brk
), 0, new_brk
- target_brk
);
1116 target_brk
= new_brk
;
1117 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (new_brk <= brk_page)\n", target_brk
);
1121 /* We need to allocate more memory after the brk... Note that
1122 * we don't use MAP_FIXED because that will map over the top of
1123 * any existing mapping (like the one with the host libc or qemu
1124 * itself); instead we treat "mapped but at wrong address" as
1125 * a failure and unmap again.
1127 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
);
1128 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
1129 PROT_READ
|PROT_WRITE
,
1130 MAP_ANON
|MAP_PRIVATE
, 0, 0));
1132 if (mapped_addr
== brk_page
) {
1133 /* Heap contents are initialized to zero, as for anonymous
1134 * mapped pages. Technically the new pages are already
1135 * initialized to zero since they *are* anonymous mapped
1136 * pages, however we have to take care with the contents that
1137 * come from the remaining part of the previous page: it may
1138 * contains garbage data due to a previous heap usage (grown
1139 * then shrunken). */
1140 memset(g2h(target_brk
), 0, brk_page
- target_brk
);
1142 target_brk
= new_brk
;
1143 brk_page
= HOST_PAGE_ALIGN(target_brk
);
1144 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr == brk_page)\n",
1147 } else if (mapped_addr
!= -1) {
1148 /* Mapped but at wrong address, meaning there wasn't actually
1149 * enough space for this brk.
1151 target_munmap(mapped_addr
, new_alloc_size
);
1153 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (mapped_addr != -1)\n", target_brk
);
1156 DEBUGF_BRK(TARGET_ABI_FMT_lx
" (otherwise)\n", target_brk
);
1159 #if defined(TARGET_ALPHA)
1160 /* We (partially) emulate OSF/1 on Alpha, which requires we
1161 return a proper errno, not an unchanged brk value. */
1162 return -TARGET_ENOMEM
;
1164 /* For everything else, return the previous break. */
1168 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
1169 abi_ulong target_fds_addr
,
1173 abi_ulong b
, *target_fds
;
1175 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
1176 if (!(target_fds
= lock_user(VERIFY_READ
,
1178 sizeof(abi_ulong
) * nw
,
1180 return -TARGET_EFAULT
;
1184 for (i
= 0; i
< nw
; i
++) {
1185 /* grab the abi_ulong */
1186 __get_user(b
, &target_fds
[i
]);
1187 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1188 /* check the bit inside the abi_ulong */
1195 unlock_user(target_fds
, target_fds_addr
, 0);
1200 static inline abi_ulong
copy_from_user_fdset_ptr(fd_set
*fds
, fd_set
**fds_ptr
,
1201 abi_ulong target_fds_addr
,
1204 if (target_fds_addr
) {
1205 if (copy_from_user_fdset(fds
, target_fds_addr
, n
))
1206 return -TARGET_EFAULT
;
1214 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
1220 abi_ulong
*target_fds
;
1222 nw
= DIV_ROUND_UP(n
, TARGET_ABI_BITS
);
1223 if (!(target_fds
= lock_user(VERIFY_WRITE
,
1225 sizeof(abi_ulong
) * nw
,
1227 return -TARGET_EFAULT
;
1230 for (i
= 0; i
< nw
; i
++) {
1232 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
1233 v
|= ((abi_ulong
)(FD_ISSET(k
, fds
) != 0) << j
);
1236 __put_user(v
, &target_fds
[i
]);
1239 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
1244 #if defined(__alpha__)
1245 #define HOST_HZ 1024
1250 static inline abi_long
host_to_target_clock_t(long ticks
)
1252 #if HOST_HZ == TARGET_HZ
1255 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
1259 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
1260 const struct rusage
*rusage
)
1262 struct target_rusage
*target_rusage
;
1264 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
1265 return -TARGET_EFAULT
;
1266 target_rusage
->ru_utime
.tv_sec
= tswapal(rusage
->ru_utime
.tv_sec
);
1267 target_rusage
->ru_utime
.tv_usec
= tswapal(rusage
->ru_utime
.tv_usec
);
1268 target_rusage
->ru_stime
.tv_sec
= tswapal(rusage
->ru_stime
.tv_sec
);
1269 target_rusage
->ru_stime
.tv_usec
= tswapal(rusage
->ru_stime
.tv_usec
);
1270 target_rusage
->ru_maxrss
= tswapal(rusage
->ru_maxrss
);
1271 target_rusage
->ru_ixrss
= tswapal(rusage
->ru_ixrss
);
1272 target_rusage
->ru_idrss
= tswapal(rusage
->ru_idrss
);
1273 target_rusage
->ru_isrss
= tswapal(rusage
->ru_isrss
);
1274 target_rusage
->ru_minflt
= tswapal(rusage
->ru_minflt
);
1275 target_rusage
->ru_majflt
= tswapal(rusage
->ru_majflt
);
1276 target_rusage
->ru_nswap
= tswapal(rusage
->ru_nswap
);
1277 target_rusage
->ru_inblock
= tswapal(rusage
->ru_inblock
);
1278 target_rusage
->ru_oublock
= tswapal(rusage
->ru_oublock
);
1279 target_rusage
->ru_msgsnd
= tswapal(rusage
->ru_msgsnd
);
1280 target_rusage
->ru_msgrcv
= tswapal(rusage
->ru_msgrcv
);
1281 target_rusage
->ru_nsignals
= tswapal(rusage
->ru_nsignals
);
1282 target_rusage
->ru_nvcsw
= tswapal(rusage
->ru_nvcsw
);
1283 target_rusage
->ru_nivcsw
= tswapal(rusage
->ru_nivcsw
);
1284 unlock_user_struct(target_rusage
, target_addr
, 1);
1289 static inline rlim_t
target_to_host_rlim(abi_ulong target_rlim
)
1291 abi_ulong target_rlim_swap
;
1294 target_rlim_swap
= tswapal(target_rlim
);
1295 if (target_rlim_swap
== TARGET_RLIM_INFINITY
)
1296 return RLIM_INFINITY
;
1298 result
= target_rlim_swap
;
1299 if (target_rlim_swap
!= (rlim_t
)result
)
1300 return RLIM_INFINITY
;
1305 static inline abi_ulong
host_to_target_rlim(rlim_t rlim
)
1307 abi_ulong target_rlim_swap
;
1310 if (rlim
== RLIM_INFINITY
|| rlim
!= (abi_long
)rlim
)
1311 target_rlim_swap
= TARGET_RLIM_INFINITY
;
1313 target_rlim_swap
= rlim
;
1314 result
= tswapal(target_rlim_swap
);
1319 static inline int target_to_host_resource(int code
)
1322 case TARGET_RLIMIT_AS
:
1324 case TARGET_RLIMIT_CORE
:
1326 case TARGET_RLIMIT_CPU
:
1328 case TARGET_RLIMIT_DATA
:
1330 case TARGET_RLIMIT_FSIZE
:
1331 return RLIMIT_FSIZE
;
1332 case TARGET_RLIMIT_LOCKS
:
1333 return RLIMIT_LOCKS
;
1334 case TARGET_RLIMIT_MEMLOCK
:
1335 return RLIMIT_MEMLOCK
;
1336 case TARGET_RLIMIT_MSGQUEUE
:
1337 return RLIMIT_MSGQUEUE
;
1338 case TARGET_RLIMIT_NICE
:
1340 case TARGET_RLIMIT_NOFILE
:
1341 return RLIMIT_NOFILE
;
1342 case TARGET_RLIMIT_NPROC
:
1343 return RLIMIT_NPROC
;
1344 case TARGET_RLIMIT_RSS
:
1346 case TARGET_RLIMIT_RTPRIO
:
1347 return RLIMIT_RTPRIO
;
1348 case TARGET_RLIMIT_SIGPENDING
:
1349 return RLIMIT_SIGPENDING
;
1350 case TARGET_RLIMIT_STACK
:
1351 return RLIMIT_STACK
;
1357 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
1358 abi_ulong target_tv_addr
)
1360 struct target_timeval
*target_tv
;
1362 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
1363 return -TARGET_EFAULT
;
1365 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1366 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1368 unlock_user_struct(target_tv
, target_tv_addr
, 0);
1373 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
1374 const struct timeval
*tv
)
1376 struct target_timeval
*target_tv
;
1378 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
1379 return -TARGET_EFAULT
;
1381 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1382 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1384 unlock_user_struct(target_tv
, target_tv_addr
, 1);
1389 static inline abi_long
copy_from_user_timezone(struct timezone
*tz
,
1390 abi_ulong target_tz_addr
)
1392 struct target_timezone
*target_tz
;
1394 if (!lock_user_struct(VERIFY_READ
, target_tz
, target_tz_addr
, 1)) {
1395 return -TARGET_EFAULT
;
1398 __get_user(tz
->tz_minuteswest
, &target_tz
->tz_minuteswest
);
1399 __get_user(tz
->tz_dsttime
, &target_tz
->tz_dsttime
);
1401 unlock_user_struct(target_tz
, target_tz_addr
, 0);
1406 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1409 static inline abi_long
copy_from_user_mq_attr(struct mq_attr
*attr
,
1410 abi_ulong target_mq_attr_addr
)
1412 struct target_mq_attr
*target_mq_attr
;
1414 if (!lock_user_struct(VERIFY_READ
, target_mq_attr
,
1415 target_mq_attr_addr
, 1))
1416 return -TARGET_EFAULT
;
1418 __get_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1419 __get_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1420 __get_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1421 __get_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1423 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 0);
1428 static inline abi_long
copy_to_user_mq_attr(abi_ulong target_mq_attr_addr
,
1429 const struct mq_attr
*attr
)
1431 struct target_mq_attr
*target_mq_attr
;
1433 if (!lock_user_struct(VERIFY_WRITE
, target_mq_attr
,
1434 target_mq_attr_addr
, 0))
1435 return -TARGET_EFAULT
;
1437 __put_user(attr
->mq_flags
, &target_mq_attr
->mq_flags
);
1438 __put_user(attr
->mq_maxmsg
, &target_mq_attr
->mq_maxmsg
);
1439 __put_user(attr
->mq_msgsize
, &target_mq_attr
->mq_msgsize
);
1440 __put_user(attr
->mq_curmsgs
, &target_mq_attr
->mq_curmsgs
);
1442 unlock_user_struct(target_mq_attr
, target_mq_attr_addr
, 1);
1448 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1449 /* do_select() must return target values and target errnos. */
1450 static abi_long
do_select(int n
,
1451 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
1452 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
1454 fd_set rfds
, wfds
, efds
;
1455 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
1457 struct timespec ts
, *ts_ptr
;
1460 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
1464 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
1468 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
1473 if (target_tv_addr
) {
1474 if (copy_from_user_timeval(&tv
, target_tv_addr
))
1475 return -TARGET_EFAULT
;
1476 ts
.tv_sec
= tv
.tv_sec
;
1477 ts
.tv_nsec
= tv
.tv_usec
* 1000;
1483 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
1486 if (!is_error(ret
)) {
1487 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
1488 return -TARGET_EFAULT
;
1489 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
1490 return -TARGET_EFAULT
;
1491 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
1492 return -TARGET_EFAULT
;
1494 if (target_tv_addr
) {
1495 tv
.tv_sec
= ts
.tv_sec
;
1496 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
1497 if (copy_to_user_timeval(target_tv_addr
, &tv
)) {
1498 return -TARGET_EFAULT
;
1506 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1507 static abi_long
do_old_select(abi_ulong arg1
)
1509 struct target_sel_arg_struct
*sel
;
1510 abi_ulong inp
, outp
, exp
, tvp
;
1513 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1)) {
1514 return -TARGET_EFAULT
;
1517 nsel
= tswapal(sel
->n
);
1518 inp
= tswapal(sel
->inp
);
1519 outp
= tswapal(sel
->outp
);
1520 exp
= tswapal(sel
->exp
);
1521 tvp
= tswapal(sel
->tvp
);
1523 unlock_user_struct(sel
, arg1
, 0);
1525 return do_select(nsel
, inp
, outp
, exp
, tvp
);
1530 static abi_long
do_pipe2(int host_pipe
[], int flags
)
1533 return pipe2(host_pipe
, flags
);
1539 static abi_long
do_pipe(void *cpu_env
, abi_ulong pipedes
,
1540 int flags
, int is_pipe2
)
1544 ret
= flags
? do_pipe2(host_pipe
, flags
) : pipe(host_pipe
);
1547 return get_errno(ret
);
1549 /* Several targets have special calling conventions for the original
1550 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1552 #if defined(TARGET_ALPHA)
1553 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = host_pipe
[1];
1554 return host_pipe
[0];
1555 #elif defined(TARGET_MIPS)
1556 ((CPUMIPSState
*)cpu_env
)->active_tc
.gpr
[3] = host_pipe
[1];
1557 return host_pipe
[0];
1558 #elif defined(TARGET_SH4)
1559 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
1560 return host_pipe
[0];
1561 #elif defined(TARGET_SPARC)
1562 ((CPUSPARCState
*)cpu_env
)->regwptr
[1] = host_pipe
[1];
1563 return host_pipe
[0];
1567 if (put_user_s32(host_pipe
[0], pipedes
)
1568 || put_user_s32(host_pipe
[1], pipedes
+ sizeof(host_pipe
[0])))
1569 return -TARGET_EFAULT
;
1570 return get_errno(ret
);
1573 static inline abi_long
target_to_host_ip_mreq(struct ip_mreqn
*mreqn
,
1574 abi_ulong target_addr
,
1577 struct target_ip_mreqn
*target_smreqn
;
1579 target_smreqn
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1581 return -TARGET_EFAULT
;
1582 mreqn
->imr_multiaddr
.s_addr
= target_smreqn
->imr_multiaddr
.s_addr
;
1583 mreqn
->imr_address
.s_addr
= target_smreqn
->imr_address
.s_addr
;
1584 if (len
== sizeof(struct target_ip_mreqn
))
1585 mreqn
->imr_ifindex
= tswapal(target_smreqn
->imr_ifindex
);
1586 unlock_user(target_smreqn
, target_addr
, 0);
1591 static inline abi_long
target_to_host_sockaddr(int fd
, struct sockaddr
*addr
,
1592 abi_ulong target_addr
,
1595 const socklen_t unix_maxlen
= sizeof (struct sockaddr_un
);
1596 sa_family_t sa_family
;
1597 struct target_sockaddr
*target_saddr
;
1599 if (fd_trans_target_to_host_addr(fd
)) {
1600 return fd_trans_target_to_host_addr(fd
)(addr
, target_addr
, len
);
1603 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
1605 return -TARGET_EFAULT
;
1607 sa_family
= tswap16(target_saddr
->sa_family
);
1609 /* Oops. The caller might send a incomplete sun_path; sun_path
1610 * must be terminated by \0 (see the manual page), but
1611 * unfortunately it is quite common to specify sockaddr_un
1612 * length as "strlen(x->sun_path)" while it should be
1613 * "strlen(...) + 1". We'll fix that here if needed.
1614 * Linux kernel has a similar feature.
1617 if (sa_family
== AF_UNIX
) {
1618 if (len
< unix_maxlen
&& len
> 0) {
1619 char *cp
= (char*)target_saddr
;
1621 if ( cp
[len
-1] && !cp
[len
] )
1624 if (len
> unix_maxlen
)
1628 memcpy(addr
, target_saddr
, len
);
1629 addr
->sa_family
= sa_family
;
1630 if (sa_family
== AF_NETLINK
) {
1631 struct sockaddr_nl
*nladdr
;
1633 nladdr
= (struct sockaddr_nl
*)addr
;
1634 nladdr
->nl_pid
= tswap32(nladdr
->nl_pid
);
1635 nladdr
->nl_groups
= tswap32(nladdr
->nl_groups
);
1636 } else if (sa_family
== AF_PACKET
) {
1637 struct target_sockaddr_ll
*lladdr
;
1639 lladdr
= (struct target_sockaddr_ll
*)addr
;
1640 lladdr
->sll_ifindex
= tswap32(lladdr
->sll_ifindex
);
1641 lladdr
->sll_hatype
= tswap16(lladdr
->sll_hatype
);
1643 unlock_user(target_saddr
, target_addr
, 0);
1648 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
1649 struct sockaddr
*addr
,
1652 struct target_sockaddr
*target_saddr
;
1659 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
1661 return -TARGET_EFAULT
;
1662 memcpy(target_saddr
, addr
, len
);
1663 if (len
>= offsetof(struct target_sockaddr
, sa_family
) +
1664 sizeof(target_saddr
->sa_family
)) {
1665 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
1667 if (addr
->sa_family
== AF_NETLINK
&& len
>= sizeof(struct sockaddr_nl
)) {
1668 struct sockaddr_nl
*target_nl
= (struct sockaddr_nl
*)target_saddr
;
1669 target_nl
->nl_pid
= tswap32(target_nl
->nl_pid
);
1670 target_nl
->nl_groups
= tswap32(target_nl
->nl_groups
);
1671 } else if (addr
->sa_family
== AF_PACKET
) {
1672 struct sockaddr_ll
*target_ll
= (struct sockaddr_ll
*)target_saddr
;
1673 target_ll
->sll_ifindex
= tswap32(target_ll
->sll_ifindex
);
1674 target_ll
->sll_hatype
= tswap16(target_ll
->sll_hatype
);
1675 } else if (addr
->sa_family
== AF_INET6
&&
1676 len
>= sizeof(struct target_sockaddr_in6
)) {
1677 struct target_sockaddr_in6
*target_in6
=
1678 (struct target_sockaddr_in6
*)target_saddr
;
1679 target_in6
->sin6_scope_id
= tswap16(target_in6
->sin6_scope_id
);
1681 unlock_user(target_saddr
, target_addr
, len
);
1686 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
1687 struct target_msghdr
*target_msgh
)
1689 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1690 abi_long msg_controllen
;
1691 abi_ulong target_cmsg_addr
;
1692 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1693 socklen_t space
= 0;
1695 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1696 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1698 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1699 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
1700 target_cmsg_start
= target_cmsg
;
1702 return -TARGET_EFAULT
;
1704 while (cmsg
&& target_cmsg
) {
1705 void *data
= CMSG_DATA(cmsg
);
1706 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1708 int len
= tswapal(target_cmsg
->cmsg_len
)
1709 - sizeof(struct target_cmsghdr
);
1711 space
+= CMSG_SPACE(len
);
1712 if (space
> msgh
->msg_controllen
) {
1713 space
-= CMSG_SPACE(len
);
1714 /* This is a QEMU bug, since we allocated the payload
1715 * area ourselves (unlike overflow in host-to-target
1716 * conversion, which is just the guest giving us a buffer
1717 * that's too small). It can't happen for the payload types
1718 * we currently support; if it becomes an issue in future
1719 * we would need to improve our allocation strategy to
1720 * something more intelligent than "twice the size of the
1721 * target buffer we're reading from".
1723 gemu_log("Host cmsg overflow\n");
1727 if (tswap32(target_cmsg
->cmsg_level
) == TARGET_SOL_SOCKET
) {
1728 cmsg
->cmsg_level
= SOL_SOCKET
;
1730 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
1732 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
1733 cmsg
->cmsg_len
= CMSG_LEN(len
);
1735 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
1736 int *fd
= (int *)data
;
1737 int *target_fd
= (int *)target_data
;
1738 int i
, numfds
= len
/ sizeof(int);
1740 for (i
= 0; i
< numfds
; i
++) {
1741 __get_user(fd
[i
], target_fd
+ i
);
1743 } else if (cmsg
->cmsg_level
== SOL_SOCKET
1744 && cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
1745 struct ucred
*cred
= (struct ucred
*)data
;
1746 struct target_ucred
*target_cred
=
1747 (struct target_ucred
*)target_data
;
1749 __get_user(cred
->pid
, &target_cred
->pid
);
1750 __get_user(cred
->uid
, &target_cred
->uid
);
1751 __get_user(cred
->gid
, &target_cred
->gid
);
1753 gemu_log("Unsupported ancillary data: %d/%d\n",
1754 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1755 memcpy(data
, target_data
, len
);
1758 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1759 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1762 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
1764 msgh
->msg_controllen
= space
;
1768 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
1769 struct msghdr
*msgh
)
1771 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
1772 abi_long msg_controllen
;
1773 abi_ulong target_cmsg_addr
;
1774 struct target_cmsghdr
*target_cmsg
, *target_cmsg_start
;
1775 socklen_t space
= 0;
1777 msg_controllen
= tswapal(target_msgh
->msg_controllen
);
1778 if (msg_controllen
< sizeof (struct target_cmsghdr
))
1780 target_cmsg_addr
= tswapal(target_msgh
->msg_control
);
1781 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
1782 target_cmsg_start
= target_cmsg
;
1784 return -TARGET_EFAULT
;
1786 while (cmsg
&& target_cmsg
) {
1787 void *data
= CMSG_DATA(cmsg
);
1788 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
1790 int len
= cmsg
->cmsg_len
- sizeof(struct cmsghdr
);
1791 int tgt_len
, tgt_space
;
1793 /* We never copy a half-header but may copy half-data;
1794 * this is Linux's behaviour in put_cmsg(). Note that
1795 * truncation here is a guest problem (which we report
1796 * to the guest via the CTRUNC bit), unlike truncation
1797 * in target_to_host_cmsg, which is a QEMU bug.
1799 if (msg_controllen
< sizeof(struct target_cmsghdr
)) {
1800 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1804 if (cmsg
->cmsg_level
== SOL_SOCKET
) {
1805 target_cmsg
->cmsg_level
= tswap32(TARGET_SOL_SOCKET
);
1807 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
1809 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
1811 /* Payload types which need a different size of payload on
1812 * the target must adjust tgt_len here.
1814 switch (cmsg
->cmsg_level
) {
1816 switch (cmsg
->cmsg_type
) {
1818 tgt_len
= sizeof(struct target_timeval
);
1828 if (msg_controllen
< TARGET_CMSG_LEN(tgt_len
)) {
1829 target_msgh
->msg_flags
|= tswap32(MSG_CTRUNC
);
1830 tgt_len
= msg_controllen
- sizeof(struct target_cmsghdr
);
1833 /* We must now copy-and-convert len bytes of payload
1834 * into tgt_len bytes of destination space. Bear in mind
1835 * that in both source and destination we may be dealing
1836 * with a truncated value!
1838 switch (cmsg
->cmsg_level
) {
1840 switch (cmsg
->cmsg_type
) {
1843 int *fd
= (int *)data
;
1844 int *target_fd
= (int *)target_data
;
1845 int i
, numfds
= tgt_len
/ sizeof(int);
1847 for (i
= 0; i
< numfds
; i
++) {
1848 __put_user(fd
[i
], target_fd
+ i
);
1854 struct timeval
*tv
= (struct timeval
*)data
;
1855 struct target_timeval
*target_tv
=
1856 (struct target_timeval
*)target_data
;
1858 if (len
!= sizeof(struct timeval
) ||
1859 tgt_len
!= sizeof(struct target_timeval
)) {
1863 /* copy struct timeval to target */
1864 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
1865 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
1868 case SCM_CREDENTIALS
:
1870 struct ucred
*cred
= (struct ucred
*)data
;
1871 struct target_ucred
*target_cred
=
1872 (struct target_ucred
*)target_data
;
1874 __put_user(cred
->pid
, &target_cred
->pid
);
1875 __put_user(cred
->uid
, &target_cred
->uid
);
1876 __put_user(cred
->gid
, &target_cred
->gid
);
1885 switch (cmsg
->cmsg_type
) {
1888 uint32_t *v
= (uint32_t *)data
;
1889 uint32_t *t_int
= (uint32_t *)target_data
;
1891 if (len
!= sizeof(uint32_t) ||
1892 tgt_len
!= sizeof(uint32_t)) {
1895 __put_user(*v
, t_int
);
1901 struct sock_extended_err ee
;
1902 struct sockaddr_in offender
;
1904 struct errhdr_t
*errh
= (struct errhdr_t
*)data
;
1905 struct errhdr_t
*target_errh
=
1906 (struct errhdr_t
*)target_data
;
1908 if (len
!= sizeof(struct errhdr_t
) ||
1909 tgt_len
!= sizeof(struct errhdr_t
)) {
1912 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1913 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1914 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1915 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1916 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1917 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1918 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1919 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1920 (void *) &errh
->offender
, sizeof(errh
->offender
));
1929 switch (cmsg
->cmsg_type
) {
1932 uint32_t *v
= (uint32_t *)data
;
1933 uint32_t *t_int
= (uint32_t *)target_data
;
1935 if (len
!= sizeof(uint32_t) ||
1936 tgt_len
!= sizeof(uint32_t)) {
1939 __put_user(*v
, t_int
);
1945 struct sock_extended_err ee
;
1946 struct sockaddr_in6 offender
;
1948 struct errhdr6_t
*errh
= (struct errhdr6_t
*)data
;
1949 struct errhdr6_t
*target_errh
=
1950 (struct errhdr6_t
*)target_data
;
1952 if (len
!= sizeof(struct errhdr6_t
) ||
1953 tgt_len
!= sizeof(struct errhdr6_t
)) {
1956 __put_user(errh
->ee
.ee_errno
, &target_errh
->ee
.ee_errno
);
1957 __put_user(errh
->ee
.ee_origin
, &target_errh
->ee
.ee_origin
);
1958 __put_user(errh
->ee
.ee_type
, &target_errh
->ee
.ee_type
);
1959 __put_user(errh
->ee
.ee_code
, &target_errh
->ee
.ee_code
);
1960 __put_user(errh
->ee
.ee_pad
, &target_errh
->ee
.ee_pad
);
1961 __put_user(errh
->ee
.ee_info
, &target_errh
->ee
.ee_info
);
1962 __put_user(errh
->ee
.ee_data
, &target_errh
->ee
.ee_data
);
1963 host_to_target_sockaddr((unsigned long) &target_errh
->offender
,
1964 (void *) &errh
->offender
, sizeof(errh
->offender
));
1974 gemu_log("Unsupported ancillary data: %d/%d\n",
1975 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1976 memcpy(target_data
, data
, MIN(len
, tgt_len
));
1977 if (tgt_len
> len
) {
1978 memset(target_data
+ len
, 0, tgt_len
- len
);
1982 target_cmsg
->cmsg_len
= tswapal(TARGET_CMSG_LEN(tgt_len
));
1983 tgt_space
= TARGET_CMSG_SPACE(tgt_len
);
1984 if (msg_controllen
< tgt_space
) {
1985 tgt_space
= msg_controllen
;
1987 msg_controllen
-= tgt_space
;
1989 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
1990 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
,
1993 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
1995 target_msgh
->msg_controllen
= tswapal(space
);
1999 static void tswap_nlmsghdr(struct nlmsghdr
*nlh
)
2001 nlh
->nlmsg_len
= tswap32(nlh
->nlmsg_len
);
2002 nlh
->nlmsg_type
= tswap16(nlh
->nlmsg_type
);
2003 nlh
->nlmsg_flags
= tswap16(nlh
->nlmsg_flags
);
2004 nlh
->nlmsg_seq
= tswap32(nlh
->nlmsg_seq
);
2005 nlh
->nlmsg_pid
= tswap32(nlh
->nlmsg_pid
);
2008 static abi_long
host_to_target_for_each_nlmsg(struct nlmsghdr
*nlh
,
2010 abi_long (*host_to_target_nlmsg
)
2011 (struct nlmsghdr
*))
2016 while (len
> sizeof(struct nlmsghdr
)) {
2018 nlmsg_len
= nlh
->nlmsg_len
;
2019 if (nlmsg_len
< sizeof(struct nlmsghdr
) ||
2024 switch (nlh
->nlmsg_type
) {
2026 tswap_nlmsghdr(nlh
);
2032 struct nlmsgerr
*e
= NLMSG_DATA(nlh
);
2033 e
->error
= tswap32(e
->error
);
2034 tswap_nlmsghdr(&e
->msg
);
2035 tswap_nlmsghdr(nlh
);
2039 ret
= host_to_target_nlmsg(nlh
);
2041 tswap_nlmsghdr(nlh
);
2046 tswap_nlmsghdr(nlh
);
2047 len
-= NLMSG_ALIGN(nlmsg_len
);
2048 nlh
= (struct nlmsghdr
*)(((char*)nlh
) + NLMSG_ALIGN(nlmsg_len
));
2053 static abi_long
target_to_host_for_each_nlmsg(struct nlmsghdr
*nlh
,
2055 abi_long (*target_to_host_nlmsg
)
2056 (struct nlmsghdr
*))
2060 while (len
> sizeof(struct nlmsghdr
)) {
2061 if (tswap32(nlh
->nlmsg_len
) < sizeof(struct nlmsghdr
) ||
2062 tswap32(nlh
->nlmsg_len
) > len
) {
2065 tswap_nlmsghdr(nlh
);
2066 switch (nlh
->nlmsg_type
) {
2073 struct nlmsgerr
*e
= NLMSG_DATA(nlh
);
2074 e
->error
= tswap32(e
->error
);
2075 tswap_nlmsghdr(&e
->msg
);
2079 ret
= target_to_host_nlmsg(nlh
);
2084 len
-= NLMSG_ALIGN(nlh
->nlmsg_len
);
2085 nlh
= (struct nlmsghdr
*)(((char *)nlh
) + NLMSG_ALIGN(nlh
->nlmsg_len
));
2090 #ifdef CONFIG_RTNETLINK
2091 static abi_long
host_to_target_for_each_nlattr(struct nlattr
*nlattr
,
2092 size_t len
, void *context
,
2093 abi_long (*host_to_target_nlattr
)
2097 unsigned short nla_len
;
2100 while (len
> sizeof(struct nlattr
)) {
2101 nla_len
= nlattr
->nla_len
;
2102 if (nla_len
< sizeof(struct nlattr
) ||
2106 ret
= host_to_target_nlattr(nlattr
, context
);
2107 nlattr
->nla_len
= tswap16(nlattr
->nla_len
);
2108 nlattr
->nla_type
= tswap16(nlattr
->nla_type
);
2112 len
-= NLA_ALIGN(nla_len
);
2113 nlattr
= (struct nlattr
*)(((char *)nlattr
) + NLA_ALIGN(nla_len
));
2118 static abi_long
host_to_target_for_each_rtattr(struct rtattr
*rtattr
,
2120 abi_long (*host_to_target_rtattr
)
2123 unsigned short rta_len
;
2126 while (len
> sizeof(struct rtattr
)) {
2127 rta_len
= rtattr
->rta_len
;
2128 if (rta_len
< sizeof(struct rtattr
) ||
2132 ret
= host_to_target_rtattr(rtattr
);
2133 rtattr
->rta_len
= tswap16(rtattr
->rta_len
);
2134 rtattr
->rta_type
= tswap16(rtattr
->rta_type
);
2138 len
-= RTA_ALIGN(rta_len
);
2139 rtattr
= (struct rtattr
*)(((char *)rtattr
) + RTA_ALIGN(rta_len
));
2144 #define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
2146 static abi_long
host_to_target_data_bridge_nlattr(struct nlattr
*nlattr
,
2153 switch (nlattr
->nla_type
) {
2155 case QEMU_IFLA_BR_FDB_FLUSH
:
2158 case QEMU_IFLA_BR_GROUP_ADDR
:
2161 case QEMU_IFLA_BR_VLAN_FILTERING
:
2162 case QEMU_IFLA_BR_TOPOLOGY_CHANGE
:
2163 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED
:
2164 case QEMU_IFLA_BR_MCAST_ROUTER
:
2165 case QEMU_IFLA_BR_MCAST_SNOOPING
:
2166 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR
:
2167 case QEMU_IFLA_BR_MCAST_QUERIER
:
2168 case QEMU_IFLA_BR_NF_CALL_IPTABLES
:
2169 case QEMU_IFLA_BR_NF_CALL_IP6TABLES
:
2170 case QEMU_IFLA_BR_NF_CALL_ARPTABLES
:
2173 case QEMU_IFLA_BR_PRIORITY
:
2174 case QEMU_IFLA_BR_VLAN_PROTOCOL
:
2175 case QEMU_IFLA_BR_GROUP_FWD_MASK
:
2176 case QEMU_IFLA_BR_ROOT_PORT
:
2177 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID
:
2178 u16
= NLA_DATA(nlattr
);
2179 *u16
= tswap16(*u16
);
2182 case QEMU_IFLA_BR_FORWARD_DELAY
:
2183 case QEMU_IFLA_BR_HELLO_TIME
:
2184 case QEMU_IFLA_BR_MAX_AGE
:
2185 case QEMU_IFLA_BR_AGEING_TIME
:
2186 case QEMU_IFLA_BR_STP_STATE
:
2187 case QEMU_IFLA_BR_ROOT_PATH_COST
:
2188 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY
:
2189 case QEMU_IFLA_BR_MCAST_HASH_MAX
:
2190 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT
:
2191 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT
:
2192 u32
= NLA_DATA(nlattr
);
2193 *u32
= tswap32(*u32
);
2196 case QEMU_IFLA_BR_HELLO_TIMER
:
2197 case QEMU_IFLA_BR_TCN_TIMER
:
2198 case QEMU_IFLA_BR_GC_TIMER
:
2199 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER
:
2200 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL
:
2201 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL
:
2202 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL
:
2203 case QEMU_IFLA_BR_MCAST_QUERY_INTVL
:
2204 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL
:
2205 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL
:
2206 u64
= NLA_DATA(nlattr
);
2207 *u64
= tswap64(*u64
);
2209 /* ifla_bridge_id: uin8_t[] */
2210 case QEMU_IFLA_BR_ROOT_ID
:
2211 case QEMU_IFLA_BR_BRIDGE_ID
:
2214 gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr
->nla_type
);
2220 static abi_long
host_to_target_slave_data_bridge_nlattr(struct nlattr
*nlattr
,
2227 switch (nlattr
->nla_type
) {
2229 case QEMU_IFLA_BRPORT_STATE
:
2230 case QEMU_IFLA_BRPORT_MODE
:
2231 case QEMU_IFLA_BRPORT_GUARD
:
2232 case QEMU_IFLA_BRPORT_PROTECT
:
2233 case QEMU_IFLA_BRPORT_FAST_LEAVE
:
2234 case QEMU_IFLA_BRPORT_LEARNING
:
2235 case QEMU_IFLA_BRPORT_UNICAST_FLOOD
:
2236 case QEMU_IFLA_BRPORT_PROXYARP
:
2237 case QEMU_IFLA_BRPORT_LEARNING_SYNC
:
2238 case QEMU_IFLA_BRPORT_PROXYARP_WIFI
:
2239 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK
:
2240 case QEMU_IFLA_BRPORT_CONFIG_PENDING
:
2241 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER
:
2244 case QEMU_IFLA_BRPORT_PRIORITY
:
2245 case QEMU_IFLA_BRPORT_DESIGNATED_PORT
:
2246 case QEMU_IFLA_BRPORT_DESIGNATED_COST
:
2247 case QEMU_IFLA_BRPORT_ID
:
2248 case QEMU_IFLA_BRPORT_NO
:
2249 u16
= NLA_DATA(nlattr
);
2250 *u16
= tswap16(*u16
);
2253 case QEMU_IFLA_BRPORT_COST
:
2254 u32
= NLA_DATA(nlattr
);
2255 *u32
= tswap32(*u32
);
2258 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER
:
2259 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER
:
2260 case QEMU_IFLA_BRPORT_HOLD_TIMER
:
2261 u64
= NLA_DATA(nlattr
);
2262 *u64
= tswap64(*u64
);
2264 /* ifla_bridge_id: uint8_t[] */
2265 case QEMU_IFLA_BRPORT_ROOT_ID
:
2266 case QEMU_IFLA_BRPORT_BRIDGE_ID
:
2269 gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr
->nla_type
);
2275 struct linkinfo_context
{
2282 static abi_long
host_to_target_data_linkinfo_nlattr(struct nlattr
*nlattr
,
2285 struct linkinfo_context
*li_context
= context
;
2287 switch (nlattr
->nla_type
) {
2289 case QEMU_IFLA_INFO_KIND
:
2290 li_context
->name
= NLA_DATA(nlattr
);
2291 li_context
->len
= nlattr
->nla_len
- NLA_HDRLEN
;
2293 case QEMU_IFLA_INFO_SLAVE_KIND
:
2294 li_context
->slave_name
= NLA_DATA(nlattr
);
2295 li_context
->slave_len
= nlattr
->nla_len
- NLA_HDRLEN
;
2298 case QEMU_IFLA_INFO_XSTATS
:
2299 /* FIXME: only used by CAN */
2302 case QEMU_IFLA_INFO_DATA
:
2303 if (strncmp(li_context
->name
, "bridge",
2304 li_context
->len
) == 0) {
2305 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
),
2308 host_to_target_data_bridge_nlattr
);
2310 gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context
->name
);
2313 case QEMU_IFLA_INFO_SLAVE_DATA
:
2314 if (strncmp(li_context
->slave_name
, "bridge",
2315 li_context
->slave_len
) == 0) {
2316 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
),
2319 host_to_target_slave_data_bridge_nlattr
);
2321 gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
2322 li_context
->slave_name
);
2326 gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr
->nla_type
);
2333 static abi_long
host_to_target_data_inet_nlattr(struct nlattr
*nlattr
,
2339 switch (nlattr
->nla_type
) {
2340 case QEMU_IFLA_INET_CONF
:
2341 u32
= NLA_DATA(nlattr
);
2342 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u32
);
2344 u32
[i
] = tswap32(u32
[i
]);
2348 gemu_log("Unknown host AF_INET type: %d\n", nlattr
->nla_type
);
2353 static abi_long
host_to_target_data_inet6_nlattr(struct nlattr
*nlattr
,
2358 struct ifla_cacheinfo
*ci
;
2361 switch (nlattr
->nla_type
) {
2363 case QEMU_IFLA_INET6_TOKEN
:
2366 case QEMU_IFLA_INET6_ADDR_GEN_MODE
:
2369 case QEMU_IFLA_INET6_FLAGS
:
2370 u32
= NLA_DATA(nlattr
);
2371 *u32
= tswap32(*u32
);
2374 case QEMU_IFLA_INET6_CONF
:
2375 u32
= NLA_DATA(nlattr
);
2376 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u32
);
2378 u32
[i
] = tswap32(u32
[i
]);
2381 /* ifla_cacheinfo */
2382 case QEMU_IFLA_INET6_CACHEINFO
:
2383 ci
= NLA_DATA(nlattr
);
2384 ci
->max_reasm_len
= tswap32(ci
->max_reasm_len
);
2385 ci
->tstamp
= tswap32(ci
->tstamp
);
2386 ci
->reachable_time
= tswap32(ci
->reachable_time
);
2387 ci
->retrans_time
= tswap32(ci
->retrans_time
);
2390 case QEMU_IFLA_INET6_STATS
:
2391 case QEMU_IFLA_INET6_ICMP6STATS
:
2392 u64
= NLA_DATA(nlattr
);
2393 for (i
= 0; i
< (nlattr
->nla_len
- NLA_HDRLEN
) / sizeof(*u64
);
2395 u64
[i
] = tswap64(u64
[i
]);
2399 gemu_log("Unknown host AF_INET6 type: %d\n", nlattr
->nla_type
);
2404 static abi_long
host_to_target_data_spec_nlattr(struct nlattr
*nlattr
,
2407 switch (nlattr
->nla_type
) {
2409 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
), nlattr
->nla_len
,
2411 host_to_target_data_inet_nlattr
);
2413 return host_to_target_for_each_nlattr(NLA_DATA(nlattr
), nlattr
->nla_len
,
2415 host_to_target_data_inet6_nlattr
);
2417 gemu_log("Unknown host AF_SPEC type: %d\n", nlattr
->nla_type
);
2423 static abi_long
host_to_target_data_link_rtattr(struct rtattr
*rtattr
)
2426 struct rtnl_link_stats
*st
;
2427 struct rtnl_link_stats64
*st64
;
2428 struct rtnl_link_ifmap
*map
;
2429 struct linkinfo_context li_context
;
2431 switch (rtattr
->rta_type
) {
2433 case QEMU_IFLA_ADDRESS
:
2434 case QEMU_IFLA_BROADCAST
:
2436 case QEMU_IFLA_IFNAME
:
2437 case QEMU_IFLA_QDISC
:
2440 case QEMU_IFLA_OPERSTATE
:
2441 case QEMU_IFLA_LINKMODE
:
2442 case QEMU_IFLA_CARRIER
:
2443 case QEMU_IFLA_PROTO_DOWN
:
2447 case QEMU_IFLA_LINK
:
2448 case QEMU_IFLA_WEIGHT
:
2449 case QEMU_IFLA_TXQLEN
:
2450 case QEMU_IFLA_CARRIER_CHANGES
:
2451 case QEMU_IFLA_NUM_RX_QUEUES
:
2452 case QEMU_IFLA_NUM_TX_QUEUES
:
2453 case QEMU_IFLA_PROMISCUITY
:
2454 case QEMU_IFLA_EXT_MASK
:
2455 case QEMU_IFLA_LINK_NETNSID
:
2456 case QEMU_IFLA_GROUP
:
2457 case QEMU_IFLA_MASTER
:
2458 case QEMU_IFLA_NUM_VF
:
2459 case QEMU_IFLA_GSO_MAX_SEGS
:
2460 case QEMU_IFLA_GSO_MAX_SIZE
:
2461 u32
= RTA_DATA(rtattr
);
2462 *u32
= tswap32(*u32
);
2464 /* struct rtnl_link_stats */
2465 case QEMU_IFLA_STATS
:
2466 st
= RTA_DATA(rtattr
);
2467 st
->rx_packets
= tswap32(st
->rx_packets
);
2468 st
->tx_packets
= tswap32(st
->tx_packets
);
2469 st
->rx_bytes
= tswap32(st
->rx_bytes
);
2470 st
->tx_bytes
= tswap32(st
->tx_bytes
);
2471 st
->rx_errors
= tswap32(st
->rx_errors
);
2472 st
->tx_errors
= tswap32(st
->tx_errors
);
2473 st
->rx_dropped
= tswap32(st
->rx_dropped
);
2474 st
->tx_dropped
= tswap32(st
->tx_dropped
);
2475 st
->multicast
= tswap32(st
->multicast
);
2476 st
->collisions
= tswap32(st
->collisions
);
2478 /* detailed rx_errors: */
2479 st
->rx_length_errors
= tswap32(st
->rx_length_errors
);
2480 st
->rx_over_errors
= tswap32(st
->rx_over_errors
);
2481 st
->rx_crc_errors
= tswap32(st
->rx_crc_errors
);
2482 st
->rx_frame_errors
= tswap32(st
->rx_frame_errors
);
2483 st
->rx_fifo_errors
= tswap32(st
->rx_fifo_errors
);
2484 st
->rx_missed_errors
= tswap32(st
->rx_missed_errors
);
2486 /* detailed tx_errors */
2487 st
->tx_aborted_errors
= tswap32(st
->tx_aborted_errors
);
2488 st
->tx_carrier_errors
= tswap32(st
->tx_carrier_errors
);
2489 st
->tx_fifo_errors
= tswap32(st
->tx_fifo_errors
);
2490 st
->tx_heartbeat_errors
= tswap32(st
->tx_heartbeat_errors
);
2491 st
->tx_window_errors
= tswap32(st
->tx_window_errors
);
2494 st
->rx_compressed
= tswap32(st
->rx_compressed
);
2495 st
->tx_compressed
= tswap32(st
->tx_compressed
);
2497 /* struct rtnl_link_stats64 */
2498 case QEMU_IFLA_STATS64
:
2499 st64
= RTA_DATA(rtattr
);
2500 st64
->rx_packets
= tswap64(st64
->rx_packets
);
2501 st64
->tx_packets
= tswap64(st64
->tx_packets
);
2502 st64
->rx_bytes
= tswap64(st64
->rx_bytes
);
2503 st64
->tx_bytes
= tswap64(st64
->tx_bytes
);
2504 st64
->rx_errors
= tswap64(st64
->rx_errors
);
2505 st64
->tx_errors
= tswap64(st64
->tx_errors
);
2506 st64
->rx_dropped
= tswap64(st64
->rx_dropped
);
2507 st64
->tx_dropped
= tswap64(st64
->tx_dropped
);
2508 st64
->multicast
= tswap64(st64
->multicast
);
2509 st64
->collisions
= tswap64(st64
->collisions
);
2511 /* detailed rx_errors: */
2512 st64
->rx_length_errors
= tswap64(st64
->rx_length_errors
);
2513 st64
->rx_over_errors
= tswap64(st64
->rx_over_errors
);
2514 st64
->rx_crc_errors
= tswap64(st64
->rx_crc_errors
);
2515 st64
->rx_frame_errors
= tswap64(st64
->rx_frame_errors
);
2516 st64
->rx_fifo_errors
= tswap64(st64
->rx_fifo_errors
);
2517 st64
->rx_missed_errors
= tswap64(st64
->rx_missed_errors
);
2519 /* detailed tx_errors */
2520 st64
->tx_aborted_errors
= tswap64(st64
->tx_aborted_errors
);
2521 st64
->tx_carrier_errors
= tswap64(st64
->tx_carrier_errors
);
2522 st64
->tx_fifo_errors
= tswap64(st64
->tx_fifo_errors
);
2523 st64
->tx_heartbeat_errors
= tswap64(st64
->tx_heartbeat_errors
);
2524 st64
->tx_window_errors
= tswap64(st64
->tx_window_errors
);
2527 st64
->rx_compressed
= tswap64(st64
->rx_compressed
);
2528 st64
->tx_compressed
= tswap64(st64
->tx_compressed
);
2530 /* struct rtnl_link_ifmap */
2532 map
= RTA_DATA(rtattr
);
2533 map
->mem_start
= tswap64(map
->mem_start
);
2534 map
->mem_end
= tswap64(map
->mem_end
);
2535 map
->base_addr
= tswap64(map
->base_addr
);
2536 map
->irq
= tswap16(map
->irq
);
2539 case QEMU_IFLA_LINKINFO
:
2540 memset(&li_context
, 0, sizeof(li_context
));
2541 return host_to_target_for_each_nlattr(RTA_DATA(rtattr
), rtattr
->rta_len
,
2543 host_to_target_data_linkinfo_nlattr
);
2544 case QEMU_IFLA_AF_SPEC
:
2545 return host_to_target_for_each_nlattr(RTA_DATA(rtattr
), rtattr
->rta_len
,
2547 host_to_target_data_spec_nlattr
);
2549 gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr
->rta_type
);
2555 static abi_long
host_to_target_data_addr_rtattr(struct rtattr
*rtattr
)
2558 struct ifa_cacheinfo
*ci
;
2560 switch (rtattr
->rta_type
) {
2561 /* binary: depends on family type */
2571 u32
= RTA_DATA(rtattr
);
2572 *u32
= tswap32(*u32
);
2574 /* struct ifa_cacheinfo */
2576 ci
= RTA_DATA(rtattr
);
2577 ci
->ifa_prefered
= tswap32(ci
->ifa_prefered
);
2578 ci
->ifa_valid
= tswap32(ci
->ifa_valid
);
2579 ci
->cstamp
= tswap32(ci
->cstamp
);
2580 ci
->tstamp
= tswap32(ci
->tstamp
);
2583 gemu_log("Unknown host IFA type: %d\n", rtattr
->rta_type
);
2589 static abi_long
host_to_target_data_route_rtattr(struct rtattr
*rtattr
)
2592 switch (rtattr
->rta_type
) {
2593 /* binary: depends on family type */
2602 u32
= RTA_DATA(rtattr
);
2603 *u32
= tswap32(*u32
);
2606 gemu_log("Unknown host RTA type: %d\n", rtattr
->rta_type
);
2612 static abi_long
host_to_target_link_rtattr(struct rtattr
*rtattr
,
2613 uint32_t rtattr_len
)
2615 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2616 host_to_target_data_link_rtattr
);
2619 static abi_long
host_to_target_addr_rtattr(struct rtattr
*rtattr
,
2620 uint32_t rtattr_len
)
2622 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2623 host_to_target_data_addr_rtattr
);
2626 static abi_long
host_to_target_route_rtattr(struct rtattr
*rtattr
,
2627 uint32_t rtattr_len
)
2629 return host_to_target_for_each_rtattr(rtattr
, rtattr_len
,
2630 host_to_target_data_route_rtattr
);
2633 static abi_long
host_to_target_data_route(struct nlmsghdr
*nlh
)
2636 struct ifinfomsg
*ifi
;
2637 struct ifaddrmsg
*ifa
;
2640 nlmsg_len
= nlh
->nlmsg_len
;
2641 switch (nlh
->nlmsg_type
) {
2645 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifi
))) {
2646 ifi
= NLMSG_DATA(nlh
);
2647 ifi
->ifi_type
= tswap16(ifi
->ifi_type
);
2648 ifi
->ifi_index
= tswap32(ifi
->ifi_index
);
2649 ifi
->ifi_flags
= tswap32(ifi
->ifi_flags
);
2650 ifi
->ifi_change
= tswap32(ifi
->ifi_change
);
2651 host_to_target_link_rtattr(IFLA_RTA(ifi
),
2652 nlmsg_len
- NLMSG_LENGTH(sizeof(*ifi
)));
2658 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifa
))) {
2659 ifa
= NLMSG_DATA(nlh
);
2660 ifa
->ifa_index
= tswap32(ifa
->ifa_index
);
2661 host_to_target_addr_rtattr(IFA_RTA(ifa
),
2662 nlmsg_len
- NLMSG_LENGTH(sizeof(*ifa
)));
2668 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*rtm
))) {
2669 rtm
= NLMSG_DATA(nlh
);
2670 rtm
->rtm_flags
= tswap32(rtm
->rtm_flags
);
2671 host_to_target_route_rtattr(RTM_RTA(rtm
),
2672 nlmsg_len
- NLMSG_LENGTH(sizeof(*rtm
)));
2676 return -TARGET_EINVAL
;
2681 static inline abi_long
host_to_target_nlmsg_route(struct nlmsghdr
*nlh
,
2684 return host_to_target_for_each_nlmsg(nlh
, len
, host_to_target_data_route
);
2687 static abi_long
target_to_host_for_each_rtattr(struct rtattr
*rtattr
,
2689 abi_long (*target_to_host_rtattr
)
2694 while (len
>= sizeof(struct rtattr
)) {
2695 if (tswap16(rtattr
->rta_len
) < sizeof(struct rtattr
) ||
2696 tswap16(rtattr
->rta_len
) > len
) {
2699 rtattr
->rta_len
= tswap16(rtattr
->rta_len
);
2700 rtattr
->rta_type
= tswap16(rtattr
->rta_type
);
2701 ret
= target_to_host_rtattr(rtattr
);
2705 len
-= RTA_ALIGN(rtattr
->rta_len
);
2706 rtattr
= (struct rtattr
*)(((char *)rtattr
) +
2707 RTA_ALIGN(rtattr
->rta_len
));
2712 static abi_long
target_to_host_data_link_rtattr(struct rtattr
*rtattr
)
2714 switch (rtattr
->rta_type
) {
2716 gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr
->rta_type
);
2722 static abi_long
target_to_host_data_addr_rtattr(struct rtattr
*rtattr
)
2724 switch (rtattr
->rta_type
) {
2725 /* binary: depends on family type */
2730 gemu_log("Unknown target IFA type: %d\n", rtattr
->rta_type
);
2736 static abi_long
target_to_host_data_route_rtattr(struct rtattr
*rtattr
)
2739 switch (rtattr
->rta_type
) {
2740 /* binary: depends on family type */
2748 u32
= RTA_DATA(rtattr
);
2749 *u32
= tswap32(*u32
);
2752 gemu_log("Unknown target RTA type: %d\n", rtattr
->rta_type
);
2758 static void target_to_host_link_rtattr(struct rtattr
*rtattr
,
2759 uint32_t rtattr_len
)
2761 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2762 target_to_host_data_link_rtattr
);
2765 static void target_to_host_addr_rtattr(struct rtattr
*rtattr
,
2766 uint32_t rtattr_len
)
2768 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2769 target_to_host_data_addr_rtattr
);
2772 static void target_to_host_route_rtattr(struct rtattr
*rtattr
,
2773 uint32_t rtattr_len
)
2775 target_to_host_for_each_rtattr(rtattr
, rtattr_len
,
2776 target_to_host_data_route_rtattr
);
2779 static abi_long
target_to_host_data_route(struct nlmsghdr
*nlh
)
2781 struct ifinfomsg
*ifi
;
2782 struct ifaddrmsg
*ifa
;
2785 switch (nlh
->nlmsg_type
) {
2790 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifi
))) {
2791 ifi
= NLMSG_DATA(nlh
);
2792 ifi
->ifi_type
= tswap16(ifi
->ifi_type
);
2793 ifi
->ifi_index
= tswap32(ifi
->ifi_index
);
2794 ifi
->ifi_flags
= tswap32(ifi
->ifi_flags
);
2795 ifi
->ifi_change
= tswap32(ifi
->ifi_change
);
2796 target_to_host_link_rtattr(IFLA_RTA(ifi
), nlh
->nlmsg_len
-
2797 NLMSG_LENGTH(sizeof(*ifi
)));
2803 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*ifa
))) {
2804 ifa
= NLMSG_DATA(nlh
);
2805 ifa
->ifa_index
= tswap32(ifa
->ifa_index
);
2806 target_to_host_addr_rtattr(IFA_RTA(ifa
), nlh
->nlmsg_len
-
2807 NLMSG_LENGTH(sizeof(*ifa
)));
2814 if (nlh
->nlmsg_len
>= NLMSG_LENGTH(sizeof(*rtm
))) {
2815 rtm
= NLMSG_DATA(nlh
);
2816 rtm
->rtm_flags
= tswap32(rtm
->rtm_flags
);
2817 target_to_host_route_rtattr(RTM_RTA(rtm
), nlh
->nlmsg_len
-
2818 NLMSG_LENGTH(sizeof(*rtm
)));
2822 return -TARGET_EOPNOTSUPP
;
2827 static abi_long
target_to_host_nlmsg_route(struct nlmsghdr
*nlh
, size_t len
)
2829 return target_to_host_for_each_nlmsg(nlh
, len
, target_to_host_data_route
);
2831 #endif /* CONFIG_RTNETLINK */
2833 static abi_long
host_to_target_data_audit(struct nlmsghdr
*nlh
)
2835 switch (nlh
->nlmsg_type
) {
2837 gemu_log("Unknown host audit message type %d\n",
2839 return -TARGET_EINVAL
;
2844 static inline abi_long
host_to_target_nlmsg_audit(struct nlmsghdr
*nlh
,
2847 return host_to_target_for_each_nlmsg(nlh
, len
, host_to_target_data_audit
);
2850 static abi_long
target_to_host_data_audit(struct nlmsghdr
*nlh
)
2852 switch (nlh
->nlmsg_type
) {
2854 case AUDIT_FIRST_USER_MSG
... AUDIT_LAST_USER_MSG
:
2855 case AUDIT_FIRST_USER_MSG2
... AUDIT_LAST_USER_MSG2
:
2858 gemu_log("Unknown target audit message type %d\n",
2860 return -TARGET_EINVAL
;
2866 static abi_long
target_to_host_nlmsg_audit(struct nlmsghdr
*nlh
, size_t len
)
2868 return target_to_host_for_each_nlmsg(nlh
, len
, target_to_host_data_audit
);
2871 /* do_setsockopt() Must return target values and target errnos. */
2872 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
2873 abi_ulong optval_addr
, socklen_t optlen
)
2877 struct ip_mreqn
*ip_mreq
;
2878 struct ip_mreq_source
*ip_mreq_source
;
2882 /* TCP options all take an 'int' value. */
2883 if (optlen
< sizeof(uint32_t))
2884 return -TARGET_EINVAL
;
2886 if (get_user_u32(val
, optval_addr
))
2887 return -TARGET_EFAULT
;
2888 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2895 case IP_ROUTER_ALERT
:
2899 case IP_MTU_DISCOVER
:
2906 case IP_MULTICAST_TTL
:
2907 case IP_MULTICAST_LOOP
:
2909 if (optlen
>= sizeof(uint32_t)) {
2910 if (get_user_u32(val
, optval_addr
))
2911 return -TARGET_EFAULT
;
2912 } else if (optlen
>= 1) {
2913 if (get_user_u8(val
, optval_addr
))
2914 return -TARGET_EFAULT
;
2916 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
2918 case IP_ADD_MEMBERSHIP
:
2919 case IP_DROP_MEMBERSHIP
:
2920 if (optlen
< sizeof (struct target_ip_mreq
) ||
2921 optlen
> sizeof (struct target_ip_mreqn
))
2922 return -TARGET_EINVAL
;
2924 ip_mreq
= (struct ip_mreqn
*) alloca(optlen
);
2925 target_to_host_ip_mreq(ip_mreq
, optval_addr
, optlen
);
2926 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq
, optlen
));
2929 case IP_BLOCK_SOURCE
:
2930 case IP_UNBLOCK_SOURCE
:
2931 case IP_ADD_SOURCE_MEMBERSHIP
:
2932 case IP_DROP_SOURCE_MEMBERSHIP
:
2933 if (optlen
!= sizeof (struct target_ip_mreq_source
))
2934 return -TARGET_EINVAL
;
2936 ip_mreq_source
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
2937 ret
= get_errno(setsockopt(sockfd
, level
, optname
, ip_mreq_source
, optlen
));
2938 unlock_user (ip_mreq_source
, optval_addr
, 0);
2947 case IPV6_MTU_DISCOVER
:
2950 case IPV6_RECVPKTINFO
:
2951 case IPV6_UNICAST_HOPS
:
2953 case IPV6_RECVHOPLIMIT
:
2954 case IPV6_2292HOPLIMIT
:
2957 if (optlen
< sizeof(uint32_t)) {
2958 return -TARGET_EINVAL
;
2960 if (get_user_u32(val
, optval_addr
)) {
2961 return -TARGET_EFAULT
;
2963 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2964 &val
, sizeof(val
)));
2968 struct in6_pktinfo pki
;
2970 if (optlen
< sizeof(pki
)) {
2971 return -TARGET_EINVAL
;
2974 if (copy_from_user(&pki
, optval_addr
, sizeof(pki
))) {
2975 return -TARGET_EFAULT
;
2978 pki
.ipi6_ifindex
= tswap32(pki
.ipi6_ifindex
);
2980 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
2981 &pki
, sizeof(pki
)));
2992 struct icmp6_filter icmp6f
;
2994 if (optlen
> sizeof(icmp6f
)) {
2995 optlen
= sizeof(icmp6f
);
2998 if (copy_from_user(&icmp6f
, optval_addr
, optlen
)) {
2999 return -TARGET_EFAULT
;
3002 for (val
= 0; val
< 8; val
++) {
3003 icmp6f
.data
[val
] = tswap32(icmp6f
.data
[val
]);
3006 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3018 /* those take an u32 value */
3019 if (optlen
< sizeof(uint32_t)) {
3020 return -TARGET_EINVAL
;
3023 if (get_user_u32(val
, optval_addr
)) {
3024 return -TARGET_EFAULT
;
3026 ret
= get_errno(setsockopt(sockfd
, level
, optname
,
3027 &val
, sizeof(val
)));
3034 case TARGET_SOL_SOCKET
:
3036 case TARGET_SO_RCVTIMEO
:
3040 optname
= SO_RCVTIMEO
;
3043 if (optlen
!= sizeof(struct target_timeval
)) {
3044 return -TARGET_EINVAL
;
3047 if (copy_from_user_timeval(&tv
, optval_addr
)) {
3048 return -TARGET_EFAULT
;
3051 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
3055 case TARGET_SO_SNDTIMEO
:
3056 optname
= SO_SNDTIMEO
;
3058 case TARGET_SO_ATTACH_FILTER
:
3060 struct target_sock_fprog
*tfprog
;
3061 struct target_sock_filter
*tfilter
;
3062 struct sock_fprog fprog
;
3063 struct sock_filter
*filter
;
3066 if (optlen
!= sizeof(*tfprog
)) {
3067 return -TARGET_EINVAL
;
3069 if (!lock_user_struct(VERIFY_READ
, tfprog
, optval_addr
, 0)) {
3070 return -TARGET_EFAULT
;
3072 if (!lock_user_struct(VERIFY_READ
, tfilter
,
3073 tswapal(tfprog
->filter
), 0)) {
3074 unlock_user_struct(tfprog
, optval_addr
, 1);
3075 return -TARGET_EFAULT
;
3078 fprog
.len
= tswap16(tfprog
->len
);
3079 filter
= g_try_new(struct sock_filter
, fprog
.len
);
3080 if (filter
== NULL
) {
3081 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
3082 unlock_user_struct(tfprog
, optval_addr
, 1);
3083 return -TARGET_ENOMEM
;
3085 for (i
= 0; i
< fprog
.len
; i
++) {
3086 filter
[i
].code
= tswap16(tfilter
[i
].code
);
3087 filter
[i
].jt
= tfilter
[i
].jt
;
3088 filter
[i
].jf
= tfilter
[i
].jf
;
3089 filter
[i
].k
= tswap32(tfilter
[i
].k
);
3091 fprog
.filter
= filter
;
3093 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
,
3094 SO_ATTACH_FILTER
, &fprog
, sizeof(fprog
)));
3097 unlock_user_struct(tfilter
, tfprog
->filter
, 1);
3098 unlock_user_struct(tfprog
, optval_addr
, 1);
3101 case TARGET_SO_BINDTODEVICE
:
3103 char *dev_ifname
, *addr_ifname
;
3105 if (optlen
> IFNAMSIZ
- 1) {
3106 optlen
= IFNAMSIZ
- 1;
3108 dev_ifname
= lock_user(VERIFY_READ
, optval_addr
, optlen
, 1);
3110 return -TARGET_EFAULT
;
3112 optname
= SO_BINDTODEVICE
;
3113 addr_ifname
= alloca(IFNAMSIZ
);
3114 memcpy(addr_ifname
, dev_ifname
, optlen
);
3115 addr_ifname
[optlen
] = 0;
3116 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
,
3117 addr_ifname
, optlen
));
3118 unlock_user (dev_ifname
, optval_addr
, 0);
3121 /* Options with 'int' argument. */
3122 case TARGET_SO_DEBUG
:
3125 case TARGET_SO_REUSEADDR
:
3126 optname
= SO_REUSEADDR
;
3128 case TARGET_SO_TYPE
:
3131 case TARGET_SO_ERROR
:
3134 case TARGET_SO_DONTROUTE
:
3135 optname
= SO_DONTROUTE
;
3137 case TARGET_SO_BROADCAST
:
3138 optname
= SO_BROADCAST
;
3140 case TARGET_SO_SNDBUF
:
3141 optname
= SO_SNDBUF
;
3143 case TARGET_SO_SNDBUFFORCE
:
3144 optname
= SO_SNDBUFFORCE
;
3146 case TARGET_SO_RCVBUF
:
3147 optname
= SO_RCVBUF
;
3149 case TARGET_SO_RCVBUFFORCE
:
3150 optname
= SO_RCVBUFFORCE
;
3152 case TARGET_SO_KEEPALIVE
:
3153 optname
= SO_KEEPALIVE
;
3155 case TARGET_SO_OOBINLINE
:
3156 optname
= SO_OOBINLINE
;
3158 case TARGET_SO_NO_CHECK
:
3159 optname
= SO_NO_CHECK
;
3161 case TARGET_SO_PRIORITY
:
3162 optname
= SO_PRIORITY
;
3165 case TARGET_SO_BSDCOMPAT
:
3166 optname
= SO_BSDCOMPAT
;
3169 case TARGET_SO_PASSCRED
:
3170 optname
= SO_PASSCRED
;
3172 case TARGET_SO_PASSSEC
:
3173 optname
= SO_PASSSEC
;
3175 case TARGET_SO_TIMESTAMP
:
3176 optname
= SO_TIMESTAMP
;
3178 case TARGET_SO_RCVLOWAT
:
3179 optname
= SO_RCVLOWAT
;
3184 if (optlen
< sizeof(uint32_t))
3185 return -TARGET_EINVAL
;
3187 if (get_user_u32(val
, optval_addr
))
3188 return -TARGET_EFAULT
;
3189 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
3193 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level
, optname
);
3194 ret
= -TARGET_ENOPROTOOPT
;
3199 /* do_getsockopt() Must return target values and target errnos. */
3200 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
3201 abi_ulong optval_addr
, abi_ulong optlen
)
3208 case TARGET_SOL_SOCKET
:
3211 /* These don't just return a single integer */
3212 case TARGET_SO_LINGER
:
3213 case TARGET_SO_RCVTIMEO
:
3214 case TARGET_SO_SNDTIMEO
:
3215 case TARGET_SO_PEERNAME
:
3217 case TARGET_SO_PEERCRED
: {
3220 struct target_ucred
*tcr
;
3222 if (get_user_u32(len
, optlen
)) {
3223 return -TARGET_EFAULT
;
3226 return -TARGET_EINVAL
;
3230 ret
= get_errno(getsockopt(sockfd
, level
, SO_PEERCRED
,
3238 if (!lock_user_struct(VERIFY_WRITE
, tcr
, optval_addr
, 0)) {
3239 return -TARGET_EFAULT
;
3241 __put_user(cr
.pid
, &tcr
->pid
);
3242 __put_user(cr
.uid
, &tcr
->uid
);
3243 __put_user(cr
.gid
, &tcr
->gid
);
3244 unlock_user_struct(tcr
, optval_addr
, 1);
3245 if (put_user_u32(len
, optlen
)) {
3246 return -TARGET_EFAULT
;
3250 /* Options with 'int' argument. */
3251 case TARGET_SO_DEBUG
:
3254 case TARGET_SO_REUSEADDR
:
3255 optname
= SO_REUSEADDR
;
3257 case TARGET_SO_TYPE
:
3260 case TARGET_SO_ERROR
:
3263 case TARGET_SO_DONTROUTE
:
3264 optname
= SO_DONTROUTE
;
3266 case TARGET_SO_BROADCAST
:
3267 optname
= SO_BROADCAST
;
3269 case TARGET_SO_SNDBUF
:
3270 optname
= SO_SNDBUF
;
3272 case TARGET_SO_RCVBUF
:
3273 optname
= SO_RCVBUF
;
3275 case TARGET_SO_KEEPALIVE
:
3276 optname
= SO_KEEPALIVE
;
3278 case TARGET_SO_OOBINLINE
:
3279 optname
= SO_OOBINLINE
;
3281 case TARGET_SO_NO_CHECK
:
3282 optname
= SO_NO_CHECK
;
3284 case TARGET_SO_PRIORITY
:
3285 optname
= SO_PRIORITY
;
3288 case TARGET_SO_BSDCOMPAT
:
3289 optname
= SO_BSDCOMPAT
;
3292 case TARGET_SO_PASSCRED
:
3293 optname
= SO_PASSCRED
;
3295 case TARGET_SO_TIMESTAMP
:
3296 optname
= SO_TIMESTAMP
;
3298 case TARGET_SO_RCVLOWAT
:
3299 optname
= SO_RCVLOWAT
;
3301 case TARGET_SO_ACCEPTCONN
:
3302 optname
= SO_ACCEPTCONN
;
3309 /* TCP options all take an 'int' value. */
3311 if (get_user_u32(len
, optlen
))
3312 return -TARGET_EFAULT
;
3314 return -TARGET_EINVAL
;
3316 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
3319 if (optname
== SO_TYPE
) {
3320 val
= host_to_target_sock_type(val
);
3325 if (put_user_u32(val
, optval_addr
))
3326 return -TARGET_EFAULT
;
3328 if (put_user_u8(val
, optval_addr
))
3329 return -TARGET_EFAULT
;
3331 if (put_user_u32(len
, optlen
))
3332 return -TARGET_EFAULT
;
3339 case IP_ROUTER_ALERT
:
3343 case IP_MTU_DISCOVER
:
3349 case IP_MULTICAST_TTL
:
3350 case IP_MULTICAST_LOOP
:
3351 if (get_user_u32(len
, optlen
))
3352 return -TARGET_EFAULT
;
3354 return -TARGET_EINVAL
;
3356 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
3359 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
3361 if (put_user_u32(len
, optlen
)
3362 || put_user_u8(val
, optval_addr
))
3363 return -TARGET_EFAULT
;
3365 if (len
> sizeof(int))
3367 if (put_user_u32(len
, optlen
)
3368 || put_user_u32(val
, optval_addr
))
3369 return -TARGET_EFAULT
;
3373 ret
= -TARGET_ENOPROTOOPT
;
3379 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
3381 ret
= -TARGET_EOPNOTSUPP
;
3387 static struct iovec
*lock_iovec(int type
, abi_ulong target_addr
,
3388 abi_ulong count
, int copy
)
3390 struct target_iovec
*target_vec
;
3392 abi_ulong total_len
, max_len
;
3395 bool bad_address
= false;
3401 if (count
> IOV_MAX
) {
3406 vec
= g_try_new0(struct iovec
, count
);
3412 target_vec
= lock_user(VERIFY_READ
, target_addr
,
3413 count
* sizeof(struct target_iovec
), 1);
3414 if (target_vec
== NULL
) {
3419 /* ??? If host page size > target page size, this will result in a
3420 value larger than what we can actually support. */
3421 max_len
= 0x7fffffff & TARGET_PAGE_MASK
;
3424 for (i
= 0; i
< count
; i
++) {
3425 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3426 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3431 } else if (len
== 0) {
3432 /* Zero length pointer is ignored. */
3433 vec
[i
].iov_base
= 0;
3435 vec
[i
].iov_base
= lock_user(type
, base
, len
, copy
);
3436 /* If the first buffer pointer is bad, this is a fault. But
3437 * subsequent bad buffers will result in a partial write; this
3438 * is realized by filling the vector with null pointers and
3440 if (!vec
[i
].iov_base
) {
3451 if (len
> max_len
- total_len
) {
3452 len
= max_len
- total_len
;
3455 vec
[i
].iov_len
= len
;
3459 unlock_user(target_vec
, target_addr
, 0);
3464 if (tswapal(target_vec
[i
].iov_len
) > 0) {
3465 unlock_user(vec
[i
].iov_base
, tswapal(target_vec
[i
].iov_base
), 0);
3468 unlock_user(target_vec
, target_addr
, 0);
3475 static void unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
3476 abi_ulong count
, int copy
)
3478 struct target_iovec
*target_vec
;
3481 target_vec
= lock_user(VERIFY_READ
, target_addr
,
3482 count
* sizeof(struct target_iovec
), 1);
3484 for (i
= 0; i
< count
; i
++) {
3485 abi_ulong base
= tswapal(target_vec
[i
].iov_base
);
3486 abi_long len
= tswapal(target_vec
[i
].iov_len
);
3490 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
3492 unlock_user(target_vec
, target_addr
, 0);
3498 static inline int target_to_host_sock_type(int *type
)
3501 int target_type
= *type
;
3503 switch (target_type
& TARGET_SOCK_TYPE_MASK
) {
3504 case TARGET_SOCK_DGRAM
:
3505 host_type
= SOCK_DGRAM
;
3507 case TARGET_SOCK_STREAM
:
3508 host_type
= SOCK_STREAM
;
3511 host_type
= target_type
& TARGET_SOCK_TYPE_MASK
;
3514 if (target_type
& TARGET_SOCK_CLOEXEC
) {
3515 #if defined(SOCK_CLOEXEC)
3516 host_type
|= SOCK_CLOEXEC
;
3518 return -TARGET_EINVAL
;
3521 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3522 #if defined(SOCK_NONBLOCK)
3523 host_type
|= SOCK_NONBLOCK
;
3524 #elif !defined(O_NONBLOCK)
3525 return -TARGET_EINVAL
;
3532 /* Try to emulate socket type flags after socket creation. */
3533 static int sock_flags_fixup(int fd
, int target_type
)
3535 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3536 if (target_type
& TARGET_SOCK_NONBLOCK
) {
3537 int flags
= fcntl(fd
, F_GETFL
);
3538 if (fcntl(fd
, F_SETFL
, O_NONBLOCK
| flags
) == -1) {
3540 return -TARGET_EINVAL
;
3547 static abi_long
packet_target_to_host_sockaddr(void *host_addr
,
3548 abi_ulong target_addr
,
3551 struct sockaddr
*addr
= host_addr
;
3552 struct target_sockaddr
*target_saddr
;
3554 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
3555 if (!target_saddr
) {
3556 return -TARGET_EFAULT
;
3559 memcpy(addr
, target_saddr
, len
);
3560 addr
->sa_family
= tswap16(target_saddr
->sa_family
);
3561 /* spkt_protocol is big-endian */
3563 unlock_user(target_saddr
, target_addr
, 0);
3567 static TargetFdTrans target_packet_trans
= {
3568 .target_to_host_addr
= packet_target_to_host_sockaddr
,
3571 #ifdef CONFIG_RTNETLINK
3572 static abi_long
netlink_route_target_to_host(void *buf
, size_t len
)
3576 ret
= target_to_host_nlmsg_route(buf
, len
);
3584 static abi_long
netlink_route_host_to_target(void *buf
, size_t len
)
3588 ret
= host_to_target_nlmsg_route(buf
, len
);
3596 static TargetFdTrans target_netlink_route_trans
= {
3597 .target_to_host_data
= netlink_route_target_to_host
,
3598 .host_to_target_data
= netlink_route_host_to_target
,
3600 #endif /* CONFIG_RTNETLINK */
3602 static abi_long
netlink_audit_target_to_host(void *buf
, size_t len
)
3606 ret
= target_to_host_nlmsg_audit(buf
, len
);
3614 static abi_long
netlink_audit_host_to_target(void *buf
, size_t len
)
3618 ret
= host_to_target_nlmsg_audit(buf
, len
);
3626 static TargetFdTrans target_netlink_audit_trans
= {
3627 .target_to_host_data
= netlink_audit_target_to_host
,
3628 .host_to_target_data
= netlink_audit_host_to_target
,
3631 /* do_socket() Must return target values and target errnos. */
3632 static abi_long
do_socket(int domain
, int type
, int protocol
)
3634 int target_type
= type
;
3637 ret
= target_to_host_sock_type(&type
);
3642 if (domain
== PF_NETLINK
&& !(
3643 #ifdef CONFIG_RTNETLINK
3644 protocol
== NETLINK_ROUTE
||
3646 protocol
== NETLINK_KOBJECT_UEVENT
||
3647 protocol
== NETLINK_AUDIT
)) {
3648 return -EPFNOSUPPORT
;
3651 if (domain
== AF_PACKET
||
3652 (domain
== AF_INET
&& type
== SOCK_PACKET
)) {
3653 protocol
= tswap16(protocol
);
3656 ret
= get_errno(socket(domain
, type
, protocol
));
3658 ret
= sock_flags_fixup(ret
, target_type
);
3659 if (type
== SOCK_PACKET
) {
3660 /* Manage an obsolete case :
3661 * if socket type is SOCK_PACKET, bind by name
3663 fd_trans_register(ret
, &target_packet_trans
);
3664 } else if (domain
== PF_NETLINK
) {
3666 #ifdef CONFIG_RTNETLINK
3668 fd_trans_register(ret
, &target_netlink_route_trans
);
3671 case NETLINK_KOBJECT_UEVENT
:
3672 /* nothing to do: messages are strings */
3675 fd_trans_register(ret
, &target_netlink_audit_trans
);
3678 g_assert_not_reached();
3685 /* do_bind() Must return target values and target errnos. */
3686 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
3692 if ((int)addrlen
< 0) {
3693 return -TARGET_EINVAL
;
3696 addr
= alloca(addrlen
+1);
3698 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3702 return get_errno(bind(sockfd
, addr
, addrlen
));
3705 /* do_connect() Must return target values and target errnos. */
3706 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
3712 if ((int)addrlen
< 0) {
3713 return -TARGET_EINVAL
;
3716 addr
= alloca(addrlen
+1);
3718 ret
= target_to_host_sockaddr(sockfd
, addr
, target_addr
, addrlen
);
3722 return get_errno(safe_connect(sockfd
, addr
, addrlen
));
3725 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
3726 static abi_long
do_sendrecvmsg_locked(int fd
, struct target_msghdr
*msgp
,
3727 int flags
, int send
)
3733 abi_ulong target_vec
;
3735 if (msgp
->msg_name
) {
3736 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
3737 msg
.msg_name
= alloca(msg
.msg_namelen
+1);
3738 ret
= target_to_host_sockaddr(fd
, msg
.msg_name
,
3739 tswapal(msgp
->msg_name
),
3741 if (ret
== -TARGET_EFAULT
) {
3742 /* For connected sockets msg_name and msg_namelen must
3743 * be ignored, so returning EFAULT immediately is wrong.
3744 * Instead, pass a bad msg_name to the host kernel, and
3745 * let it decide whether to return EFAULT or not.
3747 msg
.msg_name
= (void *)-1;
3752 msg
.msg_name
= NULL
;
3753 msg
.msg_namelen
= 0;
3755 msg
.msg_controllen
= 2 * tswapal(msgp
->msg_controllen
);
3756 msg
.msg_control
= alloca(msg
.msg_controllen
);
3757 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
3759 count
= tswapal(msgp
->msg_iovlen
);
3760 target_vec
= tswapal(msgp
->msg_iov
);
3762 if (count
> IOV_MAX
) {
3763 /* sendrcvmsg returns a different errno for this condition than
3764 * readv/writev, so we must catch it here before lock_iovec() does.
3766 ret
= -TARGET_EMSGSIZE
;
3770 vec
= lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
,
3771 target_vec
, count
, send
);
3773 ret
= -host_to_target_errno(errno
);
3776 msg
.msg_iovlen
= count
;
3780 if (fd_trans_target_to_host_data(fd
)) {
3783 host_msg
= g_malloc(msg
.msg_iov
->iov_len
);
3784 memcpy(host_msg
, msg
.msg_iov
->iov_base
, msg
.msg_iov
->iov_len
);
3785 ret
= fd_trans_target_to_host_data(fd
)(host_msg
,
3786 msg
.msg_iov
->iov_len
);
3788 msg
.msg_iov
->iov_base
= host_msg
;
3789 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3793 ret
= target_to_host_cmsg(&msg
, msgp
);
3795 ret
= get_errno(safe_sendmsg(fd
, &msg
, flags
));
3799 ret
= get_errno(safe_recvmsg(fd
, &msg
, flags
));
3800 if (!is_error(ret
)) {
3802 if (fd_trans_host_to_target_data(fd
)) {
3803 ret
= fd_trans_host_to_target_data(fd
)(msg
.msg_iov
->iov_base
,
3806 ret
= host_to_target_cmsg(msgp
, &msg
);
3808 if (!is_error(ret
)) {
3809 msgp
->msg_namelen
= tswap32(msg
.msg_namelen
);
3810 if (msg
.msg_name
!= NULL
&& msg
.msg_name
!= (void *)-1) {
3811 ret
= host_to_target_sockaddr(tswapal(msgp
->msg_name
),
3812 msg
.msg_name
, msg
.msg_namelen
);
3824 unlock_iovec(vec
, target_vec
, count
, !send
);
3829 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
3830 int flags
, int send
)
3833 struct target_msghdr
*msgp
;
3835 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
3839 return -TARGET_EFAULT
;
3841 ret
= do_sendrecvmsg_locked(fd
, msgp
, flags
, send
);
3842 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
3846 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
3847 * so it might not have this *mmsg-specific flag either.
3849 #ifndef MSG_WAITFORONE
3850 #define MSG_WAITFORONE 0x10000
3853 static abi_long
do_sendrecvmmsg(int fd
, abi_ulong target_msgvec
,
3854 unsigned int vlen
, unsigned int flags
,
3857 struct target_mmsghdr
*mmsgp
;
3861 if (vlen
> UIO_MAXIOV
) {
3865 mmsgp
= lock_user(VERIFY_WRITE
, target_msgvec
, sizeof(*mmsgp
) * vlen
, 1);
3867 return -TARGET_EFAULT
;
3870 for (i
= 0; i
< vlen
; i
++) {
3871 ret
= do_sendrecvmsg_locked(fd
, &mmsgp
[i
].msg_hdr
, flags
, send
);
3872 if (is_error(ret
)) {
3875 mmsgp
[i
].msg_len
= tswap32(ret
);
3876 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3877 if (flags
& MSG_WAITFORONE
) {
3878 flags
|= MSG_DONTWAIT
;
3882 unlock_user(mmsgp
, target_msgvec
, sizeof(*mmsgp
) * i
);
3884 /* Return number of datagrams sent if we sent any at all;
3885 * otherwise return the error.
3893 /* do_accept4() Must return target values and target errnos. */
3894 static abi_long
do_accept4(int fd
, abi_ulong target_addr
,
3895 abi_ulong target_addrlen_addr
, int flags
)
3902 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
3904 if (target_addr
== 0) {
3905 return get_errno(safe_accept4(fd
, NULL
, NULL
, host_flags
));
3908 /* linux returns EINVAL if addrlen pointer is invalid */
3909 if (get_user_u32(addrlen
, target_addrlen_addr
))
3910 return -TARGET_EINVAL
;
3912 if ((int)addrlen
< 0) {
3913 return -TARGET_EINVAL
;
3916 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3917 return -TARGET_EINVAL
;
3919 addr
= alloca(addrlen
);
3921 ret
= get_errno(safe_accept4(fd
, addr
, &addrlen
, host_flags
));
3922 if (!is_error(ret
)) {
3923 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
3924 if (put_user_u32(addrlen
, target_addrlen_addr
))
3925 ret
= -TARGET_EFAULT
;
3930 /* do_getpeername() Must return target values and target errnos. */
3931 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
3932 abi_ulong target_addrlen_addr
)
3938 if (get_user_u32(addrlen
, target_addrlen_addr
))
3939 return -TARGET_EFAULT
;
3941 if ((int)addrlen
< 0) {
3942 return -TARGET_EINVAL
;
3945 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3946 return -TARGET_EFAULT
;
3948 addr
= alloca(addrlen
);
3950 ret
= get_errno(getpeername(fd
, addr
, &addrlen
));
3951 if (!is_error(ret
)) {
3952 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
3953 if (put_user_u32(addrlen
, target_addrlen_addr
))
3954 ret
= -TARGET_EFAULT
;
3959 /* do_getsockname() Must return target values and target errnos. */
3960 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
3961 abi_ulong target_addrlen_addr
)
3967 if (get_user_u32(addrlen
, target_addrlen_addr
))
3968 return -TARGET_EFAULT
;
3970 if ((int)addrlen
< 0) {
3971 return -TARGET_EINVAL
;
3974 if (!access_ok(VERIFY_WRITE
, target_addr
, addrlen
))
3975 return -TARGET_EFAULT
;
3977 addr
= alloca(addrlen
);
3979 ret
= get_errno(getsockname(fd
, addr
, &addrlen
));
3980 if (!is_error(ret
)) {
3981 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
3982 if (put_user_u32(addrlen
, target_addrlen_addr
))
3983 ret
= -TARGET_EFAULT
;
3988 /* do_socketpair() Must return target values and target errnos. */
3989 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
3990 abi_ulong target_tab_addr
)
3995 target_to_host_sock_type(&type
);
3997 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
3998 if (!is_error(ret
)) {
3999 if (put_user_s32(tab
[0], target_tab_addr
)
4000 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
4001 ret
= -TARGET_EFAULT
;
4006 /* do_sendto() Must return target values and target errnos. */
4007 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
4008 abi_ulong target_addr
, socklen_t addrlen
)
4012 void *copy_msg
= NULL
;
4015 if ((int)addrlen
< 0) {
4016 return -TARGET_EINVAL
;
4019 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
4021 return -TARGET_EFAULT
;
4022 if (fd_trans_target_to_host_data(fd
)) {
4023 copy_msg
= host_msg
;
4024 host_msg
= g_malloc(len
);
4025 memcpy(host_msg
, copy_msg
, len
);
4026 ret
= fd_trans_target_to_host_data(fd
)(host_msg
, len
);
4032 addr
= alloca(addrlen
+1);
4033 ret
= target_to_host_sockaddr(fd
, addr
, target_addr
, addrlen
);
4037 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
4039 ret
= get_errno(safe_sendto(fd
, host_msg
, len
, flags
, NULL
, 0));
4044 host_msg
= copy_msg
;
4046 unlock_user(host_msg
, msg
, 0);
4050 /* do_recvfrom() Must return target values and target errnos. */
4051 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
4052 abi_ulong target_addr
,
4053 abi_ulong target_addrlen
)
4060 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
4062 return -TARGET_EFAULT
;
4064 if (get_user_u32(addrlen
, target_addrlen
)) {
4065 ret
= -TARGET_EFAULT
;
4068 if ((int)addrlen
< 0) {
4069 ret
= -TARGET_EINVAL
;
4072 addr
= alloca(addrlen
);
4073 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
,
4076 addr
= NULL
; /* To keep compiler quiet. */
4077 ret
= get_errno(safe_recvfrom(fd
, host_msg
, len
, flags
, NULL
, 0));
4079 if (!is_error(ret
)) {
4080 if (fd_trans_host_to_target_data(fd
)) {
4081 ret
= fd_trans_host_to_target_data(fd
)(host_msg
, ret
);
4084 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
4085 if (put_user_u32(addrlen
, target_addrlen
)) {
4086 ret
= -TARGET_EFAULT
;
4090 unlock_user(host_msg
, msg
, len
);
4093 unlock_user(host_msg
, msg
, 0);
4098 #ifdef TARGET_NR_socketcall
4099 /* do_socketcall() must return target values and target errnos. */
4100 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
4102 static const unsigned nargs
[] = { /* number of arguments per operation */
4103 [TARGET_SYS_SOCKET
] = 3, /* domain, type, protocol */
4104 [TARGET_SYS_BIND
] = 3, /* fd, addr, addrlen */
4105 [TARGET_SYS_CONNECT
] = 3, /* fd, addr, addrlen */
4106 [TARGET_SYS_LISTEN
] = 2, /* fd, backlog */
4107 [TARGET_SYS_ACCEPT
] = 3, /* fd, addr, addrlen */
4108 [TARGET_SYS_GETSOCKNAME
] = 3, /* fd, addr, addrlen */
4109 [TARGET_SYS_GETPEERNAME
] = 3, /* fd, addr, addrlen */
4110 [TARGET_SYS_SOCKETPAIR
] = 4, /* domain, type, protocol, tab */
4111 [TARGET_SYS_SEND
] = 4, /* fd, msg, len, flags */
4112 [TARGET_SYS_RECV
] = 4, /* fd, msg, len, flags */
4113 [TARGET_SYS_SENDTO
] = 6, /* fd, msg, len, flags, addr, addrlen */
4114 [TARGET_SYS_RECVFROM
] = 6, /* fd, msg, len, flags, addr, addrlen */
4115 [TARGET_SYS_SHUTDOWN
] = 2, /* fd, how */
4116 [TARGET_SYS_SETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
4117 [TARGET_SYS_GETSOCKOPT
] = 5, /* fd, level, optname, optval, optlen */
4118 [TARGET_SYS_SENDMSG
] = 3, /* fd, msg, flags */
4119 [TARGET_SYS_RECVMSG
] = 3, /* fd, msg, flags */
4120 [TARGET_SYS_ACCEPT4
] = 4, /* fd, addr, addrlen, flags */
4121 [TARGET_SYS_RECVMMSG
] = 4, /* fd, msgvec, vlen, flags */
4122 [TARGET_SYS_SENDMMSG
] = 4, /* fd, msgvec, vlen, flags */
4124 abi_long a
[6]; /* max 6 args */
4127 /* check the range of the first argument num */
4128 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
4129 if (num
< 1 || num
> TARGET_SYS_SENDMMSG
) {
4130 return -TARGET_EINVAL
;
4132 /* ensure we have space for args */
4133 if (nargs
[num
] > ARRAY_SIZE(a
)) {
4134 return -TARGET_EINVAL
;
4136 /* collect the arguments in a[] according to nargs[] */
4137 for (i
= 0; i
< nargs
[num
]; ++i
) {
4138 if (get_user_ual(a
[i
], vptr
+ i
* sizeof(abi_long
)) != 0) {
4139 return -TARGET_EFAULT
;
4142 /* now when we have the args, invoke the appropriate underlying function */
4144 case TARGET_SYS_SOCKET
: /* domain, type, protocol */
4145 return do_socket(a
[0], a
[1], a
[2]);
4146 case TARGET_SYS_BIND
: /* sockfd, addr, addrlen */
4147 return do_bind(a
[0], a
[1], a
[2]);
4148 case TARGET_SYS_CONNECT
: /* sockfd, addr, addrlen */
4149 return do_connect(a
[0], a
[1], a
[2]);
4150 case TARGET_SYS_LISTEN
: /* sockfd, backlog */
4151 return get_errno(listen(a
[0], a
[1]));
4152 case TARGET_SYS_ACCEPT
: /* sockfd, addr, addrlen */
4153 return do_accept4(a
[0], a
[1], a
[2], 0);
4154 case TARGET_SYS_GETSOCKNAME
: /* sockfd, addr, addrlen */
4155 return do_getsockname(a
[0], a
[1], a
[2]);
4156 case TARGET_SYS_GETPEERNAME
: /* sockfd, addr, addrlen */
4157 return do_getpeername(a
[0], a
[1], a
[2]);
4158 case TARGET_SYS_SOCKETPAIR
: /* domain, type, protocol, tab */
4159 return do_socketpair(a
[0], a
[1], a
[2], a
[3]);
4160 case TARGET_SYS_SEND
: /* sockfd, msg, len, flags */
4161 return do_sendto(a
[0], a
[1], a
[2], a
[3], 0, 0);
4162 case TARGET_SYS_RECV
: /* sockfd, msg, len, flags */
4163 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], 0, 0);
4164 case TARGET_SYS_SENDTO
: /* sockfd, msg, len, flags, addr, addrlen */
4165 return do_sendto(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
4166 case TARGET_SYS_RECVFROM
: /* sockfd, msg, len, flags, addr, addrlen */
4167 return do_recvfrom(a
[0], a
[1], a
[2], a
[3], a
[4], a
[5]);
4168 case TARGET_SYS_SHUTDOWN
: /* sockfd, how */
4169 return get_errno(shutdown(a
[0], a
[1]));
4170 case TARGET_SYS_SETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
4171 return do_setsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
4172 case TARGET_SYS_GETSOCKOPT
: /* sockfd, level, optname, optval, optlen */
4173 return do_getsockopt(a
[0], a
[1], a
[2], a
[3], a
[4]);
4174 case TARGET_SYS_SENDMSG
: /* sockfd, msg, flags */
4175 return do_sendrecvmsg(a
[0], a
[1], a
[2], 1);
4176 case TARGET_SYS_RECVMSG
: /* sockfd, msg, flags */
4177 return do_sendrecvmsg(a
[0], a
[1], a
[2], 0);
4178 case TARGET_SYS_ACCEPT4
: /* sockfd, addr, addrlen, flags */
4179 return do_accept4(a
[0], a
[1], a
[2], a
[3]);
4180 case TARGET_SYS_RECVMMSG
: /* sockfd, msgvec, vlen, flags */
4181 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 0);
4182 case TARGET_SYS_SENDMMSG
: /* sockfd, msgvec, vlen, flags */
4183 return do_sendrecvmmsg(a
[0], a
[1], a
[2], a
[3], 1);
4185 gemu_log("Unsupported socketcall: %d\n", num
);
4186 return -TARGET_EINVAL
;
4191 #define N_SHM_REGIONS 32
4193 static struct shm_region
{
4197 } shm_regions
[N_SHM_REGIONS
];
4199 #ifndef TARGET_SEMID64_DS
4200 /* asm-generic version of this struct */
4201 struct target_semid64_ds
4203 struct target_ipc_perm sem_perm
;
4204 abi_ulong sem_otime
;
4205 #if TARGET_ABI_BITS == 32
4206 abi_ulong __unused1
;
4208 abi_ulong sem_ctime
;
4209 #if TARGET_ABI_BITS == 32
4210 abi_ulong __unused2
;
4212 abi_ulong sem_nsems
;
4213 abi_ulong __unused3
;
4214 abi_ulong __unused4
;
4218 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
4219 abi_ulong target_addr
)
4221 struct target_ipc_perm
*target_ip
;
4222 struct target_semid64_ds
*target_sd
;
4224 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4225 return -TARGET_EFAULT
;
4226 target_ip
= &(target_sd
->sem_perm
);
4227 host_ip
->__key
= tswap32(target_ip
->__key
);
4228 host_ip
->uid
= tswap32(target_ip
->uid
);
4229 host_ip
->gid
= tswap32(target_ip
->gid
);
4230 host_ip
->cuid
= tswap32(target_ip
->cuid
);
4231 host_ip
->cgid
= tswap32(target_ip
->cgid
);
4232 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4233 host_ip
->mode
= tswap32(target_ip
->mode
);
4235 host_ip
->mode
= tswap16(target_ip
->mode
);
4237 #if defined(TARGET_PPC)
4238 host_ip
->__seq
= tswap32(target_ip
->__seq
);
4240 host_ip
->__seq
= tswap16(target_ip
->__seq
);
4242 unlock_user_struct(target_sd
, target_addr
, 0);
4246 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
4247 struct ipc_perm
*host_ip
)
4249 struct target_ipc_perm
*target_ip
;
4250 struct target_semid64_ds
*target_sd
;
4252 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4253 return -TARGET_EFAULT
;
4254 target_ip
= &(target_sd
->sem_perm
);
4255 target_ip
->__key
= tswap32(host_ip
->__key
);
4256 target_ip
->uid
= tswap32(host_ip
->uid
);
4257 target_ip
->gid
= tswap32(host_ip
->gid
);
4258 target_ip
->cuid
= tswap32(host_ip
->cuid
);
4259 target_ip
->cgid
= tswap32(host_ip
->cgid
);
4260 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
4261 target_ip
->mode
= tswap32(host_ip
->mode
);
4263 target_ip
->mode
= tswap16(host_ip
->mode
);
4265 #if defined(TARGET_PPC)
4266 target_ip
->__seq
= tswap32(host_ip
->__seq
);
4268 target_ip
->__seq
= tswap16(host_ip
->__seq
);
4270 unlock_user_struct(target_sd
, target_addr
, 1);
4274 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
4275 abi_ulong target_addr
)
4277 struct target_semid64_ds
*target_sd
;
4279 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4280 return -TARGET_EFAULT
;
4281 if (target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
))
4282 return -TARGET_EFAULT
;
4283 host_sd
->sem_nsems
= tswapal(target_sd
->sem_nsems
);
4284 host_sd
->sem_otime
= tswapal(target_sd
->sem_otime
);
4285 host_sd
->sem_ctime
= tswapal(target_sd
->sem_ctime
);
4286 unlock_user_struct(target_sd
, target_addr
, 0);
4290 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
4291 struct semid_ds
*host_sd
)
4293 struct target_semid64_ds
*target_sd
;
4295 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4296 return -TARGET_EFAULT
;
4297 if (host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
)))
4298 return -TARGET_EFAULT
;
4299 target_sd
->sem_nsems
= tswapal(host_sd
->sem_nsems
);
4300 target_sd
->sem_otime
= tswapal(host_sd
->sem_otime
);
4301 target_sd
->sem_ctime
= tswapal(host_sd
->sem_ctime
);
4302 unlock_user_struct(target_sd
, target_addr
, 1);
4306 struct target_seminfo
{
4319 static inline abi_long
host_to_target_seminfo(abi_ulong target_addr
,
4320 struct seminfo
*host_seminfo
)
4322 struct target_seminfo
*target_seminfo
;
4323 if (!lock_user_struct(VERIFY_WRITE
, target_seminfo
, target_addr
, 0))
4324 return -TARGET_EFAULT
;
4325 __put_user(host_seminfo
->semmap
, &target_seminfo
->semmap
);
4326 __put_user(host_seminfo
->semmni
, &target_seminfo
->semmni
);
4327 __put_user(host_seminfo
->semmns
, &target_seminfo
->semmns
);
4328 __put_user(host_seminfo
->semmnu
, &target_seminfo
->semmnu
);
4329 __put_user(host_seminfo
->semmsl
, &target_seminfo
->semmsl
);
4330 __put_user(host_seminfo
->semopm
, &target_seminfo
->semopm
);
4331 __put_user(host_seminfo
->semume
, &target_seminfo
->semume
);
4332 __put_user(host_seminfo
->semusz
, &target_seminfo
->semusz
);
4333 __put_user(host_seminfo
->semvmx
, &target_seminfo
->semvmx
);
4334 __put_user(host_seminfo
->semaem
, &target_seminfo
->semaem
);
4335 unlock_user_struct(target_seminfo
, target_addr
, 1);
4341 struct semid_ds
*buf
;
4342 unsigned short *array
;
4343 struct seminfo
*__buf
;
4346 union target_semun
{
4353 static inline abi_long
target_to_host_semarray(int semid
, unsigned short **host_array
,
4354 abi_ulong target_addr
)
4357 unsigned short *array
;
4359 struct semid_ds semid_ds
;
4362 semun
.buf
= &semid_ds
;
4364 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
4366 return get_errno(ret
);
4368 nsems
= semid_ds
.sem_nsems
;
4370 *host_array
= g_try_new(unsigned short, nsems
);
4372 return -TARGET_ENOMEM
;
4374 array
= lock_user(VERIFY_READ
, target_addr
,
4375 nsems
*sizeof(unsigned short), 1);
4377 g_free(*host_array
);
4378 return -TARGET_EFAULT
;
4381 for(i
=0; i
<nsems
; i
++) {
4382 __get_user((*host_array
)[i
], &array
[i
]);
4384 unlock_user(array
, target_addr
, 0);
4389 static inline abi_long
host_to_target_semarray(int semid
, abi_ulong target_addr
,
4390 unsigned short **host_array
)
4393 unsigned short *array
;
4395 struct semid_ds semid_ds
;
4398 semun
.buf
= &semid_ds
;
4400 ret
= semctl(semid
, 0, IPC_STAT
, semun
);
4402 return get_errno(ret
);
4404 nsems
= semid_ds
.sem_nsems
;
4406 array
= lock_user(VERIFY_WRITE
, target_addr
,
4407 nsems
*sizeof(unsigned short), 0);
4409 return -TARGET_EFAULT
;
4411 for(i
=0; i
<nsems
; i
++) {
4412 __put_user((*host_array
)[i
], &array
[i
]);
4414 g_free(*host_array
);
4415 unlock_user(array
, target_addr
, 1);
4420 static inline abi_long
do_semctl(int semid
, int semnum
, int cmd
,
4421 abi_ulong target_arg
)
4423 union target_semun target_su
= { .buf
= target_arg
};
4425 struct semid_ds dsarg
;
4426 unsigned short *array
= NULL
;
4427 struct seminfo seminfo
;
4428 abi_long ret
= -TARGET_EINVAL
;
4435 /* In 64 bit cross-endian situations, we will erroneously pick up
4436 * the wrong half of the union for the "val" element. To rectify
4437 * this, the entire 8-byte structure is byteswapped, followed by
4438 * a swap of the 4 byte val field. In other cases, the data is
4439 * already in proper host byte order. */
4440 if (sizeof(target_su
.val
) != (sizeof(target_su
.buf
))) {
4441 target_su
.buf
= tswapal(target_su
.buf
);
4442 arg
.val
= tswap32(target_su
.val
);
4444 arg
.val
= target_su
.val
;
4446 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4450 err
= target_to_host_semarray(semid
, &array
, target_su
.array
);
4454 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4455 err
= host_to_target_semarray(semid
, target_su
.array
, &array
);
4462 err
= target_to_host_semid_ds(&dsarg
, target_su
.buf
);
4466 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4467 err
= host_to_target_semid_ds(target_su
.buf
, &dsarg
);
4473 arg
.__buf
= &seminfo
;
4474 ret
= get_errno(semctl(semid
, semnum
, cmd
, arg
));
4475 err
= host_to_target_seminfo(target_su
.__buf
, &seminfo
);
4483 ret
= get_errno(semctl(semid
, semnum
, cmd
, NULL
));
4490 struct target_sembuf
{
4491 unsigned short sem_num
;
4496 static inline abi_long
target_to_host_sembuf(struct sembuf
*host_sembuf
,
4497 abi_ulong target_addr
,
4500 struct target_sembuf
*target_sembuf
;
4503 target_sembuf
= lock_user(VERIFY_READ
, target_addr
,
4504 nsops
*sizeof(struct target_sembuf
), 1);
4506 return -TARGET_EFAULT
;
4508 for(i
=0; i
<nsops
; i
++) {
4509 __get_user(host_sembuf
[i
].sem_num
, &target_sembuf
[i
].sem_num
);
4510 __get_user(host_sembuf
[i
].sem_op
, &target_sembuf
[i
].sem_op
);
4511 __get_user(host_sembuf
[i
].sem_flg
, &target_sembuf
[i
].sem_flg
);
4514 unlock_user(target_sembuf
, target_addr
, 0);
4519 static inline abi_long
do_semop(int semid
, abi_long ptr
, unsigned nsops
)
4521 struct sembuf sops
[nsops
];
4523 if (target_to_host_sembuf(sops
, ptr
, nsops
))
4524 return -TARGET_EFAULT
;
4526 return get_errno(safe_semtimedop(semid
, sops
, nsops
, NULL
));
4529 struct target_msqid_ds
4531 struct target_ipc_perm msg_perm
;
4532 abi_ulong msg_stime
;
4533 #if TARGET_ABI_BITS == 32
4534 abi_ulong __unused1
;
4536 abi_ulong msg_rtime
;
4537 #if TARGET_ABI_BITS == 32
4538 abi_ulong __unused2
;
4540 abi_ulong msg_ctime
;
4541 #if TARGET_ABI_BITS == 32
4542 abi_ulong __unused3
;
4544 abi_ulong __msg_cbytes
;
4546 abi_ulong msg_qbytes
;
4547 abi_ulong msg_lspid
;
4548 abi_ulong msg_lrpid
;
4549 abi_ulong __unused4
;
4550 abi_ulong __unused5
;
4553 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
4554 abi_ulong target_addr
)
4556 struct target_msqid_ds
*target_md
;
4558 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
4559 return -TARGET_EFAULT
;
4560 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
4561 return -TARGET_EFAULT
;
4562 host_md
->msg_stime
= tswapal(target_md
->msg_stime
);
4563 host_md
->msg_rtime
= tswapal(target_md
->msg_rtime
);
4564 host_md
->msg_ctime
= tswapal(target_md
->msg_ctime
);
4565 host_md
->__msg_cbytes
= tswapal(target_md
->__msg_cbytes
);
4566 host_md
->msg_qnum
= tswapal(target_md
->msg_qnum
);
4567 host_md
->msg_qbytes
= tswapal(target_md
->msg_qbytes
);
4568 host_md
->msg_lspid
= tswapal(target_md
->msg_lspid
);
4569 host_md
->msg_lrpid
= tswapal(target_md
->msg_lrpid
);
4570 unlock_user_struct(target_md
, target_addr
, 0);
4574 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
4575 struct msqid_ds
*host_md
)
4577 struct target_msqid_ds
*target_md
;
4579 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
4580 return -TARGET_EFAULT
;
4581 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
4582 return -TARGET_EFAULT
;
4583 target_md
->msg_stime
= tswapal(host_md
->msg_stime
);
4584 target_md
->msg_rtime
= tswapal(host_md
->msg_rtime
);
4585 target_md
->msg_ctime
= tswapal(host_md
->msg_ctime
);
4586 target_md
->__msg_cbytes
= tswapal(host_md
->__msg_cbytes
);
4587 target_md
->msg_qnum
= tswapal(host_md
->msg_qnum
);
4588 target_md
->msg_qbytes
= tswapal(host_md
->msg_qbytes
);
4589 target_md
->msg_lspid
= tswapal(host_md
->msg_lspid
);
4590 target_md
->msg_lrpid
= tswapal(host_md
->msg_lrpid
);
4591 unlock_user_struct(target_md
, target_addr
, 1);
4595 struct target_msginfo
{
4603 unsigned short int msgseg
;
4606 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
4607 struct msginfo
*host_msginfo
)
4609 struct target_msginfo
*target_msginfo
;
4610 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
4611 return -TARGET_EFAULT
;
4612 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
4613 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
4614 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
4615 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
4616 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
4617 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
4618 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
4619 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
4620 unlock_user_struct(target_msginfo
, target_addr
, 1);
4624 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
4626 struct msqid_ds dsarg
;
4627 struct msginfo msginfo
;
4628 abi_long ret
= -TARGET_EINVAL
;
4636 if (target_to_host_msqid_ds(&dsarg
,ptr
))
4637 return -TARGET_EFAULT
;
4638 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
4639 if (host_to_target_msqid_ds(ptr
,&dsarg
))
4640 return -TARGET_EFAULT
;
4643 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
4647 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
4648 if (host_to_target_msginfo(ptr
, &msginfo
))
4649 return -TARGET_EFAULT
;
4656 struct target_msgbuf
{
4661 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
4662 ssize_t msgsz
, int msgflg
)
4664 struct target_msgbuf
*target_mb
;
4665 struct msgbuf
*host_mb
;
4669 return -TARGET_EINVAL
;
4672 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
4673 return -TARGET_EFAULT
;
4674 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4676 unlock_user_struct(target_mb
, msgp
, 0);
4677 return -TARGET_ENOMEM
;
4679 host_mb
->mtype
= (abi_long
) tswapal(target_mb
->mtype
);
4680 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
4681 ret
= get_errno(safe_msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
4683 unlock_user_struct(target_mb
, msgp
, 0);
4688 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
4689 ssize_t msgsz
, abi_long msgtyp
,
4692 struct target_msgbuf
*target_mb
;
4694 struct msgbuf
*host_mb
;
4698 return -TARGET_EINVAL
;
4701 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
4702 return -TARGET_EFAULT
;
4704 host_mb
= g_try_malloc(msgsz
+ sizeof(long));
4706 ret
= -TARGET_ENOMEM
;
4709 ret
= get_errno(safe_msgrcv(msqid
, host_mb
, msgsz
, msgtyp
, msgflg
));
4712 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
4713 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
4714 if (!target_mtext
) {
4715 ret
= -TARGET_EFAULT
;
4718 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
4719 unlock_user(target_mtext
, target_mtext_addr
, ret
);
4722 target_mb
->mtype
= tswapal(host_mb
->mtype
);
4726 unlock_user_struct(target_mb
, msgp
, 1);
4731 static inline abi_long
target_to_host_shmid_ds(struct shmid_ds
*host_sd
,
4732 abi_ulong target_addr
)
4734 struct target_shmid_ds
*target_sd
;
4736 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
4737 return -TARGET_EFAULT
;
4738 if (target_to_host_ipc_perm(&(host_sd
->shm_perm
), target_addr
))
4739 return -TARGET_EFAULT
;
4740 __get_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4741 __get_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4742 __get_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4743 __get_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4744 __get_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4745 __get_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4746 __get_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4747 unlock_user_struct(target_sd
, target_addr
, 0);
4751 static inline abi_long
host_to_target_shmid_ds(abi_ulong target_addr
,
4752 struct shmid_ds
*host_sd
)
4754 struct target_shmid_ds
*target_sd
;
4756 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
4757 return -TARGET_EFAULT
;
4758 if (host_to_target_ipc_perm(target_addr
, &(host_sd
->shm_perm
)))
4759 return -TARGET_EFAULT
;
4760 __put_user(host_sd
->shm_segsz
, &target_sd
->shm_segsz
);
4761 __put_user(host_sd
->shm_atime
, &target_sd
->shm_atime
);
4762 __put_user(host_sd
->shm_dtime
, &target_sd
->shm_dtime
);
4763 __put_user(host_sd
->shm_ctime
, &target_sd
->shm_ctime
);
4764 __put_user(host_sd
->shm_cpid
, &target_sd
->shm_cpid
);
4765 __put_user(host_sd
->shm_lpid
, &target_sd
->shm_lpid
);
4766 __put_user(host_sd
->shm_nattch
, &target_sd
->shm_nattch
);
4767 unlock_user_struct(target_sd
, target_addr
, 1);
4771 struct target_shminfo
{
4779 static inline abi_long
host_to_target_shminfo(abi_ulong target_addr
,
4780 struct shminfo
*host_shminfo
)
4782 struct target_shminfo
*target_shminfo
;
4783 if (!lock_user_struct(VERIFY_WRITE
, target_shminfo
, target_addr
, 0))
4784 return -TARGET_EFAULT
;
4785 __put_user(host_shminfo
->shmmax
, &target_shminfo
->shmmax
);
4786 __put_user(host_shminfo
->shmmin
, &target_shminfo
->shmmin
);
4787 __put_user(host_shminfo
->shmmni
, &target_shminfo
->shmmni
);
4788 __put_user(host_shminfo
->shmseg
, &target_shminfo
->shmseg
);
4789 __put_user(host_shminfo
->shmall
, &target_shminfo
->shmall
);
4790 unlock_user_struct(target_shminfo
, target_addr
, 1);
4794 struct target_shm_info
{
4799 abi_ulong swap_attempts
;
4800 abi_ulong swap_successes
;
4803 static inline abi_long
host_to_target_shm_info(abi_ulong target_addr
,
4804 struct shm_info
*host_shm_info
)
4806 struct target_shm_info
*target_shm_info
;
4807 if (!lock_user_struct(VERIFY_WRITE
, target_shm_info
, target_addr
, 0))
4808 return -TARGET_EFAULT
;
4809 __put_user(host_shm_info
->used_ids
, &target_shm_info
->used_ids
);
4810 __put_user(host_shm_info
->shm_tot
, &target_shm_info
->shm_tot
);
4811 __put_user(host_shm_info
->shm_rss
, &target_shm_info
->shm_rss
);
4812 __put_user(host_shm_info
->shm_swp
, &target_shm_info
->shm_swp
);
4813 __put_user(host_shm_info
->swap_attempts
, &target_shm_info
->swap_attempts
);
4814 __put_user(host_shm_info
->swap_successes
, &target_shm_info
->swap_successes
);
4815 unlock_user_struct(target_shm_info
, target_addr
, 1);
4819 static inline abi_long
do_shmctl(int shmid
, int cmd
, abi_long buf
)
4821 struct shmid_ds dsarg
;
4822 struct shminfo shminfo
;
4823 struct shm_info shm_info
;
4824 abi_long ret
= -TARGET_EINVAL
;
4832 if (target_to_host_shmid_ds(&dsarg
, buf
))
4833 return -TARGET_EFAULT
;
4834 ret
= get_errno(shmctl(shmid
, cmd
, &dsarg
));
4835 if (host_to_target_shmid_ds(buf
, &dsarg
))
4836 return -TARGET_EFAULT
;
4839 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shminfo
));
4840 if (host_to_target_shminfo(buf
, &shminfo
))
4841 return -TARGET_EFAULT
;
4844 ret
= get_errno(shmctl(shmid
, cmd
, (struct shmid_ds
*)&shm_info
));
4845 if (host_to_target_shm_info(buf
, &shm_info
))
4846 return -TARGET_EFAULT
;
4851 ret
= get_errno(shmctl(shmid
, cmd
, NULL
));
4858 #ifndef TARGET_FORCE_SHMLBA
4859 /* For most architectures, SHMLBA is the same as the page size;
4860 * some architectures have larger values, in which case they should
4861 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
4862 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
4863 * and defining its own value for SHMLBA.
4865 * The kernel also permits SHMLBA to be set by the architecture to a
4866 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
4867 * this means that addresses are rounded to the large size if
4868 * SHM_RND is set but addresses not aligned to that size are not rejected
4869 * as long as they are at least page-aligned. Since the only architecture
4870 * which uses this is ia64 this code doesn't provide for that oddity.
4872 static inline abi_ulong
target_shmlba(CPUArchState
*cpu_env
)
4874 return TARGET_PAGE_SIZE
;
4878 static inline abi_ulong
do_shmat(CPUArchState
*cpu_env
,
4879 int shmid
, abi_ulong shmaddr
, int shmflg
)
4883 struct shmid_ds shm_info
;
4887 /* find out the length of the shared memory segment */
4888 ret
= get_errno(shmctl(shmid
, IPC_STAT
, &shm_info
));
4889 if (is_error(ret
)) {
4890 /* can't get length, bail out */
4894 shmlba
= target_shmlba(cpu_env
);
4896 if (shmaddr
& (shmlba
- 1)) {
4897 if (shmflg
& SHM_RND
) {
4898 shmaddr
&= ~(shmlba
- 1);
4900 return -TARGET_EINVAL
;
4907 host_raddr
= shmat(shmid
, (void *)g2h(shmaddr
), shmflg
);
4909 abi_ulong mmap_start
;
4911 mmap_start
= mmap_find_vma(0, shm_info
.shm_segsz
);
4913 if (mmap_start
== -1) {
4915 host_raddr
= (void *)-1;
4917 host_raddr
= shmat(shmid
, g2h(mmap_start
), shmflg
| SHM_REMAP
);
4920 if (host_raddr
== (void *)-1) {
4922 return get_errno((long)host_raddr
);
4924 raddr
=h2g((unsigned long)host_raddr
);
4926 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
4927 PAGE_VALID
| PAGE_READ
|
4928 ((shmflg
& SHM_RDONLY
)? 0 : PAGE_WRITE
));
4930 for (i
= 0; i
< N_SHM_REGIONS
; i
++) {
4931 if (!shm_regions
[i
].in_use
) {
4932 shm_regions
[i
].in_use
= true;
4933 shm_regions
[i
].start
= raddr
;
4934 shm_regions
[i
].size
= shm_info
.shm_segsz
;
4944 static inline abi_long
do_shmdt(abi_ulong shmaddr
)
4948 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
4949 if (shm_regions
[i
].in_use
&& shm_regions
[i
].start
== shmaddr
) {
4950 shm_regions
[i
].in_use
= false;
4951 page_set_flags(shmaddr
, shmaddr
+ shm_regions
[i
].size
, 0);
4956 return get_errno(shmdt(g2h(shmaddr
)));
4959 #ifdef TARGET_NR_ipc
4960 /* ??? This only works with linear mappings. */
4961 /* do_ipc() must return target values and target errnos. */
4962 static abi_long
do_ipc(CPUArchState
*cpu_env
,
4963 unsigned int call
, abi_long first
,
4964 abi_long second
, abi_long third
,
4965 abi_long ptr
, abi_long fifth
)
4970 version
= call
>> 16;
4975 ret
= do_semop(first
, ptr
, second
);
4979 ret
= get_errno(semget(first
, second
, third
));
4982 case IPCOP_semctl
: {
4983 /* The semun argument to semctl is passed by value, so dereference the
4986 get_user_ual(atptr
, ptr
);
4987 ret
= do_semctl(first
, second
, third
, atptr
);
4992 ret
= get_errno(msgget(first
, second
));
4996 ret
= do_msgsnd(first
, ptr
, second
, third
);
5000 ret
= do_msgctl(first
, second
, ptr
);
5007 struct target_ipc_kludge
{
5012 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
5013 ret
= -TARGET_EFAULT
;
5017 ret
= do_msgrcv(first
, tswapal(tmp
->msgp
), second
, tswapal(tmp
->msgtyp
), third
);
5019 unlock_user_struct(tmp
, ptr
, 0);
5023 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
5032 raddr
= do_shmat(cpu_env
, first
, ptr
, second
);
5033 if (is_error(raddr
))
5034 return get_errno(raddr
);
5035 if (put_user_ual(raddr
, third
))
5036 return -TARGET_EFAULT
;
5040 ret
= -TARGET_EINVAL
;
5045 ret
= do_shmdt(ptr
);
5049 /* IPC_* flag values are the same on all linux platforms */
5050 ret
= get_errno(shmget(first
, second
, third
));
5053 /* IPC_* and SHM_* command values are the same on all linux platforms */
5055 ret
= do_shmctl(first
, second
, ptr
);
5058 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
5059 ret
= -TARGET_ENOSYS
;
5066 /* kernel structure types definitions */
5068 #define STRUCT(name, ...) STRUCT_ ## name,
5069 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
5071 #include "syscall_types.h"
5075 #undef STRUCT_SPECIAL
5077 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
5078 #define STRUCT_SPECIAL(name)
5079 #include "syscall_types.h"
5081 #undef STRUCT_SPECIAL
5083 typedef struct IOCTLEntry IOCTLEntry
;
5085 typedef abi_long
do_ioctl_fn(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5086 int fd
, int cmd
, abi_long arg
);
5090 unsigned int host_cmd
;
5093 do_ioctl_fn
*do_ioctl
;
5094 const argtype arg_type
[5];
5097 #define IOC_R 0x0001
5098 #define IOC_W 0x0002
5099 #define IOC_RW (IOC_R | IOC_W)
5101 #define MAX_STRUCT_SIZE 4096
5103 #ifdef CONFIG_FIEMAP
5104 /* So fiemap access checks don't overflow on 32 bit systems.
5105 * This is very slightly smaller than the limit imposed by
5106 * the underlying kernel.
5108 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
5109 / sizeof(struct fiemap_extent))
5111 static abi_long
do_ioctl_fs_ioc_fiemap(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5112 int fd
, int cmd
, abi_long arg
)
5114 /* The parameter for this ioctl is a struct fiemap followed
5115 * by an array of struct fiemap_extent whose size is set
5116 * in fiemap->fm_extent_count. The array is filled in by the
5119 int target_size_in
, target_size_out
;
5121 const argtype
*arg_type
= ie
->arg_type
;
5122 const argtype extent_arg_type
[] = { MK_STRUCT(STRUCT_fiemap_extent
) };
5125 int i
, extent_size
= thunk_type_size(extent_arg_type
, 0);
5129 assert(arg_type
[0] == TYPE_PTR
);
5130 assert(ie
->access
== IOC_RW
);
5132 target_size_in
= thunk_type_size(arg_type
, 0);
5133 argptr
= lock_user(VERIFY_READ
, arg
, target_size_in
, 1);
5135 return -TARGET_EFAULT
;
5137 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5138 unlock_user(argptr
, arg
, 0);
5139 fm
= (struct fiemap
*)buf_temp
;
5140 if (fm
->fm_extent_count
> FIEMAP_MAX_EXTENTS
) {
5141 return -TARGET_EINVAL
;
5144 outbufsz
= sizeof (*fm
) +
5145 (sizeof(struct fiemap_extent
) * fm
->fm_extent_count
);
5147 if (outbufsz
> MAX_STRUCT_SIZE
) {
5148 /* We can't fit all the extents into the fixed size buffer.
5149 * Allocate one that is large enough and use it instead.
5151 fm
= g_try_malloc(outbufsz
);
5153 return -TARGET_ENOMEM
;
5155 memcpy(fm
, buf_temp
, sizeof(struct fiemap
));
5158 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, fm
));
5159 if (!is_error(ret
)) {
5160 target_size_out
= target_size_in
;
5161 /* An extent_count of 0 means we were only counting the extents
5162 * so there are no structs to copy
5164 if (fm
->fm_extent_count
!= 0) {
5165 target_size_out
+= fm
->fm_mapped_extents
* extent_size
;
5167 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size_out
, 0);
5169 ret
= -TARGET_EFAULT
;
5171 /* Convert the struct fiemap */
5172 thunk_convert(argptr
, fm
, arg_type
, THUNK_TARGET
);
5173 if (fm
->fm_extent_count
!= 0) {
5174 p
= argptr
+ target_size_in
;
5175 /* ...and then all the struct fiemap_extents */
5176 for (i
= 0; i
< fm
->fm_mapped_extents
; i
++) {
5177 thunk_convert(p
, &fm
->fm_extents
[i
], extent_arg_type
,
5182 unlock_user(argptr
, arg
, target_size_out
);
5192 static abi_long
do_ioctl_ifconf(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5193 int fd
, int cmd
, abi_long arg
)
5195 const argtype
*arg_type
= ie
->arg_type
;
5199 struct ifconf
*host_ifconf
;
5201 const argtype ifreq_arg_type
[] = { MK_STRUCT(STRUCT_sockaddr_ifreq
) };
5202 int target_ifreq_size
;
5207 abi_long target_ifc_buf
;
5211 assert(arg_type
[0] == TYPE_PTR
);
5212 assert(ie
->access
== IOC_RW
);
5215 target_size
= thunk_type_size(arg_type
, 0);
5217 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5219 return -TARGET_EFAULT
;
5220 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5221 unlock_user(argptr
, arg
, 0);
5223 host_ifconf
= (struct ifconf
*)(unsigned long)buf_temp
;
5224 target_ifc_len
= host_ifconf
->ifc_len
;
5225 target_ifc_buf
= (abi_long
)(unsigned long)host_ifconf
->ifc_buf
;
5227 target_ifreq_size
= thunk_type_size(ifreq_arg_type
, 0);
5228 nb_ifreq
= target_ifc_len
/ target_ifreq_size
;
5229 host_ifc_len
= nb_ifreq
* sizeof(struct ifreq
);
5231 outbufsz
= sizeof(*host_ifconf
) + host_ifc_len
;
5232 if (outbufsz
> MAX_STRUCT_SIZE
) {
5233 /* We can't fit all the extents into the fixed size buffer.
5234 * Allocate one that is large enough and use it instead.
5236 host_ifconf
= malloc(outbufsz
);
5238 return -TARGET_ENOMEM
;
5240 memcpy(host_ifconf
, buf_temp
, sizeof(*host_ifconf
));
5243 host_ifc_buf
= (char*)host_ifconf
+ sizeof(*host_ifconf
);
5245 host_ifconf
->ifc_len
= host_ifc_len
;
5246 host_ifconf
->ifc_buf
= host_ifc_buf
;
5248 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_ifconf
));
5249 if (!is_error(ret
)) {
5250 /* convert host ifc_len to target ifc_len */
5252 nb_ifreq
= host_ifconf
->ifc_len
/ sizeof(struct ifreq
);
5253 target_ifc_len
= nb_ifreq
* target_ifreq_size
;
5254 host_ifconf
->ifc_len
= target_ifc_len
;
5256 /* restore target ifc_buf */
5258 host_ifconf
->ifc_buf
= (char *)(unsigned long)target_ifc_buf
;
5260 /* copy struct ifconf to target user */
5262 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5264 return -TARGET_EFAULT
;
5265 thunk_convert(argptr
, host_ifconf
, arg_type
, THUNK_TARGET
);
5266 unlock_user(argptr
, arg
, target_size
);
5268 /* copy ifreq[] to target user */
5270 argptr
= lock_user(VERIFY_WRITE
, target_ifc_buf
, target_ifc_len
, 0);
5271 for (i
= 0; i
< nb_ifreq
; i
++) {
5272 thunk_convert(argptr
+ i
* target_ifreq_size
,
5273 host_ifc_buf
+ i
* sizeof(struct ifreq
),
5274 ifreq_arg_type
, THUNK_TARGET
);
5276 unlock_user(argptr
, target_ifc_buf
, target_ifc_len
);
5286 static abi_long
do_ioctl_dm(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
5287 int cmd
, abi_long arg
)
5290 struct dm_ioctl
*host_dm
;
5291 abi_long guest_data
;
5292 uint32_t guest_data_size
;
5294 const argtype
*arg_type
= ie
->arg_type
;
5296 void *big_buf
= NULL
;
5300 target_size
= thunk_type_size(arg_type
, 0);
5301 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5303 ret
= -TARGET_EFAULT
;
5306 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5307 unlock_user(argptr
, arg
, 0);
5309 /* buf_temp is too small, so fetch things into a bigger buffer */
5310 big_buf
= g_malloc0(((struct dm_ioctl
*)buf_temp
)->data_size
* 2);
5311 memcpy(big_buf
, buf_temp
, target_size
);
5315 guest_data
= arg
+ host_dm
->data_start
;
5316 if ((guest_data
- arg
) < 0) {
5317 ret
= -TARGET_EINVAL
;
5320 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5321 host_data
= (char*)host_dm
+ host_dm
->data_start
;
5323 argptr
= lock_user(VERIFY_READ
, guest_data
, guest_data_size
, 1);
5325 ret
= -TARGET_EFAULT
;
5329 switch (ie
->host_cmd
) {
5331 case DM_LIST_DEVICES
:
5334 case DM_DEV_SUSPEND
:
5337 case DM_TABLE_STATUS
:
5338 case DM_TABLE_CLEAR
:
5340 case DM_LIST_VERSIONS
:
5344 case DM_DEV_SET_GEOMETRY
:
5345 /* data contains only strings */
5346 memcpy(host_data
, argptr
, guest_data_size
);
5349 memcpy(host_data
, argptr
, guest_data_size
);
5350 *(uint64_t*)host_data
= tswap64(*(uint64_t*)argptr
);
5354 void *gspec
= argptr
;
5355 void *cur_data
= host_data
;
5356 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5357 int spec_size
= thunk_type_size(arg_type
, 0);
5360 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5361 struct dm_target_spec
*spec
= cur_data
;
5365 thunk_convert(spec
, gspec
, arg_type
, THUNK_HOST
);
5366 slen
= strlen((char*)gspec
+ spec_size
) + 1;
5368 spec
->next
= sizeof(*spec
) + slen
;
5369 strcpy((char*)&spec
[1], gspec
+ spec_size
);
5371 cur_data
+= spec
->next
;
5376 ret
= -TARGET_EINVAL
;
5377 unlock_user(argptr
, guest_data
, 0);
5380 unlock_user(argptr
, guest_data
, 0);
5382 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5383 if (!is_error(ret
)) {
5384 guest_data
= arg
+ host_dm
->data_start
;
5385 guest_data_size
= host_dm
->data_size
- host_dm
->data_start
;
5386 argptr
= lock_user(VERIFY_WRITE
, guest_data
, guest_data_size
, 0);
5387 switch (ie
->host_cmd
) {
5392 case DM_DEV_SUSPEND
:
5395 case DM_TABLE_CLEAR
:
5397 case DM_DEV_SET_GEOMETRY
:
5398 /* no return data */
5400 case DM_LIST_DEVICES
:
5402 struct dm_name_list
*nl
= (void*)host_dm
+ host_dm
->data_start
;
5403 uint32_t remaining_data
= guest_data_size
;
5404 void *cur_data
= argptr
;
5405 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_name_list
) };
5406 int nl_size
= 12; /* can't use thunk_size due to alignment */
5409 uint32_t next
= nl
->next
;
5411 nl
->next
= nl_size
+ (strlen(nl
->name
) + 1);
5413 if (remaining_data
< nl
->next
) {
5414 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5417 thunk_convert(cur_data
, nl
, arg_type
, THUNK_TARGET
);
5418 strcpy(cur_data
+ nl_size
, nl
->name
);
5419 cur_data
+= nl
->next
;
5420 remaining_data
-= nl
->next
;
5424 nl
= (void*)nl
+ next
;
5429 case DM_TABLE_STATUS
:
5431 struct dm_target_spec
*spec
= (void*)host_dm
+ host_dm
->data_start
;
5432 void *cur_data
= argptr
;
5433 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_spec
) };
5434 int spec_size
= thunk_type_size(arg_type
, 0);
5437 for (i
= 0; i
< host_dm
->target_count
; i
++) {
5438 uint32_t next
= spec
->next
;
5439 int slen
= strlen((char*)&spec
[1]) + 1;
5440 spec
->next
= (cur_data
- argptr
) + spec_size
+ slen
;
5441 if (guest_data_size
< spec
->next
) {
5442 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5445 thunk_convert(cur_data
, spec
, arg_type
, THUNK_TARGET
);
5446 strcpy(cur_data
+ spec_size
, (char*)&spec
[1]);
5447 cur_data
= argptr
+ spec
->next
;
5448 spec
= (void*)host_dm
+ host_dm
->data_start
+ next
;
5454 void *hdata
= (void*)host_dm
+ host_dm
->data_start
;
5455 int count
= *(uint32_t*)hdata
;
5456 uint64_t *hdev
= hdata
+ 8;
5457 uint64_t *gdev
= argptr
+ 8;
5460 *(uint32_t*)argptr
= tswap32(count
);
5461 for (i
= 0; i
< count
; i
++) {
5462 *gdev
= tswap64(*hdev
);
5468 case DM_LIST_VERSIONS
:
5470 struct dm_target_versions
*vers
= (void*)host_dm
+ host_dm
->data_start
;
5471 uint32_t remaining_data
= guest_data_size
;
5472 void *cur_data
= argptr
;
5473 const argtype arg_type
[] = { MK_STRUCT(STRUCT_dm_target_versions
) };
5474 int vers_size
= thunk_type_size(arg_type
, 0);
5477 uint32_t next
= vers
->next
;
5479 vers
->next
= vers_size
+ (strlen(vers
->name
) + 1);
5481 if (remaining_data
< vers
->next
) {
5482 host_dm
->flags
|= DM_BUFFER_FULL_FLAG
;
5485 thunk_convert(cur_data
, vers
, arg_type
, THUNK_TARGET
);
5486 strcpy(cur_data
+ vers_size
, vers
->name
);
5487 cur_data
+= vers
->next
;
5488 remaining_data
-= vers
->next
;
5492 vers
= (void*)vers
+ next
;
5497 unlock_user(argptr
, guest_data
, 0);
5498 ret
= -TARGET_EINVAL
;
5501 unlock_user(argptr
, guest_data
, guest_data_size
);
5503 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5505 ret
= -TARGET_EFAULT
;
5508 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5509 unlock_user(argptr
, arg
, target_size
);
5516 static abi_long
do_ioctl_blkpg(const IOCTLEntry
*ie
, uint8_t *buf_temp
, int fd
,
5517 int cmd
, abi_long arg
)
5521 const argtype
*arg_type
= ie
->arg_type
;
5522 const argtype part_arg_type
[] = { MK_STRUCT(STRUCT_blkpg_partition
) };
5525 struct blkpg_ioctl_arg
*host_blkpg
= (void*)buf_temp
;
5526 struct blkpg_partition host_part
;
5528 /* Read and convert blkpg */
5530 target_size
= thunk_type_size(arg_type
, 0);
5531 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5533 ret
= -TARGET_EFAULT
;
5536 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5537 unlock_user(argptr
, arg
, 0);
5539 switch (host_blkpg
->op
) {
5540 case BLKPG_ADD_PARTITION
:
5541 case BLKPG_DEL_PARTITION
:
5542 /* payload is struct blkpg_partition */
5545 /* Unknown opcode */
5546 ret
= -TARGET_EINVAL
;
5550 /* Read and convert blkpg->data */
5551 arg
= (abi_long
)(uintptr_t)host_blkpg
->data
;
5552 target_size
= thunk_type_size(part_arg_type
, 0);
5553 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5555 ret
= -TARGET_EFAULT
;
5558 thunk_convert(&host_part
, argptr
, part_arg_type
, THUNK_HOST
);
5559 unlock_user(argptr
, arg
, 0);
5561 /* Swizzle the data pointer to our local copy and call! */
5562 host_blkpg
->data
= &host_part
;
5563 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, host_blkpg
));
5569 static abi_long
do_ioctl_rt(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5570 int fd
, int cmd
, abi_long arg
)
5572 const argtype
*arg_type
= ie
->arg_type
;
5573 const StructEntry
*se
;
5574 const argtype
*field_types
;
5575 const int *dst_offsets
, *src_offsets
;
5578 abi_ulong
*target_rt_dev_ptr
;
5579 unsigned long *host_rt_dev_ptr
;
5583 assert(ie
->access
== IOC_W
);
5584 assert(*arg_type
== TYPE_PTR
);
5586 assert(*arg_type
== TYPE_STRUCT
);
5587 target_size
= thunk_type_size(arg_type
, 0);
5588 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5590 return -TARGET_EFAULT
;
5593 assert(*arg_type
== (int)STRUCT_rtentry
);
5594 se
= struct_entries
+ *arg_type
++;
5595 assert(se
->convert
[0] == NULL
);
5596 /* convert struct here to be able to catch rt_dev string */
5597 field_types
= se
->field_types
;
5598 dst_offsets
= se
->field_offsets
[THUNK_HOST
];
5599 src_offsets
= se
->field_offsets
[THUNK_TARGET
];
5600 for (i
= 0; i
< se
->nb_fields
; i
++) {
5601 if (dst_offsets
[i
] == offsetof(struct rtentry
, rt_dev
)) {
5602 assert(*field_types
== TYPE_PTRVOID
);
5603 target_rt_dev_ptr
= (abi_ulong
*)(argptr
+ src_offsets
[i
]);
5604 host_rt_dev_ptr
= (unsigned long *)(buf_temp
+ dst_offsets
[i
]);
5605 if (*target_rt_dev_ptr
!= 0) {
5606 *host_rt_dev_ptr
= (unsigned long)lock_user_string(
5607 tswapal(*target_rt_dev_ptr
));
5608 if (!*host_rt_dev_ptr
) {
5609 unlock_user(argptr
, arg
, 0);
5610 return -TARGET_EFAULT
;
5613 *host_rt_dev_ptr
= 0;
5618 field_types
= thunk_convert(buf_temp
+ dst_offsets
[i
],
5619 argptr
+ src_offsets
[i
],
5620 field_types
, THUNK_HOST
);
5622 unlock_user(argptr
, arg
, 0);
5624 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5625 if (*host_rt_dev_ptr
!= 0) {
5626 unlock_user((void *)*host_rt_dev_ptr
,
5627 *target_rt_dev_ptr
, 0);
5632 static abi_long
do_ioctl_kdsigaccept(const IOCTLEntry
*ie
, uint8_t *buf_temp
,
5633 int fd
, int cmd
, abi_long arg
)
5635 int sig
= target_to_host_signal(arg
);
5636 return get_errno(safe_ioctl(fd
, ie
->host_cmd
, sig
));
5639 static IOCTLEntry ioctl_entries
[] = {
5640 #define IOCTL(cmd, access, ...) \
5641 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5642 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5643 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
5644 #define IOCTL_IGNORE(cmd) \
5645 { TARGET_ ## cmd, 0, #cmd },
5650 /* ??? Implement proper locking for ioctls. */
5651 /* do_ioctl() Must return target values and target errnos. */
5652 static abi_long
do_ioctl(int fd
, int cmd
, abi_long arg
)
5654 const IOCTLEntry
*ie
;
5655 const argtype
*arg_type
;
5657 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
5663 if (ie
->target_cmd
== 0) {
5664 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
5665 return -TARGET_ENOSYS
;
5667 if (ie
->target_cmd
== cmd
)
5671 arg_type
= ie
->arg_type
;
5673 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd
, ie
->name
);
5676 return ie
->do_ioctl(ie
, buf_temp
, fd
, cmd
, arg
);
5677 } else if (!ie
->host_cmd
) {
5678 /* Some architectures define BSD ioctls in their headers
5679 that are not implemented in Linux. */
5680 return -TARGET_ENOSYS
;
5683 switch(arg_type
[0]) {
5686 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
));
5690 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, arg
));
5694 target_size
= thunk_type_size(arg_type
, 0);
5695 switch(ie
->access
) {
5697 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5698 if (!is_error(ret
)) {
5699 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5701 return -TARGET_EFAULT
;
5702 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5703 unlock_user(argptr
, arg
, target_size
);
5707 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5709 return -TARGET_EFAULT
;
5710 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5711 unlock_user(argptr
, arg
, 0);
5712 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5716 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
5718 return -TARGET_EFAULT
;
5719 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
5720 unlock_user(argptr
, arg
, 0);
5721 ret
= get_errno(safe_ioctl(fd
, ie
->host_cmd
, buf_temp
));
5722 if (!is_error(ret
)) {
5723 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
5725 return -TARGET_EFAULT
;
5726 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
5727 unlock_user(argptr
, arg
, target_size
);
5733 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5734 (long)cmd
, arg_type
[0]);
5735 ret
= -TARGET_ENOSYS
;
5741 static const bitmask_transtbl iflag_tbl
[] = {
5742 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
5743 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
5744 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
5745 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
5746 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
5747 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
5748 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
5749 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
5750 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
5751 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
5752 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
5753 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
5754 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
5755 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
5759 static const bitmask_transtbl oflag_tbl
[] = {
5760 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
5761 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
5762 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
5763 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
5764 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
5765 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
5766 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
5767 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
5768 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
5769 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
5770 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
5771 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
5772 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
5773 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
5774 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
5775 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
5776 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
5777 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
5778 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
5779 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
5780 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
5781 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
5782 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
5783 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
5787 static const bitmask_transtbl cflag_tbl
[] = {
5788 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
5789 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
5790 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
5791 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
5792 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
5793 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
5794 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
5795 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
5796 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
5797 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
5798 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
5799 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
5800 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
5801 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
5802 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
5803 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
5804 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
5805 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
5806 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
5807 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
5808 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
5809 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
5810 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
5811 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
5812 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
5813 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
5814 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
5815 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
5816 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
5817 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
5818 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
5822 static const bitmask_transtbl lflag_tbl
[] = {
5823 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
5824 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
5825 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
5826 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
5827 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
5828 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
5829 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
5830 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
5831 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
5832 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
5833 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
5834 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
5835 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
5836 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
5837 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
5841 static void target_to_host_termios (void *dst
, const void *src
)
5843 struct host_termios
*host
= dst
;
5844 const struct target_termios
*target
= src
;
5847 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
5849 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
5851 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
5853 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
5854 host
->c_line
= target
->c_line
;
5856 memset(host
->c_cc
, 0, sizeof(host
->c_cc
));
5857 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
5858 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
5859 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
5860 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
5861 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
5862 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
5863 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
5864 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
5865 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
5866 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
5867 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
5868 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
5869 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
5870 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
5871 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
5872 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
5873 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
5876 static void host_to_target_termios (void *dst
, const void *src
)
5878 struct target_termios
*target
= dst
;
5879 const struct host_termios
*host
= src
;
5882 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
5884 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
5886 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
5888 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
5889 target
->c_line
= host
->c_line
;
5891 memset(target
->c_cc
, 0, sizeof(target
->c_cc
));
5892 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
5893 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
5894 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
5895 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
5896 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
5897 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
5898 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
5899 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
5900 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
5901 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
5902 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
5903 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
5904 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
5905 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
5906 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
5907 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
5908 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
5911 static const StructEntry struct_termios_def
= {
5912 .convert
= { host_to_target_termios
, target_to_host_termios
},
5913 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
5914 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
5917 static bitmask_transtbl mmap_flags_tbl
[] = {
5918 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
5919 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
5920 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
5921 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
,
5922 MAP_ANONYMOUS
, MAP_ANONYMOUS
},
5923 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
,
5924 MAP_GROWSDOWN
, MAP_GROWSDOWN
},
5925 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
,
5926 MAP_DENYWRITE
, MAP_DENYWRITE
},
5927 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
,
5928 MAP_EXECUTABLE
, MAP_EXECUTABLE
},
5929 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
5930 { TARGET_MAP_NORESERVE
, TARGET_MAP_NORESERVE
,
5931 MAP_NORESERVE
, MAP_NORESERVE
},
5932 { TARGET_MAP_HUGETLB
, TARGET_MAP_HUGETLB
, MAP_HUGETLB
, MAP_HUGETLB
},
5933 /* MAP_STACK had been ignored by the kernel for quite some time.
5934 Recognize it for the target insofar as we do not want to pass
5935 it through to the host. */
5936 { TARGET_MAP_STACK
, TARGET_MAP_STACK
, 0, 0 },
5940 #if defined(TARGET_I386)
5942 /* NOTE: there is really one LDT for all the threads */
5943 static uint8_t *ldt_table
;
5945 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
5952 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
5953 if (size
> bytecount
)
5955 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
5957 return -TARGET_EFAULT
;
5958 /* ??? Should this by byteswapped? */
5959 memcpy(p
, ldt_table
, size
);
5960 unlock_user(p
, ptr
, size
);
5964 /* XXX: add locking support */
5965 static abi_long
write_ldt(CPUX86State
*env
,
5966 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
5968 struct target_modify_ldt_ldt_s ldt_info
;
5969 struct target_modify_ldt_ldt_s
*target_ldt_info
;
5970 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
5971 int seg_not_present
, useable
, lm
;
5972 uint32_t *lp
, entry_1
, entry_2
;
5974 if (bytecount
!= sizeof(ldt_info
))
5975 return -TARGET_EINVAL
;
5976 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
5977 return -TARGET_EFAULT
;
5978 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
5979 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
5980 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
5981 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
5982 unlock_user_struct(target_ldt_info
, ptr
, 0);
5984 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
5985 return -TARGET_EINVAL
;
5986 seg_32bit
= ldt_info
.flags
& 1;
5987 contents
= (ldt_info
.flags
>> 1) & 3;
5988 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
5989 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
5990 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
5991 useable
= (ldt_info
.flags
>> 6) & 1;
5995 lm
= (ldt_info
.flags
>> 7) & 1;
5997 if (contents
== 3) {
5999 return -TARGET_EINVAL
;
6000 if (seg_not_present
== 0)
6001 return -TARGET_EINVAL
;
6003 /* allocate the LDT */
6005 env
->ldt
.base
= target_mmap(0,
6006 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
,
6007 PROT_READ
|PROT_WRITE
,
6008 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
6009 if (env
->ldt
.base
== -1)
6010 return -TARGET_ENOMEM
;
6011 memset(g2h(env
->ldt
.base
), 0,
6012 TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
6013 env
->ldt
.limit
= 0xffff;
6014 ldt_table
= g2h(env
->ldt
.base
);
6017 /* NOTE: same code as Linux kernel */
6018 /* Allow LDTs to be cleared by the user. */
6019 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6022 read_exec_only
== 1 &&
6024 limit_in_pages
== 0 &&
6025 seg_not_present
== 1 &&
6033 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6034 (ldt_info
.limit
& 0x0ffff);
6035 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6036 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6037 (ldt_info
.limit
& 0xf0000) |
6038 ((read_exec_only
^ 1) << 9) |
6040 ((seg_not_present
^ 1) << 15) |
6042 (limit_in_pages
<< 23) |
6046 entry_2
|= (useable
<< 20);
6048 /* Install the new entry ... */
6050 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
6051 lp
[0] = tswap32(entry_1
);
6052 lp
[1] = tswap32(entry_2
);
6056 /* specific and weird i386 syscalls */
6057 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
6058 unsigned long bytecount
)
6064 ret
= read_ldt(ptr
, bytecount
);
6067 ret
= write_ldt(env
, ptr
, bytecount
, 1);
6070 ret
= write_ldt(env
, ptr
, bytecount
, 0);
6073 ret
= -TARGET_ENOSYS
;
6079 #if defined(TARGET_I386) && defined(TARGET_ABI32)
6080 abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6082 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
6083 struct target_modify_ldt_ldt_s ldt_info
;
6084 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6085 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
6086 int seg_not_present
, useable
, lm
;
6087 uint32_t *lp
, entry_1
, entry_2
;
6090 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6091 if (!target_ldt_info
)
6092 return -TARGET_EFAULT
;
6093 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
6094 ldt_info
.base_addr
= tswapal(target_ldt_info
->base_addr
);
6095 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
6096 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
6097 if (ldt_info
.entry_number
== -1) {
6098 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
6099 if (gdt_table
[i
] == 0) {
6100 ldt_info
.entry_number
= i
;
6101 target_ldt_info
->entry_number
= tswap32(i
);
6106 unlock_user_struct(target_ldt_info
, ptr
, 1);
6108 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
6109 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
6110 return -TARGET_EINVAL
;
6111 seg_32bit
= ldt_info
.flags
& 1;
6112 contents
= (ldt_info
.flags
>> 1) & 3;
6113 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
6114 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
6115 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
6116 useable
= (ldt_info
.flags
>> 6) & 1;
6120 lm
= (ldt_info
.flags
>> 7) & 1;
6123 if (contents
== 3) {
6124 if (seg_not_present
== 0)
6125 return -TARGET_EINVAL
;
6128 /* NOTE: same code as Linux kernel */
6129 /* Allow LDTs to be cleared by the user. */
6130 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
6131 if ((contents
== 0 &&
6132 read_exec_only
== 1 &&
6134 limit_in_pages
== 0 &&
6135 seg_not_present
== 1 &&
6143 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
6144 (ldt_info
.limit
& 0x0ffff);
6145 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
6146 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
6147 (ldt_info
.limit
& 0xf0000) |
6148 ((read_exec_only
^ 1) << 9) |
6150 ((seg_not_present
^ 1) << 15) |
6152 (limit_in_pages
<< 23) |
6157 /* Install the new entry ... */
6159 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
6160 lp
[0] = tswap32(entry_1
);
6161 lp
[1] = tswap32(entry_2
);
6165 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
6167 struct target_modify_ldt_ldt_s
*target_ldt_info
;
6168 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
6169 uint32_t base_addr
, limit
, flags
;
6170 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
6171 int seg_not_present
, useable
, lm
;
6172 uint32_t *lp
, entry_1
, entry_2
;
6174 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
6175 if (!target_ldt_info
)
6176 return -TARGET_EFAULT
;
6177 idx
= tswap32(target_ldt_info
->entry_number
);
6178 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
6179 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
6180 unlock_user_struct(target_ldt_info
, ptr
, 1);
6181 return -TARGET_EINVAL
;
6183 lp
= (uint32_t *)(gdt_table
+ idx
);
6184 entry_1
= tswap32(lp
[0]);
6185 entry_2
= tswap32(lp
[1]);
6187 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
6188 contents
= (entry_2
>> 10) & 3;
6189 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
6190 seg_32bit
= (entry_2
>> 22) & 1;
6191 limit_in_pages
= (entry_2
>> 23) & 1;
6192 useable
= (entry_2
>> 20) & 1;
6196 lm
= (entry_2
>> 21) & 1;
6198 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
6199 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
6200 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
6201 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
6202 base_addr
= (entry_1
>> 16) |
6203 (entry_2
& 0xff000000) |
6204 ((entry_2
& 0xff) << 16);
6205 target_ldt_info
->base_addr
= tswapal(base_addr
);
6206 target_ldt_info
->limit
= tswap32(limit
);
6207 target_ldt_info
->flags
= tswap32(flags
);
6208 unlock_user_struct(target_ldt_info
, ptr
, 1);
6211 #endif /* TARGET_I386 && TARGET_ABI32 */
6213 #ifndef TARGET_ABI32
6214 abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
6221 case TARGET_ARCH_SET_GS
:
6222 case TARGET_ARCH_SET_FS
:
6223 if (code
== TARGET_ARCH_SET_GS
)
6227 cpu_x86_load_seg(env
, idx
, 0);
6228 env
->segs
[idx
].base
= addr
;
6230 case TARGET_ARCH_GET_GS
:
6231 case TARGET_ARCH_GET_FS
:
6232 if (code
== TARGET_ARCH_GET_GS
)
6236 val
= env
->segs
[idx
].base
;
6237 if (put_user(val
, addr
, abi_ulong
))
6238 ret
= -TARGET_EFAULT
;
6241 ret
= -TARGET_EINVAL
;
6248 #endif /* defined(TARGET_I386) */
6250 #define NEW_STACK_SIZE 0x40000
6253 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
6256 pthread_mutex_t mutex
;
6257 pthread_cond_t cond
;
6260 abi_ulong child_tidptr
;
6261 abi_ulong parent_tidptr
;
6265 static void *clone_func(void *arg
)
6267 new_thread_info
*info
= arg
;
6272 rcu_register_thread();
6273 tcg_register_thread();
6275 cpu
= ENV_GET_CPU(env
);
6277 ts
= (TaskState
*)cpu
->opaque
;
6278 info
->tid
= gettid();
6280 if (info
->child_tidptr
)
6281 put_user_u32(info
->tid
, info
->child_tidptr
);
6282 if (info
->parent_tidptr
)
6283 put_user_u32(info
->tid
, info
->parent_tidptr
);
6284 /* Enable signals. */
6285 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
6286 /* Signal to the parent that we're ready. */
6287 pthread_mutex_lock(&info
->mutex
);
6288 pthread_cond_broadcast(&info
->cond
);
6289 pthread_mutex_unlock(&info
->mutex
);
6290 /* Wait until the parent has finished initializing the tls state. */
6291 pthread_mutex_lock(&clone_lock
);
6292 pthread_mutex_unlock(&clone_lock
);
6298 /* do_fork() Must return host values and target errnos (unlike most
6299 do_*() functions). */
6300 static int do_fork(CPUArchState
*env
, unsigned int flags
, abi_ulong newsp
,
6301 abi_ulong parent_tidptr
, target_ulong newtls
,
6302 abi_ulong child_tidptr
)
6304 CPUState
*cpu
= ENV_GET_CPU(env
);
6308 CPUArchState
*new_env
;
6311 flags
&= ~CLONE_IGNORED_FLAGS
;
6313 /* Emulate vfork() with fork() */
6314 if (flags
& CLONE_VFORK
)
6315 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
6317 if (flags
& CLONE_VM
) {
6318 TaskState
*parent_ts
= (TaskState
*)cpu
->opaque
;
6319 new_thread_info info
;
6320 pthread_attr_t attr
;
6322 if (((flags
& CLONE_THREAD_FLAGS
) != CLONE_THREAD_FLAGS
) ||
6323 (flags
& CLONE_INVALID_THREAD_FLAGS
)) {
6324 return -TARGET_EINVAL
;
6327 ts
= g_new0(TaskState
, 1);
6328 init_task_state(ts
);
6329 /* we create a new CPU instance. */
6330 new_env
= cpu_copy(env
);
6331 /* Init regs that differ from the parent. */
6332 cpu_clone_regs(new_env
, newsp
);
6333 new_cpu
= ENV_GET_CPU(new_env
);
6334 new_cpu
->opaque
= ts
;
6335 ts
->bprm
= parent_ts
->bprm
;
6336 ts
->info
= parent_ts
->info
;
6337 ts
->signal_mask
= parent_ts
->signal_mask
;
6339 if (flags
& CLONE_CHILD_CLEARTID
) {
6340 ts
->child_tidptr
= child_tidptr
;
6343 if (flags
& CLONE_SETTLS
) {
6344 cpu_set_tls (new_env
, newtls
);
6347 /* Grab a mutex so that thread setup appears atomic. */
6348 pthread_mutex_lock(&clone_lock
);
6350 memset(&info
, 0, sizeof(info
));
6351 pthread_mutex_init(&info
.mutex
, NULL
);
6352 pthread_mutex_lock(&info
.mutex
);
6353 pthread_cond_init(&info
.cond
, NULL
);
6355 if (flags
& CLONE_CHILD_SETTID
) {
6356 info
.child_tidptr
= child_tidptr
;
6358 if (flags
& CLONE_PARENT_SETTID
) {
6359 info
.parent_tidptr
= parent_tidptr
;
6362 ret
= pthread_attr_init(&attr
);
6363 ret
= pthread_attr_setstacksize(&attr
, NEW_STACK_SIZE
);
6364 ret
= pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
6365 /* It is not safe to deliver signals until the child has finished
6366 initializing, so temporarily block all signals. */
6367 sigfillset(&sigmask
);
6368 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
6370 /* If this is our first additional thread, we need to ensure we
6371 * generate code for parallel execution and flush old translations.
6373 if (!parallel_cpus
) {
6374 parallel_cpus
= true;
6378 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
6379 /* TODO: Free new CPU state if thread creation failed. */
6381 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
6382 pthread_attr_destroy(&attr
);
6384 /* Wait for the child to initialize. */
6385 pthread_cond_wait(&info
.cond
, &info
.mutex
);
6390 pthread_mutex_unlock(&info
.mutex
);
6391 pthread_cond_destroy(&info
.cond
);
6392 pthread_mutex_destroy(&info
.mutex
);
6393 pthread_mutex_unlock(&clone_lock
);
6395 /* if no CLONE_VM, we consider it is a fork */
6396 if (flags
& CLONE_INVALID_FORK_FLAGS
) {
6397 return -TARGET_EINVAL
;
6400 /* We can't support custom termination signals */
6401 if ((flags
& CSIGNAL
) != TARGET_SIGCHLD
) {
6402 return -TARGET_EINVAL
;
6405 if (block_signals()) {
6406 return -TARGET_ERESTARTSYS
;
6412 /* Child Process. */
6413 cpu_clone_regs(env
, newsp
);
6415 /* There is a race condition here. The parent process could
6416 theoretically read the TID in the child process before the child
6417 tid is set. This would require using either ptrace
6418 (not implemented) or having *_tidptr to point at a shared memory
6419 mapping. We can't repeat the spinlock hack used above because
6420 the child process gets its own copy of the lock. */
6421 if (flags
& CLONE_CHILD_SETTID
)
6422 put_user_u32(gettid(), child_tidptr
);
6423 if (flags
& CLONE_PARENT_SETTID
)
6424 put_user_u32(gettid(), parent_tidptr
);
6425 ts
= (TaskState
*)cpu
->opaque
;
6426 if (flags
& CLONE_SETTLS
)
6427 cpu_set_tls (env
, newtls
);
6428 if (flags
& CLONE_CHILD_CLEARTID
)
6429 ts
->child_tidptr
= child_tidptr
;
6437 /* warning : doesn't handle linux specific flags... */
6438 static int target_to_host_fcntl_cmd(int cmd
)
6441 case TARGET_F_DUPFD
:
6442 case TARGET_F_GETFD
:
6443 case TARGET_F_SETFD
:
6444 case TARGET_F_GETFL
:
6445 case TARGET_F_SETFL
:
6447 case TARGET_F_GETLK
:
6449 case TARGET_F_SETLK
:
6451 case TARGET_F_SETLKW
:
6453 case TARGET_F_GETOWN
:
6455 case TARGET_F_SETOWN
:
6457 case TARGET_F_GETSIG
:
6459 case TARGET_F_SETSIG
:
6461 #if TARGET_ABI_BITS == 32
6462 case TARGET_F_GETLK64
:
6464 case TARGET_F_SETLK64
:
6466 case TARGET_F_SETLKW64
:
6469 case TARGET_F_SETLEASE
:
6471 case TARGET_F_GETLEASE
:
6473 #ifdef F_DUPFD_CLOEXEC
6474 case TARGET_F_DUPFD_CLOEXEC
:
6475 return F_DUPFD_CLOEXEC
;
6477 case TARGET_F_NOTIFY
:
6480 case TARGET_F_GETOWN_EX
:
6484 case TARGET_F_SETOWN_EX
:
6488 case TARGET_F_SETPIPE_SZ
:
6489 return F_SETPIPE_SZ
;
6490 case TARGET_F_GETPIPE_SZ
:
6491 return F_GETPIPE_SZ
;
6494 return -TARGET_EINVAL
;
6496 return -TARGET_EINVAL
;
6499 #define TRANSTBL_CONVERT(a) { -1, TARGET_##a, -1, a }
6500 static const bitmask_transtbl flock_tbl
[] = {
6501 TRANSTBL_CONVERT(F_RDLCK
),
6502 TRANSTBL_CONVERT(F_WRLCK
),
6503 TRANSTBL_CONVERT(F_UNLCK
),
6504 TRANSTBL_CONVERT(F_EXLCK
),
6505 TRANSTBL_CONVERT(F_SHLCK
),
6509 static inline abi_long
copy_from_user_flock(struct flock64
*fl
,
6510 abi_ulong target_flock_addr
)
6512 struct target_flock
*target_fl
;
6515 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6516 return -TARGET_EFAULT
;
6519 __get_user(l_type
, &target_fl
->l_type
);
6520 fl
->l_type
= target_to_host_bitmask(l_type
, flock_tbl
);
6521 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6522 __get_user(fl
->l_start
, &target_fl
->l_start
);
6523 __get_user(fl
->l_len
, &target_fl
->l_len
);
6524 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6525 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6529 static inline abi_long
copy_to_user_flock(abi_ulong target_flock_addr
,
6530 const struct flock64
*fl
)
6532 struct target_flock
*target_fl
;
6535 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6536 return -TARGET_EFAULT
;
6539 l_type
= host_to_target_bitmask(fl
->l_type
, flock_tbl
);
6540 __put_user(l_type
, &target_fl
->l_type
);
6541 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6542 __put_user(fl
->l_start
, &target_fl
->l_start
);
6543 __put_user(fl
->l_len
, &target_fl
->l_len
);
6544 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6545 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6549 typedef abi_long
from_flock64_fn(struct flock64
*fl
, abi_ulong target_addr
);
6550 typedef abi_long
to_flock64_fn(abi_ulong target_addr
, const struct flock64
*fl
);
6552 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6553 static inline abi_long
copy_from_user_eabi_flock64(struct flock64
*fl
,
6554 abi_ulong target_flock_addr
)
6556 struct target_eabi_flock64
*target_fl
;
6559 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6560 return -TARGET_EFAULT
;
6563 __get_user(l_type
, &target_fl
->l_type
);
6564 fl
->l_type
= target_to_host_bitmask(l_type
, flock_tbl
);
6565 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6566 __get_user(fl
->l_start
, &target_fl
->l_start
);
6567 __get_user(fl
->l_len
, &target_fl
->l_len
);
6568 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6569 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6573 static inline abi_long
copy_to_user_eabi_flock64(abi_ulong target_flock_addr
,
6574 const struct flock64
*fl
)
6576 struct target_eabi_flock64
*target_fl
;
6579 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6580 return -TARGET_EFAULT
;
6583 l_type
= host_to_target_bitmask(fl
->l_type
, flock_tbl
);
6584 __put_user(l_type
, &target_fl
->l_type
);
6585 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6586 __put_user(fl
->l_start
, &target_fl
->l_start
);
6587 __put_user(fl
->l_len
, &target_fl
->l_len
);
6588 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6589 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6594 static inline abi_long
copy_from_user_flock64(struct flock64
*fl
,
6595 abi_ulong target_flock_addr
)
6597 struct target_flock64
*target_fl
;
6600 if (!lock_user_struct(VERIFY_READ
, target_fl
, target_flock_addr
, 1)) {
6601 return -TARGET_EFAULT
;
6604 __get_user(l_type
, &target_fl
->l_type
);
6605 fl
->l_type
= target_to_host_bitmask(l_type
, flock_tbl
);
6606 __get_user(fl
->l_whence
, &target_fl
->l_whence
);
6607 __get_user(fl
->l_start
, &target_fl
->l_start
);
6608 __get_user(fl
->l_len
, &target_fl
->l_len
);
6609 __get_user(fl
->l_pid
, &target_fl
->l_pid
);
6610 unlock_user_struct(target_fl
, target_flock_addr
, 0);
6614 static inline abi_long
copy_to_user_flock64(abi_ulong target_flock_addr
,
6615 const struct flock64
*fl
)
6617 struct target_flock64
*target_fl
;
6620 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, target_flock_addr
, 0)) {
6621 return -TARGET_EFAULT
;
6624 l_type
= host_to_target_bitmask(fl
->l_type
, flock_tbl
);
6625 __put_user(l_type
, &target_fl
->l_type
);
6626 __put_user(fl
->l_whence
, &target_fl
->l_whence
);
6627 __put_user(fl
->l_start
, &target_fl
->l_start
);
6628 __put_user(fl
->l_len
, &target_fl
->l_len
);
6629 __put_user(fl
->l_pid
, &target_fl
->l_pid
);
6630 unlock_user_struct(target_fl
, target_flock_addr
, 1);
6634 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
6636 struct flock64 fl64
;
6638 struct f_owner_ex fox
;
6639 struct target_f_owner_ex
*target_fox
;
6642 int host_cmd
= target_to_host_fcntl_cmd(cmd
);
6644 if (host_cmd
== -TARGET_EINVAL
)
6648 case TARGET_F_GETLK
:
6649 ret
= copy_from_user_flock(&fl64
, arg
);
6653 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6655 ret
= copy_to_user_flock(arg
, &fl64
);
6659 case TARGET_F_SETLK
:
6660 case TARGET_F_SETLKW
:
6661 ret
= copy_from_user_flock(&fl64
, arg
);
6665 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6668 case TARGET_F_GETLK64
:
6669 ret
= copy_from_user_flock64(&fl64
, arg
);
6673 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6675 ret
= copy_to_user_flock64(arg
, &fl64
);
6678 case TARGET_F_SETLK64
:
6679 case TARGET_F_SETLKW64
:
6680 ret
= copy_from_user_flock64(&fl64
, arg
);
6684 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fl64
));
6687 case TARGET_F_GETFL
:
6688 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6690 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
6694 case TARGET_F_SETFL
:
6695 ret
= get_errno(safe_fcntl(fd
, host_cmd
,
6696 target_to_host_bitmask(arg
,
6701 case TARGET_F_GETOWN_EX
:
6702 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6704 if (!lock_user_struct(VERIFY_WRITE
, target_fox
, arg
, 0))
6705 return -TARGET_EFAULT
;
6706 target_fox
->type
= tswap32(fox
.type
);
6707 target_fox
->pid
= tswap32(fox
.pid
);
6708 unlock_user_struct(target_fox
, arg
, 1);
6714 case TARGET_F_SETOWN_EX
:
6715 if (!lock_user_struct(VERIFY_READ
, target_fox
, arg
, 1))
6716 return -TARGET_EFAULT
;
6717 fox
.type
= tswap32(target_fox
->type
);
6718 fox
.pid
= tswap32(target_fox
->pid
);
6719 unlock_user_struct(target_fox
, arg
, 0);
6720 ret
= get_errno(safe_fcntl(fd
, host_cmd
, &fox
));
6724 case TARGET_F_SETOWN
:
6725 case TARGET_F_GETOWN
:
6726 case TARGET_F_SETSIG
:
6727 case TARGET_F_GETSIG
:
6728 case TARGET_F_SETLEASE
:
6729 case TARGET_F_GETLEASE
:
6730 case TARGET_F_SETPIPE_SZ
:
6731 case TARGET_F_GETPIPE_SZ
:
6732 ret
= get_errno(safe_fcntl(fd
, host_cmd
, arg
));
6736 ret
= get_errno(safe_fcntl(fd
, cmd
, arg
));
6744 static inline int high2lowuid(int uid
)
6752 static inline int high2lowgid(int gid
)
6760 static inline int low2highuid(int uid
)
6762 if ((int16_t)uid
== -1)
6768 static inline int low2highgid(int gid
)
6770 if ((int16_t)gid
== -1)
6775 static inline int tswapid(int id
)
6780 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6782 #else /* !USE_UID16 */
6783 static inline int high2lowuid(int uid
)
6787 static inline int high2lowgid(int gid
)
6791 static inline int low2highuid(int uid
)
6795 static inline int low2highgid(int gid
)
6799 static inline int tswapid(int id
)
6804 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6806 #endif /* USE_UID16 */
6808 /* We must do direct syscalls for setting UID/GID, because we want to
6809 * implement the Linux system call semantics of "change only for this thread",
6810 * not the libc/POSIX semantics of "change for all threads in process".
6811 * (See http://ewontfix.com/17/ for more details.)
6812 * We use the 32-bit version of the syscalls if present; if it is not
6813 * then either the host architecture supports 32-bit UIDs natively with
6814 * the standard syscall, or the 16-bit UID is the best we can do.
6816 #ifdef __NR_setuid32
6817 #define __NR_sys_setuid __NR_setuid32
6819 #define __NR_sys_setuid __NR_setuid
6821 #ifdef __NR_setgid32
6822 #define __NR_sys_setgid __NR_setgid32
6824 #define __NR_sys_setgid __NR_setgid
6826 #ifdef __NR_setresuid32
6827 #define __NR_sys_setresuid __NR_setresuid32
6829 #define __NR_sys_setresuid __NR_setresuid
6831 #ifdef __NR_setresgid32
6832 #define __NR_sys_setresgid __NR_setresgid32
6834 #define __NR_sys_setresgid __NR_setresgid
6837 _syscall1(int, sys_setuid
, uid_t
, uid
)
6838 _syscall1(int, sys_setgid
, gid_t
, gid
)
6839 _syscall3(int, sys_setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
6840 _syscall3(int, sys_setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
6842 void syscall_init(void)
6845 const argtype
*arg_type
;
6849 thunk_init(STRUCT_MAX
);
6851 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
6852 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
6853 #include "syscall_types.h"
6855 #undef STRUCT_SPECIAL
6857 /* Build target_to_host_errno_table[] table from
6858 * host_to_target_errno_table[]. */
6859 for (i
= 0; i
< ERRNO_TABLE_SIZE
; i
++) {
6860 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
6863 /* we patch the ioctl size if necessary. We rely on the fact that
6864 no ioctl has all the bits at '1' in the size field */
6866 while (ie
->target_cmd
!= 0) {
6867 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
6868 TARGET_IOC_SIZEMASK
) {
6869 arg_type
= ie
->arg_type
;
6870 if (arg_type
[0] != TYPE_PTR
) {
6871 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
6876 size
= thunk_type_size(arg_type
, 0);
6877 ie
->target_cmd
= (ie
->target_cmd
&
6878 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
6879 (size
<< TARGET_IOC_SIZESHIFT
);
6882 /* automatic consistency check if same arch */
6883 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6884 (defined(__x86_64__) && defined(TARGET_X86_64))
6885 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
6886 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6887 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
6894 #if TARGET_ABI_BITS == 32
6895 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
6897 #ifdef TARGET_WORDS_BIGENDIAN
6898 return ((uint64_t)word0
<< 32) | word1
;
6900 return ((uint64_t)word1
<< 32) | word0
;
6903 #else /* TARGET_ABI_BITS == 32 */
6904 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
6908 #endif /* TARGET_ABI_BITS != 32 */
6910 #ifdef TARGET_NR_truncate64
6911 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
6916 if (regpairs_aligned(cpu_env
, TARGET_NR_truncate64
)) {
6920 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
6924 #ifdef TARGET_NR_ftruncate64
6925 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
6930 if (regpairs_aligned(cpu_env
, TARGET_NR_ftruncate64
)) {
6934 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
6938 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
6939 abi_ulong target_addr
)
6941 struct target_timespec
*target_ts
;
6943 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
6944 return -TARGET_EFAULT
;
6945 __get_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
6946 __get_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
6947 unlock_user_struct(target_ts
, target_addr
, 0);
6951 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
6952 struct timespec
*host_ts
)
6954 struct target_timespec
*target_ts
;
6956 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
6957 return -TARGET_EFAULT
;
6958 __put_user(host_ts
->tv_sec
, &target_ts
->tv_sec
);
6959 __put_user(host_ts
->tv_nsec
, &target_ts
->tv_nsec
);
6960 unlock_user_struct(target_ts
, target_addr
, 1);
6964 static inline abi_long
target_to_host_itimerspec(struct itimerspec
*host_itspec
,
6965 abi_ulong target_addr
)
6967 struct target_itimerspec
*target_itspec
;
6969 if (!lock_user_struct(VERIFY_READ
, target_itspec
, target_addr
, 1)) {
6970 return -TARGET_EFAULT
;
6973 host_itspec
->it_interval
.tv_sec
=
6974 tswapal(target_itspec
->it_interval
.tv_sec
);
6975 host_itspec
->it_interval
.tv_nsec
=
6976 tswapal(target_itspec
->it_interval
.tv_nsec
);
6977 host_itspec
->it_value
.tv_sec
= tswapal(target_itspec
->it_value
.tv_sec
);
6978 host_itspec
->it_value
.tv_nsec
= tswapal(target_itspec
->it_value
.tv_nsec
);
6980 unlock_user_struct(target_itspec
, target_addr
, 1);
6984 static inline abi_long
host_to_target_itimerspec(abi_ulong target_addr
,
6985 struct itimerspec
*host_its
)
6987 struct target_itimerspec
*target_itspec
;
6989 if (!lock_user_struct(VERIFY_WRITE
, target_itspec
, target_addr
, 0)) {
6990 return -TARGET_EFAULT
;
6993 target_itspec
->it_interval
.tv_sec
= tswapal(host_its
->it_interval
.tv_sec
);
6994 target_itspec
->it_interval
.tv_nsec
= tswapal(host_its
->it_interval
.tv_nsec
);
6996 target_itspec
->it_value
.tv_sec
= tswapal(host_its
->it_value
.tv_sec
);
6997 target_itspec
->it_value
.tv_nsec
= tswapal(host_its
->it_value
.tv_nsec
);
6999 unlock_user_struct(target_itspec
, target_addr
, 0);
7003 static inline abi_long
target_to_host_timex(struct timex
*host_tx
,
7004 abi_long target_addr
)
7006 struct target_timex
*target_tx
;
7008 if (!lock_user_struct(VERIFY_READ
, target_tx
, target_addr
, 1)) {
7009 return -TARGET_EFAULT
;
7012 __get_user(host_tx
->modes
, &target_tx
->modes
);
7013 __get_user(host_tx
->offset
, &target_tx
->offset
);
7014 __get_user(host_tx
->freq
, &target_tx
->freq
);
7015 __get_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7016 __get_user(host_tx
->esterror
, &target_tx
->esterror
);
7017 __get_user(host_tx
->status
, &target_tx
->status
);
7018 __get_user(host_tx
->constant
, &target_tx
->constant
);
7019 __get_user(host_tx
->precision
, &target_tx
->precision
);
7020 __get_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7021 __get_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7022 __get_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7023 __get_user(host_tx
->tick
, &target_tx
->tick
);
7024 __get_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7025 __get_user(host_tx
->jitter
, &target_tx
->jitter
);
7026 __get_user(host_tx
->shift
, &target_tx
->shift
);
7027 __get_user(host_tx
->stabil
, &target_tx
->stabil
);
7028 __get_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7029 __get_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7030 __get_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7031 __get_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7032 __get_user(host_tx
->tai
, &target_tx
->tai
);
7034 unlock_user_struct(target_tx
, target_addr
, 0);
7038 static inline abi_long
host_to_target_timex(abi_long target_addr
,
7039 struct timex
*host_tx
)
7041 struct target_timex
*target_tx
;
7043 if (!lock_user_struct(VERIFY_WRITE
, target_tx
, target_addr
, 0)) {
7044 return -TARGET_EFAULT
;
7047 __put_user(host_tx
->modes
, &target_tx
->modes
);
7048 __put_user(host_tx
->offset
, &target_tx
->offset
);
7049 __put_user(host_tx
->freq
, &target_tx
->freq
);
7050 __put_user(host_tx
->maxerror
, &target_tx
->maxerror
);
7051 __put_user(host_tx
->esterror
, &target_tx
->esterror
);
7052 __put_user(host_tx
->status
, &target_tx
->status
);
7053 __put_user(host_tx
->constant
, &target_tx
->constant
);
7054 __put_user(host_tx
->precision
, &target_tx
->precision
);
7055 __put_user(host_tx
->tolerance
, &target_tx
->tolerance
);
7056 __put_user(host_tx
->time
.tv_sec
, &target_tx
->time
.tv_sec
);
7057 __put_user(host_tx
->time
.tv_usec
, &target_tx
->time
.tv_usec
);
7058 __put_user(host_tx
->tick
, &target_tx
->tick
);
7059 __put_user(host_tx
->ppsfreq
, &target_tx
->ppsfreq
);
7060 __put_user(host_tx
->jitter
, &target_tx
->jitter
);
7061 __put_user(host_tx
->shift
, &target_tx
->shift
);
7062 __put_user(host_tx
->stabil
, &target_tx
->stabil
);
7063 __put_user(host_tx
->jitcnt
, &target_tx
->jitcnt
);
7064 __put_user(host_tx
->calcnt
, &target_tx
->calcnt
);
7065 __put_user(host_tx
->errcnt
, &target_tx
->errcnt
);
7066 __put_user(host_tx
->stbcnt
, &target_tx
->stbcnt
);
7067 __put_user(host_tx
->tai
, &target_tx
->tai
);
7069 unlock_user_struct(target_tx
, target_addr
, 1);
7074 static inline abi_long
target_to_host_sigevent(struct sigevent
*host_sevp
,
7075 abi_ulong target_addr
)
7077 struct target_sigevent
*target_sevp
;
7079 if (!lock_user_struct(VERIFY_READ
, target_sevp
, target_addr
, 1)) {
7080 return -TARGET_EFAULT
;
7083 /* This union is awkward on 64 bit systems because it has a 32 bit
7084 * integer and a pointer in it; we follow the conversion approach
7085 * used for handling sigval types in signal.c so the guest should get
7086 * the correct value back even if we did a 64 bit byteswap and it's
7087 * using the 32 bit integer.
7089 host_sevp
->sigev_value
.sival_ptr
=
7090 (void *)(uintptr_t)tswapal(target_sevp
->sigev_value
.sival_ptr
);
7091 host_sevp
->sigev_signo
=
7092 target_to_host_signal(tswap32(target_sevp
->sigev_signo
));
7093 host_sevp
->sigev_notify
= tswap32(target_sevp
->sigev_notify
);
7094 host_sevp
->_sigev_un
._tid
= tswap32(target_sevp
->_sigev_un
._tid
);
7096 unlock_user_struct(target_sevp
, target_addr
, 1);
7100 #if defined(TARGET_NR_mlockall)
7101 static inline int target_to_host_mlockall_arg(int arg
)
7105 if (arg
& TARGET_MLOCKALL_MCL_CURRENT
) {
7106 result
|= MCL_CURRENT
;
7108 if (arg
& TARGET_MLOCKALL_MCL_FUTURE
) {
7109 result
|= MCL_FUTURE
;
7115 static inline abi_long
host_to_target_stat64(void *cpu_env
,
7116 abi_ulong target_addr
,
7117 struct stat
*host_st
)
7119 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
7120 if (((CPUARMState
*)cpu_env
)->eabi
) {
7121 struct target_eabi_stat64
*target_st
;
7123 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7124 return -TARGET_EFAULT
;
7125 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
7126 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7127 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7128 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7129 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7131 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7132 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7133 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7134 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7135 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7136 __put_user(host_st
->st_size
, &target_st
->st_size
);
7137 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7138 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7139 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7140 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7141 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7142 unlock_user_struct(target_st
, target_addr
, 1);
7146 #if defined(TARGET_HAS_STRUCT_STAT64)
7147 struct target_stat64
*target_st
;
7149 struct target_stat
*target_st
;
7152 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
7153 return -TARGET_EFAULT
;
7154 memset(target_st
, 0, sizeof(*target_st
));
7155 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
7156 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
7157 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7158 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
7160 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
7161 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
7162 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
7163 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
7164 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
7165 /* XXX: better use of kernel struct */
7166 __put_user(host_st
->st_size
, &target_st
->st_size
);
7167 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
7168 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
7169 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
7170 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
7171 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
7172 unlock_user_struct(target_st
, target_addr
, 1);
7178 /* ??? Using host futex calls even when target atomic operations
7179 are not really atomic probably breaks things. However implementing
7180 futexes locally would make futexes shared between multiple processes
7181 tricky. However they're probably useless because guest atomic
7182 operations won't work either. */
7183 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
7184 target_ulong uaddr2
, int val3
)
7186 struct timespec ts
, *pts
;
7189 /* ??? We assume FUTEX_* constants are the same on both host
7191 #ifdef FUTEX_CMD_MASK
7192 base_op
= op
& FUTEX_CMD_MASK
;
7198 case FUTEX_WAIT_BITSET
:
7201 target_to_host_timespec(pts
, timeout
);
7205 return get_errno(safe_futex(g2h(uaddr
), op
, tswap32(val
),
7208 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
7210 return get_errno(safe_futex(g2h(uaddr
), op
, val
, NULL
, NULL
, 0));
7212 case FUTEX_CMP_REQUEUE
:
7214 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7215 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7216 But the prototype takes a `struct timespec *'; insert casts
7217 to satisfy the compiler. We do not need to tswap TIMEOUT
7218 since it's not compared to guest memory. */
7219 pts
= (struct timespec
*)(uintptr_t) timeout
;
7220 return get_errno(safe_futex(g2h(uaddr
), op
, val
, pts
,
7222 (base_op
== FUTEX_CMP_REQUEUE
7226 return -TARGET_ENOSYS
;
7229 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7230 static abi_long
do_name_to_handle_at(abi_long dirfd
, abi_long pathname
,
7231 abi_long handle
, abi_long mount_id
,
7234 struct file_handle
*target_fh
;
7235 struct file_handle
*fh
;
7239 unsigned int size
, total_size
;
7241 if (get_user_s32(size
, handle
)) {
7242 return -TARGET_EFAULT
;
7245 name
= lock_user_string(pathname
);
7247 return -TARGET_EFAULT
;
7250 total_size
= sizeof(struct file_handle
) + size
;
7251 target_fh
= lock_user(VERIFY_WRITE
, handle
, total_size
, 0);
7253 unlock_user(name
, pathname
, 0);
7254 return -TARGET_EFAULT
;
7257 fh
= g_malloc0(total_size
);
7258 fh
->handle_bytes
= size
;
7260 ret
= get_errno(name_to_handle_at(dirfd
, path(name
), fh
, &mid
, flags
));
7261 unlock_user(name
, pathname
, 0);
7263 /* man name_to_handle_at(2):
7264 * Other than the use of the handle_bytes field, the caller should treat
7265 * the file_handle structure as an opaque data type
7268 memcpy(target_fh
, fh
, total_size
);
7269 target_fh
->handle_bytes
= tswap32(fh
->handle_bytes
);
7270 target_fh
->handle_type
= tswap32(fh
->handle_type
);
7272 unlock_user(target_fh
, handle
, total_size
);
7274 if (put_user_s32(mid
, mount_id
)) {
7275 return -TARGET_EFAULT
;
7283 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7284 static abi_long
do_open_by_handle_at(abi_long mount_fd
, abi_long handle
,
7287 struct file_handle
*target_fh
;
7288 struct file_handle
*fh
;
7289 unsigned int size
, total_size
;
7292 if (get_user_s32(size
, handle
)) {
7293 return -TARGET_EFAULT
;
7296 total_size
= sizeof(struct file_handle
) + size
;
7297 target_fh
= lock_user(VERIFY_READ
, handle
, total_size
, 1);
7299 return -TARGET_EFAULT
;
7302 fh
= g_memdup(target_fh
, total_size
);
7303 fh
->handle_bytes
= size
;
7304 fh
->handle_type
= tswap32(target_fh
->handle_type
);
7306 ret
= get_errno(open_by_handle_at(mount_fd
, fh
,
7307 target_to_host_bitmask(flags
, fcntl_flags_tbl
)));
7311 unlock_user(target_fh
, handle
, total_size
);
7317 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7319 /* signalfd siginfo conversion */
7322 host_to_target_signalfd_siginfo(struct signalfd_siginfo
*tinfo
,
7323 const struct signalfd_siginfo
*info
)
7325 int sig
= host_to_target_signal(info
->ssi_signo
);
7327 /* linux/signalfd.h defines a ssi_addr_lsb
7328 * not defined in sys/signalfd.h but used by some kernels
7331 #ifdef BUS_MCEERR_AO
7332 if (tinfo
->ssi_signo
== SIGBUS
&&
7333 (tinfo
->ssi_code
== BUS_MCEERR_AR
||
7334 tinfo
->ssi_code
== BUS_MCEERR_AO
)) {
7335 uint16_t *ssi_addr_lsb
= (uint16_t *)(&info
->ssi_addr
+ 1);
7336 uint16_t *tssi_addr_lsb
= (uint16_t *)(&tinfo
->ssi_addr
+ 1);
7337 *tssi_addr_lsb
= tswap16(*ssi_addr_lsb
);
7341 tinfo
->ssi_signo
= tswap32(sig
);
7342 tinfo
->ssi_errno
= tswap32(tinfo
->ssi_errno
);
7343 tinfo
->ssi_code
= tswap32(info
->ssi_code
);
7344 tinfo
->ssi_pid
= tswap32(info
->ssi_pid
);
7345 tinfo
->ssi_uid
= tswap32(info
->ssi_uid
);
7346 tinfo
->ssi_fd
= tswap32(info
->ssi_fd
);
7347 tinfo
->ssi_tid
= tswap32(info
->ssi_tid
);
7348 tinfo
->ssi_band
= tswap32(info
->ssi_band
);
7349 tinfo
->ssi_overrun
= tswap32(info
->ssi_overrun
);
7350 tinfo
->ssi_trapno
= tswap32(info
->ssi_trapno
);
7351 tinfo
->ssi_status
= tswap32(info
->ssi_status
);
7352 tinfo
->ssi_int
= tswap32(info
->ssi_int
);
7353 tinfo
->ssi_ptr
= tswap64(info
->ssi_ptr
);
7354 tinfo
->ssi_utime
= tswap64(info
->ssi_utime
);
7355 tinfo
->ssi_stime
= tswap64(info
->ssi_stime
);
7356 tinfo
->ssi_addr
= tswap64(info
->ssi_addr
);
7359 static abi_long
host_to_target_data_signalfd(void *buf
, size_t len
)
7363 for (i
= 0; i
< len
; i
+= sizeof(struct signalfd_siginfo
)) {
7364 host_to_target_signalfd_siginfo(buf
+ i
, buf
+ i
);
7370 static TargetFdTrans target_signalfd_trans
= {
7371 .host_to_target_data
= host_to_target_data_signalfd
,
7374 static abi_long
do_signalfd4(int fd
, abi_long mask
, int flags
)
7377 target_sigset_t
*target_mask
;
7381 if (flags
& ~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
)) {
7382 return -TARGET_EINVAL
;
7384 if (!lock_user_struct(VERIFY_READ
, target_mask
, mask
, 1)) {
7385 return -TARGET_EFAULT
;
7388 target_to_host_sigset(&host_mask
, target_mask
);
7390 host_flags
= target_to_host_bitmask(flags
, fcntl_flags_tbl
);
7392 ret
= get_errno(signalfd(fd
, &host_mask
, host_flags
));
7394 fd_trans_register(ret
, &target_signalfd_trans
);
7397 unlock_user_struct(target_mask
, mask
, 0);
7403 /* Map host to target signal numbers for the wait family of syscalls.
7404 Assume all other status bits are the same. */
7405 int host_to_target_waitstatus(int status
)
7407 if (WIFSIGNALED(status
)) {
7408 return host_to_target_signal(WTERMSIG(status
)) | (status
& ~0x7f);
7410 if (WIFSTOPPED(status
)) {
7411 return (host_to_target_signal(WSTOPSIG(status
)) << 8)
7417 static int open_self_cmdline(void *cpu_env
, int fd
)
7419 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7420 struct linux_binprm
*bprm
= ((TaskState
*)cpu
->opaque
)->bprm
;
7423 for (i
= 0; i
< bprm
->argc
; i
++) {
7424 size_t len
= strlen(bprm
->argv
[i
]) + 1;
7426 if (write(fd
, bprm
->argv
[i
], len
) != len
) {
7434 static int open_self_maps(void *cpu_env
, int fd
)
7436 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7437 TaskState
*ts
= cpu
->opaque
;
7443 fp
= fopen("/proc/self/maps", "r");
7448 while ((read
= getline(&line
, &len
, fp
)) != -1) {
7449 int fields
, dev_maj
, dev_min
, inode
;
7450 uint64_t min
, max
, offset
;
7451 char flag_r
, flag_w
, flag_x
, flag_p
;
7452 char path
[512] = "";
7453 fields
= sscanf(line
, "%"PRIx64
"-%"PRIx64
" %c%c%c%c %"PRIx64
" %x:%x %d"
7454 " %512s", &min
, &max
, &flag_r
, &flag_w
, &flag_x
,
7455 &flag_p
, &offset
, &dev_maj
, &dev_min
, &inode
, path
);
7457 if ((fields
< 10) || (fields
> 11)) {
7460 if (h2g_valid(min
)) {
7461 int flags
= page_get_flags(h2g(min
));
7462 max
= h2g_valid(max
- 1) ? max
: (uintptr_t)g2h(GUEST_ADDR_MAX
);
7463 if (page_check_range(h2g(min
), max
- min
, flags
) == -1) {
7466 if (h2g(min
) == ts
->info
->stack_limit
) {
7467 pstrcpy(path
, sizeof(path
), " [stack]");
7469 dprintf(fd
, TARGET_ABI_FMT_lx
"-" TARGET_ABI_FMT_lx
7470 " %c%c%c%c %08" PRIx64
" %02x:%02x %d %s%s\n",
7471 h2g(min
), h2g(max
- 1) + 1, flag_r
, flag_w
,
7472 flag_x
, flag_p
, offset
, dev_maj
, dev_min
, inode
,
7473 path
[0] ? " " : "", path
);
7483 static int open_self_stat(void *cpu_env
, int fd
)
7485 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7486 TaskState
*ts
= cpu
->opaque
;
7487 abi_ulong start_stack
= ts
->info
->start_stack
;
7490 for (i
= 0; i
< 44; i
++) {
7498 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
7499 } else if (i
== 1) {
7501 snprintf(buf
, sizeof(buf
), "(%s) ", ts
->bprm
->argv
[0]);
7502 } else if (i
== 27) {
7505 snprintf(buf
, sizeof(buf
), "%"PRId64
" ", val
);
7507 /* for the rest, there is MasterCard */
7508 snprintf(buf
, sizeof(buf
), "0%c", i
== 43 ? '\n' : ' ');
7512 if (write(fd
, buf
, len
) != len
) {
7520 static int open_self_auxv(void *cpu_env
, int fd
)
7522 CPUState
*cpu
= ENV_GET_CPU((CPUArchState
*)cpu_env
);
7523 TaskState
*ts
= cpu
->opaque
;
7524 abi_ulong auxv
= ts
->info
->saved_auxv
;
7525 abi_ulong len
= ts
->info
->auxv_len
;
7529 * Auxiliary vector is stored in target process stack.
7530 * read in whole auxv vector and copy it to file
7532 ptr
= lock_user(VERIFY_READ
, auxv
, len
, 0);
7536 r
= write(fd
, ptr
, len
);
7543 lseek(fd
, 0, SEEK_SET
);
7544 unlock_user(ptr
, auxv
, len
);
7550 static int is_proc_myself(const char *filename
, const char *entry
)
7552 if (!strncmp(filename
, "/proc/", strlen("/proc/"))) {
7553 filename
+= strlen("/proc/");
7554 if (!strncmp(filename
, "self/", strlen("self/"))) {
7555 filename
+= strlen("self/");
7556 } else if (*filename
>= '1' && *filename
<= '9') {
7558 snprintf(myself
, sizeof(myself
), "%d/", getpid());
7559 if (!strncmp(filename
, myself
, strlen(myself
))) {
7560 filename
+= strlen(myself
);
7567 if (!strcmp(filename
, entry
)) {
7574 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7575 static int is_proc(const char *filename
, const char *entry
)
7577 return strcmp(filename
, entry
) == 0;
7580 static int open_net_route(void *cpu_env
, int fd
)
7587 fp
= fopen("/proc/net/route", "r");
7594 read
= getline(&line
, &len
, fp
);
7595 dprintf(fd
, "%s", line
);
7599 while ((read
= getline(&line
, &len
, fp
)) != -1) {
7601 uint32_t dest
, gw
, mask
;
7602 unsigned int flags
, refcnt
, use
, metric
, mtu
, window
, irtt
;
7603 sscanf(line
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7604 iface
, &dest
, &gw
, &flags
, &refcnt
, &use
, &metric
,
7605 &mask
, &mtu
, &window
, &irtt
);
7606 dprintf(fd
, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7607 iface
, tswap32(dest
), tswap32(gw
), flags
, refcnt
, use
,
7608 metric
, tswap32(mask
), mtu
, window
, irtt
);
7618 static int do_openat(void *cpu_env
, int dirfd
, const char *pathname
, int flags
, mode_t mode
)
7621 const char *filename
;
7622 int (*fill
)(void *cpu_env
, int fd
);
7623 int (*cmp
)(const char *s1
, const char *s2
);
7625 const struct fake_open
*fake_open
;
7626 static const struct fake_open fakes
[] = {
7627 { "maps", open_self_maps
, is_proc_myself
},
7628 { "stat", open_self_stat
, is_proc_myself
},
7629 { "auxv", open_self_auxv
, is_proc_myself
},
7630 { "cmdline", open_self_cmdline
, is_proc_myself
},
7631 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7632 { "/proc/net/route", open_net_route
, is_proc
},
7634 { NULL
, NULL
, NULL
}
7637 if (is_proc_myself(pathname
, "exe")) {
7638 int execfd
= qemu_getauxval(AT_EXECFD
);
7639 return execfd
? execfd
: safe_openat(dirfd
, exec_path
, flags
, mode
);
7642 for (fake_open
= fakes
; fake_open
->filename
; fake_open
++) {
7643 if (fake_open
->cmp(pathname
, fake_open
->filename
)) {
7648 if (fake_open
->filename
) {
7650 char filename
[PATH_MAX
];
7653 /* create temporary file to map stat to */
7654 tmpdir
= getenv("TMPDIR");
7657 snprintf(filename
, sizeof(filename
), "%s/qemu-open.XXXXXX", tmpdir
);
7658 fd
= mkstemp(filename
);
7664 if ((r
= fake_open
->fill(cpu_env
, fd
))) {
7670 lseek(fd
, 0, SEEK_SET
);
7675 return safe_openat(dirfd
, path(pathname
), flags
, mode
);
7678 #define TIMER_MAGIC 0x0caf0000
7679 #define TIMER_MAGIC_MASK 0xffff0000
7681 /* Convert QEMU provided timer ID back to internal 16bit index format */
7682 static target_timer_t
get_timer_id(abi_long arg
)
7684 target_timer_t timerid
= arg
;
7686 if ((timerid
& TIMER_MAGIC_MASK
) != TIMER_MAGIC
) {
7687 return -TARGET_EINVAL
;
7692 if (timerid
>= ARRAY_SIZE(g_posix_timers
)) {
7693 return -TARGET_EINVAL
;
7699 static abi_long
swap_data_eventfd(void *buf
, size_t len
)
7701 uint64_t *counter
= buf
;
7704 if (len
< sizeof(uint64_t)) {
7708 for (i
= 0; i
< len
; i
+= sizeof(uint64_t)) {
7709 *counter
= tswap64(*counter
);
7716 static TargetFdTrans target_eventfd_trans
= {
7717 .host_to_target_data
= swap_data_eventfd
,
7718 .target_to_host_data
= swap_data_eventfd
,
7721 #if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
7722 (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
7723 defined(__NR_inotify_init1))
7724 static abi_long
host_to_target_data_inotify(void *buf
, size_t len
)
7726 struct inotify_event
*ev
;
7730 for (i
= 0; i
< len
; i
+= sizeof(struct inotify_event
) + name_len
) {
7731 ev
= (struct inotify_event
*)((char *)buf
+ i
);
7734 ev
->wd
= tswap32(ev
->wd
);
7735 ev
->mask
= tswap32(ev
->mask
);
7736 ev
->cookie
= tswap32(ev
->cookie
);
7737 ev
->len
= tswap32(name_len
);
7743 static TargetFdTrans target_inotify_trans
= {
7744 .host_to_target_data
= host_to_target_data_inotify
,
7748 static int target_to_host_cpu_mask(unsigned long *host_mask
,
7750 abi_ulong target_addr
,
7753 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7754 unsigned host_bits
= sizeof(*host_mask
) * 8;
7755 abi_ulong
*target_mask
;
7758 assert(host_size
>= target_size
);
7760 target_mask
= lock_user(VERIFY_READ
, target_addr
, target_size
, 1);
7762 return -TARGET_EFAULT
;
7764 memset(host_mask
, 0, host_size
);
7766 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7767 unsigned bit
= i
* target_bits
;
7770 __get_user(val
, &target_mask
[i
]);
7771 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7772 if (val
& (1UL << j
)) {
7773 host_mask
[bit
/ host_bits
] |= 1UL << (bit
% host_bits
);
7778 unlock_user(target_mask
, target_addr
, 0);
7782 static int host_to_target_cpu_mask(const unsigned long *host_mask
,
7784 abi_ulong target_addr
,
7787 unsigned target_bits
= sizeof(abi_ulong
) * 8;
7788 unsigned host_bits
= sizeof(*host_mask
) * 8;
7789 abi_ulong
*target_mask
;
7792 assert(host_size
>= target_size
);
7794 target_mask
= lock_user(VERIFY_WRITE
, target_addr
, target_size
, 0);
7796 return -TARGET_EFAULT
;
7799 for (i
= 0 ; i
< target_size
/ sizeof(abi_ulong
); i
++) {
7800 unsigned bit
= i
* target_bits
;
7803 for (j
= 0; j
< target_bits
; j
++, bit
++) {
7804 if (host_mask
[bit
/ host_bits
] & (1UL << (bit
% host_bits
))) {
7808 __put_user(val
, &target_mask
[i
]);
7811 unlock_user(target_mask
, target_addr
, target_size
);
7815 /* do_syscall() should always have a single exit point at the end so
7816 that actions, such as logging of syscall results, can be performed.
7817 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
7818 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
7819 abi_long arg2
, abi_long arg3
, abi_long arg4
,
7820 abi_long arg5
, abi_long arg6
, abi_long arg7
,
7823 CPUState
*cpu
= ENV_GET_CPU(cpu_env
);
7829 #if defined(DEBUG_ERESTARTSYS)
7830 /* Debug-only code for exercising the syscall-restart code paths
7831 * in the per-architecture cpu main loops: restart every syscall
7832 * the guest makes once before letting it through.
7839 return -TARGET_ERESTARTSYS
;
7845 gemu_log("syscall %d", num
);
7847 trace_guest_user_syscall(cpu
, num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
);
7849 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
7852 case TARGET_NR_exit
:
7853 /* In old applications this may be used to implement _exit(2).
7854 However in threaded applictions it is used for thread termination,
7855 and _exit_group is used for application termination.
7856 Do thread termination if we have more then one thread. */
7858 if (block_signals()) {
7859 ret
= -TARGET_ERESTARTSYS
;
7865 if (CPU_NEXT(first_cpu
)) {
7868 /* Remove the CPU from the list. */
7869 QTAILQ_REMOVE(&cpus
, cpu
, node
);
7874 if (ts
->child_tidptr
) {
7875 put_user_u32(0, ts
->child_tidptr
);
7876 sys_futex(g2h(ts
->child_tidptr
), FUTEX_WAKE
, INT_MAX
,
7880 object_unref(OBJECT(cpu
));
7882 rcu_unregister_thread();
7890 gdb_exit(cpu_env
, arg1
);
7892 ret
= 0; /* avoid warning */
7894 case TARGET_NR_read
:
7898 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
7900 ret
= get_errno(safe_read(arg1
, p
, arg3
));
7902 fd_trans_host_to_target_data(arg1
)) {
7903 ret
= fd_trans_host_to_target_data(arg1
)(p
, ret
);
7905 unlock_user(p
, arg2
, ret
);
7908 case TARGET_NR_write
:
7909 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
7911 if (fd_trans_target_to_host_data(arg1
)) {
7912 void *copy
= g_malloc(arg3
);
7913 memcpy(copy
, p
, arg3
);
7914 ret
= fd_trans_target_to_host_data(arg1
)(copy
, arg3
);
7916 ret
= get_errno(safe_write(arg1
, copy
, ret
));
7920 ret
= get_errno(safe_write(arg1
, p
, arg3
));
7922 unlock_user(p
, arg2
, 0);
7924 #ifdef TARGET_NR_open
7925 case TARGET_NR_open
:
7926 if (!(p
= lock_user_string(arg1
)))
7928 ret
= get_errno(do_openat(cpu_env
, AT_FDCWD
, p
,
7929 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
7931 fd_trans_unregister(ret
);
7932 unlock_user(p
, arg1
, 0);
7935 case TARGET_NR_openat
:
7936 if (!(p
= lock_user_string(arg2
)))
7938 ret
= get_errno(do_openat(cpu_env
, arg1
, p
,
7939 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
7941 fd_trans_unregister(ret
);
7942 unlock_user(p
, arg2
, 0);
7944 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7945 case TARGET_NR_name_to_handle_at
:
7946 ret
= do_name_to_handle_at(arg1
, arg2
, arg3
, arg4
, arg5
);
7949 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7950 case TARGET_NR_open_by_handle_at
:
7951 ret
= do_open_by_handle_at(arg1
, arg2
, arg3
);
7952 fd_trans_unregister(ret
);
7955 case TARGET_NR_close
:
7956 fd_trans_unregister(arg1
);
7957 ret
= get_errno(close(arg1
));
7962 #ifdef TARGET_NR_fork
7963 case TARGET_NR_fork
:
7964 ret
= get_errno(do_fork(cpu_env
, TARGET_SIGCHLD
, 0, 0, 0, 0));
7967 #ifdef TARGET_NR_waitpid
7968 case TARGET_NR_waitpid
:
7971 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, 0));
7972 if (!is_error(ret
) && arg2
&& ret
7973 && put_user_s32(host_to_target_waitstatus(status
), arg2
))
7978 #ifdef TARGET_NR_waitid
7979 case TARGET_NR_waitid
:
7983 ret
= get_errno(safe_waitid(arg1
, arg2
, &info
, arg4
, NULL
));
7984 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
7985 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
7987 host_to_target_siginfo(p
, &info
);
7988 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
7993 #ifdef TARGET_NR_creat /* not on alpha */
7994 case TARGET_NR_creat
:
7995 if (!(p
= lock_user_string(arg1
)))
7997 ret
= get_errno(creat(p
, arg2
));
7998 fd_trans_unregister(ret
);
7999 unlock_user(p
, arg1
, 0);
8002 #ifdef TARGET_NR_link
8003 case TARGET_NR_link
:
8006 p
= lock_user_string(arg1
);
8007 p2
= lock_user_string(arg2
);
8009 ret
= -TARGET_EFAULT
;
8011 ret
= get_errno(link(p
, p2
));
8012 unlock_user(p2
, arg2
, 0);
8013 unlock_user(p
, arg1
, 0);
8017 #if defined(TARGET_NR_linkat)
8018 case TARGET_NR_linkat
:
8023 p
= lock_user_string(arg2
);
8024 p2
= lock_user_string(arg4
);
8026 ret
= -TARGET_EFAULT
;
8028 ret
= get_errno(linkat(arg1
, p
, arg3
, p2
, arg5
));
8029 unlock_user(p
, arg2
, 0);
8030 unlock_user(p2
, arg4
, 0);
8034 #ifdef TARGET_NR_unlink
8035 case TARGET_NR_unlink
:
8036 if (!(p
= lock_user_string(arg1
)))
8038 ret
= get_errno(unlink(p
));
8039 unlock_user(p
, arg1
, 0);
8042 #if defined(TARGET_NR_unlinkat)
8043 case TARGET_NR_unlinkat
:
8044 if (!(p
= lock_user_string(arg2
)))
8046 ret
= get_errno(unlinkat(arg1
, p
, arg3
));
8047 unlock_user(p
, arg2
, 0);
8050 case TARGET_NR_execve
:
8052 char **argp
, **envp
;
8055 abi_ulong guest_argp
;
8056 abi_ulong guest_envp
;
8063 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
8064 if (get_user_ual(addr
, gp
))
8072 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
8073 if (get_user_ual(addr
, gp
))
8080 argp
= g_new0(char *, argc
+ 1);
8081 envp
= g_new0(char *, envc
+ 1);
8083 for (gp
= guest_argp
, q
= argp
; gp
;
8084 gp
+= sizeof(abi_ulong
), q
++) {
8085 if (get_user_ual(addr
, gp
))
8089 if (!(*q
= lock_user_string(addr
)))
8091 total_size
+= strlen(*q
) + 1;
8095 for (gp
= guest_envp
, q
= envp
; gp
;
8096 gp
+= sizeof(abi_ulong
), q
++) {
8097 if (get_user_ual(addr
, gp
))
8101 if (!(*q
= lock_user_string(addr
)))
8103 total_size
+= strlen(*q
) + 1;
8107 if (!(p
= lock_user_string(arg1
)))
8109 /* Although execve() is not an interruptible syscall it is
8110 * a special case where we must use the safe_syscall wrapper:
8111 * if we allow a signal to happen before we make the host
8112 * syscall then we will 'lose' it, because at the point of
8113 * execve the process leaves QEMU's control. So we use the
8114 * safe syscall wrapper to ensure that we either take the
8115 * signal as a guest signal, or else it does not happen
8116 * before the execve completes and makes it the other
8117 * program's problem.
8119 ret
= get_errno(safe_execve(p
, argp
, envp
));
8120 unlock_user(p
, arg1
, 0);
8125 ret
= -TARGET_EFAULT
;
8128 for (gp
= guest_argp
, q
= argp
; *q
;
8129 gp
+= sizeof(abi_ulong
), q
++) {
8130 if (get_user_ual(addr
, gp
)
8133 unlock_user(*q
, addr
, 0);
8135 for (gp
= guest_envp
, q
= envp
; *q
;
8136 gp
+= sizeof(abi_ulong
), q
++) {
8137 if (get_user_ual(addr
, gp
)
8140 unlock_user(*q
, addr
, 0);
8147 case TARGET_NR_chdir
:
8148 if (!(p
= lock_user_string(arg1
)))
8150 ret
= get_errno(chdir(p
));
8151 unlock_user(p
, arg1
, 0);
8153 #ifdef TARGET_NR_time
8154 case TARGET_NR_time
:
8157 ret
= get_errno(time(&host_time
));
8160 && put_user_sal(host_time
, arg1
))
8165 #ifdef TARGET_NR_mknod
8166 case TARGET_NR_mknod
:
8167 if (!(p
= lock_user_string(arg1
)))
8169 ret
= get_errno(mknod(p
, arg2
, arg3
));
8170 unlock_user(p
, arg1
, 0);
8173 #if defined(TARGET_NR_mknodat)
8174 case TARGET_NR_mknodat
:
8175 if (!(p
= lock_user_string(arg2
)))
8177 ret
= get_errno(mknodat(arg1
, p
, arg3
, arg4
));
8178 unlock_user(p
, arg2
, 0);
8181 #ifdef TARGET_NR_chmod
8182 case TARGET_NR_chmod
:
8183 if (!(p
= lock_user_string(arg1
)))
8185 ret
= get_errno(chmod(p
, arg2
));
8186 unlock_user(p
, arg1
, 0);
8189 #ifdef TARGET_NR_break
8190 case TARGET_NR_break
:
8193 #ifdef TARGET_NR_oldstat
8194 case TARGET_NR_oldstat
:
8197 case TARGET_NR_lseek
:
8198 ret
= get_errno(lseek(arg1
, arg2
, arg3
));
8200 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
8201 /* Alpha specific */
8202 case TARGET_NR_getxpid
:
8203 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
] = getppid();
8204 ret
= get_errno(getpid());
8207 #ifdef TARGET_NR_getpid
8208 case TARGET_NR_getpid
:
8209 ret
= get_errno(getpid());
8212 case TARGET_NR_mount
:
8214 /* need to look at the data field */
8218 p
= lock_user_string(arg1
);
8226 p2
= lock_user_string(arg2
);
8229 unlock_user(p
, arg1
, 0);
8235 p3
= lock_user_string(arg3
);
8238 unlock_user(p
, arg1
, 0);
8240 unlock_user(p2
, arg2
, 0);
8247 /* FIXME - arg5 should be locked, but it isn't clear how to
8248 * do that since it's not guaranteed to be a NULL-terminated
8252 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, NULL
);
8254 ret
= mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
));
8256 ret
= get_errno(ret
);
8259 unlock_user(p
, arg1
, 0);
8261 unlock_user(p2
, arg2
, 0);
8263 unlock_user(p3
, arg3
, 0);
8267 #ifdef TARGET_NR_umount
8268 case TARGET_NR_umount
:
8269 if (!(p
= lock_user_string(arg1
)))
8271 ret
= get_errno(umount(p
));
8272 unlock_user(p
, arg1
, 0);
8275 #ifdef TARGET_NR_stime /* not on alpha */
8276 case TARGET_NR_stime
:
8279 if (get_user_sal(host_time
, arg1
))
8281 ret
= get_errno(stime(&host_time
));
8285 case TARGET_NR_ptrace
:
8287 #ifdef TARGET_NR_alarm /* not on alpha */
8288 case TARGET_NR_alarm
:
8292 #ifdef TARGET_NR_oldfstat
8293 case TARGET_NR_oldfstat
:
8296 #ifdef TARGET_NR_pause /* not on alpha */
8297 case TARGET_NR_pause
:
8298 if (!block_signals()) {
8299 sigsuspend(&((TaskState
*)cpu
->opaque
)->signal_mask
);
8301 ret
= -TARGET_EINTR
;
8304 #ifdef TARGET_NR_utime
8305 case TARGET_NR_utime
:
8307 struct utimbuf tbuf
, *host_tbuf
;
8308 struct target_utimbuf
*target_tbuf
;
8310 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
8312 tbuf
.actime
= tswapal(target_tbuf
->actime
);
8313 tbuf
.modtime
= tswapal(target_tbuf
->modtime
);
8314 unlock_user_struct(target_tbuf
, arg2
, 0);
8319 if (!(p
= lock_user_string(arg1
)))
8321 ret
= get_errno(utime(p
, host_tbuf
));
8322 unlock_user(p
, arg1
, 0);
8326 #ifdef TARGET_NR_utimes
8327 case TARGET_NR_utimes
:
8329 struct timeval
*tvp
, tv
[2];
8331 if (copy_from_user_timeval(&tv
[0], arg2
)
8332 || copy_from_user_timeval(&tv
[1],
8333 arg2
+ sizeof(struct target_timeval
)))
8339 if (!(p
= lock_user_string(arg1
)))
8341 ret
= get_errno(utimes(p
, tvp
));
8342 unlock_user(p
, arg1
, 0);
8346 #if defined(TARGET_NR_futimesat)
8347 case TARGET_NR_futimesat
:
8349 struct timeval
*tvp
, tv
[2];
8351 if (copy_from_user_timeval(&tv
[0], arg3
)
8352 || copy_from_user_timeval(&tv
[1],
8353 arg3
+ sizeof(struct target_timeval
)))
8359 if (!(p
= lock_user_string(arg2
)))
8361 ret
= get_errno(futimesat(arg1
, path(p
), tvp
));
8362 unlock_user(p
, arg2
, 0);
8366 #ifdef TARGET_NR_stty
8367 case TARGET_NR_stty
:
8370 #ifdef TARGET_NR_gtty
8371 case TARGET_NR_gtty
:
8374 #ifdef TARGET_NR_access
8375 case TARGET_NR_access
:
8376 if (!(p
= lock_user_string(arg1
)))
8378 ret
= get_errno(access(path(p
), arg2
));
8379 unlock_user(p
, arg1
, 0);
8382 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
8383 case TARGET_NR_faccessat
:
8384 if (!(p
= lock_user_string(arg2
)))
8386 ret
= get_errno(faccessat(arg1
, p
, arg3
, 0));
8387 unlock_user(p
, arg2
, 0);
8390 #ifdef TARGET_NR_nice /* not on alpha */
8391 case TARGET_NR_nice
:
8392 ret
= get_errno(nice(arg1
));
8395 #ifdef TARGET_NR_ftime
8396 case TARGET_NR_ftime
:
8399 case TARGET_NR_sync
:
8403 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
8404 case TARGET_NR_syncfs
:
8405 ret
= get_errno(syncfs(arg1
));
8408 case TARGET_NR_kill
:
8409 ret
= get_errno(safe_kill(arg1
, target_to_host_signal(arg2
)));
8411 #ifdef TARGET_NR_rename
8412 case TARGET_NR_rename
:
8415 p
= lock_user_string(arg1
);
8416 p2
= lock_user_string(arg2
);
8418 ret
= -TARGET_EFAULT
;
8420 ret
= get_errno(rename(p
, p2
));
8421 unlock_user(p2
, arg2
, 0);
8422 unlock_user(p
, arg1
, 0);
8426 #if defined(TARGET_NR_renameat)
8427 case TARGET_NR_renameat
:
8430 p
= lock_user_string(arg2
);
8431 p2
= lock_user_string(arg4
);
8433 ret
= -TARGET_EFAULT
;
8435 ret
= get_errno(renameat(arg1
, p
, arg3
, p2
));
8436 unlock_user(p2
, arg4
, 0);
8437 unlock_user(p
, arg2
, 0);
8441 #if defined(TARGET_NR_renameat2)
8442 case TARGET_NR_renameat2
:
8445 p
= lock_user_string(arg2
);
8446 p2
= lock_user_string(arg4
);
8448 ret
= -TARGET_EFAULT
;
8450 ret
= get_errno(sys_renameat2(arg1
, p
, arg3
, p2
, arg5
));
8452 unlock_user(p2
, arg4
, 0);
8453 unlock_user(p
, arg2
, 0);
8457 #ifdef TARGET_NR_mkdir
8458 case TARGET_NR_mkdir
:
8459 if (!(p
= lock_user_string(arg1
)))
8461 ret
= get_errno(mkdir(p
, arg2
));
8462 unlock_user(p
, arg1
, 0);
8465 #if defined(TARGET_NR_mkdirat)
8466 case TARGET_NR_mkdirat
:
8467 if (!(p
= lock_user_string(arg2
)))
8469 ret
= get_errno(mkdirat(arg1
, p
, arg3
));
8470 unlock_user(p
, arg2
, 0);
8473 #ifdef TARGET_NR_rmdir
8474 case TARGET_NR_rmdir
:
8475 if (!(p
= lock_user_string(arg1
)))
8477 ret
= get_errno(rmdir(p
));
8478 unlock_user(p
, arg1
, 0);
8482 ret
= get_errno(dup(arg1
));
8484 fd_trans_dup(arg1
, ret
);
8487 #ifdef TARGET_NR_pipe
8488 case TARGET_NR_pipe
:
8489 ret
= do_pipe(cpu_env
, arg1
, 0, 0);
8492 #ifdef TARGET_NR_pipe2
8493 case TARGET_NR_pipe2
:
8494 ret
= do_pipe(cpu_env
, arg1
,
8495 target_to_host_bitmask(arg2
, fcntl_flags_tbl
), 1);
8498 case TARGET_NR_times
:
8500 struct target_tms
*tmsp
;
8502 ret
= get_errno(times(&tms
));
8504 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
8507 tmsp
->tms_utime
= tswapal(host_to_target_clock_t(tms
.tms_utime
));
8508 tmsp
->tms_stime
= tswapal(host_to_target_clock_t(tms
.tms_stime
));
8509 tmsp
->tms_cutime
= tswapal(host_to_target_clock_t(tms
.tms_cutime
));
8510 tmsp
->tms_cstime
= tswapal(host_to_target_clock_t(tms
.tms_cstime
));
8513 ret
= host_to_target_clock_t(ret
);
8516 #ifdef TARGET_NR_prof
8517 case TARGET_NR_prof
:
8520 #ifdef TARGET_NR_signal
8521 case TARGET_NR_signal
:
8524 case TARGET_NR_acct
:
8526 ret
= get_errno(acct(NULL
));
8528 if (!(p
= lock_user_string(arg1
)))
8530 ret
= get_errno(acct(path(p
)));
8531 unlock_user(p
, arg1
, 0);
8534 #ifdef TARGET_NR_umount2
8535 case TARGET_NR_umount2
:
8536 if (!(p
= lock_user_string(arg1
)))
8538 ret
= get_errno(umount2(p
, arg2
));
8539 unlock_user(p
, arg1
, 0);
8542 #ifdef TARGET_NR_lock
8543 case TARGET_NR_lock
:
8546 case TARGET_NR_ioctl
:
8547 ret
= do_ioctl(arg1
, arg2
, arg3
);
8549 case TARGET_NR_fcntl
:
8550 ret
= do_fcntl(arg1
, arg2
, arg3
);
8552 #ifdef TARGET_NR_mpx
8556 case TARGET_NR_setpgid
:
8557 ret
= get_errno(setpgid(arg1
, arg2
));
8559 #ifdef TARGET_NR_ulimit
8560 case TARGET_NR_ulimit
:
8563 #ifdef TARGET_NR_oldolduname
8564 case TARGET_NR_oldolduname
:
8567 case TARGET_NR_umask
:
8568 ret
= get_errno(umask(arg1
));
8570 case TARGET_NR_chroot
:
8571 if (!(p
= lock_user_string(arg1
)))
8573 ret
= get_errno(chroot(p
));
8574 unlock_user(p
, arg1
, 0);
8576 #ifdef TARGET_NR_ustat
8577 case TARGET_NR_ustat
:
8580 #ifdef TARGET_NR_dup2
8581 case TARGET_NR_dup2
:
8582 ret
= get_errno(dup2(arg1
, arg2
));
8584 fd_trans_dup(arg1
, arg2
);
8588 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
8589 case TARGET_NR_dup3
:
8593 if ((arg3
& ~TARGET_O_CLOEXEC
) != 0) {
8596 host_flags
= target_to_host_bitmask(arg3
, fcntl_flags_tbl
);
8597 ret
= get_errno(dup3(arg1
, arg2
, host_flags
));
8599 fd_trans_dup(arg1
, arg2
);
8604 #ifdef TARGET_NR_getppid /* not on alpha */
8605 case TARGET_NR_getppid
:
8606 ret
= get_errno(getppid());
8609 #ifdef TARGET_NR_getpgrp
8610 case TARGET_NR_getpgrp
:
8611 ret
= get_errno(getpgrp());
8614 case TARGET_NR_setsid
:
8615 ret
= get_errno(setsid());
8617 #ifdef TARGET_NR_sigaction
8618 case TARGET_NR_sigaction
:
8620 #if defined(TARGET_ALPHA)
8621 struct target_sigaction act
, oact
, *pact
= 0;
8622 struct target_old_sigaction
*old_act
;
8624 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8626 act
._sa_handler
= old_act
->_sa_handler
;
8627 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
8628 act
.sa_flags
= old_act
->sa_flags
;
8629 act
.sa_restorer
= 0;
8630 unlock_user_struct(old_act
, arg2
, 0);
8633 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8634 if (!is_error(ret
) && arg3
) {
8635 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8637 old_act
->_sa_handler
= oact
._sa_handler
;
8638 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
8639 old_act
->sa_flags
= oact
.sa_flags
;
8640 unlock_user_struct(old_act
, arg3
, 1);
8642 #elif defined(TARGET_MIPS)
8643 struct target_sigaction act
, oact
, *pact
, *old_act
;
8646 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8648 act
._sa_handler
= old_act
->_sa_handler
;
8649 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
8650 act
.sa_flags
= old_act
->sa_flags
;
8651 unlock_user_struct(old_act
, arg2
, 0);
8657 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8659 if (!is_error(ret
) && arg3
) {
8660 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8662 old_act
->_sa_handler
= oact
._sa_handler
;
8663 old_act
->sa_flags
= oact
.sa_flags
;
8664 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
8665 old_act
->sa_mask
.sig
[1] = 0;
8666 old_act
->sa_mask
.sig
[2] = 0;
8667 old_act
->sa_mask
.sig
[3] = 0;
8668 unlock_user_struct(old_act
, arg3
, 1);
8671 struct target_old_sigaction
*old_act
;
8672 struct target_sigaction act
, oact
, *pact
;
8674 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
8676 act
._sa_handler
= old_act
->_sa_handler
;
8677 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
8678 act
.sa_flags
= old_act
->sa_flags
;
8679 act
.sa_restorer
= old_act
->sa_restorer
;
8680 unlock_user_struct(old_act
, arg2
, 0);
8685 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8686 if (!is_error(ret
) && arg3
) {
8687 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
8689 old_act
->_sa_handler
= oact
._sa_handler
;
8690 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
8691 old_act
->sa_flags
= oact
.sa_flags
;
8692 old_act
->sa_restorer
= oact
.sa_restorer
;
8693 unlock_user_struct(old_act
, arg3
, 1);
8699 case TARGET_NR_rt_sigaction
:
8701 #if defined(TARGET_ALPHA)
8702 /* For Alpha and SPARC this is a 5 argument syscall, with
8703 * a 'restorer' parameter which must be copied into the
8704 * sa_restorer field of the sigaction struct.
8705 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
8706 * and arg5 is the sigsetsize.
8707 * Alpha also has a separate rt_sigaction struct that it uses
8708 * here; SPARC uses the usual sigaction struct.
8710 struct target_rt_sigaction
*rt_act
;
8711 struct target_sigaction act
, oact
, *pact
= 0;
8713 if (arg4
!= sizeof(target_sigset_t
)) {
8714 ret
= -TARGET_EINVAL
;
8718 if (!lock_user_struct(VERIFY_READ
, rt_act
, arg2
, 1))
8720 act
._sa_handler
= rt_act
->_sa_handler
;
8721 act
.sa_mask
= rt_act
->sa_mask
;
8722 act
.sa_flags
= rt_act
->sa_flags
;
8723 act
.sa_restorer
= arg5
;
8724 unlock_user_struct(rt_act
, arg2
, 0);
8727 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
8728 if (!is_error(ret
) && arg3
) {
8729 if (!lock_user_struct(VERIFY_WRITE
, rt_act
, arg3
, 0))
8731 rt_act
->_sa_handler
= oact
._sa_handler
;
8732 rt_act
->sa_mask
= oact
.sa_mask
;
8733 rt_act
->sa_flags
= oact
.sa_flags
;
8734 unlock_user_struct(rt_act
, arg3
, 1);
8738 target_ulong restorer
= arg4
;
8739 target_ulong sigsetsize
= arg5
;
8741 target_ulong sigsetsize
= arg4
;
8743 struct target_sigaction
*act
;
8744 struct target_sigaction
*oact
;
8746 if (sigsetsize
!= sizeof(target_sigset_t
)) {
8747 ret
= -TARGET_EINVAL
;
8751 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1)) {
8755 act
->sa_restorer
= restorer
;
8761 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
8762 ret
= -TARGET_EFAULT
;
8763 goto rt_sigaction_fail
;
8767 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
8770 unlock_user_struct(act
, arg2
, 0);
8772 unlock_user_struct(oact
, arg3
, 1);
8776 #ifdef TARGET_NR_sgetmask /* not on alpha */
8777 case TARGET_NR_sgetmask
:
8780 abi_ulong target_set
;
8781 ret
= do_sigprocmask(0, NULL
, &cur_set
);
8783 host_to_target_old_sigset(&target_set
, &cur_set
);
8789 #ifdef TARGET_NR_ssetmask /* not on alpha */
8790 case TARGET_NR_ssetmask
:
8793 abi_ulong target_set
= arg1
;
8794 target_to_host_old_sigset(&set
, &target_set
);
8795 ret
= do_sigprocmask(SIG_SETMASK
, &set
, &oset
);
8797 host_to_target_old_sigset(&target_set
, &oset
);
8803 #ifdef TARGET_NR_sigprocmask
8804 case TARGET_NR_sigprocmask
:
8806 #if defined(TARGET_ALPHA)
8807 sigset_t set
, oldset
;
8812 case TARGET_SIG_BLOCK
:
8815 case TARGET_SIG_UNBLOCK
:
8818 case TARGET_SIG_SETMASK
:
8822 ret
= -TARGET_EINVAL
;
8826 target_to_host_old_sigset(&set
, &mask
);
8828 ret
= do_sigprocmask(how
, &set
, &oldset
);
8829 if (!is_error(ret
)) {
8830 host_to_target_old_sigset(&mask
, &oldset
);
8832 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0; /* force no error */
8835 sigset_t set
, oldset
, *set_ptr
;
8840 case TARGET_SIG_BLOCK
:
8843 case TARGET_SIG_UNBLOCK
:
8846 case TARGET_SIG_SETMASK
:
8850 ret
= -TARGET_EINVAL
;
8853 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8855 target_to_host_old_sigset(&set
, p
);
8856 unlock_user(p
, arg2
, 0);
8862 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8863 if (!is_error(ret
) && arg3
) {
8864 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8866 host_to_target_old_sigset(p
, &oldset
);
8867 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8873 case TARGET_NR_rt_sigprocmask
:
8876 sigset_t set
, oldset
, *set_ptr
;
8878 if (arg4
!= sizeof(target_sigset_t
)) {
8879 ret
= -TARGET_EINVAL
;
8885 case TARGET_SIG_BLOCK
:
8888 case TARGET_SIG_UNBLOCK
:
8891 case TARGET_SIG_SETMASK
:
8895 ret
= -TARGET_EINVAL
;
8898 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
8900 target_to_host_sigset(&set
, p
);
8901 unlock_user(p
, arg2
, 0);
8907 ret
= do_sigprocmask(how
, set_ptr
, &oldset
);
8908 if (!is_error(ret
) && arg3
) {
8909 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
8911 host_to_target_sigset(p
, &oldset
);
8912 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
8916 #ifdef TARGET_NR_sigpending
8917 case TARGET_NR_sigpending
:
8920 ret
= get_errno(sigpending(&set
));
8921 if (!is_error(ret
)) {
8922 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8924 host_to_target_old_sigset(p
, &set
);
8925 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8930 case TARGET_NR_rt_sigpending
:
8934 /* Yes, this check is >, not != like most. We follow the kernel's
8935 * logic and it does it like this because it implements
8936 * NR_sigpending through the same code path, and in that case
8937 * the old_sigset_t is smaller in size.
8939 if (arg2
> sizeof(target_sigset_t
)) {
8940 ret
= -TARGET_EINVAL
;
8944 ret
= get_errno(sigpending(&set
));
8945 if (!is_error(ret
)) {
8946 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
8948 host_to_target_sigset(p
, &set
);
8949 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
8953 #ifdef TARGET_NR_sigsuspend
8954 case TARGET_NR_sigsuspend
:
8956 TaskState
*ts
= cpu
->opaque
;
8957 #if defined(TARGET_ALPHA)
8958 abi_ulong mask
= arg1
;
8959 target_to_host_old_sigset(&ts
->sigsuspend_mask
, &mask
);
8961 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8963 target_to_host_old_sigset(&ts
->sigsuspend_mask
, p
);
8964 unlock_user(p
, arg1
, 0);
8966 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8968 if (ret
!= -TARGET_ERESTARTSYS
) {
8969 ts
->in_sigsuspend
= 1;
8974 case TARGET_NR_rt_sigsuspend
:
8976 TaskState
*ts
= cpu
->opaque
;
8978 if (arg2
!= sizeof(target_sigset_t
)) {
8979 ret
= -TARGET_EINVAL
;
8982 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
8984 target_to_host_sigset(&ts
->sigsuspend_mask
, p
);
8985 unlock_user(p
, arg1
, 0);
8986 ret
= get_errno(safe_rt_sigsuspend(&ts
->sigsuspend_mask
,
8988 if (ret
!= -TARGET_ERESTARTSYS
) {
8989 ts
->in_sigsuspend
= 1;
8993 case TARGET_NR_rt_sigtimedwait
:
8996 struct timespec uts
, *puts
;
8999 if (arg4
!= sizeof(target_sigset_t
)) {
9000 ret
= -TARGET_EINVAL
;
9004 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
9006 target_to_host_sigset(&set
, p
);
9007 unlock_user(p
, arg1
, 0);
9010 target_to_host_timespec(puts
, arg3
);
9014 ret
= get_errno(safe_rt_sigtimedwait(&set
, &uinfo
, puts
,
9016 if (!is_error(ret
)) {
9018 p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
),
9023 host_to_target_siginfo(p
, &uinfo
);
9024 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
9026 ret
= host_to_target_signal(ret
);
9030 case TARGET_NR_rt_sigqueueinfo
:
9034 p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_siginfo_t
), 1);
9038 target_to_host_siginfo(&uinfo
, p
);
9039 unlock_user(p
, arg3
, 0);
9040 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
9043 case TARGET_NR_rt_tgsigqueueinfo
:
9047 p
= lock_user(VERIFY_READ
, arg4
, sizeof(target_siginfo_t
), 1);
9051 target_to_host_siginfo(&uinfo
, p
);
9052 unlock_user(p
, arg4
, 0);
9053 ret
= get_errno(sys_rt_tgsigqueueinfo(arg1
, arg2
, arg3
, &uinfo
));
9056 #ifdef TARGET_NR_sigreturn
9057 case TARGET_NR_sigreturn
:
9058 if (block_signals()) {
9059 ret
= -TARGET_ERESTARTSYS
;
9061 ret
= do_sigreturn(cpu_env
);
9065 case TARGET_NR_rt_sigreturn
:
9066 if (block_signals()) {
9067 ret
= -TARGET_ERESTARTSYS
;
9069 ret
= do_rt_sigreturn(cpu_env
);
9072 case TARGET_NR_sethostname
:
9073 if (!(p
= lock_user_string(arg1
)))
9075 ret
= get_errno(sethostname(p
, arg2
));
9076 unlock_user(p
, arg1
, 0);
9078 case TARGET_NR_setrlimit
:
9080 int resource
= target_to_host_resource(arg1
);
9081 struct target_rlimit
*target_rlim
;
9083 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
9085 rlim
.rlim_cur
= target_to_host_rlim(target_rlim
->rlim_cur
);
9086 rlim
.rlim_max
= target_to_host_rlim(target_rlim
->rlim_max
);
9087 unlock_user_struct(target_rlim
, arg2
, 0);
9088 ret
= get_errno(setrlimit(resource
, &rlim
));
9091 case TARGET_NR_getrlimit
:
9093 int resource
= target_to_host_resource(arg1
);
9094 struct target_rlimit
*target_rlim
;
9097 ret
= get_errno(getrlimit(resource
, &rlim
));
9098 if (!is_error(ret
)) {
9099 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
9101 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
9102 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
9103 unlock_user_struct(target_rlim
, arg2
, 1);
9107 case TARGET_NR_getrusage
:
9109 struct rusage rusage
;
9110 ret
= get_errno(getrusage(arg1
, &rusage
));
9111 if (!is_error(ret
)) {
9112 ret
= host_to_target_rusage(arg2
, &rusage
);
9116 case TARGET_NR_gettimeofday
:
9119 ret
= get_errno(gettimeofday(&tv
, NULL
));
9120 if (!is_error(ret
)) {
9121 if (copy_to_user_timeval(arg1
, &tv
))
9126 case TARGET_NR_settimeofday
:
9128 struct timeval tv
, *ptv
= NULL
;
9129 struct timezone tz
, *ptz
= NULL
;
9132 if (copy_from_user_timeval(&tv
, arg1
)) {
9139 if (copy_from_user_timezone(&tz
, arg2
)) {
9145 ret
= get_errno(settimeofday(ptv
, ptz
));
9148 #if defined(TARGET_NR_select)
9149 case TARGET_NR_select
:
9150 #if defined(TARGET_WANT_NI_OLD_SELECT)
9151 /* some architectures used to have old_select here
9152 * but now ENOSYS it.
9154 ret
= -TARGET_ENOSYS
;
9155 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
9156 ret
= do_old_select(arg1
);
9158 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
9162 #ifdef TARGET_NR_pselect6
9163 case TARGET_NR_pselect6
:
9165 abi_long rfd_addr
, wfd_addr
, efd_addr
, n
, ts_addr
;
9166 fd_set rfds
, wfds
, efds
;
9167 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
9168 struct timespec ts
, *ts_ptr
;
9171 * The 6th arg is actually two args smashed together,
9172 * so we cannot use the C library.
9180 abi_ulong arg_sigset
, arg_sigsize
, *arg7
;
9181 target_sigset_t
*target_sigset
;
9189 ret
= copy_from_user_fdset_ptr(&rfds
, &rfds_ptr
, rfd_addr
, n
);
9193 ret
= copy_from_user_fdset_ptr(&wfds
, &wfds_ptr
, wfd_addr
, n
);
9197 ret
= copy_from_user_fdset_ptr(&efds
, &efds_ptr
, efd_addr
, n
);
9203 * This takes a timespec, and not a timeval, so we cannot
9204 * use the do_select() helper ...
9207 if (target_to_host_timespec(&ts
, ts_addr
)) {
9215 /* Extract the two packed args for the sigset */
9218 sig
.size
= SIGSET_T_SIZE
;
9220 arg7
= lock_user(VERIFY_READ
, arg6
, sizeof(*arg7
) * 2, 1);
9224 arg_sigset
= tswapal(arg7
[0]);
9225 arg_sigsize
= tswapal(arg7
[1]);
9226 unlock_user(arg7
, arg6
, 0);
9230 if (arg_sigsize
!= sizeof(*target_sigset
)) {
9231 /* Like the kernel, we enforce correct size sigsets */
9232 ret
= -TARGET_EINVAL
;
9235 target_sigset
= lock_user(VERIFY_READ
, arg_sigset
,
9236 sizeof(*target_sigset
), 1);
9237 if (!target_sigset
) {
9240 target_to_host_sigset(&set
, target_sigset
);
9241 unlock_user(target_sigset
, arg_sigset
, 0);
9249 ret
= get_errno(safe_pselect6(n
, rfds_ptr
, wfds_ptr
, efds_ptr
,
9252 if (!is_error(ret
)) {
9253 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
9255 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
9257 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
9260 if (ts_addr
&& host_to_target_timespec(ts_addr
, &ts
))
9266 #ifdef TARGET_NR_symlink
9267 case TARGET_NR_symlink
:
9270 p
= lock_user_string(arg1
);
9271 p2
= lock_user_string(arg2
);
9273 ret
= -TARGET_EFAULT
;
9275 ret
= get_errno(symlink(p
, p2
));
9276 unlock_user(p2
, arg2
, 0);
9277 unlock_user(p
, arg1
, 0);
9281 #if defined(TARGET_NR_symlinkat)
9282 case TARGET_NR_symlinkat
:
9285 p
= lock_user_string(arg1
);
9286 p2
= lock_user_string(arg3
);
9288 ret
= -TARGET_EFAULT
;
9290 ret
= get_errno(symlinkat(p
, arg2
, p2
));
9291 unlock_user(p2
, arg3
, 0);
9292 unlock_user(p
, arg1
, 0);
9296 #ifdef TARGET_NR_oldlstat
9297 case TARGET_NR_oldlstat
:
9300 #ifdef TARGET_NR_readlink
9301 case TARGET_NR_readlink
:
9304 p
= lock_user_string(arg1
);
9305 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9307 ret
= -TARGET_EFAULT
;
9309 /* Short circuit this for the magic exe check. */
9310 ret
= -TARGET_EINVAL
;
9311 } else if (is_proc_myself((const char *)p
, "exe")) {
9312 char real
[PATH_MAX
], *temp
;
9313 temp
= realpath(exec_path
, real
);
9314 /* Return value is # of bytes that we wrote to the buffer. */
9316 ret
= get_errno(-1);
9318 /* Don't worry about sign mismatch as earlier mapping
9319 * logic would have thrown a bad address error. */
9320 ret
= MIN(strlen(real
), arg3
);
9321 /* We cannot NUL terminate the string. */
9322 memcpy(p2
, real
, ret
);
9325 ret
= get_errno(readlink(path(p
), p2
, arg3
));
9327 unlock_user(p2
, arg2
, ret
);
9328 unlock_user(p
, arg1
, 0);
9332 #if defined(TARGET_NR_readlinkat)
9333 case TARGET_NR_readlinkat
:
9336 p
= lock_user_string(arg2
);
9337 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
9339 ret
= -TARGET_EFAULT
;
9340 } else if (is_proc_myself((const char *)p
, "exe")) {
9341 char real
[PATH_MAX
], *temp
;
9342 temp
= realpath(exec_path
, real
);
9343 ret
= temp
== NULL
? get_errno(-1) : strlen(real
) ;
9344 snprintf((char *)p2
, arg4
, "%s", real
);
9346 ret
= get_errno(readlinkat(arg1
, path(p
), p2
, arg4
));
9348 unlock_user(p2
, arg3
, ret
);
9349 unlock_user(p
, arg2
, 0);
9353 #ifdef TARGET_NR_uselib
9354 case TARGET_NR_uselib
:
9357 #ifdef TARGET_NR_swapon
9358 case TARGET_NR_swapon
:
9359 if (!(p
= lock_user_string(arg1
)))
9361 ret
= get_errno(swapon(p
, arg2
));
9362 unlock_user(p
, arg1
, 0);
9365 case TARGET_NR_reboot
:
9366 if (arg3
== LINUX_REBOOT_CMD_RESTART2
) {
9367 /* arg4 must be ignored in all other cases */
9368 p
= lock_user_string(arg4
);
9372 ret
= get_errno(reboot(arg1
, arg2
, arg3
, p
));
9373 unlock_user(p
, arg4
, 0);
9375 ret
= get_errno(reboot(arg1
, arg2
, arg3
, NULL
));
9378 #ifdef TARGET_NR_readdir
9379 case TARGET_NR_readdir
:
9382 #ifdef TARGET_NR_mmap
9383 case TARGET_NR_mmap
:
9384 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
9385 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
9386 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
9387 || defined(TARGET_S390X)
9390 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
9391 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
9399 unlock_user(v
, arg1
, 0);
9400 ret
= get_errno(target_mmap(v1
, v2
, v3
,
9401 target_to_host_bitmask(v4
, mmap_flags_tbl
),
9405 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
9406 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
9412 #ifdef TARGET_NR_mmap2
9413 case TARGET_NR_mmap2
:
9415 #define MMAP_SHIFT 12
9417 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
9418 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
9420 arg6
<< MMAP_SHIFT
));
9423 case TARGET_NR_munmap
:
9424 ret
= get_errno(target_munmap(arg1
, arg2
));
9426 case TARGET_NR_mprotect
:
9428 TaskState
*ts
= cpu
->opaque
;
9429 /* Special hack to detect libc making the stack executable. */
9430 if ((arg3
& PROT_GROWSDOWN
)
9431 && arg1
>= ts
->info
->stack_limit
9432 && arg1
<= ts
->info
->start_stack
) {
9433 arg3
&= ~PROT_GROWSDOWN
;
9434 arg2
= arg2
+ arg1
- ts
->info
->stack_limit
;
9435 arg1
= ts
->info
->stack_limit
;
9438 ret
= get_errno(target_mprotect(arg1
, arg2
, arg3
));
9440 #ifdef TARGET_NR_mremap
9441 case TARGET_NR_mremap
:
9442 ret
= get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
9445 /* ??? msync/mlock/munlock are broken for softmmu. */
9446 #ifdef TARGET_NR_msync
9447 case TARGET_NR_msync
:
9448 ret
= get_errno(msync(g2h(arg1
), arg2
, arg3
));
9451 #ifdef TARGET_NR_mlock
9452 case TARGET_NR_mlock
:
9453 ret
= get_errno(mlock(g2h(arg1
), arg2
));
9456 #ifdef TARGET_NR_munlock
9457 case TARGET_NR_munlock
:
9458 ret
= get_errno(munlock(g2h(arg1
), arg2
));
9461 #ifdef TARGET_NR_mlockall
9462 case TARGET_NR_mlockall
:
9463 ret
= get_errno(mlockall(target_to_host_mlockall_arg(arg1
)));
9466 #ifdef TARGET_NR_munlockall
9467 case TARGET_NR_munlockall
:
9468 ret
= get_errno(munlockall());
9471 case TARGET_NR_truncate
:
9472 if (!(p
= lock_user_string(arg1
)))
9474 ret
= get_errno(truncate(p
, arg2
));
9475 unlock_user(p
, arg1
, 0);
9477 case TARGET_NR_ftruncate
:
9478 ret
= get_errno(ftruncate(arg1
, arg2
));
9480 case TARGET_NR_fchmod
:
9481 ret
= get_errno(fchmod(arg1
, arg2
));
9483 #if defined(TARGET_NR_fchmodat)
9484 case TARGET_NR_fchmodat
:
9485 if (!(p
= lock_user_string(arg2
)))
9487 ret
= get_errno(fchmodat(arg1
, p
, arg3
, 0));
9488 unlock_user(p
, arg2
, 0);
9491 case TARGET_NR_getpriority
:
9492 /* Note that negative values are valid for getpriority, so we must
9493 differentiate based on errno settings. */
9495 ret
= getpriority(arg1
, arg2
);
9496 if (ret
== -1 && errno
!= 0) {
9497 ret
= -host_to_target_errno(errno
);
9501 /* Return value is the unbiased priority. Signal no error. */
9502 ((CPUAlphaState
*)cpu_env
)->ir
[IR_V0
] = 0;
9504 /* Return value is a biased priority to avoid negative numbers. */
9508 case TARGET_NR_setpriority
:
9509 ret
= get_errno(setpriority(arg1
, arg2
, arg3
));
9511 #ifdef TARGET_NR_profil
9512 case TARGET_NR_profil
:
9515 case TARGET_NR_statfs
:
9516 if (!(p
= lock_user_string(arg1
)))
9518 ret
= get_errno(statfs(path(p
), &stfs
));
9519 unlock_user(p
, arg1
, 0);
9521 if (!is_error(ret
)) {
9522 struct target_statfs
*target_stfs
;
9524 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
9526 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
9527 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
9528 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
9529 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
9530 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
9531 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
9532 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
9533 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
9534 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
9535 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
9536 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
9537 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
9538 unlock_user_struct(target_stfs
, arg2
, 1);
9541 case TARGET_NR_fstatfs
:
9542 ret
= get_errno(fstatfs(arg1
, &stfs
));
9543 goto convert_statfs
;
9544 #ifdef TARGET_NR_statfs64
9545 case TARGET_NR_statfs64
:
9546 if (!(p
= lock_user_string(arg1
)))
9548 ret
= get_errno(statfs(path(p
), &stfs
));
9549 unlock_user(p
, arg1
, 0);
9551 if (!is_error(ret
)) {
9552 struct target_statfs64
*target_stfs
;
9554 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
9556 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
9557 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
9558 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
9559 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
9560 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
9561 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
9562 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
9563 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
9564 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
9565 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
9566 __put_user(stfs
.f_frsize
, &target_stfs
->f_frsize
);
9567 memset(target_stfs
->f_spare
, 0, sizeof(target_stfs
->f_spare
));
9568 unlock_user_struct(target_stfs
, arg3
, 1);
9571 case TARGET_NR_fstatfs64
:
9572 ret
= get_errno(fstatfs(arg1
, &stfs
));
9573 goto convert_statfs64
;
9575 #ifdef TARGET_NR_ioperm
9576 case TARGET_NR_ioperm
:
9579 #ifdef TARGET_NR_socketcall
9580 case TARGET_NR_socketcall
:
9581 ret
= do_socketcall(arg1
, arg2
);
9584 #ifdef TARGET_NR_accept
9585 case TARGET_NR_accept
:
9586 ret
= do_accept4(arg1
, arg2
, arg3
, 0);
9589 #ifdef TARGET_NR_accept4
9590 case TARGET_NR_accept4
:
9591 ret
= do_accept4(arg1
, arg2
, arg3
, arg4
);
9594 #ifdef TARGET_NR_bind
9595 case TARGET_NR_bind
:
9596 ret
= do_bind(arg1
, arg2
, arg3
);
9599 #ifdef TARGET_NR_connect
9600 case TARGET_NR_connect
:
9601 ret
= do_connect(arg1
, arg2
, arg3
);
9604 #ifdef TARGET_NR_getpeername
9605 case TARGET_NR_getpeername
:
9606 ret
= do_getpeername(arg1
, arg2
, arg3
);
9609 #ifdef TARGET_NR_getsockname
9610 case TARGET_NR_getsockname
:
9611 ret
= do_getsockname(arg1
, arg2
, arg3
);
9614 #ifdef TARGET_NR_getsockopt
9615 case TARGET_NR_getsockopt
:
9616 ret
= do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
9619 #ifdef TARGET_NR_listen
9620 case TARGET_NR_listen
:
9621 ret
= get_errno(listen(arg1
, arg2
));
9624 #ifdef TARGET_NR_recv
9625 case TARGET_NR_recv
:
9626 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
9629 #ifdef TARGET_NR_recvfrom
9630 case TARGET_NR_recvfrom
:
9631 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9634 #ifdef TARGET_NR_recvmsg
9635 case TARGET_NR_recvmsg
:
9636 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
9639 #ifdef TARGET_NR_send
9640 case TARGET_NR_send
:
9641 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
9644 #ifdef TARGET_NR_sendmsg
9645 case TARGET_NR_sendmsg
:
9646 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
9649 #ifdef TARGET_NR_sendmmsg
9650 case TARGET_NR_sendmmsg
:
9651 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 1);
9653 case TARGET_NR_recvmmsg
:
9654 ret
= do_sendrecvmmsg(arg1
, arg2
, arg3
, arg4
, 0);
9657 #ifdef TARGET_NR_sendto
9658 case TARGET_NR_sendto
:
9659 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9662 #ifdef TARGET_NR_shutdown
9663 case TARGET_NR_shutdown
:
9664 ret
= get_errno(shutdown(arg1
, arg2
));
9667 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
9668 case TARGET_NR_getrandom
:
9669 p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
9673 ret
= get_errno(getrandom(p
, arg2
, arg3
));
9674 unlock_user(p
, arg1
, ret
);
9677 #ifdef TARGET_NR_socket
9678 case TARGET_NR_socket
:
9679 ret
= do_socket(arg1
, arg2
, arg3
);
9682 #ifdef TARGET_NR_socketpair
9683 case TARGET_NR_socketpair
:
9684 ret
= do_socketpair(arg1
, arg2
, arg3
, arg4
);
9687 #ifdef TARGET_NR_setsockopt
9688 case TARGET_NR_setsockopt
:
9689 ret
= do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
9692 #if defined(TARGET_NR_syslog)
9693 case TARGET_NR_syslog
:
9698 case TARGET_SYSLOG_ACTION_CLOSE
: /* Close log */
9699 case TARGET_SYSLOG_ACTION_OPEN
: /* Open log */
9700 case TARGET_SYSLOG_ACTION_CLEAR
: /* Clear ring buffer */
9701 case TARGET_SYSLOG_ACTION_CONSOLE_OFF
: /* Disable logging */
9702 case TARGET_SYSLOG_ACTION_CONSOLE_ON
: /* Enable logging */
9703 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL
: /* Set messages level */
9704 case TARGET_SYSLOG_ACTION_SIZE_UNREAD
: /* Number of chars */
9705 case TARGET_SYSLOG_ACTION_SIZE_BUFFER
: /* Size of the buffer */
9707 ret
= get_errno(sys_syslog((int)arg1
, NULL
, (int)arg3
));
9710 case TARGET_SYSLOG_ACTION_READ
: /* Read from log */
9711 case TARGET_SYSLOG_ACTION_READ_CLEAR
: /* Read/clear msgs */
9712 case TARGET_SYSLOG_ACTION_READ_ALL
: /* Read last messages */
9714 ret
= -TARGET_EINVAL
;
9722 p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
9724 ret
= -TARGET_EFAULT
;
9727 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
9728 unlock_user(p
, arg2
, arg3
);
9738 case TARGET_NR_setitimer
:
9740 struct itimerval value
, ovalue
, *pvalue
;
9744 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
9745 || copy_from_user_timeval(&pvalue
->it_value
,
9746 arg2
+ sizeof(struct target_timeval
)))
9751 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
9752 if (!is_error(ret
) && arg3
) {
9753 if (copy_to_user_timeval(arg3
,
9754 &ovalue
.it_interval
)
9755 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
9761 case TARGET_NR_getitimer
:
9763 struct itimerval value
;
9765 ret
= get_errno(getitimer(arg1
, &value
));
9766 if (!is_error(ret
) && arg2
) {
9767 if (copy_to_user_timeval(arg2
,
9769 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
9775 #ifdef TARGET_NR_stat
9776 case TARGET_NR_stat
:
9777 if (!(p
= lock_user_string(arg1
)))
9779 ret
= get_errno(stat(path(p
), &st
));
9780 unlock_user(p
, arg1
, 0);
9783 #ifdef TARGET_NR_lstat
9784 case TARGET_NR_lstat
:
9785 if (!(p
= lock_user_string(arg1
)))
9787 ret
= get_errno(lstat(path(p
), &st
));
9788 unlock_user(p
, arg1
, 0);
9791 case TARGET_NR_fstat
:
9793 ret
= get_errno(fstat(arg1
, &st
));
9794 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
9797 if (!is_error(ret
)) {
9798 struct target_stat
*target_st
;
9800 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
9802 memset(target_st
, 0, sizeof(*target_st
));
9803 __put_user(st
.st_dev
, &target_st
->st_dev
);
9804 __put_user(st
.st_ino
, &target_st
->st_ino
);
9805 __put_user(st
.st_mode
, &target_st
->st_mode
);
9806 __put_user(st
.st_uid
, &target_st
->st_uid
);
9807 __put_user(st
.st_gid
, &target_st
->st_gid
);
9808 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
9809 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
9810 __put_user(st
.st_size
, &target_st
->st_size
);
9811 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
9812 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
9813 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
9814 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
9815 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
9816 unlock_user_struct(target_st
, arg2
, 1);
9820 #ifdef TARGET_NR_olduname
9821 case TARGET_NR_olduname
:
9824 #ifdef TARGET_NR_iopl
9825 case TARGET_NR_iopl
:
9828 case TARGET_NR_vhangup
:
9829 ret
= get_errno(vhangup());
9831 #ifdef TARGET_NR_idle
9832 case TARGET_NR_idle
:
9835 #ifdef TARGET_NR_syscall
9836 case TARGET_NR_syscall
:
9837 ret
= do_syscall(cpu_env
, arg1
& 0xffff, arg2
, arg3
, arg4
, arg5
,
9838 arg6
, arg7
, arg8
, 0);
9841 case TARGET_NR_wait4
:
9844 abi_long status_ptr
= arg2
;
9845 struct rusage rusage
, *rusage_ptr
;
9846 abi_ulong target_rusage
= arg4
;
9847 abi_long rusage_err
;
9849 rusage_ptr
= &rusage
;
9852 ret
= get_errno(safe_wait4(arg1
, &status
, arg3
, rusage_ptr
));
9853 if (!is_error(ret
)) {
9854 if (status_ptr
&& ret
) {
9855 status
= host_to_target_waitstatus(status
);
9856 if (put_user_s32(status
, status_ptr
))
9859 if (target_rusage
) {
9860 rusage_err
= host_to_target_rusage(target_rusage
, &rusage
);
9868 #ifdef TARGET_NR_swapoff
9869 case TARGET_NR_swapoff
:
9870 if (!(p
= lock_user_string(arg1
)))
9872 ret
= get_errno(swapoff(p
));
9873 unlock_user(p
, arg1
, 0);
9876 case TARGET_NR_sysinfo
:
9878 struct target_sysinfo
*target_value
;
9879 struct sysinfo value
;
9880 ret
= get_errno(sysinfo(&value
));
9881 if (!is_error(ret
) && arg1
)
9883 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
9885 __put_user(value
.uptime
, &target_value
->uptime
);
9886 __put_user(value
.loads
[0], &target_value
->loads
[0]);
9887 __put_user(value
.loads
[1], &target_value
->loads
[1]);
9888 __put_user(value
.loads
[2], &target_value
->loads
[2]);
9889 __put_user(value
.totalram
, &target_value
->totalram
);
9890 __put_user(value
.freeram
, &target_value
->freeram
);
9891 __put_user(value
.sharedram
, &target_value
->sharedram
);
9892 __put_user(value
.bufferram
, &target_value
->bufferram
);
9893 __put_user(value
.totalswap
, &target_value
->totalswap
);
9894 __put_user(value
.freeswap
, &target_value
->freeswap
);
9895 __put_user(value
.procs
, &target_value
->procs
);
9896 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
9897 __put_user(value
.freehigh
, &target_value
->freehigh
);
9898 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
9899 unlock_user_struct(target_value
, arg1
, 1);
9903 #ifdef TARGET_NR_ipc
9905 ret
= do_ipc(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
9908 #ifdef TARGET_NR_semget
9909 case TARGET_NR_semget
:
9910 ret
= get_errno(semget(arg1
, arg2
, arg3
));
9913 #ifdef TARGET_NR_semop
9914 case TARGET_NR_semop
:
9915 ret
= do_semop(arg1
, arg2
, arg3
);
9918 #ifdef TARGET_NR_semctl
9919 case TARGET_NR_semctl
:
9920 ret
= do_semctl(arg1
, arg2
, arg3
, arg4
);
9923 #ifdef TARGET_NR_msgctl
9924 case TARGET_NR_msgctl
:
9925 ret
= do_msgctl(arg1
, arg2
, arg3
);
9928 #ifdef TARGET_NR_msgget
9929 case TARGET_NR_msgget
:
9930 ret
= get_errno(msgget(arg1
, arg2
));
9933 #ifdef TARGET_NR_msgrcv
9934 case TARGET_NR_msgrcv
:
9935 ret
= do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
9938 #ifdef TARGET_NR_msgsnd
9939 case TARGET_NR_msgsnd
:
9940 ret
= do_msgsnd(arg1
, arg2
, arg3
, arg4
);
9943 #ifdef TARGET_NR_shmget
9944 case TARGET_NR_shmget
:
9945 ret
= get_errno(shmget(arg1
, arg2
, arg3
));
9948 #ifdef TARGET_NR_shmctl
9949 case TARGET_NR_shmctl
:
9950 ret
= do_shmctl(arg1
, arg2
, arg3
);
9953 #ifdef TARGET_NR_shmat
9954 case TARGET_NR_shmat
:
9955 ret
= do_shmat(cpu_env
, arg1
, arg2
, arg3
);
9958 #ifdef TARGET_NR_shmdt
9959 case TARGET_NR_shmdt
:
9960 ret
= do_shmdt(arg1
);
9963 case TARGET_NR_fsync
:
9964 ret
= get_errno(fsync(arg1
));
9966 case TARGET_NR_clone
:
9967 /* Linux manages to have three different orderings for its
9968 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
9969 * match the kernel's CONFIG_CLONE_* settings.
9970 * Microblaze is further special in that it uses a sixth
9971 * implicit argument to clone for the TLS pointer.
9973 #if defined(TARGET_MICROBLAZE)
9974 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg4
, arg6
, arg5
));
9975 #elif defined(TARGET_CLONE_BACKWARDS)
9976 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
9977 #elif defined(TARGET_CLONE_BACKWARDS2)
9978 ret
= get_errno(do_fork(cpu_env
, arg2
, arg1
, arg3
, arg5
, arg4
));
9980 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
9983 #ifdef __NR_exit_group
9984 /* new thread calls */
9985 case TARGET_NR_exit_group
:
9989 gdb_exit(cpu_env
, arg1
);
9990 ret
= get_errno(exit_group(arg1
));
9993 case TARGET_NR_setdomainname
:
9994 if (!(p
= lock_user_string(arg1
)))
9996 ret
= get_errno(setdomainname(p
, arg2
));
9997 unlock_user(p
, arg1
, 0);
9999 case TARGET_NR_uname
:
10000 /* no need to transcode because we use the linux syscall */
10002 struct new_utsname
* buf
;
10004 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
10006 ret
= get_errno(sys_uname(buf
));
10007 if (!is_error(ret
)) {
10008 /* Overwrite the native machine name with whatever is being
10010 strcpy (buf
->machine
, cpu_to_uname_machine(cpu_env
));
10011 /* Allow the user to override the reported release. */
10012 if (qemu_uname_release
&& *qemu_uname_release
) {
10013 g_strlcpy(buf
->release
, qemu_uname_release
,
10014 sizeof(buf
->release
));
10017 unlock_user_struct(buf
, arg1
, 1);
10021 case TARGET_NR_modify_ldt
:
10022 ret
= do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
10024 #if !defined(TARGET_X86_64)
10025 case TARGET_NR_vm86old
:
10026 goto unimplemented
;
10027 case TARGET_NR_vm86
:
10028 ret
= do_vm86(cpu_env
, arg1
, arg2
);
10032 case TARGET_NR_adjtimex
:
10034 struct timex host_buf
;
10036 if (target_to_host_timex(&host_buf
, arg1
) != 0) {
10039 ret
= get_errno(adjtimex(&host_buf
));
10040 if (!is_error(ret
)) {
10041 if (host_to_target_timex(arg1
, &host_buf
) != 0) {
10047 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
10048 case TARGET_NR_clock_adjtime
:
10050 struct timex htx
, *phtx
= &htx
;
10052 if (target_to_host_timex(phtx
, arg2
) != 0) {
10055 ret
= get_errno(clock_adjtime(arg1
, phtx
));
10056 if (!is_error(ret
) && phtx
) {
10057 if (host_to_target_timex(arg2
, phtx
) != 0) {
10064 #ifdef TARGET_NR_create_module
10065 case TARGET_NR_create_module
:
10067 case TARGET_NR_init_module
:
10068 case TARGET_NR_delete_module
:
10069 #ifdef TARGET_NR_get_kernel_syms
10070 case TARGET_NR_get_kernel_syms
:
10072 goto unimplemented
;
10073 case TARGET_NR_quotactl
:
10074 goto unimplemented
;
10075 case TARGET_NR_getpgid
:
10076 ret
= get_errno(getpgid(arg1
));
10078 case TARGET_NR_fchdir
:
10079 ret
= get_errno(fchdir(arg1
));
10081 #ifdef TARGET_NR_bdflush /* not on x86_64 */
10082 case TARGET_NR_bdflush
:
10083 goto unimplemented
;
10085 #ifdef TARGET_NR_sysfs
10086 case TARGET_NR_sysfs
:
10087 goto unimplemented
;
10089 case TARGET_NR_personality
:
10090 ret
= get_errno(personality(arg1
));
10092 #ifdef TARGET_NR_afs_syscall
10093 case TARGET_NR_afs_syscall
:
10094 goto unimplemented
;
10096 #ifdef TARGET_NR__llseek /* Not on alpha */
10097 case TARGET_NR__llseek
:
10100 #if !defined(__NR_llseek)
10101 res
= lseek(arg1
, ((uint64_t)arg2
<< 32) | (abi_ulong
)arg3
, arg5
);
10103 ret
= get_errno(res
);
10108 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
10110 if ((ret
== 0) && put_user_s64(res
, arg4
)) {
10116 #ifdef TARGET_NR_getdents
10117 case TARGET_NR_getdents
:
10118 #ifdef __NR_getdents
10119 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
10121 struct target_dirent
*target_dirp
;
10122 struct linux_dirent
*dirp
;
10123 abi_long count
= arg3
;
10125 dirp
= g_try_malloc(count
);
10127 ret
= -TARGET_ENOMEM
;
10131 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
10132 if (!is_error(ret
)) {
10133 struct linux_dirent
*de
;
10134 struct target_dirent
*tde
;
10136 int reclen
, treclen
;
10137 int count1
, tnamelen
;
10141 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10145 reclen
= de
->d_reclen
;
10146 tnamelen
= reclen
- offsetof(struct linux_dirent
, d_name
);
10147 assert(tnamelen
>= 0);
10148 treclen
= tnamelen
+ offsetof(struct target_dirent
, d_name
);
10149 assert(count1
+ treclen
<= count
);
10150 tde
->d_reclen
= tswap16(treclen
);
10151 tde
->d_ino
= tswapal(de
->d_ino
);
10152 tde
->d_off
= tswapal(de
->d_off
);
10153 memcpy(tde
->d_name
, de
->d_name
, tnamelen
);
10154 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
10156 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
10160 unlock_user(target_dirp
, arg2
, ret
);
10166 struct linux_dirent
*dirp
;
10167 abi_long count
= arg3
;
10169 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10171 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
10172 if (!is_error(ret
)) {
10173 struct linux_dirent
*de
;
10178 reclen
= de
->d_reclen
;
10181 de
->d_reclen
= tswap16(reclen
);
10182 tswapls(&de
->d_ino
);
10183 tswapls(&de
->d_off
);
10184 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
10188 unlock_user(dirp
, arg2
, ret
);
10192 /* Implement getdents in terms of getdents64 */
10194 struct linux_dirent64
*dirp
;
10195 abi_long count
= arg3
;
10197 dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0);
10201 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
10202 if (!is_error(ret
)) {
10203 /* Convert the dirent64 structs to target dirent. We do this
10204 * in-place, since we can guarantee that a target_dirent is no
10205 * larger than a dirent64; however this means we have to be
10206 * careful to read everything before writing in the new format.
10208 struct linux_dirent64
*de
;
10209 struct target_dirent
*tde
;
10214 tde
= (struct target_dirent
*)dirp
;
10216 int namelen
, treclen
;
10217 int reclen
= de
->d_reclen
;
10218 uint64_t ino
= de
->d_ino
;
10219 int64_t off
= de
->d_off
;
10220 uint8_t type
= de
->d_type
;
10222 namelen
= strlen(de
->d_name
);
10223 treclen
= offsetof(struct target_dirent
, d_name
)
10225 treclen
= QEMU_ALIGN_UP(treclen
, sizeof(abi_long
));
10227 memmove(tde
->d_name
, de
->d_name
, namelen
+ 1);
10228 tde
->d_ino
= tswapal(ino
);
10229 tde
->d_off
= tswapal(off
);
10230 tde
->d_reclen
= tswap16(treclen
);
10231 /* The target_dirent type is in what was formerly a padding
10232 * byte at the end of the structure:
10234 *(((char *)tde
) + treclen
- 1) = type
;
10236 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
10237 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
10243 unlock_user(dirp
, arg2
, ret
);
10247 #endif /* TARGET_NR_getdents */
10248 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
10249 case TARGET_NR_getdents64
:
10251 struct linux_dirent64
*dirp
;
10252 abi_long count
= arg3
;
10253 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
10255 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
10256 if (!is_error(ret
)) {
10257 struct linux_dirent64
*de
;
10262 reclen
= de
->d_reclen
;
10265 de
->d_reclen
= tswap16(reclen
);
10266 tswap64s((uint64_t *)&de
->d_ino
);
10267 tswap64s((uint64_t *)&de
->d_off
);
10268 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
10272 unlock_user(dirp
, arg2
, ret
);
10275 #endif /* TARGET_NR_getdents64 */
10276 #if defined(TARGET_NR__newselect)
10277 case TARGET_NR__newselect
:
10278 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
10281 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
10282 # ifdef TARGET_NR_poll
10283 case TARGET_NR_poll
:
10285 # ifdef TARGET_NR_ppoll
10286 case TARGET_NR_ppoll
:
10289 struct target_pollfd
*target_pfd
;
10290 unsigned int nfds
= arg2
;
10291 struct pollfd
*pfd
;
10297 if (nfds
> (INT_MAX
/ sizeof(struct target_pollfd
))) {
10298 ret
= -TARGET_EINVAL
;
10302 target_pfd
= lock_user(VERIFY_WRITE
, arg1
,
10303 sizeof(struct target_pollfd
) * nfds
, 1);
10308 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
10309 for (i
= 0; i
< nfds
; i
++) {
10310 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
10311 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
10316 # ifdef TARGET_NR_ppoll
10317 case TARGET_NR_ppoll
:
10319 struct timespec _timeout_ts
, *timeout_ts
= &_timeout_ts
;
10320 target_sigset_t
*target_set
;
10321 sigset_t _set
, *set
= &_set
;
10324 if (target_to_host_timespec(timeout_ts
, arg3
)) {
10325 unlock_user(target_pfd
, arg1
, 0);
10333 if (arg5
!= sizeof(target_sigset_t
)) {
10334 unlock_user(target_pfd
, arg1
, 0);
10335 ret
= -TARGET_EINVAL
;
10339 target_set
= lock_user(VERIFY_READ
, arg4
, sizeof(target_sigset_t
), 1);
10341 unlock_user(target_pfd
, arg1
, 0);
10344 target_to_host_sigset(set
, target_set
);
10349 ret
= get_errno(safe_ppoll(pfd
, nfds
, timeout_ts
,
10350 set
, SIGSET_T_SIZE
));
10352 if (!is_error(ret
) && arg3
) {
10353 host_to_target_timespec(arg3
, timeout_ts
);
10356 unlock_user(target_set
, arg4
, 0);
10361 # ifdef TARGET_NR_poll
10362 case TARGET_NR_poll
:
10364 struct timespec ts
, *pts
;
10367 /* Convert ms to secs, ns */
10368 ts
.tv_sec
= arg3
/ 1000;
10369 ts
.tv_nsec
= (arg3
% 1000) * 1000000LL;
10372 /* -ve poll() timeout means "infinite" */
10375 ret
= get_errno(safe_ppoll(pfd
, nfds
, pts
, NULL
, 0));
10380 g_assert_not_reached();
10383 if (!is_error(ret
)) {
10384 for(i
= 0; i
< nfds
; i
++) {
10385 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
10388 unlock_user(target_pfd
, arg1
, sizeof(struct target_pollfd
) * nfds
);
10392 case TARGET_NR_flock
:
10393 /* NOTE: the flock constant seems to be the same for every
10395 ret
= get_errno(safe_flock(arg1
, arg2
));
10397 case TARGET_NR_readv
:
10399 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
10401 ret
= get_errno(safe_readv(arg1
, vec
, arg3
));
10402 unlock_iovec(vec
, arg2
, arg3
, 1);
10404 ret
= -host_to_target_errno(errno
);
10408 case TARGET_NR_writev
:
10410 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
10412 ret
= get_errno(safe_writev(arg1
, vec
, arg3
));
10413 unlock_iovec(vec
, arg2
, arg3
, 0);
10415 ret
= -host_to_target_errno(errno
);
10419 #if defined(TARGET_NR_preadv)
10420 case TARGET_NR_preadv
:
10422 struct iovec
*vec
= lock_iovec(VERIFY_WRITE
, arg2
, arg3
, 0);
10424 ret
= get_errno(safe_preadv(arg1
, vec
, arg3
, arg4
, arg5
));
10425 unlock_iovec(vec
, arg2
, arg3
, 1);
10427 ret
= -host_to_target_errno(errno
);
10432 #if defined(TARGET_NR_pwritev)
10433 case TARGET_NR_pwritev
:
10435 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
10437 ret
= get_errno(safe_pwritev(arg1
, vec
, arg3
, arg4
, arg5
));
10438 unlock_iovec(vec
, arg2
, arg3
, 0);
10440 ret
= -host_to_target_errno(errno
);
10445 case TARGET_NR_getsid
:
10446 ret
= get_errno(getsid(arg1
));
10448 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
10449 case TARGET_NR_fdatasync
:
10450 ret
= get_errno(fdatasync(arg1
));
10453 #ifdef TARGET_NR__sysctl
10454 case TARGET_NR__sysctl
:
10455 /* We don't implement this, but ENOTDIR is always a safe
10457 ret
= -TARGET_ENOTDIR
;
10460 case TARGET_NR_sched_getaffinity
:
10462 unsigned int mask_size
;
10463 unsigned long *mask
;
10466 * sched_getaffinity needs multiples of ulong, so need to take
10467 * care of mismatches between target ulong and host ulong sizes.
10469 if (arg2
& (sizeof(abi_ulong
) - 1)) {
10470 ret
= -TARGET_EINVAL
;
10473 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
10475 mask
= alloca(mask_size
);
10476 memset(mask
, 0, mask_size
);
10477 ret
= get_errno(sys_sched_getaffinity(arg1
, mask_size
, mask
));
10479 if (!is_error(ret
)) {
10481 /* More data returned than the caller's buffer will fit.
10482 * This only happens if sizeof(abi_long) < sizeof(long)
10483 * and the caller passed us a buffer holding an odd number
10484 * of abi_longs. If the host kernel is actually using the
10485 * extra 4 bytes then fail EINVAL; otherwise we can just
10486 * ignore them and only copy the interesting part.
10488 int numcpus
= sysconf(_SC_NPROCESSORS_CONF
);
10489 if (numcpus
> arg2
* 8) {
10490 ret
= -TARGET_EINVAL
;
10496 ret
= host_to_target_cpu_mask(mask
, mask_size
, arg3
, arg2
);
10500 case TARGET_NR_sched_setaffinity
:
10502 unsigned int mask_size
;
10503 unsigned long *mask
;
10506 * sched_setaffinity needs multiples of ulong, so need to take
10507 * care of mismatches between target ulong and host ulong sizes.
10509 if (arg2
& (sizeof(abi_ulong
) - 1)) {
10510 ret
= -TARGET_EINVAL
;
10513 mask_size
= (arg2
+ (sizeof(*mask
) - 1)) & ~(sizeof(*mask
) - 1);
10514 mask
= alloca(mask_size
);
10516 ret
= target_to_host_cpu_mask(mask
, mask_size
, arg3
, arg2
);
10521 ret
= get_errno(sys_sched_setaffinity(arg1
, mask_size
, mask
));
10524 case TARGET_NR_getcpu
:
10526 unsigned cpu
, node
;
10527 ret
= get_errno(sys_getcpu(arg1
? &cpu
: NULL
,
10528 arg2
? &node
: NULL
,
10530 if (is_error(ret
)) {
10533 if (arg1
&& put_user_u32(cpu
, arg1
)) {
10536 if (arg2
&& put_user_u32(node
, arg2
)) {
10541 case TARGET_NR_sched_setparam
:
10543 struct sched_param
*target_schp
;
10544 struct sched_param schp
;
10547 return -TARGET_EINVAL
;
10549 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
10551 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
10552 unlock_user_struct(target_schp
, arg2
, 0);
10553 ret
= get_errno(sched_setparam(arg1
, &schp
));
10556 case TARGET_NR_sched_getparam
:
10558 struct sched_param
*target_schp
;
10559 struct sched_param schp
;
10562 return -TARGET_EINVAL
;
10564 ret
= get_errno(sched_getparam(arg1
, &schp
));
10565 if (!is_error(ret
)) {
10566 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
10568 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
10569 unlock_user_struct(target_schp
, arg2
, 1);
10573 case TARGET_NR_sched_setscheduler
:
10575 struct sched_param
*target_schp
;
10576 struct sched_param schp
;
10578 return -TARGET_EINVAL
;
10580 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
10582 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
10583 unlock_user_struct(target_schp
, arg3
, 0);
10584 ret
= get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
10587 case TARGET_NR_sched_getscheduler
:
10588 ret
= get_errno(sched_getscheduler(arg1
));
10590 case TARGET_NR_sched_yield
:
10591 ret
= get_errno(sched_yield());
10593 case TARGET_NR_sched_get_priority_max
:
10594 ret
= get_errno(sched_get_priority_max(arg1
));
10596 case TARGET_NR_sched_get_priority_min
:
10597 ret
= get_errno(sched_get_priority_min(arg1
));
10599 case TARGET_NR_sched_rr_get_interval
:
10601 struct timespec ts
;
10602 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
10603 if (!is_error(ret
)) {
10604 ret
= host_to_target_timespec(arg2
, &ts
);
10608 case TARGET_NR_nanosleep
:
10610 struct timespec req
, rem
;
10611 target_to_host_timespec(&req
, arg1
);
10612 ret
= get_errno(safe_nanosleep(&req
, &rem
));
10613 if (is_error(ret
) && arg2
) {
10614 host_to_target_timespec(arg2
, &rem
);
10618 #ifdef TARGET_NR_query_module
10619 case TARGET_NR_query_module
:
10620 goto unimplemented
;
10622 #ifdef TARGET_NR_nfsservctl
10623 case TARGET_NR_nfsservctl
:
10624 goto unimplemented
;
10626 case TARGET_NR_prctl
:
10628 case PR_GET_PDEATHSIG
:
10631 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
10632 if (!is_error(ret
) && arg2
10633 && put_user_ual(deathsig
, arg2
)) {
10641 void *name
= lock_user(VERIFY_WRITE
, arg2
, 16, 1);
10645 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
10646 arg3
, arg4
, arg5
));
10647 unlock_user(name
, arg2
, 16);
10652 void *name
= lock_user(VERIFY_READ
, arg2
, 16, 1);
10656 ret
= get_errno(prctl(arg1
, (unsigned long)name
,
10657 arg3
, arg4
, arg5
));
10658 unlock_user(name
, arg2
, 0);
10662 case PR_GET_SECCOMP
:
10663 case PR_SET_SECCOMP
:
10664 /* Disable seccomp to prevent the target disabling syscalls we
10666 ret
= -TARGET_EINVAL
;
10669 /* Most prctl options have no pointer arguments */
10670 ret
= get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
10674 #ifdef TARGET_NR_arch_prctl
10675 case TARGET_NR_arch_prctl
:
10676 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
10677 ret
= do_arch_prctl(cpu_env
, arg1
, arg2
);
10680 goto unimplemented
;
10683 #ifdef TARGET_NR_pread64
10684 case TARGET_NR_pread64
:
10685 if (regpairs_aligned(cpu_env
, num
)) {
10689 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
10691 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10692 unlock_user(p
, arg2
, ret
);
10694 case TARGET_NR_pwrite64
:
10695 if (regpairs_aligned(cpu_env
, num
)) {
10699 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
10701 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
10702 unlock_user(p
, arg2
, 0);
10705 case TARGET_NR_getcwd
:
10706 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
10708 ret
= get_errno(sys_getcwd1(p
, arg2
));
10709 unlock_user(p
, arg1
, ret
);
10711 case TARGET_NR_capget
:
10712 case TARGET_NR_capset
:
10714 struct target_user_cap_header
*target_header
;
10715 struct target_user_cap_data
*target_data
= NULL
;
10716 struct __user_cap_header_struct header
;
10717 struct __user_cap_data_struct data
[2];
10718 struct __user_cap_data_struct
*dataptr
= NULL
;
10719 int i
, target_datalen
;
10720 int data_items
= 1;
10722 if (!lock_user_struct(VERIFY_WRITE
, target_header
, arg1
, 1)) {
10725 header
.version
= tswap32(target_header
->version
);
10726 header
.pid
= tswap32(target_header
->pid
);
10728 if (header
.version
!= _LINUX_CAPABILITY_VERSION
) {
10729 /* Version 2 and up takes pointer to two user_data structs */
10733 target_datalen
= sizeof(*target_data
) * data_items
;
10736 if (num
== TARGET_NR_capget
) {
10737 target_data
= lock_user(VERIFY_WRITE
, arg2
, target_datalen
, 0);
10739 target_data
= lock_user(VERIFY_READ
, arg2
, target_datalen
, 1);
10741 if (!target_data
) {
10742 unlock_user_struct(target_header
, arg1
, 0);
10746 if (num
== TARGET_NR_capset
) {
10747 for (i
= 0; i
< data_items
; i
++) {
10748 data
[i
].effective
= tswap32(target_data
[i
].effective
);
10749 data
[i
].permitted
= tswap32(target_data
[i
].permitted
);
10750 data
[i
].inheritable
= tswap32(target_data
[i
].inheritable
);
10757 if (num
== TARGET_NR_capget
) {
10758 ret
= get_errno(capget(&header
, dataptr
));
10760 ret
= get_errno(capset(&header
, dataptr
));
10763 /* The kernel always updates version for both capget and capset */
10764 target_header
->version
= tswap32(header
.version
);
10765 unlock_user_struct(target_header
, arg1
, 1);
10768 if (num
== TARGET_NR_capget
) {
10769 for (i
= 0; i
< data_items
; i
++) {
10770 target_data
[i
].effective
= tswap32(data
[i
].effective
);
10771 target_data
[i
].permitted
= tswap32(data
[i
].permitted
);
10772 target_data
[i
].inheritable
= tswap32(data
[i
].inheritable
);
10774 unlock_user(target_data
, arg2
, target_datalen
);
10776 unlock_user(target_data
, arg2
, 0);
10781 case TARGET_NR_sigaltstack
:
10782 ret
= do_sigaltstack(arg1
, arg2
, get_sp_from_cpustate((CPUArchState
*)cpu_env
));
10785 #ifdef CONFIG_SENDFILE
10786 case TARGET_NR_sendfile
:
10788 off_t
*offp
= NULL
;
10791 ret
= get_user_sal(off
, arg3
);
10792 if (is_error(ret
)) {
10797 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10798 if (!is_error(ret
) && arg3
) {
10799 abi_long ret2
= put_user_sal(off
, arg3
);
10800 if (is_error(ret2
)) {
10806 #ifdef TARGET_NR_sendfile64
10807 case TARGET_NR_sendfile64
:
10809 off_t
*offp
= NULL
;
10812 ret
= get_user_s64(off
, arg3
);
10813 if (is_error(ret
)) {
10818 ret
= get_errno(sendfile(arg1
, arg2
, offp
, arg4
));
10819 if (!is_error(ret
) && arg3
) {
10820 abi_long ret2
= put_user_s64(off
, arg3
);
10821 if (is_error(ret2
)) {
10829 case TARGET_NR_sendfile
:
10830 #ifdef TARGET_NR_sendfile64
10831 case TARGET_NR_sendfile64
:
10833 goto unimplemented
;
10836 #ifdef TARGET_NR_getpmsg
10837 case TARGET_NR_getpmsg
:
10838 goto unimplemented
;
10840 #ifdef TARGET_NR_putpmsg
10841 case TARGET_NR_putpmsg
:
10842 goto unimplemented
;
10844 #ifdef TARGET_NR_vfork
10845 case TARGET_NR_vfork
:
10846 ret
= get_errno(do_fork(cpu_env
,
10847 CLONE_VFORK
| CLONE_VM
| TARGET_SIGCHLD
,
10851 #ifdef TARGET_NR_ugetrlimit
10852 case TARGET_NR_ugetrlimit
:
10854 struct rlimit rlim
;
10855 int resource
= target_to_host_resource(arg1
);
10856 ret
= get_errno(getrlimit(resource
, &rlim
));
10857 if (!is_error(ret
)) {
10858 struct target_rlimit
*target_rlim
;
10859 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
10861 target_rlim
->rlim_cur
= host_to_target_rlim(rlim
.rlim_cur
);
10862 target_rlim
->rlim_max
= host_to_target_rlim(rlim
.rlim_max
);
10863 unlock_user_struct(target_rlim
, arg2
, 1);
10868 #ifdef TARGET_NR_truncate64
10869 case TARGET_NR_truncate64
:
10870 if (!(p
= lock_user_string(arg1
)))
10872 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
10873 unlock_user(p
, arg1
, 0);
10876 #ifdef TARGET_NR_ftruncate64
10877 case TARGET_NR_ftruncate64
:
10878 ret
= target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
10881 #ifdef TARGET_NR_stat64
10882 case TARGET_NR_stat64
:
10883 if (!(p
= lock_user_string(arg1
)))
10885 ret
= get_errno(stat(path(p
), &st
));
10886 unlock_user(p
, arg1
, 0);
10887 if (!is_error(ret
))
10888 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10891 #ifdef TARGET_NR_lstat64
10892 case TARGET_NR_lstat64
:
10893 if (!(p
= lock_user_string(arg1
)))
10895 ret
= get_errno(lstat(path(p
), &st
));
10896 unlock_user(p
, arg1
, 0);
10897 if (!is_error(ret
))
10898 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10901 #ifdef TARGET_NR_fstat64
10902 case TARGET_NR_fstat64
:
10903 ret
= get_errno(fstat(arg1
, &st
));
10904 if (!is_error(ret
))
10905 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
10908 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
10909 #ifdef TARGET_NR_fstatat64
10910 case TARGET_NR_fstatat64
:
10912 #ifdef TARGET_NR_newfstatat
10913 case TARGET_NR_newfstatat
:
10915 if (!(p
= lock_user_string(arg2
)))
10917 ret
= get_errno(fstatat(arg1
, path(p
), &st
, arg4
));
10918 if (!is_error(ret
))
10919 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
10922 #ifdef TARGET_NR_lchown
10923 case TARGET_NR_lchown
:
10924 if (!(p
= lock_user_string(arg1
)))
10926 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
10927 unlock_user(p
, arg1
, 0);
10930 #ifdef TARGET_NR_getuid
10931 case TARGET_NR_getuid
:
10932 ret
= get_errno(high2lowuid(getuid()));
10935 #ifdef TARGET_NR_getgid
10936 case TARGET_NR_getgid
:
10937 ret
= get_errno(high2lowgid(getgid()));
10940 #ifdef TARGET_NR_geteuid
10941 case TARGET_NR_geteuid
:
10942 ret
= get_errno(high2lowuid(geteuid()));
10945 #ifdef TARGET_NR_getegid
10946 case TARGET_NR_getegid
:
10947 ret
= get_errno(high2lowgid(getegid()));
10950 case TARGET_NR_setreuid
:
10951 ret
= get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
10953 case TARGET_NR_setregid
:
10954 ret
= get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
10956 case TARGET_NR_getgroups
:
10958 int gidsetsize
= arg1
;
10959 target_id
*target_grouplist
;
10963 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10964 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
10965 if (gidsetsize
== 0)
10967 if (!is_error(ret
)) {
10968 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* sizeof(target_id
), 0);
10969 if (!target_grouplist
)
10971 for(i
= 0;i
< ret
; i
++)
10972 target_grouplist
[i
] = tswapid(high2lowgid(grouplist
[i
]));
10973 unlock_user(target_grouplist
, arg2
, gidsetsize
* sizeof(target_id
));
10977 case TARGET_NR_setgroups
:
10979 int gidsetsize
= arg1
;
10980 target_id
*target_grouplist
;
10981 gid_t
*grouplist
= NULL
;
10984 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
10985 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* sizeof(target_id
), 1);
10986 if (!target_grouplist
) {
10987 ret
= -TARGET_EFAULT
;
10990 for (i
= 0; i
< gidsetsize
; i
++) {
10991 grouplist
[i
] = low2highgid(tswapid(target_grouplist
[i
]));
10993 unlock_user(target_grouplist
, arg2
, 0);
10995 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
10998 case TARGET_NR_fchown
:
10999 ret
= get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
11001 #if defined(TARGET_NR_fchownat)
11002 case TARGET_NR_fchownat
:
11003 if (!(p
= lock_user_string(arg2
)))
11005 ret
= get_errno(fchownat(arg1
, p
, low2highuid(arg3
),
11006 low2highgid(arg4
), arg5
));
11007 unlock_user(p
, arg2
, 0);
11010 #ifdef TARGET_NR_setresuid
11011 case TARGET_NR_setresuid
:
11012 ret
= get_errno(sys_setresuid(low2highuid(arg1
),
11014 low2highuid(arg3
)));
11017 #ifdef TARGET_NR_getresuid
11018 case TARGET_NR_getresuid
:
11020 uid_t ruid
, euid
, suid
;
11021 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
11022 if (!is_error(ret
)) {
11023 if (put_user_id(high2lowuid(ruid
), arg1
)
11024 || put_user_id(high2lowuid(euid
), arg2
)
11025 || put_user_id(high2lowuid(suid
), arg3
))
11031 #ifdef TARGET_NR_getresgid
11032 case TARGET_NR_setresgid
:
11033 ret
= get_errno(sys_setresgid(low2highgid(arg1
),
11035 low2highgid(arg3
)));
11038 #ifdef TARGET_NR_getresgid
11039 case TARGET_NR_getresgid
:
11041 gid_t rgid
, egid
, sgid
;
11042 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
11043 if (!is_error(ret
)) {
11044 if (put_user_id(high2lowgid(rgid
), arg1
)
11045 || put_user_id(high2lowgid(egid
), arg2
)
11046 || put_user_id(high2lowgid(sgid
), arg3
))
11052 #ifdef TARGET_NR_chown
11053 case TARGET_NR_chown
:
11054 if (!(p
= lock_user_string(arg1
)))
11056 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
11057 unlock_user(p
, arg1
, 0);
11060 case TARGET_NR_setuid
:
11061 ret
= get_errno(sys_setuid(low2highuid(arg1
)));
11063 case TARGET_NR_setgid
:
11064 ret
= get_errno(sys_setgid(low2highgid(arg1
)));
11066 case TARGET_NR_setfsuid
:
11067 ret
= get_errno(setfsuid(arg1
));
11069 case TARGET_NR_setfsgid
:
11070 ret
= get_errno(setfsgid(arg1
));
11073 #ifdef TARGET_NR_lchown32
11074 case TARGET_NR_lchown32
:
11075 if (!(p
= lock_user_string(arg1
)))
11077 ret
= get_errno(lchown(p
, arg2
, arg3
));
11078 unlock_user(p
, arg1
, 0);
11081 #ifdef TARGET_NR_getuid32
11082 case TARGET_NR_getuid32
:
11083 ret
= get_errno(getuid());
11087 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
11088 /* Alpha specific */
11089 case TARGET_NR_getxuid
:
11093 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=euid
;
11095 ret
= get_errno(getuid());
11098 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
11099 /* Alpha specific */
11100 case TARGET_NR_getxgid
:
11104 ((CPUAlphaState
*)cpu_env
)->ir
[IR_A4
]=egid
;
11106 ret
= get_errno(getgid());
11109 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
11110 /* Alpha specific */
11111 case TARGET_NR_osf_getsysinfo
:
11112 ret
= -TARGET_EOPNOTSUPP
;
11114 case TARGET_GSI_IEEE_FP_CONTROL
:
11116 uint64_t swcr
, fpcr
= cpu_alpha_load_fpcr (cpu_env
);
11118 /* Copied from linux ieee_fpcr_to_swcr. */
11119 swcr
= (fpcr
>> 35) & SWCR_STATUS_MASK
;
11120 swcr
|= (fpcr
>> 36) & SWCR_MAP_DMZ
;
11121 swcr
|= (~fpcr
>> 48) & (SWCR_TRAP_ENABLE_INV
11122 | SWCR_TRAP_ENABLE_DZE
11123 | SWCR_TRAP_ENABLE_OVF
);
11124 swcr
|= (~fpcr
>> 57) & (SWCR_TRAP_ENABLE_UNF
11125 | SWCR_TRAP_ENABLE_INE
);
11126 swcr
|= (fpcr
>> 47) & SWCR_MAP_UMZ
;
11127 swcr
|= (~fpcr
>> 41) & SWCR_TRAP_ENABLE_DNO
;
11129 if (put_user_u64 (swcr
, arg2
))
11135 /* case GSI_IEEE_STATE_AT_SIGNAL:
11136 -- Not implemented in linux kernel.
11138 -- Retrieves current unaligned access state; not much used.
11139 case GSI_PROC_TYPE:
11140 -- Retrieves implver information; surely not used.
11141 case GSI_GET_HWRPB:
11142 -- Grabs a copy of the HWRPB; surely not used.
11147 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
11148 /* Alpha specific */
11149 case TARGET_NR_osf_setsysinfo
:
11150 ret
= -TARGET_EOPNOTSUPP
;
11152 case TARGET_SSI_IEEE_FP_CONTROL
:
11154 uint64_t swcr
, fpcr
, orig_fpcr
;
11156 if (get_user_u64 (swcr
, arg2
)) {
11159 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
11160 fpcr
= orig_fpcr
& FPCR_DYN_MASK
;
11162 /* Copied from linux ieee_swcr_to_fpcr. */
11163 fpcr
|= (swcr
& SWCR_STATUS_MASK
) << 35;
11164 fpcr
|= (swcr
& SWCR_MAP_DMZ
) << 36;
11165 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_INV
11166 | SWCR_TRAP_ENABLE_DZE
11167 | SWCR_TRAP_ENABLE_OVF
)) << 48;
11168 fpcr
|= (~swcr
& (SWCR_TRAP_ENABLE_UNF
11169 | SWCR_TRAP_ENABLE_INE
)) << 57;
11170 fpcr
|= (swcr
& SWCR_MAP_UMZ
? FPCR_UNDZ
| FPCR_UNFD
: 0);
11171 fpcr
|= (~swcr
& SWCR_TRAP_ENABLE_DNO
) << 41;
11173 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
11178 case TARGET_SSI_IEEE_RAISE_EXCEPTION
:
11180 uint64_t exc
, fpcr
, orig_fpcr
;
11183 if (get_user_u64(exc
, arg2
)) {
11187 orig_fpcr
= cpu_alpha_load_fpcr(cpu_env
);
11189 /* We only add to the exception status here. */
11190 fpcr
= orig_fpcr
| ((exc
& SWCR_STATUS_MASK
) << 35);
11192 cpu_alpha_store_fpcr(cpu_env
, fpcr
);
11195 /* Old exceptions are not signaled. */
11196 fpcr
&= ~(orig_fpcr
& FPCR_STATUS_MASK
);
11198 /* If any exceptions set by this call,
11199 and are unmasked, send a signal. */
11201 if ((fpcr
& (FPCR_INE
| FPCR_INED
)) == FPCR_INE
) {
11202 si_code
= TARGET_FPE_FLTRES
;
11204 if ((fpcr
& (FPCR_UNF
| FPCR_UNFD
)) == FPCR_UNF
) {
11205 si_code
= TARGET_FPE_FLTUND
;
11207 if ((fpcr
& (FPCR_OVF
| FPCR_OVFD
)) == FPCR_OVF
) {
11208 si_code
= TARGET_FPE_FLTOVF
;
11210 if ((fpcr
& (FPCR_DZE
| FPCR_DZED
)) == FPCR_DZE
) {
11211 si_code
= TARGET_FPE_FLTDIV
;
11213 if ((fpcr
& (FPCR_INV
| FPCR_INVD
)) == FPCR_INV
) {
11214 si_code
= TARGET_FPE_FLTINV
;
11216 if (si_code
!= 0) {
11217 target_siginfo_t info
;
11218 info
.si_signo
= SIGFPE
;
11220 info
.si_code
= si_code
;
11221 info
._sifields
._sigfault
._addr
11222 = ((CPUArchState
*)cpu_env
)->pc
;
11223 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
11224 QEMU_SI_FAULT
, &info
);
11229 /* case SSI_NVPAIRS:
11230 -- Used with SSIN_UACPROC to enable unaligned accesses.
11231 case SSI_IEEE_STATE_AT_SIGNAL:
11232 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
11233 -- Not implemented in linux kernel
11238 #ifdef TARGET_NR_osf_sigprocmask
11239 /* Alpha specific. */
11240 case TARGET_NR_osf_sigprocmask
:
11244 sigset_t set
, oldset
;
11247 case TARGET_SIG_BLOCK
:
11250 case TARGET_SIG_UNBLOCK
:
11253 case TARGET_SIG_SETMASK
:
11257 ret
= -TARGET_EINVAL
;
11261 target_to_host_old_sigset(&set
, &mask
);
11262 ret
= do_sigprocmask(how
, &set
, &oldset
);
11264 host_to_target_old_sigset(&mask
, &oldset
);
11271 #ifdef TARGET_NR_getgid32
11272 case TARGET_NR_getgid32
:
11273 ret
= get_errno(getgid());
11276 #ifdef TARGET_NR_geteuid32
11277 case TARGET_NR_geteuid32
:
11278 ret
= get_errno(geteuid());
11281 #ifdef TARGET_NR_getegid32
11282 case TARGET_NR_getegid32
:
11283 ret
= get_errno(getegid());
11286 #ifdef TARGET_NR_setreuid32
11287 case TARGET_NR_setreuid32
:
11288 ret
= get_errno(setreuid(arg1
, arg2
));
11291 #ifdef TARGET_NR_setregid32
11292 case TARGET_NR_setregid32
:
11293 ret
= get_errno(setregid(arg1
, arg2
));
11296 #ifdef TARGET_NR_getgroups32
11297 case TARGET_NR_getgroups32
:
11299 int gidsetsize
= arg1
;
11300 uint32_t *target_grouplist
;
11304 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11305 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
11306 if (gidsetsize
== 0)
11308 if (!is_error(ret
)) {
11309 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
11310 if (!target_grouplist
) {
11311 ret
= -TARGET_EFAULT
;
11314 for(i
= 0;i
< ret
; i
++)
11315 target_grouplist
[i
] = tswap32(grouplist
[i
]);
11316 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
11321 #ifdef TARGET_NR_setgroups32
11322 case TARGET_NR_setgroups32
:
11324 int gidsetsize
= arg1
;
11325 uint32_t *target_grouplist
;
11329 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
11330 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
11331 if (!target_grouplist
) {
11332 ret
= -TARGET_EFAULT
;
11335 for(i
= 0;i
< gidsetsize
; i
++)
11336 grouplist
[i
] = tswap32(target_grouplist
[i
]);
11337 unlock_user(target_grouplist
, arg2
, 0);
11338 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
11342 #ifdef TARGET_NR_fchown32
11343 case TARGET_NR_fchown32
:
11344 ret
= get_errno(fchown(arg1
, arg2
, arg3
));
11347 #ifdef TARGET_NR_setresuid32
11348 case TARGET_NR_setresuid32
:
11349 ret
= get_errno(sys_setresuid(arg1
, arg2
, arg3
));
11352 #ifdef TARGET_NR_getresuid32
11353 case TARGET_NR_getresuid32
:
11355 uid_t ruid
, euid
, suid
;
11356 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
11357 if (!is_error(ret
)) {
11358 if (put_user_u32(ruid
, arg1
)
11359 || put_user_u32(euid
, arg2
)
11360 || put_user_u32(suid
, arg3
))
11366 #ifdef TARGET_NR_setresgid32
11367 case TARGET_NR_setresgid32
:
11368 ret
= get_errno(sys_setresgid(arg1
, arg2
, arg3
));
11371 #ifdef TARGET_NR_getresgid32
11372 case TARGET_NR_getresgid32
:
11374 gid_t rgid
, egid
, sgid
;
11375 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
11376 if (!is_error(ret
)) {
11377 if (put_user_u32(rgid
, arg1
)
11378 || put_user_u32(egid
, arg2
)
11379 || put_user_u32(sgid
, arg3
))
11385 #ifdef TARGET_NR_chown32
11386 case TARGET_NR_chown32
:
11387 if (!(p
= lock_user_string(arg1
)))
11389 ret
= get_errno(chown(p
, arg2
, arg3
));
11390 unlock_user(p
, arg1
, 0);
11393 #ifdef TARGET_NR_setuid32
11394 case TARGET_NR_setuid32
:
11395 ret
= get_errno(sys_setuid(arg1
));
11398 #ifdef TARGET_NR_setgid32
11399 case TARGET_NR_setgid32
:
11400 ret
= get_errno(sys_setgid(arg1
));
11403 #ifdef TARGET_NR_setfsuid32
11404 case TARGET_NR_setfsuid32
:
11405 ret
= get_errno(setfsuid(arg1
));
11408 #ifdef TARGET_NR_setfsgid32
11409 case TARGET_NR_setfsgid32
:
11410 ret
= get_errno(setfsgid(arg1
));
11414 case TARGET_NR_pivot_root
:
11415 goto unimplemented
;
11416 #ifdef TARGET_NR_mincore
11417 case TARGET_NR_mincore
:
11420 ret
= -TARGET_ENOMEM
;
11421 a
= lock_user(VERIFY_READ
, arg1
, arg2
, 0);
11425 ret
= -TARGET_EFAULT
;
11426 p
= lock_user_string(arg3
);
11430 ret
= get_errno(mincore(a
, arg2
, p
));
11431 unlock_user(p
, arg3
, ret
);
11433 unlock_user(a
, arg1
, 0);
11437 #ifdef TARGET_NR_arm_fadvise64_64
11438 case TARGET_NR_arm_fadvise64_64
:
11439 /* arm_fadvise64_64 looks like fadvise64_64 but
11440 * with different argument order: fd, advice, offset, len
11441 * rather than the usual fd, offset, len, advice.
11442 * Note that offset and len are both 64-bit so appear as
11443 * pairs of 32-bit registers.
11445 ret
= posix_fadvise(arg1
, target_offset64(arg3
, arg4
),
11446 target_offset64(arg5
, arg6
), arg2
);
11447 ret
= -host_to_target_errno(ret
);
11451 #if TARGET_ABI_BITS == 32
11453 #ifdef TARGET_NR_fadvise64_64
11454 case TARGET_NR_fadvise64_64
:
11455 #if defined(TARGET_PPC)
11456 /* 6 args: fd, advice, offset (high, low), len (high, low) */
11464 /* 6 args: fd, offset (high, low), len (high, low), advice */
11465 if (regpairs_aligned(cpu_env
, num
)) {
11466 /* offset is in (3,4), len in (5,6) and advice in 7 */
11474 ret
= -host_to_target_errno(posix_fadvise(arg1
,
11475 target_offset64(arg2
, arg3
),
11476 target_offset64(arg4
, arg5
),
11481 #ifdef TARGET_NR_fadvise64
11482 case TARGET_NR_fadvise64
:
11483 /* 5 args: fd, offset (high, low), len, advice */
11484 if (regpairs_aligned(cpu_env
, num
)) {
11485 /* offset is in (3,4), len in 5 and advice in 6 */
11491 ret
= -host_to_target_errno(posix_fadvise(arg1
,
11492 target_offset64(arg2
, arg3
),
11497 #else /* not a 32-bit ABI */
11498 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
11499 #ifdef TARGET_NR_fadvise64_64
11500 case TARGET_NR_fadvise64_64
:
11502 #ifdef TARGET_NR_fadvise64
11503 case TARGET_NR_fadvise64
:
11505 #ifdef TARGET_S390X
11507 case 4: arg4
= POSIX_FADV_NOREUSE
+ 1; break; /* make sure it's an invalid value */
11508 case 5: arg4
= POSIX_FADV_NOREUSE
+ 2; break; /* ditto */
11509 case 6: arg4
= POSIX_FADV_DONTNEED
; break;
11510 case 7: arg4
= POSIX_FADV_NOREUSE
; break;
11514 ret
= -host_to_target_errno(posix_fadvise(arg1
, arg2
, arg3
, arg4
));
11517 #endif /* end of 64-bit ABI fadvise handling */
11519 #ifdef TARGET_NR_madvise
11520 case TARGET_NR_madvise
:
11521 /* A straight passthrough may not be safe because qemu sometimes
11522 turns private file-backed mappings into anonymous mappings.
11523 This will break MADV_DONTNEED.
11524 This is a hint, so ignoring and returning success is ok. */
11525 ret
= get_errno(0);
11528 #if TARGET_ABI_BITS == 32
11529 case TARGET_NR_fcntl64
:
11533 from_flock64_fn
*copyfrom
= copy_from_user_flock64
;
11534 to_flock64_fn
*copyto
= copy_to_user_flock64
;
11537 if (((CPUARMState
*)cpu_env
)->eabi
) {
11538 copyfrom
= copy_from_user_eabi_flock64
;
11539 copyto
= copy_to_user_eabi_flock64
;
11543 cmd
= target_to_host_fcntl_cmd(arg2
);
11544 if (cmd
== -TARGET_EINVAL
) {
11550 case TARGET_F_GETLK64
:
11551 ret
= copyfrom(&fl
, arg3
);
11555 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
11557 ret
= copyto(arg3
, &fl
);
11561 case TARGET_F_SETLK64
:
11562 case TARGET_F_SETLKW64
:
11563 ret
= copyfrom(&fl
, arg3
);
11567 ret
= get_errno(safe_fcntl(arg1
, cmd
, &fl
));
11570 ret
= do_fcntl(arg1
, arg2
, arg3
);
11576 #ifdef TARGET_NR_cacheflush
11577 case TARGET_NR_cacheflush
:
11578 /* self-modifying code is handled automatically, so nothing needed */
11582 #ifdef TARGET_NR_security
11583 case TARGET_NR_security
:
11584 goto unimplemented
;
11586 #ifdef TARGET_NR_getpagesize
11587 case TARGET_NR_getpagesize
:
11588 ret
= TARGET_PAGE_SIZE
;
11591 case TARGET_NR_gettid
:
11592 ret
= get_errno(gettid());
11594 #ifdef TARGET_NR_readahead
11595 case TARGET_NR_readahead
:
11596 #if TARGET_ABI_BITS == 32
11597 if (regpairs_aligned(cpu_env
, num
)) {
11602 ret
= get_errno(readahead(arg1
, target_offset64(arg2
, arg3
) , arg4
));
11604 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
11609 #ifdef TARGET_NR_setxattr
11610 case TARGET_NR_listxattr
:
11611 case TARGET_NR_llistxattr
:
11615 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11617 ret
= -TARGET_EFAULT
;
11621 p
= lock_user_string(arg1
);
11623 if (num
== TARGET_NR_listxattr
) {
11624 ret
= get_errno(listxattr(p
, b
, arg3
));
11626 ret
= get_errno(llistxattr(p
, b
, arg3
));
11629 ret
= -TARGET_EFAULT
;
11631 unlock_user(p
, arg1
, 0);
11632 unlock_user(b
, arg2
, arg3
);
11635 case TARGET_NR_flistxattr
:
11639 b
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
11641 ret
= -TARGET_EFAULT
;
11645 ret
= get_errno(flistxattr(arg1
, b
, arg3
));
11646 unlock_user(b
, arg2
, arg3
);
11649 case TARGET_NR_setxattr
:
11650 case TARGET_NR_lsetxattr
:
11652 void *p
, *n
, *v
= 0;
11654 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11656 ret
= -TARGET_EFAULT
;
11660 p
= lock_user_string(arg1
);
11661 n
= lock_user_string(arg2
);
11663 if (num
== TARGET_NR_setxattr
) {
11664 ret
= get_errno(setxattr(p
, n
, v
, arg4
, arg5
));
11666 ret
= get_errno(lsetxattr(p
, n
, v
, arg4
, arg5
));
11669 ret
= -TARGET_EFAULT
;
11671 unlock_user(p
, arg1
, 0);
11672 unlock_user(n
, arg2
, 0);
11673 unlock_user(v
, arg3
, 0);
11676 case TARGET_NR_fsetxattr
:
11680 v
= lock_user(VERIFY_READ
, arg3
, arg4
, 1);
11682 ret
= -TARGET_EFAULT
;
11686 n
= lock_user_string(arg2
);
11688 ret
= get_errno(fsetxattr(arg1
, n
, v
, arg4
, arg5
));
11690 ret
= -TARGET_EFAULT
;
11692 unlock_user(n
, arg2
, 0);
11693 unlock_user(v
, arg3
, 0);
11696 case TARGET_NR_getxattr
:
11697 case TARGET_NR_lgetxattr
:
11699 void *p
, *n
, *v
= 0;
11701 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11703 ret
= -TARGET_EFAULT
;
11707 p
= lock_user_string(arg1
);
11708 n
= lock_user_string(arg2
);
11710 if (num
== TARGET_NR_getxattr
) {
11711 ret
= get_errno(getxattr(p
, n
, v
, arg4
));
11713 ret
= get_errno(lgetxattr(p
, n
, v
, arg4
));
11716 ret
= -TARGET_EFAULT
;
11718 unlock_user(p
, arg1
, 0);
11719 unlock_user(n
, arg2
, 0);
11720 unlock_user(v
, arg3
, arg4
);
11723 case TARGET_NR_fgetxattr
:
11727 v
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
11729 ret
= -TARGET_EFAULT
;
11733 n
= lock_user_string(arg2
);
11735 ret
= get_errno(fgetxattr(arg1
, n
, v
, arg4
));
11737 ret
= -TARGET_EFAULT
;
11739 unlock_user(n
, arg2
, 0);
11740 unlock_user(v
, arg3
, arg4
);
11743 case TARGET_NR_removexattr
:
11744 case TARGET_NR_lremovexattr
:
11747 p
= lock_user_string(arg1
);
11748 n
= lock_user_string(arg2
);
11750 if (num
== TARGET_NR_removexattr
) {
11751 ret
= get_errno(removexattr(p
, n
));
11753 ret
= get_errno(lremovexattr(p
, n
));
11756 ret
= -TARGET_EFAULT
;
11758 unlock_user(p
, arg1
, 0);
11759 unlock_user(n
, arg2
, 0);
11762 case TARGET_NR_fremovexattr
:
11765 n
= lock_user_string(arg2
);
11767 ret
= get_errno(fremovexattr(arg1
, n
));
11769 ret
= -TARGET_EFAULT
;
11771 unlock_user(n
, arg2
, 0);
11775 #endif /* CONFIG_ATTR */
11776 #ifdef TARGET_NR_set_thread_area
11777 case TARGET_NR_set_thread_area
:
11778 #if defined(TARGET_MIPS)
11779 ((CPUMIPSState
*) cpu_env
)->active_tc
.CP0_UserLocal
= arg1
;
11782 #elif defined(TARGET_CRIS)
11784 ret
= -TARGET_EINVAL
;
11786 ((CPUCRISState
*) cpu_env
)->pregs
[PR_PID
] = arg1
;
11790 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
11791 ret
= do_set_thread_area(cpu_env
, arg1
);
11793 #elif defined(TARGET_M68K)
11795 TaskState
*ts
= cpu
->opaque
;
11796 ts
->tp_value
= arg1
;
11801 goto unimplemented_nowarn
;
11804 #ifdef TARGET_NR_get_thread_area
11805 case TARGET_NR_get_thread_area
:
11806 #if defined(TARGET_I386) && defined(TARGET_ABI32)
11807 ret
= do_get_thread_area(cpu_env
, arg1
);
11809 #elif defined(TARGET_M68K)
11811 TaskState
*ts
= cpu
->opaque
;
11812 ret
= ts
->tp_value
;
11816 goto unimplemented_nowarn
;
11819 #ifdef TARGET_NR_getdomainname
11820 case TARGET_NR_getdomainname
:
11821 goto unimplemented_nowarn
;
11824 #ifdef TARGET_NR_clock_gettime
11825 case TARGET_NR_clock_gettime
:
11827 struct timespec ts
;
11828 ret
= get_errno(clock_gettime(arg1
, &ts
));
11829 if (!is_error(ret
)) {
11830 host_to_target_timespec(arg2
, &ts
);
11835 #ifdef TARGET_NR_clock_getres
11836 case TARGET_NR_clock_getres
:
11838 struct timespec ts
;
11839 ret
= get_errno(clock_getres(arg1
, &ts
));
11840 if (!is_error(ret
)) {
11841 host_to_target_timespec(arg2
, &ts
);
11846 #ifdef TARGET_NR_clock_nanosleep
11847 case TARGET_NR_clock_nanosleep
:
11849 struct timespec ts
;
11850 target_to_host_timespec(&ts
, arg3
);
11851 ret
= get_errno(safe_clock_nanosleep(arg1
, arg2
,
11852 &ts
, arg4
? &ts
: NULL
));
11854 host_to_target_timespec(arg4
, &ts
);
11856 #if defined(TARGET_PPC)
11857 /* clock_nanosleep is odd in that it returns positive errno values.
11858 * On PPC, CR0 bit 3 should be set in such a situation. */
11859 if (ret
&& ret
!= -TARGET_ERESTARTSYS
) {
11860 ((CPUPPCState
*)cpu_env
)->crf
[0] |= 1;
11867 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11868 case TARGET_NR_set_tid_address
:
11869 ret
= get_errno(set_tid_address((int *)g2h(arg1
)));
11873 case TARGET_NR_tkill
:
11874 ret
= get_errno(safe_tkill((int)arg1
, target_to_host_signal(arg2
)));
11877 case TARGET_NR_tgkill
:
11878 ret
= get_errno(safe_tgkill((int)arg1
, (int)arg2
,
11879 target_to_host_signal(arg3
)));
11882 #ifdef TARGET_NR_set_robust_list
11883 case TARGET_NR_set_robust_list
:
11884 case TARGET_NR_get_robust_list
:
11885 /* The ABI for supporting robust futexes has userspace pass
11886 * the kernel a pointer to a linked list which is updated by
11887 * userspace after the syscall; the list is walked by the kernel
11888 * when the thread exits. Since the linked list in QEMU guest
11889 * memory isn't a valid linked list for the host and we have
11890 * no way to reliably intercept the thread-death event, we can't
11891 * support these. Silently return ENOSYS so that guest userspace
11892 * falls back to a non-robust futex implementation (which should
11893 * be OK except in the corner case of the guest crashing while
11894 * holding a mutex that is shared with another process via
11897 goto unimplemented_nowarn
;
11900 #if defined(TARGET_NR_utimensat)
11901 case TARGET_NR_utimensat
:
11903 struct timespec
*tsp
, ts
[2];
11907 target_to_host_timespec(ts
, arg3
);
11908 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
11912 ret
= get_errno(sys_utimensat(arg1
, NULL
, tsp
, arg4
));
11914 if (!(p
= lock_user_string(arg2
))) {
11915 ret
= -TARGET_EFAULT
;
11918 ret
= get_errno(sys_utimensat(arg1
, path(p
), tsp
, arg4
));
11919 unlock_user(p
, arg2
, 0);
11924 case TARGET_NR_futex
:
11925 ret
= do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
11927 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
11928 case TARGET_NR_inotify_init
:
11929 ret
= get_errno(sys_inotify_init());
11931 fd_trans_register(ret
, &target_inotify_trans
);
11935 #ifdef CONFIG_INOTIFY1
11936 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11937 case TARGET_NR_inotify_init1
:
11938 ret
= get_errno(sys_inotify_init1(target_to_host_bitmask(arg1
,
11939 fcntl_flags_tbl
)));
11941 fd_trans_register(ret
, &target_inotify_trans
);
11946 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
11947 case TARGET_NR_inotify_add_watch
:
11948 p
= lock_user_string(arg2
);
11949 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
11950 unlock_user(p
, arg2
, 0);
11953 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
11954 case TARGET_NR_inotify_rm_watch
:
11955 ret
= get_errno(sys_inotify_rm_watch(arg1
, arg2
));
11959 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
11960 case TARGET_NR_mq_open
:
11962 struct mq_attr posix_mq_attr
;
11963 struct mq_attr
*pposix_mq_attr
;
11966 host_flags
= target_to_host_bitmask(arg2
, fcntl_flags_tbl
);
11967 pposix_mq_attr
= NULL
;
11969 if (copy_from_user_mq_attr(&posix_mq_attr
, arg4
) != 0) {
11972 pposix_mq_attr
= &posix_mq_attr
;
11974 p
= lock_user_string(arg1
- 1);
11978 ret
= get_errno(mq_open(p
, host_flags
, arg3
, pposix_mq_attr
));
11979 unlock_user (p
, arg1
, 0);
11983 case TARGET_NR_mq_unlink
:
11984 p
= lock_user_string(arg1
- 1);
11986 ret
= -TARGET_EFAULT
;
11989 ret
= get_errno(mq_unlink(p
));
11990 unlock_user (p
, arg1
, 0);
11993 case TARGET_NR_mq_timedsend
:
11995 struct timespec ts
;
11997 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
11999 target_to_host_timespec(&ts
, arg5
);
12000 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, &ts
));
12001 host_to_target_timespec(arg5
, &ts
);
12003 ret
= get_errno(safe_mq_timedsend(arg1
, p
, arg3
, arg4
, NULL
));
12005 unlock_user (p
, arg2
, arg3
);
12009 case TARGET_NR_mq_timedreceive
:
12011 struct timespec ts
;
12014 p
= lock_user (VERIFY_READ
, arg2
, arg3
, 1);
12016 target_to_host_timespec(&ts
, arg5
);
12017 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
12019 host_to_target_timespec(arg5
, &ts
);
12021 ret
= get_errno(safe_mq_timedreceive(arg1
, p
, arg3
,
12024 unlock_user (p
, arg2
, arg3
);
12026 put_user_u32(prio
, arg4
);
12030 /* Not implemented for now... */
12031 /* case TARGET_NR_mq_notify: */
12034 case TARGET_NR_mq_getsetattr
:
12036 struct mq_attr posix_mq_attr_in
, posix_mq_attr_out
;
12039 ret
= mq_getattr(arg1
, &posix_mq_attr_out
);
12040 copy_to_user_mq_attr(arg3
, &posix_mq_attr_out
);
12043 copy_from_user_mq_attr(&posix_mq_attr_in
, arg2
);
12044 ret
|= mq_setattr(arg1
, &posix_mq_attr_in
, &posix_mq_attr_out
);
12051 #ifdef CONFIG_SPLICE
12052 #ifdef TARGET_NR_tee
12053 case TARGET_NR_tee
:
12055 ret
= get_errno(tee(arg1
,arg2
,arg3
,arg4
));
12059 #ifdef TARGET_NR_splice
12060 case TARGET_NR_splice
:
12062 loff_t loff_in
, loff_out
;
12063 loff_t
*ploff_in
= NULL
, *ploff_out
= NULL
;
12065 if (get_user_u64(loff_in
, arg2
)) {
12068 ploff_in
= &loff_in
;
12071 if (get_user_u64(loff_out
, arg4
)) {
12074 ploff_out
= &loff_out
;
12076 ret
= get_errno(splice(arg1
, ploff_in
, arg3
, ploff_out
, arg5
, arg6
));
12078 if (put_user_u64(loff_in
, arg2
)) {
12083 if (put_user_u64(loff_out
, arg4
)) {
12090 #ifdef TARGET_NR_vmsplice
12091 case TARGET_NR_vmsplice
:
12093 struct iovec
*vec
= lock_iovec(VERIFY_READ
, arg2
, arg3
, 1);
12095 ret
= get_errno(vmsplice(arg1
, vec
, arg3
, arg4
));
12096 unlock_iovec(vec
, arg2
, arg3
, 0);
12098 ret
= -host_to_target_errno(errno
);
12103 #endif /* CONFIG_SPLICE */
12104 #ifdef CONFIG_EVENTFD
12105 #if defined(TARGET_NR_eventfd)
12106 case TARGET_NR_eventfd
:
12107 ret
= get_errno(eventfd(arg1
, 0));
12109 fd_trans_register(ret
, &target_eventfd_trans
);
12113 #if defined(TARGET_NR_eventfd2)
12114 case TARGET_NR_eventfd2
:
12116 int host_flags
= arg2
& (~(TARGET_O_NONBLOCK
| TARGET_O_CLOEXEC
));
12117 if (arg2
& TARGET_O_NONBLOCK
) {
12118 host_flags
|= O_NONBLOCK
;
12120 if (arg2
& TARGET_O_CLOEXEC
) {
12121 host_flags
|= O_CLOEXEC
;
12123 ret
= get_errno(eventfd(arg1
, host_flags
));
12125 fd_trans_register(ret
, &target_eventfd_trans
);
12130 #endif /* CONFIG_EVENTFD */
12131 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
12132 case TARGET_NR_fallocate
:
12133 #if TARGET_ABI_BITS == 32
12134 ret
= get_errno(fallocate(arg1
, arg2
, target_offset64(arg3
, arg4
),
12135 target_offset64(arg5
, arg6
)));
12137 ret
= get_errno(fallocate(arg1
, arg2
, arg3
, arg4
));
12141 #if defined(CONFIG_SYNC_FILE_RANGE)
12142 #if defined(TARGET_NR_sync_file_range)
12143 case TARGET_NR_sync_file_range
:
12144 #if TARGET_ABI_BITS == 32
12145 #if defined(TARGET_MIPS)
12146 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
12147 target_offset64(arg5
, arg6
), arg7
));
12149 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg2
, arg3
),
12150 target_offset64(arg4
, arg5
), arg6
));
12151 #endif /* !TARGET_MIPS */
12153 ret
= get_errno(sync_file_range(arg1
, arg2
, arg3
, arg4
));
12157 #if defined(TARGET_NR_sync_file_range2)
12158 case TARGET_NR_sync_file_range2
:
12159 /* This is like sync_file_range but the arguments are reordered */
12160 #if TARGET_ABI_BITS == 32
12161 ret
= get_errno(sync_file_range(arg1
, target_offset64(arg3
, arg4
),
12162 target_offset64(arg5
, arg6
), arg2
));
12164 ret
= get_errno(sync_file_range(arg1
, arg3
, arg4
, arg2
));
12169 #if defined(TARGET_NR_signalfd4)
12170 case TARGET_NR_signalfd4
:
12171 ret
= do_signalfd4(arg1
, arg2
, arg4
);
12174 #if defined(TARGET_NR_signalfd)
12175 case TARGET_NR_signalfd
:
12176 ret
= do_signalfd4(arg1
, arg2
, 0);
12179 #if defined(CONFIG_EPOLL)
12180 #if defined(TARGET_NR_epoll_create)
12181 case TARGET_NR_epoll_create
:
12182 ret
= get_errno(epoll_create(arg1
));
12185 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
12186 case TARGET_NR_epoll_create1
:
12187 ret
= get_errno(epoll_create1(arg1
));
12190 #if defined(TARGET_NR_epoll_ctl)
12191 case TARGET_NR_epoll_ctl
:
12193 struct epoll_event ep
;
12194 struct epoll_event
*epp
= 0;
12196 struct target_epoll_event
*target_ep
;
12197 if (!lock_user_struct(VERIFY_READ
, target_ep
, arg4
, 1)) {
12200 ep
.events
= tswap32(target_ep
->events
);
12201 /* The epoll_data_t union is just opaque data to the kernel,
12202 * so we transfer all 64 bits across and need not worry what
12203 * actual data type it is.
12205 ep
.data
.u64
= tswap64(target_ep
->data
.u64
);
12206 unlock_user_struct(target_ep
, arg4
, 0);
12209 ret
= get_errno(epoll_ctl(arg1
, arg2
, arg3
, epp
));
12214 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
12215 #if defined(TARGET_NR_epoll_wait)
12216 case TARGET_NR_epoll_wait
:
12218 #if defined(TARGET_NR_epoll_pwait)
12219 case TARGET_NR_epoll_pwait
:
12222 struct target_epoll_event
*target_ep
;
12223 struct epoll_event
*ep
;
12225 int maxevents
= arg3
;
12226 int timeout
= arg4
;
12228 if (maxevents
<= 0 || maxevents
> TARGET_EP_MAX_EVENTS
) {
12229 ret
= -TARGET_EINVAL
;
12233 target_ep
= lock_user(VERIFY_WRITE
, arg2
,
12234 maxevents
* sizeof(struct target_epoll_event
), 1);
12239 ep
= g_try_new(struct epoll_event
, maxevents
);
12241 unlock_user(target_ep
, arg2
, 0);
12242 ret
= -TARGET_ENOMEM
;
12247 #if defined(TARGET_NR_epoll_pwait)
12248 case TARGET_NR_epoll_pwait
:
12250 target_sigset_t
*target_set
;
12251 sigset_t _set
, *set
= &_set
;
12254 if (arg6
!= sizeof(target_sigset_t
)) {
12255 ret
= -TARGET_EINVAL
;
12259 target_set
= lock_user(VERIFY_READ
, arg5
,
12260 sizeof(target_sigset_t
), 1);
12262 ret
= -TARGET_EFAULT
;
12265 target_to_host_sigset(set
, target_set
);
12266 unlock_user(target_set
, arg5
, 0);
12271 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
12272 set
, SIGSET_T_SIZE
));
12276 #if defined(TARGET_NR_epoll_wait)
12277 case TARGET_NR_epoll_wait
:
12278 ret
= get_errno(safe_epoll_pwait(epfd
, ep
, maxevents
, timeout
,
12283 ret
= -TARGET_ENOSYS
;
12285 if (!is_error(ret
)) {
12287 for (i
= 0; i
< ret
; i
++) {
12288 target_ep
[i
].events
= tswap32(ep
[i
].events
);
12289 target_ep
[i
].data
.u64
= tswap64(ep
[i
].data
.u64
);
12291 unlock_user(target_ep
, arg2
,
12292 ret
* sizeof(struct target_epoll_event
));
12294 unlock_user(target_ep
, arg2
, 0);
12301 #ifdef TARGET_NR_prlimit64
12302 case TARGET_NR_prlimit64
:
12304 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
12305 struct target_rlimit64
*target_rnew
, *target_rold
;
12306 struct host_rlimit64 rnew
, rold
, *rnewp
= 0;
12307 int resource
= target_to_host_resource(arg2
);
12309 if (!lock_user_struct(VERIFY_READ
, target_rnew
, arg3
, 1)) {
12312 rnew
.rlim_cur
= tswap64(target_rnew
->rlim_cur
);
12313 rnew
.rlim_max
= tswap64(target_rnew
->rlim_max
);
12314 unlock_user_struct(target_rnew
, arg3
, 0);
12318 ret
= get_errno(sys_prlimit64(arg1
, resource
, rnewp
, arg4
? &rold
: 0));
12319 if (!is_error(ret
) && arg4
) {
12320 if (!lock_user_struct(VERIFY_WRITE
, target_rold
, arg4
, 1)) {
12323 target_rold
->rlim_cur
= tswap64(rold
.rlim_cur
);
12324 target_rold
->rlim_max
= tswap64(rold
.rlim_max
);
12325 unlock_user_struct(target_rold
, arg4
, 1);
12330 #ifdef TARGET_NR_gethostname
12331 case TARGET_NR_gethostname
:
12333 char *name
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0);
12335 ret
= get_errno(gethostname(name
, arg2
));
12336 unlock_user(name
, arg1
, arg2
);
12338 ret
= -TARGET_EFAULT
;
12343 #ifdef TARGET_NR_atomic_cmpxchg_32
12344 case TARGET_NR_atomic_cmpxchg_32
:
12346 /* should use start_exclusive from main.c */
12347 abi_ulong mem_value
;
12348 if (get_user_u32(mem_value
, arg6
)) {
12349 target_siginfo_t info
;
12350 info
.si_signo
= SIGSEGV
;
12352 info
.si_code
= TARGET_SEGV_MAPERR
;
12353 info
._sifields
._sigfault
._addr
= arg6
;
12354 queue_signal((CPUArchState
*)cpu_env
, info
.si_signo
,
12355 QEMU_SI_FAULT
, &info
);
12359 if (mem_value
== arg2
)
12360 put_user_u32(arg1
, arg6
);
12365 #ifdef TARGET_NR_atomic_barrier
12366 case TARGET_NR_atomic_barrier
:
12368 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
12374 #ifdef TARGET_NR_timer_create
12375 case TARGET_NR_timer_create
:
12377 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
12379 struct sigevent host_sevp
= { {0}, }, *phost_sevp
= NULL
;
12382 int timer_index
= next_free_host_timer();
12384 if (timer_index
< 0) {
12385 ret
= -TARGET_EAGAIN
;
12387 timer_t
*phtimer
= g_posix_timers
+ timer_index
;
12390 phost_sevp
= &host_sevp
;
12391 ret
= target_to_host_sigevent(phost_sevp
, arg2
);
12397 ret
= get_errno(timer_create(clkid
, phost_sevp
, phtimer
));
12401 if (put_user(TIMER_MAGIC
| timer_index
, arg3
, target_timer_t
)) {
12410 #ifdef TARGET_NR_timer_settime
12411 case TARGET_NR_timer_settime
:
12413 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
12414 * struct itimerspec * old_value */
12415 target_timer_t timerid
= get_timer_id(arg1
);
12419 } else if (arg3
== 0) {
12420 ret
= -TARGET_EINVAL
;
12422 timer_t htimer
= g_posix_timers
[timerid
];
12423 struct itimerspec hspec_new
= {{0},}, hspec_old
= {{0},};
12425 if (target_to_host_itimerspec(&hspec_new
, arg3
)) {
12429 timer_settime(htimer
, arg2
, &hspec_new
, &hspec_old
));
12430 if (arg4
&& host_to_target_itimerspec(arg4
, &hspec_old
)) {
12438 #ifdef TARGET_NR_timer_gettime
12439 case TARGET_NR_timer_gettime
:
12441 /* args: timer_t timerid, struct itimerspec *curr_value */
12442 target_timer_t timerid
= get_timer_id(arg1
);
12446 } else if (!arg2
) {
12447 ret
= -TARGET_EFAULT
;
12449 timer_t htimer
= g_posix_timers
[timerid
];
12450 struct itimerspec hspec
;
12451 ret
= get_errno(timer_gettime(htimer
, &hspec
));
12453 if (host_to_target_itimerspec(arg2
, &hspec
)) {
12454 ret
= -TARGET_EFAULT
;
12461 #ifdef TARGET_NR_timer_getoverrun
12462 case TARGET_NR_timer_getoverrun
:
12464 /* args: timer_t timerid */
12465 target_timer_t timerid
= get_timer_id(arg1
);
12470 timer_t htimer
= g_posix_timers
[timerid
];
12471 ret
= get_errno(timer_getoverrun(htimer
));
12473 fd_trans_unregister(ret
);
12478 #ifdef TARGET_NR_timer_delete
12479 case TARGET_NR_timer_delete
:
12481 /* args: timer_t timerid */
12482 target_timer_t timerid
= get_timer_id(arg1
);
12487 timer_t htimer
= g_posix_timers
[timerid
];
12488 ret
= get_errno(timer_delete(htimer
));
12489 g_posix_timers
[timerid
] = 0;
12495 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
12496 case TARGET_NR_timerfd_create
:
12497 ret
= get_errno(timerfd_create(arg1
,
12498 target_to_host_bitmask(arg2
, fcntl_flags_tbl
)));
12502 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
12503 case TARGET_NR_timerfd_gettime
:
12505 struct itimerspec its_curr
;
12507 ret
= get_errno(timerfd_gettime(arg1
, &its_curr
));
12509 if (arg2
&& host_to_target_itimerspec(arg2
, &its_curr
)) {
12516 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
12517 case TARGET_NR_timerfd_settime
:
12519 struct itimerspec its_new
, its_old
, *p_new
;
12522 if (target_to_host_itimerspec(&its_new
, arg3
)) {
12530 ret
= get_errno(timerfd_settime(arg1
, arg2
, p_new
, &its_old
));
12532 if (arg4
&& host_to_target_itimerspec(arg4
, &its_old
)) {
12539 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
12540 case TARGET_NR_ioprio_get
:
12541 ret
= get_errno(ioprio_get(arg1
, arg2
));
12545 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
12546 case TARGET_NR_ioprio_set
:
12547 ret
= get_errno(ioprio_set(arg1
, arg2
, arg3
));
12551 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
12552 case TARGET_NR_setns
:
12553 ret
= get_errno(setns(arg1
, arg2
));
12556 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
12557 case TARGET_NR_unshare
:
12558 ret
= get_errno(unshare(arg1
));
12561 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
12562 case TARGET_NR_kcmp
:
12563 ret
= get_errno(kcmp(arg1
, arg2
, arg3
, arg4
, arg5
));
12569 gemu_log("qemu: Unsupported syscall: %d\n", num
);
12570 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
12571 unimplemented_nowarn
:
12573 ret
= -TARGET_ENOSYS
;
12578 gemu_log(" = " TARGET_ABI_FMT_ld
"\n", ret
);
12581 print_syscall_ret(num
, ret
);
12582 trace_guest_user_syscall_ret(cpu
, num
, ret
);
12585 ret
= -TARGET_EFAULT
;