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