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