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