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