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