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