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