]> git.proxmox.com Git - mirror_qemu.git/blob - linux-user/syscall.c
projects / mirror_qemu.git / blob
? search:


5bc42c017eebcbaa7fc975bac15d181302986ae2
[mirror_qemu.git] / linux-user / syscall.c
1 /*
2 * Linux syscalls
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #define _ATFILE_SOURCE
20 #include "qemu/osdep.h"
21 #include "qemu/cutils.h"
22 #include "qemu/path.h"
23 #include <elf.h>
24 #include <endian.h>
25 #include <grp.h>
26 #include <sys/ipc.h>
27 #include <sys/msg.h>
28 #include <sys/wait.h>
29 #include <sys/mount.h>
30 #include <sys/file.h>
31 #include <sys/fsuid.h>
32 #include <sys/personality.h>
33 #include <sys/prctl.h>
34 #include <sys/resource.h>
35 #include <sys/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, nb_read);
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 /* Overwrite 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 g_strlcpy(buf->release, qemu_uname_release,
9246 sizeof(buf->release));
9247 }
9248 }
9249 unlock_user_struct(buf, arg1, 1);
9250 }
9251 break;
9252 #ifdef TARGET_I386
9253 case TARGET_NR_modify_ldt:
9254 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
9255 break;
9256 #if !defined(TARGET_X86_64)
9257 case TARGET_NR_vm86old:
9258 goto unimplemented;
9259 case TARGET_NR_vm86:
9260 ret = do_vm86(cpu_env, arg1, arg2);
9261 break;
9262 #endif
9263 #endif
9264 case TARGET_NR_adjtimex:
9265 goto unimplemented;
9266 #ifdef TARGET_NR_create_module
9267 case TARGET_NR_create_module:
9268 #endif
9269 case TARGET_NR_init_module:
9270 case TARGET_NR_delete_module:
9271 #ifdef TARGET_NR_get_kernel_syms
9272 case TARGET_NR_get_kernel_syms:
9273 #endif
9274 goto unimplemented;
9275 case TARGET_NR_quotactl:
9276 goto unimplemented;
9277 case TARGET_NR_getpgid:
9278 ret = get_errno(getpgid(arg1));
9279 break;
9280 case TARGET_NR_fchdir:
9281 ret = get_errno(fchdir(arg1));
9282 break;
9283 #ifdef TARGET_NR_bdflush /* not on x86_64 */
9284 case TARGET_NR_bdflush:
9285 goto unimplemented;
9286 #endif
9287 #ifdef TARGET_NR_sysfs
9288 case TARGET_NR_sysfs:
9289 goto unimplemented;
9290 #endif
9291 case TARGET_NR_personality:
9292 ret = get_errno(personality(arg1));
9293 break;
9294 #ifdef TARGET_NR_afs_syscall
9295 case TARGET_NR_afs_syscall:
9296 goto unimplemented;
9297 #endif
9298 #ifdef TARGET_NR__llseek /* Not on alpha */
9299 case TARGET_NR__llseek:
9300 {
9301 int64_t res;
9302 #if !defined(__NR_llseek)
9303 res = lseek(arg1, ((uint64_t)arg2 << 32) | arg3, arg5);
9304 if (res == -1) {
9305 ret = get_errno(res);
9306 } else {
9307 ret = 0;
9308 }
9309 #else
9310 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
9311 #endif
9312 if ((ret == 0) && put_user_s64(res, arg4)) {
9313 goto efault;
9314 }
9315 }
9316 break;
9317 #endif
9318 #ifdef TARGET_NR_getdents
9319 case TARGET_NR_getdents:
9320 #ifdef __NR_getdents
9321 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
9322 {
9323 struct target_dirent *target_dirp;
9324 struct linux_dirent *dirp;
9325 abi_long count = arg3;
9326
9327 dirp = g_try_malloc(count);
9328 if (!dirp) {
9329 ret = -TARGET_ENOMEM;
9330 goto fail;
9331 }
9332
9333 ret = get_errno(sys_getdents(arg1, dirp, count));
9334 if (!is_error(ret)) {
9335 struct linux_dirent *de;
9336 struct target_dirent *tde;
9337 int len = ret;
9338 int reclen, treclen;
9339 int count1, tnamelen;
9340
9341 count1 = 0;
9342 de = dirp;
9343 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9344 goto efault;
9345 tde = target_dirp;
9346 while (len > 0) {
9347 reclen = de->d_reclen;
9348 tnamelen = reclen - offsetof(struct linux_dirent, d_name);
9349 assert(tnamelen >= 0);
9350 treclen = tnamelen + offsetof(struct target_dirent, d_name);
9351 assert(count1 + treclen <= count);
9352 tde->d_reclen = tswap16(treclen);
9353 tde->d_ino = tswapal(de->d_ino);
9354 tde->d_off = tswapal(de->d_off);
9355 memcpy(tde->d_name, de->d_name, tnamelen);
9356 de = (struct linux_dirent *)((char *)de + reclen);
9357 len -= reclen;
9358 tde = (struct target_dirent *)((char *)tde + treclen);
9359 count1 += treclen;
9360 }
9361 ret = count1;
9362 unlock_user(target_dirp, arg2, ret);
9363 }
9364 g_free(dirp);
9365 }
9366 #else
9367 {
9368 struct linux_dirent *dirp;
9369 abi_long count = arg3;
9370
9371 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9372 goto efault;
9373 ret = get_errno(sys_getdents(arg1, dirp, count));
9374 if (!is_error(ret)) {
9375 struct linux_dirent *de;
9376 int len = ret;
9377 int reclen;
9378 de = dirp;
9379 while (len > 0) {
9380 reclen = de->d_reclen;
9381 if (reclen > len)
9382 break;
9383 de->d_reclen = tswap16(reclen);
9384 tswapls(&de->d_ino);
9385 tswapls(&de->d_off);
9386 de = (struct linux_dirent *)((char *)de + reclen);
9387 len -= reclen;
9388 }
9389 }
9390 unlock_user(dirp, arg2, ret);
9391 }
9392 #endif
9393 #else
9394 /* Implement getdents in terms of getdents64 */
9395 {
9396 struct linux_dirent64 *dirp;
9397 abi_long count = arg3;
9398
9399 dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
9400 if (!dirp) {
9401 goto efault;
9402 }
9403 ret = get_errno(sys_getdents64(arg1, dirp, count));
9404 if (!is_error(ret)) {
9405 /* Convert the dirent64 structs to target dirent. We do this
9406 * in-place, since we can guarantee that a target_dirent is no
9407 * larger than a dirent64; however this means we have to be
9408 * careful to read everything before writing in the new format.
9409 */
9410 struct linux_dirent64 *de;
9411 struct target_dirent *tde;
9412 int len = ret;
9413 int tlen = 0;
9414
9415 de = dirp;
9416 tde = (struct target_dirent *)dirp;
9417 while (len > 0) {
9418 int namelen, treclen;
9419 int reclen = de->d_reclen;
9420 uint64_t ino = de->d_ino;
9421 int64_t off = de->d_off;
9422 uint8_t type = de->d_type;
9423
9424 namelen = strlen(de->d_name);
9425 treclen = offsetof(struct target_dirent, d_name)
9426 + namelen + 2;
9427 treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
9428
9429 memmove(tde->d_name, de->d_name, namelen + 1);
9430 tde->d_ino = tswapal(ino);
9431 tde->d_off = tswapal(off);
9432 tde->d_reclen = tswap16(treclen);
9433 /* The target_dirent type is in what was formerly a padding
9434 * byte at the end of the structure:
9435 */
9436 *(((char *)tde) + treclen - 1) = type;
9437
9438 de = (struct linux_dirent64 *)((char *)de + reclen);
9439 tde = (struct target_dirent *)((char *)tde + treclen);
9440 len -= reclen;
9441 tlen += treclen;
9442 }
9443 ret = tlen;
9444 }
9445 unlock_user(dirp, arg2, ret);
9446 }
9447 #endif
9448 break;
9449 #endif /* TARGET_NR_getdents */
9450 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
9451 case TARGET_NR_getdents64:
9452 {
9453 struct linux_dirent64 *dirp;
9454 abi_long count = arg3;
9455 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9456 goto efault;
9457 ret = get_errno(sys_getdents64(arg1, dirp, count));
9458 if (!is_error(ret)) {
9459 struct linux_dirent64 *de;
9460 int len = ret;
9461 int reclen;
9462 de = dirp;
9463 while (len > 0) {
9464 reclen = de->d_reclen;
9465 if (reclen > len)
9466 break;
9467 de->d_reclen = tswap16(reclen);
9468 tswap64s((uint64_t *)&de->d_ino);
9469 tswap64s((uint64_t *)&de->d_off);
9470 de = (struct linux_dirent64 *)((char *)de + reclen);
9471 len -= reclen;
9472 }
9473 }
9474 unlock_user(dirp, arg2, ret);
9475 }
9476 break;
9477 #endif /* TARGET_NR_getdents64 */
9478 #if defined(TARGET_NR__newselect)
9479 case TARGET_NR__newselect:
9480 ret = do_select(arg1, arg2, arg3, arg4, arg5);
9481 break;
9482 #endif
9483 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
9484 # ifdef TARGET_NR_poll
9485 case TARGET_NR_poll:
9486 # endif
9487 # ifdef TARGET_NR_ppoll
9488 case TARGET_NR_ppoll:
9489 # endif
9490 {
9491 struct target_pollfd *target_pfd;
9492 unsigned int nfds = arg2;
9493 struct pollfd *pfd;
9494 unsigned int i;
9495
9496 pfd = NULL;
9497 target_pfd = NULL;
9498 if (nfds) {
9499 target_pfd = lock_user(VERIFY_WRITE, arg1,
9500 sizeof(struct target_pollfd) * nfds, 1);
9501 if (!target_pfd) {
9502 goto efault;
9503 }
9504
9505 pfd = alloca(sizeof(struct pollfd) * nfds);
9506 for (i = 0; i < nfds; i++) {
9507 pfd[i].fd = tswap32(target_pfd[i].fd);
9508 pfd[i].events = tswap16(target_pfd[i].events);
9509 }
9510 }
9511
9512 switch (num) {
9513 # ifdef TARGET_NR_ppoll
9514 case TARGET_NR_ppoll:
9515 {
9516 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
9517 target_sigset_t *target_set;
9518 sigset_t _set, *set = &_set;
9519
9520 if (arg3) {
9521 if (target_to_host_timespec(timeout_ts, arg3)) {
9522 unlock_user(target_pfd, arg1, 0);
9523 goto efault;
9524 }
9525 } else {
9526 timeout_ts = NULL;
9527 }
9528
9529 if (arg4) {
9530 if (arg5 != sizeof(target_sigset_t)) {
9531 unlock_user(target_pfd, arg1, 0);
9532 ret = -TARGET_EINVAL;
9533 break;
9534 }
9535
9536 target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
9537 if (!target_set) {
9538 unlock_user(target_pfd, arg1, 0);
9539 goto efault;
9540 }
9541 target_to_host_sigset(set, target_set);
9542 } else {
9543 set = NULL;
9544 }
9545
9546 ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
9547 set, SIGSET_T_SIZE));
9548
9549 if (!is_error(ret) && arg3) {
9550 host_to_target_timespec(arg3, timeout_ts);
9551 }
9552 if (arg4) {
9553 unlock_user(target_set, arg4, 0);
9554 }
9555 break;
9556 }
9557 # endif
9558 # ifdef TARGET_NR_poll
9559 case TARGET_NR_poll:
9560 {
9561 struct timespec ts, *pts;
9562
9563 if (arg3 >= 0) {
9564 /* Convert ms to secs, ns */
9565 ts.tv_sec = arg3 / 1000;
9566 ts.tv_nsec = (arg3 % 1000) * 1000000LL;
9567 pts = &ts;
9568 } else {
9569 /* -ve poll() timeout means "infinite" */
9570 pts = NULL;
9571 }
9572 ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
9573 break;
9574 }
9575 # endif
9576 default:
9577 g_assert_not_reached();
9578 }
9579
9580 if (!is_error(ret)) {
9581 for(i = 0; i < nfds; i++) {
9582 target_pfd[i].revents = tswap16(pfd[i].revents);
9583 }
9584 }
9585 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
9586 }
9587 break;
9588 #endif
9589 case TARGET_NR_flock:
9590 /* NOTE: the flock constant seems to be the same for every
9591 Linux platform */
9592 ret = get_errno(safe_flock(arg1, arg2));
9593 break;
9594 case TARGET_NR_readv:
9595 {
9596 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
9597 if (vec != NULL) {
9598 ret = get_errno(safe_readv(arg1, vec, arg3));
9599 unlock_iovec(vec, arg2, arg3, 1);
9600 } else {
9601 ret = -host_to_target_errno(errno);
9602 }
9603 }
9604 break;
9605 case TARGET_NR_writev:
9606 {
9607 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
9608 if (vec != NULL) {
9609 ret = get_errno(safe_writev(arg1, vec, arg3));
9610 unlock_iovec(vec, arg2, arg3, 0);
9611 } else {
9612 ret = -host_to_target_errno(errno);
9613 }
9614 }
9615 break;
9616 case TARGET_NR_getsid:
9617 ret = get_errno(getsid(arg1));
9618 break;
9619 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
9620 case TARGET_NR_fdatasync:
9621 ret = get_errno(fdatasync(arg1));
9622 break;
9623 #endif
9624 #ifdef TARGET_NR__sysctl
9625 case TARGET_NR__sysctl:
9626 /* We don't implement this, but ENOTDIR is always a safe
9627 return value. */
9628 ret = -TARGET_ENOTDIR;
9629 break;
9630 #endif
9631 case TARGET_NR_sched_getaffinity:
9632 {
9633 unsigned int mask_size;
9634 unsigned long *mask;
9635
9636 /*
9637 * sched_getaffinity needs multiples of ulong, so need to take
9638 * care of mismatches between target ulong and host ulong sizes.
9639 */
9640 if (arg2 & (sizeof(abi_ulong) - 1)) {
9641 ret = -TARGET_EINVAL;
9642 break;
9643 }
9644 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
9645
9646 mask = alloca(mask_size);
9647 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
9648
9649 if (!is_error(ret)) {
9650 if (ret > arg2) {
9651 /* More data returned than the caller's buffer will fit.
9652 * This only happens if sizeof(abi_long) < sizeof(long)
9653 * and the caller passed us a buffer holding an odd number
9654 * of abi_longs. If the host kernel is actually using the
9655 * extra 4 bytes then fail EINVAL; otherwise we can just
9656 * ignore them and only copy the interesting part.
9657 */
9658 int numcpus = sysconf(_SC_NPROCESSORS_CONF);
9659 if (numcpus > arg2 * 8) {
9660 ret = -TARGET_EINVAL;
9661 break;
9662 }
9663 ret = arg2;
9664 }
9665
9666 if (copy_to_user(arg3, mask, ret)) {
9667 goto efault;
9668 }
9669 }
9670 }
9671 break;
9672 case TARGET_NR_sched_setaffinity:
9673 {
9674 unsigned int mask_size;
9675 unsigned long *mask;
9676
9677 /*
9678 * sched_setaffinity needs multiples of ulong, so need to take
9679 * care of mismatches between target ulong and host ulong sizes.
9680 */
9681 if (arg2 & (sizeof(abi_ulong) - 1)) {
9682 ret = -TARGET_EINVAL;
9683 break;
9684 }
9685 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
9686
9687 mask = alloca(mask_size);
9688 if (!lock_user_struct(VERIFY_READ, p, arg3, 1)) {
9689 goto efault;
9690 }
9691 memcpy(mask, p, arg2);
9692 unlock_user_struct(p, arg2, 0);
9693
9694 ret = get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
9695 }
9696 break;
9697 case TARGET_NR_sched_setparam:
9698 {
9699 struct sched_param *target_schp;
9700 struct sched_param schp;
9701
9702 if (arg2 == 0) {
9703 return -TARGET_EINVAL;
9704 }
9705 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
9706 goto efault;
9707 schp.sched_priority = tswap32(target_schp->sched_priority);
9708 unlock_user_struct(target_schp, arg2, 0);
9709 ret = get_errno(sched_setparam(arg1, &schp));
9710 }
9711 break;
9712 case TARGET_NR_sched_getparam:
9713 {
9714 struct sched_param *target_schp;
9715 struct sched_param schp;
9716
9717 if (arg2 == 0) {
9718 return -TARGET_EINVAL;
9719 }
9720 ret = get_errno(sched_getparam(arg1, &schp));
9721 if (!is_error(ret)) {
9722 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
9723 goto efault;
9724 target_schp->sched_priority = tswap32(schp.sched_priority);
9725 unlock_user_struct(target_schp, arg2, 1);
9726 }
9727 }
9728 break;
9729 case TARGET_NR_sched_setscheduler:
9730 {
9731 struct sched_param *target_schp;
9732 struct sched_param schp;
9733 if (arg3 == 0) {
9734 return -TARGET_EINVAL;
9735 }
9736 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
9737 goto efault;
9738 schp.sched_priority = tswap32(target_schp->sched_priority);
9739 unlock_user_struct(target_schp, arg3, 0);
9740 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
9741 }
9742 break;
9743 case TARGET_NR_sched_getscheduler:
9744 ret = get_errno(sched_getscheduler(arg1));
9745 break;
9746 case TARGET_NR_sched_yield:
9747 ret = get_errno(sched_yield());
9748 break;
9749 case TARGET_NR_sched_get_priority_max:
9750 ret = get_errno(sched_get_priority_max(arg1));
9751 break;
9752 case TARGET_NR_sched_get_priority_min:
9753 ret = get_errno(sched_get_priority_min(arg1));
9754 break;
9755 case TARGET_NR_sched_rr_get_interval:
9756 {
9757 struct timespec ts;
9758 ret = get_errno(sched_rr_get_interval(arg1, &ts));
9759 if (!is_error(ret)) {
9760 ret = host_to_target_timespec(arg2, &ts);
9761 }
9762 }
9763 break;
9764 case TARGET_NR_nanosleep:
9765 {
9766 struct timespec req, rem;
9767 target_to_host_timespec(&req, arg1);
9768 ret = get_errno(safe_nanosleep(&req, &rem));
9769 if (is_error(ret) && arg2) {
9770 host_to_target_timespec(arg2, &rem);
9771 }
9772 }
9773 break;
9774 #ifdef TARGET_NR_query_module
9775 case TARGET_NR_query_module:
9776 goto unimplemented;
9777 #endif
9778 #ifdef TARGET_NR_nfsservctl
9779 case TARGET_NR_nfsservctl:
9780 goto unimplemented;
9781 #endif
9782 case TARGET_NR_prctl:
9783 switch (arg1) {
9784 case PR_GET_PDEATHSIG:
9785 {
9786 int deathsig;
9787 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
9788 if (!is_error(ret) && arg2
9789 && put_user_ual(deathsig, arg2)) {
9790 goto efault;
9791 }
9792 break;
9793 }
9794 #ifdef PR_GET_NAME
9795 case PR_GET_NAME:
9796 {
9797 void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
9798 if (!name) {
9799 goto efault;
9800 }
9801 ret = get_errno(prctl(arg1, (unsigned long)name,
9802 arg3, arg4, arg5));
9803 unlock_user(name, arg2, 16);
9804 break;
9805 }
9806 case PR_SET_NAME:
9807 {
9808 void *name = lock_user(VERIFY_READ, arg2, 16, 1);
9809 if (!name) {
9810 goto efault;
9811 }
9812 ret = get_errno(prctl(arg1, (unsigned long)name,
9813 arg3, arg4, arg5));
9814 unlock_user(name, arg2, 0);
9815 break;
9816 }
9817 #endif
9818 default:
9819 /* Most prctl options have no pointer arguments */
9820 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
9821 break;
9822 }
9823 break;
9824 #ifdef TARGET_NR_arch_prctl
9825 case TARGET_NR_arch_prctl:
9826 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
9827 ret = do_arch_prctl(cpu_env, arg1, arg2);
9828 break;
9829 #else
9830 goto unimplemented;
9831 #endif
9832 #endif
9833 #ifdef TARGET_NR_pread64
9834 case TARGET_NR_pread64:
9835 if (regpairs_aligned(cpu_env)) {
9836 arg4 = arg5;
9837 arg5 = arg6;
9838 }
9839 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
9840 goto efault;
9841 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
9842 unlock_user(p, arg2, ret);
9843 break;
9844 case TARGET_NR_pwrite64:
9845 if (regpairs_aligned(cpu_env)) {
9846 arg4 = arg5;
9847 arg5 = arg6;
9848 }
9849 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
9850 goto efault;
9851 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
9852 unlock_user(p, arg2, 0);
9853 break;
9854 #endif
9855 case TARGET_NR_getcwd:
9856 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
9857 goto efault;
9858 ret = get_errno(sys_getcwd1(p, arg2));
9859 unlock_user(p, arg1, ret);
9860 break;
9861 case TARGET_NR_capget:
9862 case TARGET_NR_capset:
9863 {
9864 struct target_user_cap_header *target_header;
9865 struct target_user_cap_data *target_data = NULL;
9866 struct __user_cap_header_struct header;
9867 struct __user_cap_data_struct data[2];
9868 struct __user_cap_data_struct *dataptr = NULL;
9869 int i, target_datalen;
9870 int data_items = 1;
9871
9872 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
9873 goto efault;
9874 }
9875 header.version = tswap32(target_header->version);
9876 header.pid = tswap32(target_header->pid);
9877
9878 if (header.version != _LINUX_CAPABILITY_VERSION) {
9879 /* Version 2 and up takes pointer to two user_data structs */
9880 data_items = 2;
9881 }
9882
9883 target_datalen = sizeof(*target_data) * data_items;
9884
9885 if (arg2) {
9886 if (num == TARGET_NR_capget) {
9887 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0);
9888 } else {
9889 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1);
9890 }
9891 if (!target_data) {
9892 unlock_user_struct(target_header, arg1, 0);
9893 goto efault;
9894 }
9895
9896 if (num == TARGET_NR_capset) {
9897 for (i = 0; i < data_items; i++) {
9898 data[i].effective = tswap32(target_data[i].effective);
9899 data[i].permitted = tswap32(target_data[i].permitted);
9900 data[i].inheritable = tswap32(target_data[i].inheritable);
9901 }
9902 }
9903
9904 dataptr = data;
9905 }
9906
9907 if (num == TARGET_NR_capget) {
9908 ret = get_errno(capget(&header, dataptr));
9909 } else {
9910 ret = get_errno(capset(&header, dataptr));
9911 }
9912
9913 /* The kernel always updates version for both capget and capset */
9914 target_header->version = tswap32(header.version);
9915 unlock_user_struct(target_header, arg1, 1);
9916
9917 if (arg2) {
9918 if (num == TARGET_NR_capget) {
9919 for (i = 0; i < data_items; i++) {
9920 target_data[i].effective = tswap32(data[i].effective);
9921 target_data[i].permitted = tswap32(data[i].permitted);
9922 target_data[i].inheritable = tswap32(data[i].inheritable);
9923 }
9924 unlock_user(target_data, arg2, target_datalen);
9925 } else {
9926 unlock_user(target_data, arg2, 0);
9927 }
9928 }
9929 break;
9930 }
9931 case TARGET_NR_sigaltstack:
9932 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUArchState *)cpu_env));
9933 break;
9934
9935 #ifdef CONFIG_SENDFILE
9936 case TARGET_NR_sendfile:
9937 {
9938 off_t *offp = NULL;
9939 off_t off;
9940 if (arg3) {
9941 ret = get_user_sal(off, arg3);
9942 if (is_error(ret)) {
9943 break;
9944 }
9945 offp = &off;
9946 }
9947 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
9948 if (!is_error(ret) && arg3) {
9949 abi_long ret2 = put_user_sal(off, arg3);
9950 if (is_error(ret2)) {
9951 ret = ret2;
9952 }
9953 }
9954 break;
9955 }
9956 #ifdef TARGET_NR_sendfile64
9957 case TARGET_NR_sendfile64:
9958 {
9959 off_t *offp = NULL;
9960 off_t off;
9961 if (arg3) {
9962 ret = get_user_s64(off, arg3);
9963 if (is_error(ret)) {
9964 break;
9965 }
9966 offp = &off;
9967 }
9968 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
9969 if (!is_error(ret) && arg3) {
9970 abi_long ret2 = put_user_s64(off, arg3);
9971 if (is_error(ret2)) {
9972 ret = ret2;
9973 }
9974 }
9975 break;
9976 }
9977 #endif
9978 #else
9979 case TARGET_NR_sendfile:
9980 #ifdef TARGET_NR_sendfile64
9981 case TARGET_NR_sendfile64:
9982 #endif
9983 goto unimplemented;
9984 #endif
9985
9986 #ifdef TARGET_NR_getpmsg
9987 case TARGET_NR_getpmsg:
9988 goto unimplemented;
9989 #endif
9990 #ifdef TARGET_NR_putpmsg
9991 case TARGET_NR_putpmsg:
9992 goto unimplemented;
9993 #endif
9994 #ifdef TARGET_NR_vfork
9995 case TARGET_NR_vfork:
9996 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
9997 0, 0, 0, 0));
9998 break;
9999 #endif
10000 #ifdef TARGET_NR_ugetrlimit
10001 case TARGET_NR_ugetrlimit:
10002 {
10003 struct rlimit rlim;
10004 int resource = target_to_host_resource(arg1);
10005 ret = get_errno(getrlimit(resource, &rlim));
10006 if (!is_error(ret)) {
10007 struct target_rlimit *target_rlim;
10008 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
10009 goto efault;
10010 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
10011 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
10012 unlock_user_struct(target_rlim, arg2, 1);
10013 }
10014 break;
10015 }
10016 #endif
10017 #ifdef TARGET_NR_truncate64
10018 case TARGET_NR_truncate64:
10019 if (!(p = lock_user_string(arg1)))
10020 goto efault;
10021 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
10022 unlock_user(p, arg1, 0);
10023 break;
10024 #endif
10025 #ifdef TARGET_NR_ftruncate64
10026 case TARGET_NR_ftruncate64:
10027 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
10028 break;
10029 #endif
10030 #ifdef TARGET_NR_stat64
10031 case TARGET_NR_stat64:
10032 if (!(p = lock_user_string(arg1)))
10033 goto efault;
10034 ret = get_errno(stat(path(p), &st));
10035 unlock_user(p, arg1, 0);
10036 if (!is_error(ret))
10037 ret = host_to_target_stat64(cpu_env, arg2, &st);
10038 break;
10039 #endif
10040 #ifdef TARGET_NR_lstat64
10041 case TARGET_NR_lstat64:
10042 if (!(p = lock_user_string(arg1)))
10043 goto efault;
10044 ret = get_errno(lstat(path(p), &st));
10045 unlock_user(p, arg1, 0);
10046 if (!is_error(ret))
10047 ret = host_to_target_stat64(cpu_env, arg2, &st);
10048 break;
10049 #endif
10050 #ifdef TARGET_NR_fstat64
10051 case TARGET_NR_fstat64:
10052 ret = get_errno(fstat(arg1, &st));
10053 if (!is_error(ret))
10054 ret = host_to_target_stat64(cpu_env, arg2, &st);
10055 break;
10056 #endif
10057 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
10058 #ifdef TARGET_NR_fstatat64
10059 case TARGET_NR_fstatat64:
10060 #endif
10061 #ifdef TARGET_NR_newfstatat
10062 case TARGET_NR_newfstatat:
10063 #endif
10064 if (!(p = lock_user_string(arg2)))
10065 goto efault;
10066 ret = get_errno(fstatat(arg1, path(p), &st, arg4));
10067 if (!is_error(ret))
10068 ret = host_to_target_stat64(cpu_env, arg3, &st);
10069 break;
10070 #endif
10071 #ifdef TARGET_NR_lchown
10072 case TARGET_NR_lchown:
10073 if (!(p = lock_user_string(arg1)))
10074 goto efault;
10075 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
10076 unlock_user(p, arg1, 0);
10077 break;
10078 #endif
10079 #ifdef TARGET_NR_getuid
10080 case TARGET_NR_getuid:
10081 ret = get_errno(high2lowuid(getuid()));
10082 break;
10083 #endif
10084 #ifdef TARGET_NR_getgid
10085 case TARGET_NR_getgid:
10086 ret = get_errno(high2lowgid(getgid()));
10087 break;
10088 #endif
10089 #ifdef TARGET_NR_geteuid
10090 case TARGET_NR_geteuid:
10091 ret = get_errno(high2lowuid(geteuid()));
10092 break;
10093 #endif
10094 #ifdef TARGET_NR_getegid
10095 case TARGET_NR_getegid:
10096 ret = get_errno(high2lowgid(getegid()));
10097 break;
10098 #endif
10099 case TARGET_NR_setreuid:
10100 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
10101 break;
10102 case TARGET_NR_setregid:
10103 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
10104 break;
10105 case TARGET_NR_getgroups:
10106 {
10107 int gidsetsize = arg1;
10108 target_id *target_grouplist;
10109 gid_t *grouplist;
10110 int i;
10111
10112 grouplist = alloca(gidsetsize * sizeof(gid_t));
10113 ret = get_errno(getgroups(gidsetsize, grouplist));
10114 if (gidsetsize == 0)
10115 break;
10116 if (!is_error(ret)) {
10117 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
10118 if (!target_grouplist)
10119 goto efault;
10120 for(i = 0;i < ret; i++)
10121 target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
10122 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
10123 }
10124 }
10125 break;
10126 case TARGET_NR_setgroups:
10127 {
10128 int gidsetsize = arg1;
10129 target_id *target_grouplist;
10130 gid_t *grouplist = NULL;
10131 int i;
10132 if (gidsetsize) {
10133 grouplist = alloca(gidsetsize * sizeof(gid_t));
10134 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
10135 if (!target_grouplist) {
10136 ret = -TARGET_EFAULT;
10137 goto fail;
10138 }
10139 for (i = 0; i < gidsetsize; i++) {
10140 grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
10141 }
10142 unlock_user(target_grouplist, arg2, 0);
10143 }
10144 ret = get_errno(setgroups(gidsetsize, grouplist));
10145 }
10146 break;
10147 case TARGET_NR_fchown:
10148 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
10149 break;
10150 #if defined(TARGET_NR_fchownat)
10151 case TARGET_NR_fchownat:
10152 if (!(p = lock_user_string(arg2)))
10153 goto efault;
10154 ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
10155 low2highgid(arg4), arg5));
10156 unlock_user(p, arg2, 0);
10157 break;
10158 #endif
10159 #ifdef TARGET_NR_setresuid
10160 case TARGET_NR_setresuid:
10161 ret = get_errno(sys_setresuid(low2highuid(arg1),
10162 low2highuid(arg2),
10163 low2highuid(arg3)));
10164 break;
10165 #endif
10166 #ifdef TARGET_NR_getresuid
10167 case TARGET_NR_getresuid:
10168 {
10169 uid_t ruid, euid, suid;
10170 ret = get_errno(getresuid(&ruid, &euid, &suid));
10171 if (!is_error(ret)) {
10172 if (put_user_id(high2lowuid(ruid), arg1)
10173 || put_user_id(high2lowuid(euid), arg2)
10174 || put_user_id(high2lowuid(suid), arg3))
10175 goto efault;
10176 }
10177 }
10178 break;
10179 #endif
10180 #ifdef TARGET_NR_getresgid
10181 case TARGET_NR_setresgid:
10182 ret = get_errno(sys_setresgid(low2highgid(arg1),
10183 low2highgid(arg2),
10184 low2highgid(arg3)));
10185 break;
10186 #endif
10187 #ifdef TARGET_NR_getresgid
10188 case TARGET_NR_getresgid:
10189 {
10190 gid_t rgid, egid, sgid;
10191 ret = get_errno(getresgid(&rgid, &egid, &sgid));
10192 if (!is_error(ret)) {
10193 if (put_user_id(high2lowgid(rgid), arg1)
10194 || put_user_id(high2lowgid(egid), arg2)
10195 || put_user_id(high2lowgid(sgid), arg3))
10196 goto efault;
10197 }
10198 }
10199 break;
10200 #endif
10201 #ifdef TARGET_NR_chown
10202 case TARGET_NR_chown:
10203 if (!(p = lock_user_string(arg1)))
10204 goto efault;
10205 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
10206 unlock_user(p, arg1, 0);
10207 break;
10208 #endif
10209 case TARGET_NR_setuid:
10210 ret = get_errno(sys_setuid(low2highuid(arg1)));
10211 break;
10212 case TARGET_NR_setgid:
10213 ret = get_errno(sys_setgid(low2highgid(arg1)));
10214 break;
10215 case TARGET_NR_setfsuid:
10216 ret = get_errno(setfsuid(arg1));
10217 break;
10218 case TARGET_NR_setfsgid:
10219 ret = get_errno(setfsgid(arg1));
10220 break;
10221
10222 #ifdef TARGET_NR_lchown32
10223 case TARGET_NR_lchown32:
10224 if (!(p = lock_user_string(arg1)))
10225 goto efault;
10226 ret = get_errno(lchown(p, arg2, arg3));
10227 unlock_user(p, arg1, 0);
10228 break;
10229 #endif
10230 #ifdef TARGET_NR_getuid32
10231 case TARGET_NR_getuid32:
10232 ret = get_errno(getuid());
10233 break;
10234 #endif
10235
10236 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
10237 /* Alpha specific */
10238 case TARGET_NR_getxuid:
10239 {
10240 uid_t euid;
10241 euid=geteuid();
10242 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
10243 }
10244 ret = get_errno(getuid());
10245 break;
10246 #endif
10247 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
10248 /* Alpha specific */
10249 case TARGET_NR_getxgid:
10250 {
10251 uid_t egid;
10252 egid=getegid();
10253 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
10254 }
10255 ret = get_errno(getgid());
10256 break;
10257 #endif
10258 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
10259 /* Alpha specific */
10260 case TARGET_NR_osf_getsysinfo:
10261 ret = -TARGET_EOPNOTSUPP;
10262 switch (arg1) {
10263 case TARGET_GSI_IEEE_FP_CONTROL:
10264 {
10265 uint64_t swcr, fpcr = cpu_alpha_load_fpcr (cpu_env);
10266
10267 /* Copied from linux ieee_fpcr_to_swcr. */
10268 swcr = (fpcr >> 35) & SWCR_STATUS_MASK;
10269 swcr |= (fpcr >> 36) & SWCR_MAP_DMZ;
10270 swcr |= (~fpcr >> 48) & (SWCR_TRAP_ENABLE_INV
10271 | SWCR_TRAP_ENABLE_DZE
10272 | SWCR_TRAP_ENABLE_OVF);
10273 swcr |= (~fpcr >> 57) & (SWCR_TRAP_ENABLE_UNF
10274 | SWCR_TRAP_ENABLE_INE);
10275 swcr |= (fpcr >> 47) & SWCR_MAP_UMZ;
10276 swcr |= (~fpcr >> 41) & SWCR_TRAP_ENABLE_DNO;
10277
10278 if (put_user_u64 (swcr, arg2))
10279 goto efault;
10280 ret = 0;
10281 }
10282 break;
10283
10284 /* case GSI_IEEE_STATE_AT_SIGNAL:
10285 -- Not implemented in linux kernel.
10286 case GSI_UACPROC:
10287 -- Retrieves current unaligned access state; not much used.
10288 case GSI_PROC_TYPE:
10289 -- Retrieves implver information; surely not used.
10290 case GSI_GET_HWRPB:
10291 -- Grabs a copy of the HWRPB; surely not used.
10292 */
10293 }
10294 break;
10295 #endif
10296 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
10297 /* Alpha specific */
10298 case TARGET_NR_osf_setsysinfo:
10299 ret = -TARGET_EOPNOTSUPP;
10300 switch (arg1) {
10301 case TARGET_SSI_IEEE_FP_CONTROL:
10302 {
10303 uint64_t swcr, fpcr, orig_fpcr;
10304
10305 if (get_user_u64 (swcr, arg2)) {
10306 goto efault;
10307 }
10308 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
10309 fpcr = orig_fpcr & FPCR_DYN_MASK;
10310
10311 /* Copied from linux ieee_swcr_to_fpcr. */
10312 fpcr |= (swcr & SWCR_STATUS_MASK) << 35;
10313 fpcr |= (swcr & SWCR_MAP_DMZ) << 36;
10314 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_INV
10315 | SWCR_TRAP_ENABLE_DZE
10316 | SWCR_TRAP_ENABLE_OVF)) << 48;
10317 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_UNF
10318 | SWCR_TRAP_ENABLE_INE)) << 57;
10319 fpcr |= (swcr & SWCR_MAP_UMZ ? FPCR_UNDZ | FPCR_UNFD : 0);
10320 fpcr |= (~swcr & SWCR_TRAP_ENABLE_DNO) << 41;
10321
10322 cpu_alpha_store_fpcr(cpu_env, fpcr);
10323 ret = 0;
10324 }
10325 break;
10326
10327 case TARGET_SSI_IEEE_RAISE_EXCEPTION:
10328 {
10329 uint64_t exc, fpcr, orig_fpcr;
10330 int si_code;
10331
10332 if (get_user_u64(exc, arg2)) {
10333 goto efault;
10334 }
10335
10336 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
10337
10338 /* We only add to the exception status here. */
10339 fpcr = orig_fpcr | ((exc & SWCR_STATUS_MASK) << 35);
10340
10341 cpu_alpha_store_fpcr(cpu_env, fpcr);
10342 ret = 0;
10343
10344 /* Old exceptions are not signaled. */
10345 fpcr &= ~(orig_fpcr & FPCR_STATUS_MASK);
10346
10347 /* If any exceptions set by this call,
10348 and are unmasked, send a signal. */
10349 si_code = 0;
10350 if ((fpcr & (FPCR_INE | FPCR_INED)) == FPCR_INE) {
10351 si_code = TARGET_FPE_FLTRES;
10352 }
10353 if ((fpcr & (FPCR_UNF | FPCR_UNFD)) == FPCR_UNF) {
10354 si_code = TARGET_FPE_FLTUND;
10355 }
10356 if ((fpcr & (FPCR_OVF | FPCR_OVFD)) == FPCR_OVF) {
10357 si_code = TARGET_FPE_FLTOVF;
10358 }
10359 if ((fpcr & (FPCR_DZE | FPCR_DZED)) == FPCR_DZE) {
10360 si_code = TARGET_FPE_FLTDIV;
10361 }
10362 if ((fpcr & (FPCR_INV | FPCR_INVD)) == FPCR_INV) {
10363 si_code = TARGET_FPE_FLTINV;
10364 }
10365 if (si_code != 0) {
10366 target_siginfo_t info;
10367 info.si_signo = SIGFPE;
10368 info.si_errno = 0;
10369 info.si_code = si_code;
10370 info._sifields._sigfault._addr
10371 = ((CPUArchState *)cpu_env)->pc;
10372 queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
10373 }
10374 }
10375 break;
10376
10377 /* case SSI_NVPAIRS:
10378 -- Used with SSIN_UACPROC to enable unaligned accesses.
10379 case SSI_IEEE_STATE_AT_SIGNAL:
10380 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
10381 -- Not implemented in linux kernel
10382 */
10383 }
10384 break;
10385 #endif
10386 #ifdef TARGET_NR_osf_sigprocmask
10387 /* Alpha specific. */
10388 case TARGET_NR_osf_sigprocmask:
10389 {
10390 abi_ulong mask;
10391 int how;
10392 sigset_t set, oldset;
10393
10394 switch(arg1) {
10395 case TARGET_SIG_BLOCK:
10396 how = SIG_BLOCK;
10397 break;
10398 case TARGET_SIG_UNBLOCK:
10399 how = SIG_UNBLOCK;
10400 break;
10401 case TARGET_SIG_SETMASK:
10402 how = SIG_SETMASK;
10403 break;
10404 default:
10405 ret = -TARGET_EINVAL;
10406 goto fail;
10407 }
10408 mask = arg2;
10409 target_to_host_old_sigset(&set, &mask);
10410 ret = do_sigprocmask(how, &set, &oldset);
10411 if (!ret) {
10412 host_to_target_old_sigset(&mask, &oldset);
10413 ret = mask;
10414 }
10415 }
10416 break;
10417 #endif
10418
10419 #ifdef TARGET_NR_getgid32
10420 case TARGET_NR_getgid32:
10421 ret = get_errno(getgid());
10422 break;
10423 #endif
10424 #ifdef TARGET_NR_geteuid32
10425 case TARGET_NR_geteuid32:
10426 ret = get_errno(geteuid());
10427 break;
10428 #endif
10429 #ifdef TARGET_NR_getegid32
10430 case TARGET_NR_getegid32:
10431 ret = get_errno(getegid());
10432 break;
10433 #endif
10434 #ifdef TARGET_NR_setreuid32
10435 case TARGET_NR_setreuid32:
10436 ret = get_errno(setreuid(arg1, arg2));
10437 break;
10438 #endif
10439 #ifdef TARGET_NR_setregid32
10440 case TARGET_NR_setregid32:
10441 ret = get_errno(setregid(arg1, arg2));
10442 break;
10443 #endif
10444 #ifdef TARGET_NR_getgroups32
10445 case TARGET_NR_getgroups32:
10446 {
10447 int gidsetsize = arg1;
10448 uint32_t *target_grouplist;
10449 gid_t *grouplist;
10450 int i;
10451
10452 grouplist = alloca(gidsetsize * sizeof(gid_t));
10453 ret = get_errno(getgroups(gidsetsize, grouplist));
10454 if (gidsetsize == 0)
10455 break;
10456 if (!is_error(ret)) {
10457 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
10458 if (!target_grouplist) {
10459 ret = -TARGET_EFAULT;
10460 goto fail;
10461 }
10462 for(i = 0;i < ret; i++)
10463 target_grouplist[i] = tswap32(grouplist[i]);
10464 unlock_user(target_grouplist, arg2, gidsetsize * 4);
10465 }
10466 }
10467 break;
10468 #endif
10469 #ifdef TARGET_NR_setgroups32
10470 case TARGET_NR_setgroups32:
10471 {
10472 int gidsetsize = arg1;
10473 uint32_t *target_grouplist;
10474 gid_t *grouplist;
10475 int i;
10476
10477 grouplist = alloca(gidsetsize * sizeof(gid_t));
10478 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
10479 if (!target_grouplist) {
10480 ret = -TARGET_EFAULT;
10481 goto fail;
10482 }
10483 for(i = 0;i < gidsetsize; i++)
10484 grouplist[i] = tswap32(target_grouplist[i]);
10485 unlock_user(target_grouplist, arg2, 0);
10486 ret = get_errno(setgroups(gidsetsize, grouplist));
10487 }
10488 break;
10489 #endif
10490 #ifdef TARGET_NR_fchown32
10491 case TARGET_NR_fchown32:
10492 ret = get_errno(fchown(arg1, arg2, arg3));
10493 break;
10494 #endif
10495 #ifdef TARGET_NR_setresuid32
10496 case TARGET_NR_setresuid32:
10497 ret = get_errno(sys_setresuid(arg1, arg2, arg3));
10498 break;
10499 #endif
10500 #ifdef TARGET_NR_getresuid32
10501 case TARGET_NR_getresuid32:
10502 {
10503 uid_t ruid, euid, suid;
10504 ret = get_errno(getresuid(&ruid, &euid, &suid));
10505 if (!is_error(ret)) {
10506 if (put_user_u32(ruid, arg1)
10507 || put_user_u32(euid, arg2)
10508 || put_user_u32(suid, arg3))
10509 goto efault;
10510 }
10511 }
10512 break;
10513 #endif
10514 #ifdef TARGET_NR_setresgid32
10515 case TARGET_NR_setresgid32:
10516 ret = get_errno(sys_setresgid(arg1, arg2, arg3));
10517 break;
10518 #endif
10519 #ifdef TARGET_NR_getresgid32
10520 case TARGET_NR_getresgid32:
10521 {
10522 gid_t rgid, egid, sgid;
10523 ret = get_errno(getresgid(&rgid, &egid, &sgid));
10524 if (!is_error(ret)) {
10525 if (put_user_u32(rgid, arg1)
10526 || put_user_u32(egid, arg2)
10527 || put_user_u32(sgid, arg3))
10528 goto efault;
10529 }
10530 }
10531 break;
10532 #endif
10533 #ifdef TARGET_NR_chown32
10534 case TARGET_NR_chown32:
10535 if (!(p = lock_user_string(arg1)))
10536 goto efault;
10537 ret = get_errno(chown(p, arg2, arg3));
10538 unlock_user(p, arg1, 0);
10539 break;
10540 #endif
10541 #ifdef TARGET_NR_setuid32
10542 case TARGET_NR_setuid32:
10543 ret = get_errno(sys_setuid(arg1));
10544 break;
10545 #endif
10546 #ifdef TARGET_NR_setgid32
10547 case TARGET_NR_setgid32:
10548 ret = get_errno(sys_setgid(arg1));
10549 break;
10550 #endif
10551 #ifdef TARGET_NR_setfsuid32
10552 case TARGET_NR_setfsuid32:
10553 ret = get_errno(setfsuid(arg1));
10554 break;
10555 #endif
10556 #ifdef TARGET_NR_setfsgid32
10557 case TARGET_NR_setfsgid32:
10558 ret = get_errno(setfsgid(arg1));
10559 break;
10560 #endif
10561
10562 case TARGET_NR_pivot_root:
10563 goto unimplemented;
10564 #ifdef TARGET_NR_mincore
10565 case TARGET_NR_mincore:
10566 {
10567 void *a;
10568 ret = -TARGET_EFAULT;
10569 if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
10570 goto efault;
10571 if (!(p = lock_user_string(arg3)))
10572 goto mincore_fail;
10573 ret = get_errno(mincore(a, arg2, p));
10574 unlock_user(p, arg3, ret);
10575 mincore_fail:
10576 unlock_user(a, arg1, 0);
10577 }
10578 break;
10579 #endif
10580 #ifdef TARGET_NR_arm_fadvise64_64
10581 case TARGET_NR_arm_fadvise64_64:
10582 /* arm_fadvise64_64 looks like fadvise64_64 but
10583 * with different argument order: fd, advice, offset, len
10584 * rather than the usual fd, offset, len, advice.
10585 * Note that offset and len are both 64-bit so appear as
10586 * pairs of 32-bit registers.
10587 */
10588 ret = posix_fadvise(arg1, target_offset64(arg3, arg4),
10589 target_offset64(arg5, arg6), arg2);
10590 ret = -host_to_target_errno(ret);
10591 break;
10592 #endif
10593
10594 #if TARGET_ABI_BITS == 32
10595
10596 #ifdef TARGET_NR_fadvise64_64
10597 case TARGET_NR_fadvise64_64:
10598 /* 6 args: fd, offset (high, low), len (high, low), advice */
10599 if (regpairs_aligned(cpu_env)) {
10600 /* offset is in (3,4), len in (5,6) and advice in 7 */
10601 arg2 = arg3;
10602 arg3 = arg4;
10603 arg4 = arg5;
10604 arg5 = arg6;
10605 arg6 = arg7;
10606 }
10607 ret = -host_to_target_errno(posix_fadvise(arg1,
10608 target_offset64(arg2, arg3),
10609 target_offset64(arg4, arg5),
10610 arg6));
10611 break;
10612 #endif
10613
10614 #ifdef TARGET_NR_fadvise64
10615 case TARGET_NR_fadvise64:
10616 /* 5 args: fd, offset (high, low), len, advice */
10617 if (regpairs_aligned(cpu_env)) {
10618 /* offset is in (3,4), len in 5 and advice in 6 */
10619 arg2 = arg3;
10620 arg3 = arg4;
10621 arg4 = arg5;
10622 arg5 = arg6;
10623 }
10624 ret = -host_to_target_errno(posix_fadvise(arg1,
10625 target_offset64(arg2, arg3),
10626 arg4, arg5));
10627 break;
10628 #endif
10629
10630 #else /* not a 32-bit ABI */
10631 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
10632 #ifdef TARGET_NR_fadvise64_64
10633 case TARGET_NR_fadvise64_64:
10634 #endif
10635 #ifdef TARGET_NR_fadvise64
10636 case TARGET_NR_fadvise64:
10637 #endif
10638 #ifdef TARGET_S390X
10639 switch (arg4) {
10640 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
10641 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
10642 case 6: arg4 = POSIX_FADV_DONTNEED; break;
10643 case 7: arg4 = POSIX_FADV_NOREUSE; break;
10644 default: break;
10645 }
10646 #endif
10647 ret = -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4));
10648 break;
10649 #endif
10650 #endif /* end of 64-bit ABI fadvise handling */
10651
10652 #ifdef TARGET_NR_madvise
10653 case TARGET_NR_madvise:
10654 /* A straight passthrough may not be safe because qemu sometimes
10655 turns private file-backed mappings into anonymous mappings.
10656 This will break MADV_DONTNEED.
10657 This is a hint, so ignoring and returning success is ok. */
10658 ret = get_errno(0);
10659 break;
10660 #endif
10661 #if TARGET_ABI_BITS == 32
10662 case TARGET_NR_fcntl64:
10663 {
10664 int cmd;
10665 struct flock64 fl;
10666 from_flock64_fn *copyfrom = copy_from_user_flock64;
10667 to_flock64_fn *copyto = copy_to_user_flock64;
10668
10669 #ifdef TARGET_ARM
10670 if (((CPUARMState *)cpu_env)->eabi) {
10671 copyfrom = copy_from_user_eabi_flock64;
10672 copyto = copy_to_user_eabi_flock64;
10673 }
10674 #endif
10675
10676 cmd = target_to_host_fcntl_cmd(arg2);
10677 if (cmd == -TARGET_EINVAL) {
10678 ret = cmd;
10679 break;
10680 }
10681
10682 switch(arg2) {
10683 case TARGET_F_GETLK64:
10684 ret = copyfrom(&fl, arg3);
10685 if (ret) {
10686 break;
10687 }
10688 ret = get_errno(fcntl(arg1, cmd, &fl));
10689 if (ret == 0) {
10690 ret = copyto(arg3, &fl);
10691 }
10692 break;
10693
10694 case TARGET_F_SETLK64:
10695 case TARGET_F_SETLKW64:
10696 ret = copyfrom(&fl, arg3);
10697 if (ret) {
10698 break;
10699 }
10700 ret = get_errno(safe_fcntl(arg1, cmd, &fl));
10701 break;
10702 default:
10703 ret = do_fcntl(arg1, arg2, arg3);
10704 break;
10705 }
10706 break;
10707 }
10708 #endif
10709 #ifdef TARGET_NR_cacheflush
10710 case TARGET_NR_cacheflush:
10711 /* self-modifying code is handled automatically, so nothing needed */
10712 ret = 0;
10713 break;
10714 #endif
10715 #ifdef TARGET_NR_security
10716 case TARGET_NR_security:
10717 goto unimplemented;
10718 #endif
10719 #ifdef TARGET_NR_getpagesize
10720 case TARGET_NR_getpagesize:
10721 ret = TARGET_PAGE_SIZE;
10722 break;
10723 #endif
10724 case TARGET_NR_gettid:
10725 ret = get_errno(gettid());
10726 break;
10727 #ifdef TARGET_NR_readahead
10728 case TARGET_NR_readahead:
10729 #if TARGET_ABI_BITS == 32
10730 if (regpairs_aligned(cpu_env)) {
10731 arg2 = arg3;
10732 arg3 = arg4;
10733 arg4 = arg5;
10734 }
10735 ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
10736 #else
10737 ret = get_errno(readahead(arg1, arg2, arg3));
10738 #endif
10739 break;
10740 #endif
10741 #ifdef CONFIG_ATTR
10742 #ifdef TARGET_NR_setxattr
10743 case TARGET_NR_listxattr:
10744 case TARGET_NR_llistxattr:
10745 {
10746 void *p, *b = 0;
10747 if (arg2) {
10748 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10749 if (!b) {
10750 ret = -TARGET_EFAULT;
10751 break;
10752 }
10753 }
10754 p = lock_user_string(arg1);
10755 if (p) {
10756 if (num == TARGET_NR_listxattr) {
10757 ret = get_errno(listxattr(p, b, arg3));
10758 } else {
10759 ret = get_errno(llistxattr(p, b, arg3));
10760 }
10761 } else {
10762 ret = -TARGET_EFAULT;
10763 }
10764 unlock_user(p, arg1, 0);
10765 unlock_user(b, arg2, arg3);
10766 break;
10767 }
10768 case TARGET_NR_flistxattr:
10769 {
10770 void *b = 0;
10771 if (arg2) {
10772 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10773 if (!b) {
10774 ret = -TARGET_EFAULT;
10775 break;
10776 }
10777 }
10778 ret = get_errno(flistxattr(arg1, b, arg3));
10779 unlock_user(b, arg2, arg3);
10780 break;
10781 }
10782 case TARGET_NR_setxattr:
10783 case TARGET_NR_lsetxattr:
10784 {
10785 void *p, *n, *v = 0;
10786 if (arg3) {
10787 v = lock_user(VERIFY_READ, arg3, arg4, 1);
10788 if (!v) {
10789 ret = -TARGET_EFAULT;
10790 break;
10791 }
10792 }
10793 p = lock_user_string(arg1);
10794 n = lock_user_string(arg2);
10795 if (p && n) {
10796 if (num == TARGET_NR_setxattr) {
10797 ret = get_errno(setxattr(p, n, v, arg4, arg5));
10798 } else {
10799 ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
10800 }
10801 } else {
10802 ret = -TARGET_EFAULT;
10803 }
10804 unlock_user(p, arg1, 0);
10805 unlock_user(n, arg2, 0);
10806 unlock_user(v, arg3, 0);
10807 }
10808 break;
10809 case TARGET_NR_fsetxattr:
10810 {
10811 void *n, *v = 0;
10812 if (arg3) {
10813 v = lock_user(VERIFY_READ, arg3, arg4, 1);
10814 if (!v) {
10815 ret = -TARGET_EFAULT;
10816 break;
10817 }
10818 }
10819 n = lock_user_string(arg2);
10820 if (n) {
10821 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
10822 } else {
10823 ret = -TARGET_EFAULT;
10824 }
10825 unlock_user(n, arg2, 0);
10826 unlock_user(v, arg3, 0);
10827 }
10828 break;
10829 case TARGET_NR_getxattr:
10830 case TARGET_NR_lgetxattr:
10831 {
10832 void *p, *n, *v = 0;
10833 if (arg3) {
10834 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
10835 if (!v) {
10836 ret = -TARGET_EFAULT;
10837 break;
10838 }
10839 }
10840 p = lock_user_string(arg1);
10841 n = lock_user_string(arg2);
10842 if (p && n) {
10843 if (num == TARGET_NR_getxattr) {
10844 ret = get_errno(getxattr(p, n, v, arg4));
10845 } else {
10846 ret = get_errno(lgetxattr(p, n, v, arg4));
10847 }
10848 } else {
10849 ret = -TARGET_EFAULT;
10850 }
10851 unlock_user(p, arg1, 0);
10852 unlock_user(n, arg2, 0);
10853 unlock_user(v, arg3, arg4);
10854 }
10855 break;
10856 case TARGET_NR_fgetxattr:
10857 {
10858 void *n, *v = 0;
10859 if (arg3) {
10860 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
10861 if (!v) {
10862 ret = -TARGET_EFAULT;
10863 break;
10864 }
10865 }
10866 n = lock_user_string(arg2);
10867 if (n) {
10868 ret = get_errno(fgetxattr(arg1, n, v, arg4));
10869 } else {
10870 ret = -TARGET_EFAULT;
10871 }
10872 unlock_user(n, arg2, 0);
10873 unlock_user(v, arg3, arg4);
10874 }
10875 break;
10876 case TARGET_NR_removexattr:
10877 case TARGET_NR_lremovexattr:
10878 {
10879 void *p, *n;
10880 p = lock_user_string(arg1);
10881 n = lock_user_string(arg2);
10882 if (p && n) {
10883 if (num == TARGET_NR_removexattr) {
10884 ret = get_errno(removexattr(p, n));
10885 } else {
10886 ret = get_errno(lremovexattr(p, n));
10887 }
10888 } else {
10889 ret = -TARGET_EFAULT;
10890 }
10891 unlock_user(p, arg1, 0);
10892 unlock_user(n, arg2, 0);
10893 }
10894 break;
10895 case TARGET_NR_fremovexattr:
10896 {
10897 void *n;
10898 n = lock_user_string(arg2);
10899 if (n) {
10900 ret = get_errno(fremovexattr(arg1, n));
10901 } else {
10902 ret = -TARGET_EFAULT;
10903 }
10904 unlock_user(n, arg2, 0);
10905 }
10906 break;
10907 #endif
10908 #endif /* CONFIG_ATTR */
10909 #ifdef TARGET_NR_set_thread_area
10910 case TARGET_NR_set_thread_area:
10911 #if defined(TARGET_MIPS)
10912 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1;
10913 ret = 0;
10914 break;
10915 #elif defined(TARGET_CRIS)
10916 if (arg1 & 0xff)
10917 ret = -TARGET_EINVAL;
10918 else {
10919 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
10920 ret = 0;
10921 }
10922 break;
10923 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
10924 ret = do_set_thread_area(cpu_env, arg1);
10925 break;
10926 #elif defined(TARGET_M68K)
10927 {
10928 TaskState *ts = cpu->opaque;
10929 ts->tp_value = arg1;
10930 ret = 0;
10931 break;
10932 }
10933 #else
10934 goto unimplemented_nowarn;
10935 #endif
10936 #endif
10937 #ifdef TARGET_NR_get_thread_area
10938 case TARGET_NR_get_thread_area:
10939 #if defined(TARGET_I386) && defined(TARGET_ABI32)
10940 ret = do_get_thread_area(cpu_env, arg1);
10941 break;
10942 #elif defined(TARGET_M68K)
10943 {
10944 TaskState *ts = cpu->opaque;
10945 ret = ts->tp_value;
10946 break;
10947 }
10948 #else
10949 goto unimplemented_nowarn;
10950 #endif
10951 #endif
10952 #ifdef TARGET_NR_getdomainname
10953 case TARGET_NR_getdomainname:
10954 goto unimplemented_nowarn;
10955 #endif
10956
10957 #ifdef TARGET_NR_clock_gettime
10958 case TARGET_NR_clock_gettime:
10959 {
10960 struct timespec ts;
10961 ret = get_errno(clock_gettime(arg1, &ts));
10962 if (!is_error(ret)) {
10963 host_to_target_timespec(arg2, &ts);
10964 }
10965 break;
10966 }
10967 #endif
10968 #ifdef TARGET_NR_clock_getres
10969 case TARGET_NR_clock_getres:
10970 {
10971 struct timespec ts;
10972 ret = get_errno(clock_getres(arg1, &ts));
10973 if (!is_error(ret)) {
10974 host_to_target_timespec(arg2, &ts);
10975 }
10976 break;
10977 }
10978 #endif
10979 #ifdef TARGET_NR_clock_nanosleep
10980 case TARGET_NR_clock_nanosleep:
10981 {
10982 struct timespec ts;
10983 target_to_host_timespec(&ts, arg3);
10984 ret = get_errno(safe_clock_nanosleep(arg1, arg2,
10985 &ts, arg4 ? &ts : NULL));
10986 if (arg4)
10987 host_to_target_timespec(arg4, &ts);
10988
10989 #if defined(TARGET_PPC)
10990 /* clock_nanosleep is odd in that it returns positive errno values.
10991 * On PPC, CR0 bit 3 should be set in such a situation. */
10992 if (ret && ret != -TARGET_ERESTARTSYS) {
10993 ((CPUPPCState *)cpu_env)->crf[0] |= 1;
10994 }
10995 #endif
10996 break;
10997 }
10998 #endif
10999
11000 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11001 case TARGET_NR_set_tid_address:
11002 ret = get_errno(set_tid_address((int *)g2h(arg1)));
11003 break;
11004 #endif
11005
11006 case TARGET_NR_tkill:
11007 ret = get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2)));
11008 break;
11009
11010 case TARGET_NR_tgkill:
11011 ret = get_errno(safe_tgkill((int)arg1, (int)arg2,
11012 target_to_host_signal(arg3)));
11013 break;
11014
11015 #ifdef TARGET_NR_set_robust_list
11016 case TARGET_NR_set_robust_list:
11017 case TARGET_NR_get_robust_list:
11018 /* The ABI for supporting robust futexes has userspace pass
11019 * the kernel a pointer to a linked list which is updated by
11020 * userspace after the syscall; the list is walked by the kernel
11021 * when the thread exits. Since the linked list in QEMU guest
11022 * memory isn't a valid linked list for the host and we have
11023 * no way to reliably intercept the thread-death event, we can't
11024 * support these. Silently return ENOSYS so that guest userspace
11025 * falls back to a non-robust futex implementation (which should
11026 * be OK except in the corner case of the guest crashing while
11027 * holding a mutex that is shared with another process via
11028 * shared memory).
11029 */
11030 goto unimplemented_nowarn;
11031 #endif
11032
11033 #if defined(TARGET_NR_utimensat)
11034 case TARGET_NR_utimensat:
11035 {
11036 struct timespec *tsp, ts[2];
11037 if (!arg3) {
11038 tsp = NULL;
11039 } else {
11040 target_to_host_timespec(ts, arg3);
11041 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
11042 tsp = ts;
11043 }
11044 if (!arg2)
11045 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
11046 else {
11047 if (!(p = lock_user_string(arg2))) {
11048 ret = -TARGET_EFAULT;
11049 goto fail;
11050 }
11051 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
11052 unlock_user(p, arg2, 0);
11053 }
11054 }
11055 break;
11056 #endif
11057 case TARGET_NR_futex:
11058 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
11059 break;
11060 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
11061 case TARGET_NR_inotify_init:
11062 ret = get_errno(sys_inotify_init());
11063 break;
11064 #endif
11065 #ifdef CONFIG_INOTIFY1
11066 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11067 case TARGET_NR_inotify_init1:
11068 ret = get_errno(sys_inotify_init1(arg1));
11069 break;
11070 #endif
11071 #endif
11072 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
11073 case TARGET_NR_inotify_add_watch:
11074 p = lock_user_string(arg2);
11075 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
11076 unlock_user(p, arg2, 0);
11077 break;
11078 #endif
11079 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
11080 case TARGET_NR_inotify_rm_watch:
11081 ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
11082 break;
11083 #endif
11084
11085 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
11086 case TARGET_NR_mq_open:
11087 {
11088 struct mq_attr posix_mq_attr, *attrp;
11089
11090 p = lock_user_string(arg1 - 1);
11091 if (arg4 != 0) {
11092 copy_from_user_mq_attr (&posix_mq_attr, arg4);
11093 attrp = &posix_mq_attr;
11094 } else {
11095 attrp = 0;
11096 }
11097 ret = get_errno(mq_open(p, arg2, arg3, attrp));
11098 unlock_user (p, arg1, 0);
11099 }
11100 break;
11101
11102 case TARGET_NR_mq_unlink:
11103 p = lock_user_string(arg1 - 1);
11104 ret = get_errno(mq_unlink(p));
11105 unlock_user (p, arg1, 0);
11106 break;
11107
11108 case TARGET_NR_mq_timedsend:
11109 {
11110 struct timespec ts;
11111
11112 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11113 if (arg5 != 0) {
11114 target_to_host_timespec(&ts, arg5);
11115 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
11116 host_to_target_timespec(arg5, &ts);
11117 } else {
11118 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
11119 }
11120 unlock_user (p, arg2, arg3);
11121 }
11122 break;
11123
11124 case TARGET_NR_mq_timedreceive:
11125 {
11126 struct timespec ts;
11127 unsigned int prio;
11128
11129 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11130 if (arg5 != 0) {
11131 target_to_host_timespec(&ts, arg5);
11132 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11133 &prio, &ts));
11134 host_to_target_timespec(arg5, &ts);
11135 } else {
11136 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11137 &prio, NULL));
11138 }
11139 unlock_user (p, arg2, arg3);
11140 if (arg4 != 0)
11141 put_user_u32(prio, arg4);
11142 }
11143 break;
11144
11145 /* Not implemented for now... */
11146 /* case TARGET_NR_mq_notify: */
11147 /* break; */
11148
11149 case TARGET_NR_mq_getsetattr:
11150 {
11151 struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
11152 ret = 0;
11153 if (arg3 != 0) {
11154 ret = mq_getattr(arg1, &posix_mq_attr_out);
11155 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
11156 }
11157 if (arg2 != 0) {
11158 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
11159 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
11160 }
11161
11162 }
11163 break;
11164 #endif
11165
11166 #ifdef CONFIG_SPLICE
11167 #ifdef TARGET_NR_tee
11168 case TARGET_NR_tee:
11169 {
11170 ret = get_errno(tee(arg1,arg2,arg3,arg4));
11171 }
11172 break;
11173 #endif
11174 #ifdef TARGET_NR_splice
11175 case TARGET_NR_splice:
11176 {
11177 loff_t loff_in, loff_out;
11178 loff_t *ploff_in = NULL, *ploff_out = NULL;
11179 if (arg2) {
11180 if (get_user_u64(loff_in, arg2)) {
11181 goto efault;
11182 }
11183 ploff_in = &loff_in;
11184 }
11185 if (arg4) {
11186 if (get_user_u64(loff_out, arg4)) {
11187 goto efault;
11188 }
11189 ploff_out = &loff_out;
11190 }
11191 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
11192 if (arg2) {
11193 if (put_user_u64(loff_in, arg2)) {
11194 goto efault;
11195 }
11196 }
11197 if (arg4) {
11198 if (put_user_u64(loff_out, arg4)) {
11199 goto efault;
11200 }
11201 }
11202 }
11203 break;
11204 #endif
11205 #ifdef TARGET_NR_vmsplice
11206 case TARGET_NR_vmsplice:
11207 {
11208 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
11209 if (vec != NULL) {
11210 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
11211 unlock_iovec(vec, arg2, arg3, 0);
11212 } else {
11213 ret = -host_to_target_errno(errno);
11214 }
11215 }
11216 break;
11217 #endif
11218 #endif /* CONFIG_SPLICE */
11219 #ifdef CONFIG_EVENTFD
11220 #if defined(TARGET_NR_eventfd)
11221 case TARGET_NR_eventfd:
11222 ret = get_errno(eventfd(arg1, 0));
11223 fd_trans_unregister(ret);
11224 break;
11225 #endif
11226 #if defined(TARGET_NR_eventfd2)
11227 case TARGET_NR_eventfd2:
11228 {
11229 int host_flags = arg2 & (~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC));
11230 if (arg2 & TARGET_O_NONBLOCK) {
11231 host_flags |= O_NONBLOCK;
11232 }
11233 if (arg2 & TARGET_O_CLOEXEC) {
11234 host_flags |= O_CLOEXEC;
11235 }
11236 ret = get_errno(eventfd(arg1, host_flags));
11237 fd_trans_unregister(ret);
11238 break;
11239 }
11240 #endif
11241 #endif /* CONFIG_EVENTFD */
11242 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
11243 case TARGET_NR_fallocate:
11244 #if TARGET_ABI_BITS == 32
11245 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
11246 target_offset64(arg5, arg6)));
11247 #else
11248 ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
11249 #endif
11250 break;
11251 #endif
11252 #if defined(CONFIG_SYNC_FILE_RANGE)
11253 #if defined(TARGET_NR_sync_file_range)
11254 case TARGET_NR_sync_file_range:
11255 #if TARGET_ABI_BITS == 32
11256 #if defined(TARGET_MIPS)
11257 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11258 target_offset64(arg5, arg6), arg7));
11259 #else
11260 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
11261 target_offset64(arg4, arg5), arg6));
11262 #endif /* !TARGET_MIPS */
11263 #else
11264 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
11265 #endif
11266 break;
11267 #endif
11268 #if defined(TARGET_NR_sync_file_range2)
11269 case TARGET_NR_sync_file_range2:
11270 /* This is like sync_file_range but the arguments are reordered */
11271 #if TARGET_ABI_BITS == 32
11272 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11273 target_offset64(arg5, arg6), arg2));
11274 #else
11275 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
11276 #endif
11277 break;
11278 #endif
11279 #endif
11280 #if defined(TARGET_NR_signalfd4)
11281 case TARGET_NR_signalfd4:
11282 ret = do_signalfd4(arg1, arg2, arg4);
11283 break;
11284 #endif
11285 #if defined(TARGET_NR_signalfd)
11286 case TARGET_NR_signalfd:
11287 ret = do_signalfd4(arg1, arg2, 0);
11288 break;
11289 #endif
11290 #if defined(CONFIG_EPOLL)
11291 #if defined(TARGET_NR_epoll_create)
11292 case TARGET_NR_epoll_create:
11293 ret = get_errno(epoll_create(arg1));
11294 break;
11295 #endif
11296 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
11297 case TARGET_NR_epoll_create1:
11298 ret = get_errno(epoll_create1(arg1));
11299 break;
11300 #endif
11301 #if defined(TARGET_NR_epoll_ctl)
11302 case TARGET_NR_epoll_ctl:
11303 {
11304 struct epoll_event ep;
11305 struct epoll_event *epp = 0;
11306 if (arg4) {
11307 struct target_epoll_event *target_ep;
11308 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
11309 goto efault;
11310 }
11311 ep.events = tswap32(target_ep->events);
11312 /* The epoll_data_t union is just opaque data to the kernel,
11313 * so we transfer all 64 bits across and need not worry what
11314 * actual data type it is.
11315 */
11316 ep.data.u64 = tswap64(target_ep->data.u64);
11317 unlock_user_struct(target_ep, arg4, 0);
11318 epp = &ep;
11319 }
11320 ret = get_errno(epoll_ctl(arg1, arg2, arg3, epp));
11321 break;
11322 }
11323 #endif
11324
11325 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
11326 #if defined(TARGET_NR_epoll_wait)
11327 case TARGET_NR_epoll_wait:
11328 #endif
11329 #if defined(TARGET_NR_epoll_pwait)
11330 case TARGET_NR_epoll_pwait:
11331 #endif
11332 {
11333 struct target_epoll_event *target_ep;
11334 struct epoll_event *ep;
11335 int epfd = arg1;
11336 int maxevents = arg3;
11337 int timeout = arg4;
11338
11339 target_ep = lock_user(VERIFY_WRITE, arg2,
11340 maxevents * sizeof(struct target_epoll_event), 1);
11341 if (!target_ep) {
11342 goto efault;
11343 }
11344
11345 ep = alloca(maxevents * sizeof(struct epoll_event));
11346
11347 switch (num) {
11348 #if defined(TARGET_NR_epoll_pwait)
11349 case TARGET_NR_epoll_pwait:
11350 {
11351 target_sigset_t *target_set;
11352 sigset_t _set, *set = &_set;
11353
11354 if (arg5) {
11355 if (arg6 != sizeof(target_sigset_t)) {
11356 ret = -TARGET_EINVAL;
11357 break;
11358 }
11359
11360 target_set = lock_user(VERIFY_READ, arg5,
11361 sizeof(target_sigset_t), 1);
11362 if (!target_set) {
11363 unlock_user(target_ep, arg2, 0);
11364 goto efault;
11365 }
11366 target_to_host_sigset(set, target_set);
11367 unlock_user(target_set, arg5, 0);
11368 } else {
11369 set = NULL;
11370 }
11371
11372 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
11373 set, SIGSET_T_SIZE));
11374 break;
11375 }
11376 #endif
11377 #if defined(TARGET_NR_epoll_wait)
11378 case TARGET_NR_epoll_wait:
11379 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
11380 NULL, 0));
11381 break;
11382 #endif
11383 default:
11384 ret = -TARGET_ENOSYS;
11385 }
11386 if (!is_error(ret)) {
11387 int i;
11388 for (i = 0; i < ret; i++) {
11389 target_ep[i].events = tswap32(ep[i].events);
11390 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
11391 }
11392 }
11393 unlock_user(target_ep, arg2, ret * sizeof(struct target_epoll_event));
11394 break;
11395 }
11396 #endif
11397 #endif
11398 #ifdef TARGET_NR_prlimit64
11399 case TARGET_NR_prlimit64:
11400 {
11401 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
11402 struct target_rlimit64 *target_rnew, *target_rold;
11403 struct host_rlimit64 rnew, rold, *rnewp = 0;
11404 int resource = target_to_host_resource(arg2);
11405 if (arg3) {
11406 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
11407 goto efault;
11408 }
11409 rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
11410 rnew.rlim_max = tswap64(target_rnew->rlim_max);
11411 unlock_user_struct(target_rnew, arg3, 0);
11412 rnewp = &rnew;
11413 }
11414
11415 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0));
11416 if (!is_error(ret) && arg4) {
11417 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
11418 goto efault;
11419 }
11420 target_rold->rlim_cur = tswap64(rold.rlim_cur);
11421 target_rold->rlim_max = tswap64(rold.rlim_max);
11422 unlock_user_struct(target_rold, arg4, 1);
11423 }
11424 break;
11425 }
11426 #endif
11427 #ifdef TARGET_NR_gethostname
11428 case TARGET_NR_gethostname:
11429 {
11430 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
11431 if (name) {
11432 ret = get_errno(gethostname(name, arg2));
11433 unlock_user(name, arg1, arg2);
11434 } else {
11435 ret = -TARGET_EFAULT;
11436 }
11437 break;
11438 }
11439 #endif
11440 #ifdef TARGET_NR_atomic_cmpxchg_32
11441 case TARGET_NR_atomic_cmpxchg_32:
11442 {
11443 /* should use start_exclusive from main.c */
11444 abi_ulong mem_value;
11445 if (get_user_u32(mem_value, arg6)) {
11446 target_siginfo_t info;
11447 info.si_signo = SIGSEGV;
11448 info.si_errno = 0;
11449 info.si_code = TARGET_SEGV_MAPERR;
11450 info._sifields._sigfault._addr = arg6;
11451 queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
11452 ret = 0xdeadbeef;
11453
11454 }
11455 if (mem_value == arg2)
11456 put_user_u32(arg1, arg6);
11457 ret = mem_value;
11458 break;
11459 }
11460 #endif
11461 #ifdef TARGET_NR_atomic_barrier
11462 case TARGET_NR_atomic_barrier:
11463 {
11464 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
11465 ret = 0;
11466 break;
11467 }
11468 #endif
11469
11470 #ifdef TARGET_NR_timer_create
11471 case TARGET_NR_timer_create:
11472 {
11473 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
11474
11475 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
11476
11477 int clkid = arg1;
11478 int timer_index = next_free_host_timer();
11479
11480 if (timer_index < 0) {
11481 ret = -TARGET_EAGAIN;
11482 } else {
11483 timer_t *phtimer = g_posix_timers + timer_index;
11484
11485 if (arg2) {
11486 phost_sevp = &host_sevp;
11487 ret = target_to_host_sigevent(phost_sevp, arg2);
11488 if (ret != 0) {
11489 break;
11490 }
11491 }
11492
11493 ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
11494 if (ret) {
11495 phtimer = NULL;
11496 } else {
11497 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) {
11498 goto efault;
11499 }
11500 }
11501 }
11502 break;
11503 }
11504 #endif
11505
11506 #ifdef TARGET_NR_timer_settime
11507 case TARGET_NR_timer_settime:
11508 {
11509 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
11510 * struct itimerspec * old_value */
11511 target_timer_t timerid = get_timer_id(arg1);
11512
11513 if (timerid < 0) {
11514 ret = timerid;
11515 } else if (arg3 == 0) {
11516 ret = -TARGET_EINVAL;
11517 } else {
11518 timer_t htimer = g_posix_timers[timerid];
11519 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
11520
11521 target_to_host_itimerspec(&hspec_new, arg3);
11522 ret = get_errno(
11523 timer_settime(htimer, arg2, &hspec_new, &hspec_old));
11524 host_to_target_itimerspec(arg2, &hspec_old);
11525 }
11526 break;
11527 }
11528 #endif
11529
11530 #ifdef TARGET_NR_timer_gettime
11531 case TARGET_NR_timer_gettime:
11532 {
11533 /* args: timer_t timerid, struct itimerspec *curr_value */
11534 target_timer_t timerid = get_timer_id(arg1);
11535
11536 if (timerid < 0) {
11537 ret = timerid;
11538 } else if (!arg2) {
11539 ret = -TARGET_EFAULT;
11540 } else {
11541 timer_t htimer = g_posix_timers[timerid];
11542 struct itimerspec hspec;
11543 ret = get_errno(timer_gettime(htimer, &hspec));
11544
11545 if (host_to_target_itimerspec(arg2, &hspec)) {
11546 ret = -TARGET_EFAULT;
11547 }
11548 }
11549 break;
11550 }
11551 #endif
11552
11553 #ifdef TARGET_NR_timer_getoverrun
11554 case TARGET_NR_timer_getoverrun:
11555 {
11556 /* args: timer_t timerid */
11557 target_timer_t timerid = get_timer_id(arg1);
11558
11559 if (timerid < 0) {
11560 ret = timerid;
11561 } else {
11562 timer_t htimer = g_posix_timers[timerid];
11563 ret = get_errno(timer_getoverrun(htimer));
11564 }
11565 fd_trans_unregister(ret);
11566 break;
11567 }
11568 #endif
11569
11570 #ifdef TARGET_NR_timer_delete
11571 case TARGET_NR_timer_delete:
11572 {
11573 /* args: timer_t timerid */
11574 target_timer_t timerid = get_timer_id(arg1);
11575
11576 if (timerid < 0) {
11577 ret = timerid;
11578 } else {
11579 timer_t htimer = g_posix_timers[timerid];
11580 ret = get_errno(timer_delete(htimer));
11581 g_posix_timers[timerid] = 0;
11582 }
11583 break;
11584 }
11585 #endif
11586
11587 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
11588 case TARGET_NR_timerfd_create:
11589 ret = get_errno(timerfd_create(arg1,
11590 target_to_host_bitmask(arg2, fcntl_flags_tbl)));
11591 break;
11592 #endif
11593
11594 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
11595 case TARGET_NR_timerfd_gettime:
11596 {
11597 struct itimerspec its_curr;
11598
11599 ret = get_errno(timerfd_gettime(arg1, &its_curr));
11600
11601 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) {
11602 goto efault;
11603 }
11604 }
11605 break;
11606 #endif
11607
11608 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
11609 case TARGET_NR_timerfd_settime:
11610 {
11611 struct itimerspec its_new, its_old, *p_new;
11612
11613 if (arg3) {
11614 if (target_to_host_itimerspec(&its_new, arg3)) {
11615 goto efault;
11616 }
11617 p_new = &its_new;
11618 } else {
11619 p_new = NULL;
11620 }
11621
11622 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
11623
11624 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) {
11625 goto efault;
11626 }
11627 }
11628 break;
11629 #endif
11630
11631 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
11632 case TARGET_NR_ioprio_get:
11633 ret = get_errno(ioprio_get(arg1, arg2));
11634 break;
11635 #endif
11636
11637 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
11638 case TARGET_NR_ioprio_set:
11639 ret = get_errno(ioprio_set(arg1, arg2, arg3));
11640 break;
11641 #endif
11642
11643 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
11644 case TARGET_NR_setns:
11645 ret = get_errno(setns(arg1, arg2));
11646 break;
11647 #endif
11648 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
11649 case TARGET_NR_unshare:
11650 ret = get_errno(unshare(arg1));
11651 break;
11652 #endif
11653
11654 default:
11655 unimplemented:
11656 gemu_log("qemu: Unsupported syscall: %d\n", num);
11657 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
11658 unimplemented_nowarn:
11659 #endif
11660 ret = -TARGET_ENOSYS;
11661 break;
11662 }
11663 fail:
11664 #ifdef DEBUG
11665 gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
11666 #endif
11667 if(do_strace)
11668 print_syscall_ret(num, ret);
11669 trace_guest_user_syscall_ret(cpu, num, ret);
11670 return ret;
11671 efault:
11672 ret = -TARGET_EFAULT;
11673 goto fail;
11674 }
QEMU mirror