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