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