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