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