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