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