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