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