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