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