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