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