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