4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 #include <sys/types.h>
38 #include <sys/mount.h>
39 #include <sys/prctl.h>
40 #include <sys/resource.h>
45 #include <sys/socket.h>
48 #include <sys/times.h>
51 #include <sys/statfs.h>
53 #include <sys/sysinfo.h>
54 //#include <sys/user.h>
55 #include <netinet/ip.h>
56 #include <netinet/tcp.h>
57 #include <qemu-common.h>
59 #define termios host_termios
60 #define winsize host_winsize
61 #define termio host_termio
62 #define sgttyb host_sgttyb /* same as target */
63 #define tchars host_tchars /* same as target */
64 #define ltchars host_ltchars /* same as target */
66 #include <linux/termios.h>
67 #include <linux/unistd.h>
68 #include <linux/utsname.h>
69 #include <linux/cdrom.h>
70 #include <linux/hdreg.h>
71 #include <linux/soundcard.h>
73 #include <linux/mtio.h>
74 #include "linux_loop.h"
77 #include "qemu-common.h"
80 #include <linux/futex.h>
81 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
82 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
84 /* XXX: Hardcode the above values. */
85 #define CLONE_NPTL_FLAGS2 0
90 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
91 || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
92 /* 16 bit uid wrappers emulation */
96 //#include <linux/msdos_fs.h>
97 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2])
98 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2])
109 #define _syscall0(type,name) \
110 static type name (void) \
112 return syscall(__NR_##name); \
115 #define _syscall1(type,name,type1,arg1) \
116 static type name (type1 arg1) \
118 return syscall(__NR_##name, arg1); \
121 #define _syscall2(type,name,type1,arg1,type2,arg2) \
122 static type name (type1 arg1,type2 arg2) \
124 return syscall(__NR_##name, arg1, arg2); \
127 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
128 static type name (type1 arg1,type2 arg2,type3 arg3) \
130 return syscall(__NR_##name, arg1, arg2, arg3); \
133 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
134 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
136 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
139 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
141 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
143 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
147 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
148 type5,arg5,type6,arg6) \
149 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
152 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
156 #define __NR_sys_uname __NR_uname
157 #define __NR_sys_faccessat __NR_faccessat
158 #define __NR_sys_fchmodat __NR_fchmodat
159 #define __NR_sys_fchownat __NR_fchownat
160 #define __NR_sys_fstatat64 __NR_fstatat64
161 #define __NR_sys_futimesat __NR_futimesat
162 #define __NR_sys_getcwd1 __NR_getcwd
163 #define __NR_sys_getdents __NR_getdents
164 #define __NR_sys_getdents64 __NR_getdents64
165 #define __NR_sys_getpriority __NR_getpriority
166 #define __NR_sys_linkat __NR_linkat
167 #define __NR_sys_mkdirat __NR_mkdirat
168 #define __NR_sys_mknodat __NR_mknodat
169 #define __NR_sys_openat __NR_openat
170 #define __NR_sys_readlinkat __NR_readlinkat
171 #define __NR_sys_renameat __NR_renameat
172 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
173 #define __NR_sys_symlinkat __NR_symlinkat
174 #define __NR_sys_syslog __NR_syslog
175 #define __NR_sys_tgkill __NR_tgkill
176 #define __NR_sys_tkill __NR_tkill
177 #define __NR_sys_unlinkat __NR_unlinkat
178 #define __NR_sys_utimensat __NR_utimensat
179 #define __NR_sys_futex __NR_futex
181 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
182 #define __NR__llseek __NR_lseek
186 _syscall0(int, gettid
)
188 /* This is a replacement for the host gettid() and must return a host
190 static int gettid(void) {
194 _syscall1(int,sys_uname
,struct new_utsname
*,buf
)
195 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
196 _syscall4(int,sys_faccessat
,int,dirfd
,const char *,pathname
,int,mode
,int,flags
)
198 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
199 _syscall4(int,sys_fchmodat
,int,dirfd
,const char *,pathname
,
200 mode_t
,mode
,int,flags
)
202 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16)
203 _syscall5(int,sys_fchownat
,int,dirfd
,const char *,pathname
,
204 uid_t
,owner
,gid_t
,group
,int,flags
)
206 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
207 _syscall4(int,sys_fstatat64
,int,dirfd
,const char *,pathname
,
208 struct stat
*,buf
,int,flags
)
210 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
211 _syscall3(int,sys_futimesat
,int,dirfd
,const char *,pathname
,
212 const struct timeval
*,times
)
214 _syscall2(int,sys_getcwd1
,char *,buf
,size_t,size
)
215 #if TARGET_ABI_BITS == 32
216 _syscall3(int, sys_getdents
, uint
, fd
, struct dirent
*, dirp
, uint
, count
);
218 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
219 _syscall3(int, sys_getdents64
, uint
, fd
, struct dirent64
*, dirp
, uint
, count
);
221 _syscall2(int, sys_getpriority
, int, which
, int, who
);
222 #if !defined (__x86_64__)
223 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
224 loff_t
*, res
, uint
, wh
);
226 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
227 _syscall5(int,sys_linkat
,int,olddirfd
,const char *,oldpath
,
228 int,newdirfd
,const char *,newpath
,int,flags
)
230 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
231 _syscall3(int,sys_mkdirat
,int,dirfd
,const char *,pathname
,mode_t
,mode
)
233 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
234 _syscall4(int,sys_mknodat
,int,dirfd
,const char *,pathname
,
235 mode_t
,mode
,dev_t
,dev
)
237 #if defined(TARGET_NR_openat) && defined(__NR_openat)
238 _syscall4(int,sys_openat
,int,dirfd
,const char *,pathname
,int,flags
,mode_t
,mode
)
240 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
241 _syscall4(int,sys_readlinkat
,int,dirfd
,const char *,pathname
,
242 char *,buf
,size_t,bufsize
)
244 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
245 _syscall4(int,sys_renameat
,int,olddirfd
,const char *,oldpath
,
246 int,newdirfd
,const char *,newpath
)
248 _syscall3(int,sys_rt_sigqueueinfo
,int,pid
,int,sig
,siginfo_t
*,uinfo
)
249 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
250 _syscall3(int,sys_symlinkat
,const char *,oldpath
,
251 int,newdirfd
,const char *,newpath
)
253 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
254 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
255 _syscall3(int,sys_tgkill
,int,tgid
,int,pid
,int,sig
)
257 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
258 _syscall2(int,sys_tkill
,int,tid
,int,sig
)
260 #ifdef __NR_exit_group
261 _syscall1(int,exit_group
,int,error_code
)
263 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
264 _syscall1(int,set_tid_address
,int *,tidptr
)
266 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
267 _syscall3(int,sys_unlinkat
,int,dirfd
,const char *,pathname
,int,flags
)
269 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
270 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
271 const struct timespec
*,tsp
,int,flags
)
273 #if defined(USE_NPTL)
274 #if defined(TARGET_NR_futex) && defined(__NR_futex)
275 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
276 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
280 extern int personality(int);
281 extern int flock(int, int);
282 extern int setfsuid(int);
283 extern int setfsgid(int);
284 extern int setgroups(int, gid_t
*);
286 #define ERRNO_TABLE_SIZE 1200
288 /* target_to_host_errno_table[] is initialized from
289 * host_to_target_errno_table[] in syscall_init(). */
290 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
294 * This list is the union of errno values overridden in asm-<arch>/errno.h
295 * minus the errnos that are not actually generic to all archs.
297 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
298 [EIDRM
] = TARGET_EIDRM
,
299 [ECHRNG
] = TARGET_ECHRNG
,
300 [EL2NSYNC
] = TARGET_EL2NSYNC
,
301 [EL3HLT
] = TARGET_EL3HLT
,
302 [EL3RST
] = TARGET_EL3RST
,
303 [ELNRNG
] = TARGET_ELNRNG
,
304 [EUNATCH
] = TARGET_EUNATCH
,
305 [ENOCSI
] = TARGET_ENOCSI
,
306 [EL2HLT
] = TARGET_EL2HLT
,
307 [EDEADLK
] = TARGET_EDEADLK
,
308 [ENOLCK
] = TARGET_ENOLCK
,
309 [EBADE
] = TARGET_EBADE
,
310 [EBADR
] = TARGET_EBADR
,
311 [EXFULL
] = TARGET_EXFULL
,
312 [ENOANO
] = TARGET_ENOANO
,
313 [EBADRQC
] = TARGET_EBADRQC
,
314 [EBADSLT
] = TARGET_EBADSLT
,
315 [EBFONT
] = TARGET_EBFONT
,
316 [ENOSTR
] = TARGET_ENOSTR
,
317 [ENODATA
] = TARGET_ENODATA
,
318 [ETIME
] = TARGET_ETIME
,
319 [ENOSR
] = TARGET_ENOSR
,
320 [ENONET
] = TARGET_ENONET
,
321 [ENOPKG
] = TARGET_ENOPKG
,
322 [EREMOTE
] = TARGET_EREMOTE
,
323 [ENOLINK
] = TARGET_ENOLINK
,
324 [EADV
] = TARGET_EADV
,
325 [ESRMNT
] = TARGET_ESRMNT
,
326 [ECOMM
] = TARGET_ECOMM
,
327 [EPROTO
] = TARGET_EPROTO
,
328 [EDOTDOT
] = TARGET_EDOTDOT
,
329 [EMULTIHOP
] = TARGET_EMULTIHOP
,
330 [EBADMSG
] = TARGET_EBADMSG
,
331 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
332 [EOVERFLOW
] = TARGET_EOVERFLOW
,
333 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
334 [EBADFD
] = TARGET_EBADFD
,
335 [EREMCHG
] = TARGET_EREMCHG
,
336 [ELIBACC
] = TARGET_ELIBACC
,
337 [ELIBBAD
] = TARGET_ELIBBAD
,
338 [ELIBSCN
] = TARGET_ELIBSCN
,
339 [ELIBMAX
] = TARGET_ELIBMAX
,
340 [ELIBEXEC
] = TARGET_ELIBEXEC
,
341 [EILSEQ
] = TARGET_EILSEQ
,
342 [ENOSYS
] = TARGET_ENOSYS
,
343 [ELOOP
] = TARGET_ELOOP
,
344 [ERESTART
] = TARGET_ERESTART
,
345 [ESTRPIPE
] = TARGET_ESTRPIPE
,
346 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
347 [EUSERS
] = TARGET_EUSERS
,
348 [ENOTSOCK
] = TARGET_ENOTSOCK
,
349 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
350 [EMSGSIZE
] = TARGET_EMSGSIZE
,
351 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
352 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
353 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
354 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
355 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
356 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
357 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
358 [EADDRINUSE
] = TARGET_EADDRINUSE
,
359 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
360 [ENETDOWN
] = TARGET_ENETDOWN
,
361 [ENETUNREACH
] = TARGET_ENETUNREACH
,
362 [ENETRESET
] = TARGET_ENETRESET
,
363 [ECONNABORTED
] = TARGET_ECONNABORTED
,
364 [ECONNRESET
] = TARGET_ECONNRESET
,
365 [ENOBUFS
] = TARGET_ENOBUFS
,
366 [EISCONN
] = TARGET_EISCONN
,
367 [ENOTCONN
] = TARGET_ENOTCONN
,
368 [EUCLEAN
] = TARGET_EUCLEAN
,
369 [ENOTNAM
] = TARGET_ENOTNAM
,
370 [ENAVAIL
] = TARGET_ENAVAIL
,
371 [EISNAM
] = TARGET_EISNAM
,
372 [EREMOTEIO
] = TARGET_EREMOTEIO
,
373 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
374 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
375 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
376 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
377 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
378 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
379 [EALREADY
] = TARGET_EALREADY
,
380 [EINPROGRESS
] = TARGET_EINPROGRESS
,
381 [ESTALE
] = TARGET_ESTALE
,
382 [ECANCELED
] = TARGET_ECANCELED
,
383 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
384 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
386 [ENOKEY
] = TARGET_ENOKEY
,
389 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
392 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
395 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
398 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
400 #ifdef ENOTRECOVERABLE
401 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
405 static inline int host_to_target_errno(int err
)
407 if(host_to_target_errno_table
[err
])
408 return host_to_target_errno_table
[err
];
412 static inline int target_to_host_errno(int err
)
414 if (target_to_host_errno_table
[err
])
415 return target_to_host_errno_table
[err
];
419 static inline abi_long
get_errno(abi_long ret
)
422 return -host_to_target_errno(errno
);
427 static inline int is_error(abi_long ret
)
429 return (abi_ulong
)ret
>= (abi_ulong
)(-4096);
432 char *target_strerror(int err
)
434 return strerror(target_to_host_errno(err
));
437 static abi_ulong target_brk
;
438 static abi_ulong target_original_brk
;
440 void target_set_brk(abi_ulong new_brk
)
442 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
445 /* do_brk() must return target values and target errnos. */
446 abi_long
do_brk(abi_ulong new_brk
)
449 abi_long mapped_addr
;
454 if (new_brk
< target_original_brk
)
457 brk_page
= HOST_PAGE_ALIGN(target_brk
);
459 /* If the new brk is less than this, set it and we're done... */
460 if (new_brk
< brk_page
) {
461 target_brk
= new_brk
;
465 /* We need to allocate more memory after the brk... */
466 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
+ 1);
467 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
468 PROT_READ
|PROT_WRITE
,
469 MAP_ANON
|MAP_FIXED
|MAP_PRIVATE
, 0, 0));
471 if (!is_error(mapped_addr
))
472 target_brk
= new_brk
;
477 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
478 abi_ulong target_fds_addr
,
482 abi_ulong b
, *target_fds
;
484 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
485 if (!(target_fds
= lock_user(VERIFY_READ
,
487 sizeof(abi_ulong
) * nw
,
489 return -TARGET_EFAULT
;
493 for (i
= 0; i
< nw
; i
++) {
494 /* grab the abi_ulong */
495 __get_user(b
, &target_fds
[i
]);
496 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
497 /* check the bit inside the abi_ulong */
504 unlock_user(target_fds
, target_fds_addr
, 0);
509 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
515 abi_ulong
*target_fds
;
517 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
518 if (!(target_fds
= lock_user(VERIFY_WRITE
,
520 sizeof(abi_ulong
) * nw
,
522 return -TARGET_EFAULT
;
525 for (i
= 0; i
< nw
; i
++) {
527 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
528 v
|= ((FD_ISSET(k
, fds
) != 0) << j
);
531 __put_user(v
, &target_fds
[i
]);
534 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
539 #if defined(__alpha__)
545 static inline abi_long
host_to_target_clock_t(long ticks
)
547 #if HOST_HZ == TARGET_HZ
550 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
554 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
555 const struct rusage
*rusage
)
557 struct target_rusage
*target_rusage
;
559 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
560 return -TARGET_EFAULT
;
561 target_rusage
->ru_utime
.tv_sec
= tswapl(rusage
->ru_utime
.tv_sec
);
562 target_rusage
->ru_utime
.tv_usec
= tswapl(rusage
->ru_utime
.tv_usec
);
563 target_rusage
->ru_stime
.tv_sec
= tswapl(rusage
->ru_stime
.tv_sec
);
564 target_rusage
->ru_stime
.tv_usec
= tswapl(rusage
->ru_stime
.tv_usec
);
565 target_rusage
->ru_maxrss
= tswapl(rusage
->ru_maxrss
);
566 target_rusage
->ru_ixrss
= tswapl(rusage
->ru_ixrss
);
567 target_rusage
->ru_idrss
= tswapl(rusage
->ru_idrss
);
568 target_rusage
->ru_isrss
= tswapl(rusage
->ru_isrss
);
569 target_rusage
->ru_minflt
= tswapl(rusage
->ru_minflt
);
570 target_rusage
->ru_majflt
= tswapl(rusage
->ru_majflt
);
571 target_rusage
->ru_nswap
= tswapl(rusage
->ru_nswap
);
572 target_rusage
->ru_inblock
= tswapl(rusage
->ru_inblock
);
573 target_rusage
->ru_oublock
= tswapl(rusage
->ru_oublock
);
574 target_rusage
->ru_msgsnd
= tswapl(rusage
->ru_msgsnd
);
575 target_rusage
->ru_msgrcv
= tswapl(rusage
->ru_msgrcv
);
576 target_rusage
->ru_nsignals
= tswapl(rusage
->ru_nsignals
);
577 target_rusage
->ru_nvcsw
= tswapl(rusage
->ru_nvcsw
);
578 target_rusage
->ru_nivcsw
= tswapl(rusage
->ru_nivcsw
);
579 unlock_user_struct(target_rusage
, target_addr
, 1);
584 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
585 abi_ulong target_tv_addr
)
587 struct target_timeval
*target_tv
;
589 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
590 return -TARGET_EFAULT
;
592 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
593 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
595 unlock_user_struct(target_tv
, target_tv_addr
, 0);
600 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
601 const struct timeval
*tv
)
603 struct target_timeval
*target_tv
;
605 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
606 return -TARGET_EFAULT
;
608 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
609 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
611 unlock_user_struct(target_tv
, target_tv_addr
, 1);
617 /* do_select() must return target values and target errnos. */
618 static abi_long
do_select(int n
,
619 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
620 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
622 fd_set rfds
, wfds
, efds
;
623 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
624 struct timeval tv
, *tv_ptr
;
628 if (copy_from_user_fdset(&rfds
, rfd_addr
, n
))
629 return -TARGET_EFAULT
;
635 if (copy_from_user_fdset(&wfds
, wfd_addr
, n
))
636 return -TARGET_EFAULT
;
642 if (copy_from_user_fdset(&efds
, efd_addr
, n
))
643 return -TARGET_EFAULT
;
649 if (target_tv_addr
) {
650 if (copy_from_user_timeval(&tv
, target_tv_addr
))
651 return -TARGET_EFAULT
;
657 ret
= get_errno(select(n
, rfds_ptr
, wfds_ptr
, efds_ptr
, tv_ptr
));
659 if (!is_error(ret
)) {
660 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
661 return -TARGET_EFAULT
;
662 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
663 return -TARGET_EFAULT
;
664 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
665 return -TARGET_EFAULT
;
667 if (target_tv_addr
&& copy_to_user_timeval(target_tv_addr
, &tv
))
668 return -TARGET_EFAULT
;
674 static inline abi_long
target_to_host_sockaddr(struct sockaddr
*addr
,
675 abi_ulong target_addr
,
678 struct target_sockaddr
*target_saddr
;
680 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
682 return -TARGET_EFAULT
;
683 memcpy(addr
, target_saddr
, len
);
684 addr
->sa_family
= tswap16(target_saddr
->sa_family
);
685 unlock_user(target_saddr
, target_addr
, 0);
690 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
691 struct sockaddr
*addr
,
694 struct target_sockaddr
*target_saddr
;
696 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
698 return -TARGET_EFAULT
;
699 memcpy(target_saddr
, addr
, len
);
700 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
701 unlock_user(target_saddr
, target_addr
, len
);
706 /* ??? Should this also swap msgh->name? */
707 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
708 struct target_msghdr
*target_msgh
)
710 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
711 abi_long msg_controllen
;
712 abi_ulong target_cmsg_addr
;
713 struct target_cmsghdr
*target_cmsg
;
716 msg_controllen
= tswapl(target_msgh
->msg_controllen
);
717 if (msg_controllen
< sizeof (struct target_cmsghdr
))
719 target_cmsg_addr
= tswapl(target_msgh
->msg_control
);
720 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
722 return -TARGET_EFAULT
;
724 while (cmsg
&& target_cmsg
) {
725 void *data
= CMSG_DATA(cmsg
);
726 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
728 int len
= tswapl(target_cmsg
->cmsg_len
)
729 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr
));
731 space
+= CMSG_SPACE(len
);
732 if (space
> msgh
->msg_controllen
) {
733 space
-= CMSG_SPACE(len
);
734 gemu_log("Host cmsg overflow\n");
738 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
739 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
740 cmsg
->cmsg_len
= CMSG_LEN(len
);
742 if (cmsg
->cmsg_level
!= TARGET_SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
743 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg
->cmsg_level
, cmsg
->cmsg_type
);
744 memcpy(data
, target_data
, len
);
746 int *fd
= (int *)data
;
747 int *target_fd
= (int *)target_data
;
748 int i
, numfds
= len
/ sizeof(int);
750 for (i
= 0; i
< numfds
; i
++)
751 fd
[i
] = tswap32(target_fd
[i
]);
754 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
755 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
);
757 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
759 msgh
->msg_controllen
= space
;
763 /* ??? Should this also swap msgh->name? */
764 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
767 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
768 abi_long msg_controllen
;
769 abi_ulong target_cmsg_addr
;
770 struct target_cmsghdr
*target_cmsg
;
773 msg_controllen
= tswapl(target_msgh
->msg_controllen
);
774 if (msg_controllen
< sizeof (struct target_cmsghdr
))
776 target_cmsg_addr
= tswapl(target_msgh
->msg_control
);
777 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
779 return -TARGET_EFAULT
;
781 while (cmsg
&& target_cmsg
) {
782 void *data
= CMSG_DATA(cmsg
);
783 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
785 int len
= cmsg
->cmsg_len
- CMSG_ALIGN(sizeof (struct cmsghdr
));
787 space
+= TARGET_CMSG_SPACE(len
);
788 if (space
> msg_controllen
) {
789 space
-= TARGET_CMSG_SPACE(len
);
790 gemu_log("Target cmsg overflow\n");
794 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
795 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
796 target_cmsg
->cmsg_len
= tswapl(TARGET_CMSG_LEN(len
));
798 if (cmsg
->cmsg_level
!= TARGET_SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
799 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg
->cmsg_level
, cmsg
->cmsg_type
);
800 memcpy(target_data
, data
, len
);
802 int *fd
= (int *)data
;
803 int *target_fd
= (int *)target_data
;
804 int i
, numfds
= len
/ sizeof(int);
806 for (i
= 0; i
< numfds
; i
++)
807 target_fd
[i
] = tswap32(fd
[i
]);
810 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
811 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
);
813 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
815 target_msgh
->msg_controllen
= tswapl(space
);
819 /* do_setsockopt() Must return target values and target errnos. */
820 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
821 abi_ulong optval_addr
, socklen_t optlen
)
828 /* TCP options all take an 'int' value. */
829 if (optlen
< sizeof(uint32_t))
830 return -TARGET_EINVAL
;
832 if (get_user_u32(val
, optval_addr
))
833 return -TARGET_EFAULT
;
834 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
841 case IP_ROUTER_ALERT
:
845 case IP_MTU_DISCOVER
:
851 case IP_MULTICAST_TTL
:
852 case IP_MULTICAST_LOOP
:
854 if (optlen
>= sizeof(uint32_t)) {
855 if (get_user_u32(val
, optval_addr
))
856 return -TARGET_EFAULT
;
857 } else if (optlen
>= 1) {
858 if (get_user_u8(val
, optval_addr
))
859 return -TARGET_EFAULT
;
861 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
867 case TARGET_SOL_SOCKET
:
869 /* Options with 'int' argument. */
870 case TARGET_SO_DEBUG
:
873 case TARGET_SO_REUSEADDR
:
874 optname
= SO_REUSEADDR
;
879 case TARGET_SO_ERROR
:
882 case TARGET_SO_DONTROUTE
:
883 optname
= SO_DONTROUTE
;
885 case TARGET_SO_BROADCAST
:
886 optname
= SO_BROADCAST
;
888 case TARGET_SO_SNDBUF
:
891 case TARGET_SO_RCVBUF
:
894 case TARGET_SO_KEEPALIVE
:
895 optname
= SO_KEEPALIVE
;
897 case TARGET_SO_OOBINLINE
:
898 optname
= SO_OOBINLINE
;
900 case TARGET_SO_NO_CHECK
:
901 optname
= SO_NO_CHECK
;
903 case TARGET_SO_PRIORITY
:
904 optname
= SO_PRIORITY
;
907 case TARGET_SO_BSDCOMPAT
:
908 optname
= SO_BSDCOMPAT
;
911 case TARGET_SO_PASSCRED
:
912 optname
= SO_PASSCRED
;
914 case TARGET_SO_TIMESTAMP
:
915 optname
= SO_TIMESTAMP
;
917 case TARGET_SO_RCVLOWAT
:
918 optname
= SO_RCVLOWAT
;
920 case TARGET_SO_RCVTIMEO
:
921 optname
= SO_RCVTIMEO
;
923 case TARGET_SO_SNDTIMEO
:
924 optname
= SO_SNDTIMEO
;
930 if (optlen
< sizeof(uint32_t))
931 return -TARGET_EINVAL
;
933 if (get_user_u32(val
, optval_addr
))
934 return -TARGET_EFAULT
;
935 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
939 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level
, optname
);
940 ret
= -TARGET_ENOPROTOOPT
;
945 /* do_getsockopt() Must return target values and target errnos. */
946 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
947 abi_ulong optval_addr
, abi_ulong optlen
)
953 case TARGET_SOL_SOCKET
:
956 case TARGET_SO_LINGER
:
957 case TARGET_SO_RCVTIMEO
:
958 case TARGET_SO_SNDTIMEO
:
959 case TARGET_SO_PEERCRED
:
960 case TARGET_SO_PEERNAME
:
961 /* These don't just return a single integer */
968 /* TCP options all take an 'int' value. */
970 if (get_user_u32(len
, optlen
))
971 return -TARGET_EFAULT
;
973 return -TARGET_EINVAL
;
975 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
982 if (put_user_u32(val
, optval_addr
))
983 return -TARGET_EFAULT
;
985 if (put_user_u8(val
, optval_addr
))
986 return -TARGET_EFAULT
;
988 if (put_user_u32(len
, optlen
))
989 return -TARGET_EFAULT
;
996 case IP_ROUTER_ALERT
:
1000 case IP_MTU_DISCOVER
:
1006 case IP_MULTICAST_TTL
:
1007 case IP_MULTICAST_LOOP
:
1008 if (get_user_u32(len
, optlen
))
1009 return -TARGET_EFAULT
;
1011 return -TARGET_EINVAL
;
1013 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
1016 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
1018 if (put_user_u32(len
, optlen
)
1019 || put_user_u8(val
, optval_addr
))
1020 return -TARGET_EFAULT
;
1022 if (len
> sizeof(int))
1024 if (put_user_u32(len
, optlen
)
1025 || put_user_u32(val
, optval_addr
))
1026 return -TARGET_EFAULT
;
1030 ret
= -TARGET_ENOPROTOOPT
;
1036 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1038 ret
= -TARGET_EOPNOTSUPP
;
1045 * lock_iovec()/unlock_iovec() have a return code of 0 for success where
1046 * other lock functions have a return code of 0 for failure.
1048 static abi_long
lock_iovec(int type
, struct iovec
*vec
, abi_ulong target_addr
,
1049 int count
, int copy
)
1051 struct target_iovec
*target_vec
;
1055 target_vec
= lock_user(VERIFY_READ
, target_addr
, count
* sizeof(struct target_iovec
), 1);
1057 return -TARGET_EFAULT
;
1058 for(i
= 0;i
< count
; i
++) {
1059 base
= tswapl(target_vec
[i
].iov_base
);
1060 vec
[i
].iov_len
= tswapl(target_vec
[i
].iov_len
);
1061 if (vec
[i
].iov_len
!= 0) {
1062 vec
[i
].iov_base
= lock_user(type
, base
, vec
[i
].iov_len
, copy
);
1063 if (!vec
[i
].iov_base
&& vec
[i
].iov_len
)
1066 /* zero length pointer is ignored */
1067 vec
[i
].iov_base
= NULL
;
1070 unlock_user (target_vec
, target_addr
, 0);
1073 /* failure - unwind locks */
1074 for (j
= 0; j
< i
; j
++) {
1075 base
= tswapl(target_vec
[j
].iov_base
);
1076 unlock_user(vec
[j
].iov_base
, base
, 0);
1078 unlock_user (target_vec
, target_addr
, 0);
1079 return -TARGET_EFAULT
;
1082 static abi_long
unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
1083 int count
, int copy
)
1085 struct target_iovec
*target_vec
;
1089 target_vec
= lock_user(VERIFY_READ
, target_addr
, count
* sizeof(struct target_iovec
), 1);
1091 return -TARGET_EFAULT
;
1092 for(i
= 0;i
< count
; i
++) {
1093 base
= tswapl(target_vec
[i
].iov_base
);
1094 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
1096 unlock_user (target_vec
, target_addr
, 0);
1101 /* do_socket() Must return target values and target errnos. */
1102 static abi_long
do_socket(int domain
, int type
, int protocol
)
1104 #if defined(TARGET_MIPS)
1106 case TARGET_SOCK_DGRAM
:
1109 case TARGET_SOCK_STREAM
:
1112 case TARGET_SOCK_RAW
:
1115 case TARGET_SOCK_RDM
:
1118 case TARGET_SOCK_SEQPACKET
:
1119 type
= SOCK_SEQPACKET
;
1121 case TARGET_SOCK_PACKET
:
1126 if (domain
== PF_NETLINK
)
1127 return -EAFNOSUPPORT
; /* do not NETLINK socket connections possible */
1128 return get_errno(socket(domain
, type
, protocol
));
1131 /* do_bind() Must return target values and target errnos. */
1132 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
1135 void *addr
= alloca(addrlen
);
1137 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1138 return get_errno(bind(sockfd
, addr
, addrlen
));
1141 /* do_connect() Must return target values and target errnos. */
1142 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
1145 void *addr
= alloca(addrlen
);
1147 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1148 return get_errno(connect(sockfd
, addr
, addrlen
));
1151 /* do_sendrecvmsg() Must return target values and target errnos. */
1152 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
1153 int flags
, int send
)
1156 struct target_msghdr
*msgp
;
1160 abi_ulong target_vec
;
1163 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
1167 return -TARGET_EFAULT
;
1168 if (msgp
->msg_name
) {
1169 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
1170 msg
.msg_name
= alloca(msg
.msg_namelen
);
1171 target_to_host_sockaddr(msg
.msg_name
, tswapl(msgp
->msg_name
),
1174 msg
.msg_name
= NULL
;
1175 msg
.msg_namelen
= 0;
1177 msg
.msg_controllen
= 2 * tswapl(msgp
->msg_controllen
);
1178 msg
.msg_control
= alloca(msg
.msg_controllen
);
1179 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
1181 count
= tswapl(msgp
->msg_iovlen
);
1182 vec
= alloca(count
* sizeof(struct iovec
));
1183 target_vec
= tswapl(msgp
->msg_iov
);
1184 lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
, vec
, target_vec
, count
, send
);
1185 msg
.msg_iovlen
= count
;
1189 ret
= target_to_host_cmsg(&msg
, msgp
);
1191 ret
= get_errno(sendmsg(fd
, &msg
, flags
));
1193 ret
= get_errno(recvmsg(fd
, &msg
, flags
));
1195 ret
= host_to_target_cmsg(msgp
, &msg
);
1197 unlock_iovec(vec
, target_vec
, count
, !send
);
1198 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
1202 /* do_accept() Must return target values and target errnos. */
1203 static abi_long
do_accept(int fd
, abi_ulong target_addr
,
1204 abi_ulong target_addrlen_addr
)
1210 if (get_user_u32(addrlen
, target_addrlen_addr
))
1211 return -TARGET_EFAULT
;
1213 addr
= alloca(addrlen
);
1215 ret
= get_errno(accept(fd
, addr
, &addrlen
));
1216 if (!is_error(ret
)) {
1217 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1218 if (put_user_u32(addrlen
, target_addrlen_addr
))
1219 ret
= -TARGET_EFAULT
;
1224 /* do_getpeername() Must return target values and target errnos. */
1225 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
1226 abi_ulong target_addrlen_addr
)
1232 if (get_user_u32(addrlen
, target_addrlen_addr
))
1233 return -TARGET_EFAULT
;
1235 addr
= alloca(addrlen
);
1237 ret
= get_errno(getpeername(fd
, addr
, &addrlen
));
1238 if (!is_error(ret
)) {
1239 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1240 if (put_user_u32(addrlen
, target_addrlen_addr
))
1241 ret
= -TARGET_EFAULT
;
1246 /* do_getsockname() Must return target values and target errnos. */
1247 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
1248 abi_ulong target_addrlen_addr
)
1254 if (get_user_u32(addrlen
, target_addrlen_addr
))
1255 return -TARGET_EFAULT
;
1257 addr
= alloca(addrlen
);
1259 ret
= get_errno(getsockname(fd
, addr
, &addrlen
));
1260 if (!is_error(ret
)) {
1261 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1262 if (put_user_u32(addrlen
, target_addrlen_addr
))
1263 ret
= -TARGET_EFAULT
;
1268 /* do_socketpair() Must return target values and target errnos. */
1269 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
1270 abi_ulong target_tab_addr
)
1275 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
1276 if (!is_error(ret
)) {
1277 if (put_user_s32(tab
[0], target_tab_addr
)
1278 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
1279 ret
= -TARGET_EFAULT
;
1284 /* do_sendto() Must return target values and target errnos. */
1285 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
1286 abi_ulong target_addr
, socklen_t addrlen
)
1292 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
1294 return -TARGET_EFAULT
;
1296 addr
= alloca(addrlen
);
1297 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1298 ret
= get_errno(sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
1300 ret
= get_errno(send(fd
, host_msg
, len
, flags
));
1302 unlock_user(host_msg
, msg
, 0);
1306 /* do_recvfrom() Must return target values and target errnos. */
1307 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
1308 abi_ulong target_addr
,
1309 abi_ulong target_addrlen
)
1316 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
1318 return -TARGET_EFAULT
;
1320 if (get_user_u32(addrlen
, target_addrlen
)) {
1321 ret
= -TARGET_EFAULT
;
1324 addr
= alloca(addrlen
);
1325 ret
= get_errno(recvfrom(fd
, host_msg
, len
, flags
, addr
, &addrlen
));
1327 addr
= NULL
; /* To keep compiler quiet. */
1328 ret
= get_errno(recv(fd
, host_msg
, len
, flags
));
1330 if (!is_error(ret
)) {
1332 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1333 if (put_user_u32(addrlen
, target_addrlen
)) {
1334 ret
= -TARGET_EFAULT
;
1338 unlock_user(host_msg
, msg
, len
);
1341 unlock_user(host_msg
, msg
, 0);
1346 #ifdef TARGET_NR_socketcall
1347 /* do_socketcall() Must return target values and target errnos. */
1348 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
1351 const int n
= sizeof(abi_ulong
);
1356 int domain
, type
, protocol
;
1358 if (get_user_s32(domain
, vptr
)
1359 || get_user_s32(type
, vptr
+ n
)
1360 || get_user_s32(protocol
, vptr
+ 2 * n
))
1361 return -TARGET_EFAULT
;
1363 ret
= do_socket(domain
, type
, protocol
);
1369 abi_ulong target_addr
;
1372 if (get_user_s32(sockfd
, vptr
)
1373 || get_user_ual(target_addr
, vptr
+ n
)
1374 || get_user_u32(addrlen
, vptr
+ 2 * n
))
1375 return -TARGET_EFAULT
;
1377 ret
= do_bind(sockfd
, target_addr
, addrlen
);
1380 case SOCKOP_connect
:
1383 abi_ulong target_addr
;
1386 if (get_user_s32(sockfd
, vptr
)
1387 || get_user_ual(target_addr
, vptr
+ n
)
1388 || get_user_u32(addrlen
, vptr
+ 2 * n
))
1389 return -TARGET_EFAULT
;
1391 ret
= do_connect(sockfd
, target_addr
, addrlen
);
1396 int sockfd
, backlog
;
1398 if (get_user_s32(sockfd
, vptr
)
1399 || get_user_s32(backlog
, vptr
+ n
))
1400 return -TARGET_EFAULT
;
1402 ret
= get_errno(listen(sockfd
, backlog
));
1408 abi_ulong target_addr
, target_addrlen
;
1410 if (get_user_s32(sockfd
, vptr
)
1411 || get_user_ual(target_addr
, vptr
+ n
)
1412 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1413 return -TARGET_EFAULT
;
1415 ret
= do_accept(sockfd
, target_addr
, target_addrlen
);
1418 case SOCKOP_getsockname
:
1421 abi_ulong target_addr
, target_addrlen
;
1423 if (get_user_s32(sockfd
, vptr
)
1424 || get_user_ual(target_addr
, vptr
+ n
)
1425 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1426 return -TARGET_EFAULT
;
1428 ret
= do_getsockname(sockfd
, target_addr
, target_addrlen
);
1431 case SOCKOP_getpeername
:
1434 abi_ulong target_addr
, target_addrlen
;
1436 if (get_user_s32(sockfd
, vptr
)
1437 || get_user_ual(target_addr
, vptr
+ n
)
1438 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1439 return -TARGET_EFAULT
;
1441 ret
= do_getpeername(sockfd
, target_addr
, target_addrlen
);
1444 case SOCKOP_socketpair
:
1446 int domain
, type
, protocol
;
1449 if (get_user_s32(domain
, vptr
)
1450 || get_user_s32(type
, vptr
+ n
)
1451 || get_user_s32(protocol
, vptr
+ 2 * n
)
1452 || get_user_ual(tab
, vptr
+ 3 * n
))
1453 return -TARGET_EFAULT
;
1455 ret
= do_socketpair(domain
, type
, protocol
, tab
);
1465 if (get_user_s32(sockfd
, vptr
)
1466 || get_user_ual(msg
, vptr
+ n
)
1467 || get_user_ual(len
, vptr
+ 2 * n
)
1468 || get_user_s32(flags
, vptr
+ 3 * n
))
1469 return -TARGET_EFAULT
;
1471 ret
= do_sendto(sockfd
, msg
, len
, flags
, 0, 0);
1481 if (get_user_s32(sockfd
, vptr
)
1482 || get_user_ual(msg
, vptr
+ n
)
1483 || get_user_ual(len
, vptr
+ 2 * n
)
1484 || get_user_s32(flags
, vptr
+ 3 * n
))
1485 return -TARGET_EFAULT
;
1487 ret
= do_recvfrom(sockfd
, msg
, len
, flags
, 0, 0);
1499 if (get_user_s32(sockfd
, vptr
)
1500 || get_user_ual(msg
, vptr
+ n
)
1501 || get_user_ual(len
, vptr
+ 2 * n
)
1502 || get_user_s32(flags
, vptr
+ 3 * n
)
1503 || get_user_ual(addr
, vptr
+ 4 * n
)
1504 || get_user_u32(addrlen
, vptr
+ 5 * n
))
1505 return -TARGET_EFAULT
;
1507 ret
= do_sendto(sockfd
, msg
, len
, flags
, addr
, addrlen
);
1510 case SOCKOP_recvfrom
:
1519 if (get_user_s32(sockfd
, vptr
)
1520 || get_user_ual(msg
, vptr
+ n
)
1521 || get_user_ual(len
, vptr
+ 2 * n
)
1522 || get_user_s32(flags
, vptr
+ 3 * n
)
1523 || get_user_ual(addr
, vptr
+ 4 * n
)
1524 || get_user_u32(addrlen
, vptr
+ 5 * n
))
1525 return -TARGET_EFAULT
;
1527 ret
= do_recvfrom(sockfd
, msg
, len
, flags
, addr
, addrlen
);
1530 case SOCKOP_shutdown
:
1534 if (get_user_s32(sockfd
, vptr
)
1535 || get_user_s32(how
, vptr
+ n
))
1536 return -TARGET_EFAULT
;
1538 ret
= get_errno(shutdown(sockfd
, how
));
1541 case SOCKOP_sendmsg
:
1542 case SOCKOP_recvmsg
:
1545 abi_ulong target_msg
;
1548 if (get_user_s32(fd
, vptr
)
1549 || get_user_ual(target_msg
, vptr
+ n
)
1550 || get_user_s32(flags
, vptr
+ 2 * n
))
1551 return -TARGET_EFAULT
;
1553 ret
= do_sendrecvmsg(fd
, target_msg
, flags
,
1554 (num
== SOCKOP_sendmsg
));
1557 case SOCKOP_setsockopt
:
1565 if (get_user_s32(sockfd
, vptr
)
1566 || get_user_s32(level
, vptr
+ n
)
1567 || get_user_s32(optname
, vptr
+ 2 * n
)
1568 || get_user_ual(optval
, vptr
+ 3 * n
)
1569 || get_user_u32(optlen
, vptr
+ 4 * n
))
1570 return -TARGET_EFAULT
;
1572 ret
= do_setsockopt(sockfd
, level
, optname
, optval
, optlen
);
1575 case SOCKOP_getsockopt
:
1583 if (get_user_s32(sockfd
, vptr
)
1584 || get_user_s32(level
, vptr
+ n
)
1585 || get_user_s32(optname
, vptr
+ 2 * n
)
1586 || get_user_ual(optval
, vptr
+ 3 * n
)
1587 || get_user_u32(optlen
, vptr
+ 4 * n
))
1588 return -TARGET_EFAULT
;
1590 ret
= do_getsockopt(sockfd
, level
, optname
, optval
, optlen
);
1594 gemu_log("Unsupported socketcall: %d\n", num
);
1595 ret
= -TARGET_ENOSYS
;
1602 #ifdef TARGET_NR_ipc
1603 #define N_SHM_REGIONS 32
1605 static struct shm_region
{
1608 } shm_regions
[N_SHM_REGIONS
];
1610 struct target_ipc_perm
1617 unsigned short int mode
;
1618 unsigned short int __pad1
;
1619 unsigned short int __seq
;
1620 unsigned short int __pad2
;
1621 abi_ulong __unused1
;
1622 abi_ulong __unused2
;
1625 struct target_semid_ds
1627 struct target_ipc_perm sem_perm
;
1628 abi_ulong sem_otime
;
1629 abi_ulong __unused1
;
1630 abi_ulong sem_ctime
;
1631 abi_ulong __unused2
;
1632 abi_ulong sem_nsems
;
1633 abi_ulong __unused3
;
1634 abi_ulong __unused4
;
1637 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
1638 abi_ulong target_addr
)
1640 struct target_ipc_perm
*target_ip
;
1641 struct target_semid_ds
*target_sd
;
1643 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
1644 return -TARGET_EFAULT
;
1645 target_ip
=&(target_sd
->sem_perm
);
1646 host_ip
->__key
= tswapl(target_ip
->__key
);
1647 host_ip
->uid
= tswapl(target_ip
->uid
);
1648 host_ip
->gid
= tswapl(target_ip
->gid
);
1649 host_ip
->cuid
= tswapl(target_ip
->cuid
);
1650 host_ip
->cgid
= tswapl(target_ip
->cgid
);
1651 host_ip
->mode
= tswapl(target_ip
->mode
);
1652 unlock_user_struct(target_sd
, target_addr
, 0);
1656 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
1657 struct ipc_perm
*host_ip
)
1659 struct target_ipc_perm
*target_ip
;
1660 struct target_semid_ds
*target_sd
;
1662 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
1663 return -TARGET_EFAULT
;
1664 target_ip
= &(target_sd
->sem_perm
);
1665 target_ip
->__key
= tswapl(host_ip
->__key
);
1666 target_ip
->uid
= tswapl(host_ip
->uid
);
1667 target_ip
->gid
= tswapl(host_ip
->gid
);
1668 target_ip
->cuid
= tswapl(host_ip
->cuid
);
1669 target_ip
->cgid
= tswapl(host_ip
->cgid
);
1670 target_ip
->mode
= tswapl(host_ip
->mode
);
1671 unlock_user_struct(target_sd
, target_addr
, 1);
1675 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
1676 abi_ulong target_addr
)
1678 struct target_semid_ds
*target_sd
;
1680 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
1681 return -TARGET_EFAULT
;
1682 target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
);
1683 host_sd
->sem_nsems
= tswapl(target_sd
->sem_nsems
);
1684 host_sd
->sem_otime
= tswapl(target_sd
->sem_otime
);
1685 host_sd
->sem_ctime
= tswapl(target_sd
->sem_ctime
);
1686 unlock_user_struct(target_sd
, target_addr
, 0);
1690 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
1691 struct semid_ds
*host_sd
)
1693 struct target_semid_ds
*target_sd
;
1695 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
1696 return -TARGET_EFAULT
;
1697 host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
));
1698 target_sd
->sem_nsems
= tswapl(host_sd
->sem_nsems
);
1699 target_sd
->sem_otime
= tswapl(host_sd
->sem_otime
);
1700 target_sd
->sem_ctime
= tswapl(host_sd
->sem_ctime
);
1701 unlock_user_struct(target_sd
, target_addr
, 1);
1707 struct semid_ds
*buf
;
1708 unsigned short *array
;
1711 union target_semun
{
1714 unsigned short int *array
;
1717 static inline abi_long
target_to_host_semun(int cmd
,
1718 union semun
*host_su
,
1719 abi_ulong target_addr
,
1720 struct semid_ds
*ds
)
1722 union target_semun
*target_su
;
1727 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1728 return -TARGET_EFAULT
;
1729 target_to_host_semid_ds(ds
,target_su
->buf
);
1731 unlock_user_struct(target_su
, target_addr
, 0);
1735 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1736 return -TARGET_EFAULT
;
1737 host_su
->val
= tswapl(target_su
->val
);
1738 unlock_user_struct(target_su
, target_addr
, 0);
1742 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1743 return -TARGET_EFAULT
;
1744 *host_su
->array
= tswap16(*target_su
->array
);
1745 unlock_user_struct(target_su
, target_addr
, 0);
1748 gemu_log("semun operation not fully supported: %d\n", (int)cmd
);
1753 static inline abi_long
host_to_target_semun(int cmd
,
1754 abi_ulong target_addr
,
1755 union semun
*host_su
,
1756 struct semid_ds
*ds
)
1758 union target_semun
*target_su
;
1763 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1764 return -TARGET_EFAULT
;
1765 host_to_target_semid_ds(target_su
->buf
,ds
);
1766 unlock_user_struct(target_su
, target_addr
, 1);
1770 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1771 return -TARGET_EFAULT
;
1772 target_su
->val
= tswapl(host_su
->val
);
1773 unlock_user_struct(target_su
, target_addr
, 1);
1777 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1778 return -TARGET_EFAULT
;
1779 *target_su
->array
= tswap16(*host_su
->array
);
1780 unlock_user_struct(target_su
, target_addr
, 1);
1783 gemu_log("semun operation not fully supported: %d\n", (int)cmd
);
1788 static inline abi_long
do_semctl(int first
, int second
, int third
,
1792 struct semid_ds dsarg
;
1793 int cmd
= third
&0xff;
1798 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1799 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1800 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1803 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1804 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1805 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1808 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1809 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1810 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1813 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1814 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1815 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1818 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1819 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1820 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1823 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1824 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1825 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1828 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1834 struct target_msqid_ds
1836 struct target_ipc_perm msg_perm
;
1837 abi_ulong msg_stime
;
1838 abi_ulong __unused1
;
1839 abi_ulong msg_rtime
;
1840 abi_ulong __unused2
;
1841 abi_ulong msg_ctime
;
1842 abi_ulong __unused3
;
1843 abi_ulong __msg_cbytes
;
1845 abi_ulong msg_qbytes
;
1846 abi_ulong msg_lspid
;
1847 abi_ulong msg_lrpid
;
1848 abi_ulong __unused4
;
1849 abi_ulong __unused5
;
1852 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
1853 abi_ulong target_addr
)
1855 struct target_msqid_ds
*target_md
;
1857 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
1858 return -TARGET_EFAULT
;
1859 target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
);
1860 host_md
->msg_stime
= tswapl(target_md
->msg_stime
);
1861 host_md
->msg_rtime
= tswapl(target_md
->msg_rtime
);
1862 host_md
->msg_ctime
= tswapl(target_md
->msg_ctime
);
1863 host_md
->__msg_cbytes
= tswapl(target_md
->__msg_cbytes
);
1864 host_md
->msg_qnum
= tswapl(target_md
->msg_qnum
);
1865 host_md
->msg_qbytes
= tswapl(target_md
->msg_qbytes
);
1866 host_md
->msg_lspid
= tswapl(target_md
->msg_lspid
);
1867 host_md
->msg_lrpid
= tswapl(target_md
->msg_lrpid
);
1868 unlock_user_struct(target_md
, target_addr
, 0);
1872 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
1873 struct msqid_ds
*host_md
)
1875 struct target_msqid_ds
*target_md
;
1877 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
1878 return -TARGET_EFAULT
;
1879 host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
));
1880 target_md
->msg_stime
= tswapl(host_md
->msg_stime
);
1881 target_md
->msg_rtime
= tswapl(host_md
->msg_rtime
);
1882 target_md
->msg_ctime
= tswapl(host_md
->msg_ctime
);
1883 target_md
->__msg_cbytes
= tswapl(host_md
->__msg_cbytes
);
1884 target_md
->msg_qnum
= tswapl(host_md
->msg_qnum
);
1885 target_md
->msg_qbytes
= tswapl(host_md
->msg_qbytes
);
1886 target_md
->msg_lspid
= tswapl(host_md
->msg_lspid
);
1887 target_md
->msg_lrpid
= tswapl(host_md
->msg_lrpid
);
1888 unlock_user_struct(target_md
, target_addr
, 1);
1892 static inline abi_long
do_msgctl(int first
, int second
, abi_long ptr
)
1894 struct msqid_ds dsarg
;
1895 int cmd
= second
&0xff;
1900 target_to_host_msqid_ds(&dsarg
,ptr
);
1901 ret
= get_errno(msgctl(first
, cmd
, &dsarg
));
1902 host_to_target_msqid_ds(ptr
,&dsarg
);
1904 ret
= get_errno(msgctl(first
, cmd
, &dsarg
));
1909 struct target_msgbuf
{
1914 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
1915 unsigned int msgsz
, int msgflg
)
1917 struct target_msgbuf
*target_mb
;
1918 struct msgbuf
*host_mb
;
1921 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
1922 return -TARGET_EFAULT
;
1923 host_mb
= malloc(msgsz
+sizeof(long));
1924 host_mb
->mtype
= tswapl(target_mb
->mtype
);
1925 memcpy(host_mb
->mtext
,target_mb
->mtext
,msgsz
);
1926 ret
= get_errno(msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
1928 unlock_user_struct(target_mb
, msgp
, 0);
1933 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
1934 unsigned int msgsz
, int msgtype
,
1937 struct target_msgbuf
*target_mb
;
1939 struct msgbuf
*host_mb
;
1942 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
1943 return -TARGET_EFAULT
;
1944 host_mb
= malloc(msgsz
+sizeof(long));
1945 ret
= get_errno(msgrcv(msqid
, host_mb
, msgsz
, 1, msgflg
));
1947 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
1948 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
1949 if (!target_mtext
) {
1950 ret
= -TARGET_EFAULT
;
1953 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
1954 unlock_user(target_mtext
, target_mtext_addr
, ret
);
1956 target_mb
->mtype
= tswapl(host_mb
->mtype
);
1961 unlock_user_struct(target_mb
, msgp
, 1);
1965 /* ??? This only works with linear mappings. */
1966 /* do_ipc() must return target values and target errnos. */
1967 static abi_long
do_ipc(unsigned int call
, int first
,
1968 int second
, int third
,
1969 abi_long ptr
, abi_long fifth
)
1973 struct shmid_ds shm_info
;
1976 version
= call
>> 16;
1981 ret
= get_errno(semop(first
,(struct sembuf
*)g2h(ptr
), second
));
1985 ret
= get_errno(semget(first
, second
, third
));
1989 ret
= do_semctl(first
, second
, third
, ptr
);
1992 case IPCOP_semtimedop
:
1993 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
1994 ret
= -TARGET_ENOSYS
;
1998 ret
= get_errno(msgget(first
, second
));
2002 ret
= do_msgsnd(first
, ptr
, second
, third
);
2006 ret
= do_msgctl(first
, second
, ptr
);
2011 /* XXX: this code is not correct */
2014 void *__unbounded msgp
;
2018 struct ipc_kludge
*foo
= (struct ipc_kludge
*)g2h(ptr
);
2019 struct msgbuf
*msgp
= (struct msgbuf
*) foo
->msgp
;
2021 ret
= do_msgrcv(first
, (long)msgp
, second
, 0, third
);
2030 /* SHM_* flags are the same on all linux platforms */
2031 host_addr
= shmat(first
, (void *)g2h(ptr
), second
);
2032 if (host_addr
== (void *)-1) {
2033 ret
= get_errno((long)host_addr
);
2036 raddr
= h2g((unsigned long)host_addr
);
2037 /* find out the length of the shared memory segment */
2039 ret
= get_errno(shmctl(first
, IPC_STAT
, &shm_info
));
2040 if (is_error(ret
)) {
2041 /* can't get length, bail out */
2045 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
2046 PAGE_VALID
| PAGE_READ
|
2047 ((second
& SHM_RDONLY
)? 0: PAGE_WRITE
));
2048 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
2049 if (shm_regions
[i
].start
== 0) {
2050 shm_regions
[i
].start
= raddr
;
2051 shm_regions
[i
].size
= shm_info
.shm_segsz
;
2055 if (put_user_ual(raddr
, third
))
2056 return -TARGET_EFAULT
;
2061 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
2062 if (shm_regions
[i
].start
== ptr
) {
2063 shm_regions
[i
].start
= 0;
2064 page_set_flags(ptr
, shm_regions
[i
].size
, 0);
2068 ret
= get_errno(shmdt((void *)g2h(ptr
)));
2072 /* IPC_* flag values are the same on all linux platforms */
2073 ret
= get_errno(shmget(first
, second
, third
));
2076 /* IPC_* and SHM_* command values are the same on all linux platforms */
2082 ret
= get_errno(shmctl(first
, second
, NULL
));
2090 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
2091 ret
= -TARGET_ENOSYS
;
2098 /* kernel structure types definitions */
2101 #define STRUCT(name, list...) STRUCT_ ## name,
2102 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
2104 #include "syscall_types.h"
2107 #undef STRUCT_SPECIAL
2109 #define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2110 #define STRUCT_SPECIAL(name)
2111 #include "syscall_types.h"
2113 #undef STRUCT_SPECIAL
2115 typedef struct IOCTLEntry
{
2116 unsigned int target_cmd
;
2117 unsigned int host_cmd
;
2120 const argtype arg_type
[5];
2123 #define IOC_R 0x0001
2124 #define IOC_W 0x0002
2125 #define IOC_RW (IOC_R | IOC_W)
2127 #define MAX_STRUCT_SIZE 4096
2129 IOCTLEntry ioctl_entries
[] = {
2130 #define IOCTL(cmd, access, types...) \
2131 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2136 /* ??? Implement proper locking for ioctls. */
2137 /* do_ioctl() Must return target values and target errnos. */
2138 static abi_long
do_ioctl(int fd
, abi_long cmd
, abi_long arg
)
2140 const IOCTLEntry
*ie
;
2141 const argtype
*arg_type
;
2143 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
2149 if (ie
->target_cmd
== 0) {
2150 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
2151 return -TARGET_ENOSYS
;
2153 if (ie
->target_cmd
== cmd
)
2157 arg_type
= ie
->arg_type
;
2159 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd
, ie
->name
);
2161 switch(arg_type
[0]) {
2164 ret
= get_errno(ioctl(fd
, ie
->host_cmd
));
2169 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, arg
));
2173 target_size
= thunk_type_size(arg_type
, 0);
2174 switch(ie
->access
) {
2176 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2177 if (!is_error(ret
)) {
2178 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
2180 return -TARGET_EFAULT
;
2181 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
2182 unlock_user(argptr
, arg
, target_size
);
2186 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
2188 return -TARGET_EFAULT
;
2189 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
2190 unlock_user(argptr
, arg
, 0);
2191 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2195 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
2197 return -TARGET_EFAULT
;
2198 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
2199 unlock_user(argptr
, arg
, 0);
2200 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2201 if (!is_error(ret
)) {
2202 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
2204 return -TARGET_EFAULT
;
2205 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
2206 unlock_user(argptr
, arg
, target_size
);
2212 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2213 (long)cmd
, arg_type
[0]);
2214 ret
= -TARGET_ENOSYS
;
2220 bitmask_transtbl iflag_tbl
[] = {
2221 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
2222 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
2223 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
2224 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
2225 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
2226 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
2227 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
2228 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
2229 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
2230 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
2231 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
2232 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
2233 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
2234 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
2238 bitmask_transtbl oflag_tbl
[] = {
2239 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
2240 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
2241 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
2242 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
2243 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
2244 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
2245 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
2246 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
2247 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
2248 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
2249 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
2250 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
2251 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
2252 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
2253 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
2254 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
2255 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
2256 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
2257 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
2258 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
2259 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
2260 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
2261 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
2262 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
2266 bitmask_transtbl cflag_tbl
[] = {
2267 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
2268 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
2269 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
2270 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
2271 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
2272 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
2273 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
2274 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
2275 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
2276 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
2277 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
2278 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
2279 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
2280 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
2281 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
2282 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
2283 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
2284 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
2285 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
2286 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
2287 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
2288 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
2289 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
2290 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
2291 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
2292 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
2293 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
2294 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
2295 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
2296 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
2297 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
2301 bitmask_transtbl lflag_tbl
[] = {
2302 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
2303 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
2304 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
2305 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
2306 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
2307 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
2308 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
2309 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
2310 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
2311 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
2312 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
2313 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
2314 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
2315 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
2316 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
2320 static void target_to_host_termios (void *dst
, const void *src
)
2322 struct host_termios
*host
= dst
;
2323 const struct target_termios
*target
= src
;
2326 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
2328 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
2330 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
2332 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
2333 host
->c_line
= target
->c_line
;
2335 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
2336 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
2337 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
2338 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
2339 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
2340 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
2341 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
2342 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
2343 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
2344 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
2345 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
2346 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
2347 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
2348 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
2349 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
2350 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
2351 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
2354 static void host_to_target_termios (void *dst
, const void *src
)
2356 struct target_termios
*target
= dst
;
2357 const struct host_termios
*host
= src
;
2360 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
2362 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
2364 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
2366 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
2367 target
->c_line
= host
->c_line
;
2369 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
2370 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
2371 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
2372 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
2373 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
2374 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
2375 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
2376 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
2377 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
2378 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
2379 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
2380 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
2381 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
2382 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
2383 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
2384 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
2385 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
2388 StructEntry struct_termios_def
= {
2389 .convert
= { host_to_target_termios
, target_to_host_termios
},
2390 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
2391 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
2394 static bitmask_transtbl mmap_flags_tbl
[] = {
2395 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
2396 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
2397 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
2398 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
, MAP_ANONYMOUS
, MAP_ANONYMOUS
},
2399 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
, MAP_GROWSDOWN
, MAP_GROWSDOWN
},
2400 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
, MAP_DENYWRITE
, MAP_DENYWRITE
},
2401 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
, MAP_EXECUTABLE
, MAP_EXECUTABLE
},
2402 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
2406 static bitmask_transtbl fcntl_flags_tbl
[] = {
2407 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
2408 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
2409 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
2410 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
2411 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
2412 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
2413 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
2414 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
2415 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
2416 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
2417 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
2418 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
2419 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
2420 #if defined(O_DIRECT)
2421 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
2426 #if defined(TARGET_I386)
2428 /* NOTE: there is really one LDT for all the threads */
2431 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
2438 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
2439 if (size
> bytecount
)
2441 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
2443 return -TARGET_EFAULT
;
2444 /* ??? Should this by byteswapped? */
2445 memcpy(p
, ldt_table
, size
);
2446 unlock_user(p
, ptr
, size
);
2450 /* XXX: add locking support */
2451 static abi_long
write_ldt(CPUX86State
*env
,
2452 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
2454 struct target_modify_ldt_ldt_s ldt_info
;
2455 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2456 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
2457 int seg_not_present
, useable
, lm
;
2458 uint32_t *lp
, entry_1
, entry_2
;
2460 if (bytecount
!= sizeof(ldt_info
))
2461 return -TARGET_EINVAL
;
2462 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
2463 return -TARGET_EFAULT
;
2464 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
2465 ldt_info
.base_addr
= tswapl(target_ldt_info
->base_addr
);
2466 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
2467 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
2468 unlock_user_struct(target_ldt_info
, ptr
, 0);
2470 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
2471 return -TARGET_EINVAL
;
2472 seg_32bit
= ldt_info
.flags
& 1;
2473 contents
= (ldt_info
.flags
>> 1) & 3;
2474 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
2475 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
2476 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
2477 useable
= (ldt_info
.flags
>> 6) & 1;
2481 lm
= (ldt_info
.flags
>> 7) & 1;
2483 if (contents
== 3) {
2485 return -TARGET_EINVAL
;
2486 if (seg_not_present
== 0)
2487 return -TARGET_EINVAL
;
2489 /* allocate the LDT */
2491 ldt_table
= malloc(TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
2493 return -TARGET_ENOMEM
;
2494 memset(ldt_table
, 0, TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
2495 env
->ldt
.base
= h2g((unsigned long)ldt_table
);
2496 env
->ldt
.limit
= 0xffff;
2499 /* NOTE: same code as Linux kernel */
2500 /* Allow LDTs to be cleared by the user. */
2501 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
2504 read_exec_only
== 1 &&
2506 limit_in_pages
== 0 &&
2507 seg_not_present
== 1 &&
2515 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
2516 (ldt_info
.limit
& 0x0ffff);
2517 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
2518 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
2519 (ldt_info
.limit
& 0xf0000) |
2520 ((read_exec_only
^ 1) << 9) |
2522 ((seg_not_present
^ 1) << 15) |
2524 (limit_in_pages
<< 23) |
2528 entry_2
|= (useable
<< 20);
2530 /* Install the new entry ... */
2532 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
2533 lp
[0] = tswap32(entry_1
);
2534 lp
[1] = tswap32(entry_2
);
2538 /* specific and weird i386 syscalls */
2539 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
2540 unsigned long bytecount
)
2546 ret
= read_ldt(ptr
, bytecount
);
2549 ret
= write_ldt(env
, ptr
, bytecount
, 1);
2552 ret
= write_ldt(env
, ptr
, bytecount
, 0);
2555 ret
= -TARGET_ENOSYS
;
2561 #if defined(TARGET_I386) && defined(TARGET_ABI32)
2562 static abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
2564 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
2565 struct target_modify_ldt_ldt_s ldt_info
;
2566 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2567 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
2568 int seg_not_present
, useable
, lm
;
2569 uint32_t *lp
, entry_1
, entry_2
;
2572 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
2573 if (!target_ldt_info
)
2574 return -TARGET_EFAULT
;
2575 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
2576 ldt_info
.base_addr
= tswapl(target_ldt_info
->base_addr
);
2577 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
2578 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
2579 if (ldt_info
.entry_number
== -1) {
2580 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
2581 if (gdt_table
[i
] == 0) {
2582 ldt_info
.entry_number
= i
;
2583 target_ldt_info
->entry_number
= tswap32(i
);
2588 unlock_user_struct(target_ldt_info
, ptr
, 1);
2590 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
2591 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
2592 return -TARGET_EINVAL
;
2593 seg_32bit
= ldt_info
.flags
& 1;
2594 contents
= (ldt_info
.flags
>> 1) & 3;
2595 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
2596 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
2597 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
2598 useable
= (ldt_info
.flags
>> 6) & 1;
2602 lm
= (ldt_info
.flags
>> 7) & 1;
2605 if (contents
== 3) {
2606 if (seg_not_present
== 0)
2607 return -TARGET_EINVAL
;
2610 /* NOTE: same code as Linux kernel */
2611 /* Allow LDTs to be cleared by the user. */
2612 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
2613 if ((contents
== 0 &&
2614 read_exec_only
== 1 &&
2616 limit_in_pages
== 0 &&
2617 seg_not_present
== 1 &&
2625 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
2626 (ldt_info
.limit
& 0x0ffff);
2627 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
2628 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
2629 (ldt_info
.limit
& 0xf0000) |
2630 ((read_exec_only
^ 1) << 9) |
2632 ((seg_not_present
^ 1) << 15) |
2634 (limit_in_pages
<< 23) |
2639 /* Install the new entry ... */
2641 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
2642 lp
[0] = tswap32(entry_1
);
2643 lp
[1] = tswap32(entry_2
);
2647 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
2649 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2650 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
2651 uint32_t base_addr
, limit
, flags
;
2652 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
2653 int seg_not_present
, useable
, lm
;
2654 uint32_t *lp
, entry_1
, entry_2
;
2656 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
2657 if (!target_ldt_info
)
2658 return -TARGET_EFAULT
;
2659 idx
= tswap32(target_ldt_info
->entry_number
);
2660 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
2661 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
2662 unlock_user_struct(target_ldt_info
, ptr
, 1);
2663 return -TARGET_EINVAL
;
2665 lp
= (uint32_t *)(gdt_table
+ idx
);
2666 entry_1
= tswap32(lp
[0]);
2667 entry_2
= tswap32(lp
[1]);
2669 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
2670 contents
= (entry_2
>> 10) & 3;
2671 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
2672 seg_32bit
= (entry_2
>> 22) & 1;
2673 limit_in_pages
= (entry_2
>> 23) & 1;
2674 useable
= (entry_2
>> 20) & 1;
2678 lm
= (entry_2
>> 21) & 1;
2680 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
2681 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
2682 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
2683 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
2684 base_addr
= (entry_1
>> 16) |
2685 (entry_2
& 0xff000000) |
2686 ((entry_2
& 0xff) << 16);
2687 target_ldt_info
->base_addr
= tswapl(base_addr
);
2688 target_ldt_info
->limit
= tswap32(limit
);
2689 target_ldt_info
->flags
= tswap32(flags
);
2690 unlock_user_struct(target_ldt_info
, ptr
, 1);
2693 #endif /* TARGET_I386 && TARGET_ABI32 */
2695 #ifndef TARGET_ABI32
2696 static abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
2703 case TARGET_ARCH_SET_GS
:
2704 case TARGET_ARCH_SET_FS
:
2705 if (code
== TARGET_ARCH_SET_GS
)
2709 cpu_x86_load_seg(env
, idx
, 0);
2710 env
->segs
[idx
].base
= addr
;
2712 case TARGET_ARCH_GET_GS
:
2713 case TARGET_ARCH_GET_FS
:
2714 if (code
== TARGET_ARCH_GET_GS
)
2718 val
= env
->segs
[idx
].base
;
2719 if (put_user(val
, addr
, abi_ulong
))
2720 return -TARGET_EFAULT
;
2723 ret
= -TARGET_EINVAL
;
2730 #endif /* defined(TARGET_I386) */
2732 #if defined(USE_NPTL)
2734 #define NEW_STACK_SIZE PTHREAD_STACK_MIN
2736 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
2739 pthread_mutex_t mutex
;
2740 pthread_cond_t cond
;
2743 abi_ulong child_tidptr
;
2744 abi_ulong parent_tidptr
;
2748 static void *clone_func(void *arg
)
2750 new_thread_info
*info
= arg
;
2755 info
->tid
= gettid();
2756 if (info
->child_tidptr
)
2757 put_user_u32(info
->tid
, info
->child_tidptr
);
2758 if (info
->parent_tidptr
)
2759 put_user_u32(info
->tid
, info
->parent_tidptr
);
2760 /* Enable signals. */
2761 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
2762 /* Signal to the parent that we're ready. */
2763 pthread_mutex_lock(&info
->mutex
);
2764 pthread_cond_broadcast(&info
->cond
);
2765 pthread_mutex_unlock(&info
->mutex
);
2766 /* Wait until the parent has finshed initializing the tls state. */
2767 pthread_mutex_lock(&clone_lock
);
2768 pthread_mutex_unlock(&clone_lock
);
2774 /* this stack is the equivalent of the kernel stack associated with a
2776 #define NEW_STACK_SIZE 8192
2778 static int clone_func(void *arg
)
2780 CPUState
*env
= arg
;
2787 /* do_fork() Must return host values and target errnos (unlike most
2788 do_*() functions). */
2789 static int do_fork(CPUState
*env
, unsigned int flags
, abi_ulong newsp
,
2790 abi_ulong parent_tidptr
, target_ulong newtls
,
2791 abi_ulong child_tidptr
)
2797 #if defined(USE_NPTL)
2798 unsigned int nptl_flags
;
2802 if (flags
& CLONE_VM
) {
2803 #if defined(USE_NPTL)
2804 new_thread_info info
;
2805 pthread_attr_t attr
;
2807 ts
= qemu_mallocz(sizeof(TaskState
) + NEW_STACK_SIZE
);
2808 init_task_state(ts
);
2809 new_stack
= ts
->stack
;
2810 /* we create a new CPU instance. */
2811 new_env
= cpu_copy(env
);
2812 /* Init regs that differ from the parent. */
2813 cpu_clone_regs(new_env
, newsp
);
2814 new_env
->opaque
= ts
;
2815 #if defined(USE_NPTL)
2817 flags
&= ~CLONE_NPTL_FLAGS2
;
2819 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2820 if (nptl_flags
& CLONE_SETTLS
)
2821 cpu_set_tls (new_env
, newtls
);
2823 /* Grab a mutex so that thread setup appears atomic. */
2824 pthread_mutex_lock(&clone_lock
);
2826 memset(&info
, 0, sizeof(info
));
2827 pthread_mutex_init(&info
.mutex
, NULL
);
2828 pthread_mutex_lock(&info
.mutex
);
2829 pthread_cond_init(&info
.cond
, NULL
);
2831 if (nptl_flags
& CLONE_CHILD_SETTID
)
2832 info
.child_tidptr
= child_tidptr
;
2833 if (nptl_flags
& CLONE_PARENT_SETTID
)
2834 info
.parent_tidptr
= parent_tidptr
;
2836 ret
= pthread_attr_init(&attr
);
2837 ret
= pthread_attr_setstack(&attr
, new_stack
, NEW_STACK_SIZE
);
2838 /* It is not safe to deliver signals until the child has finished
2839 initializing, so temporarily block all signals. */
2840 sigfillset(&sigmask
);
2841 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
2843 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
2845 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
2846 pthread_attr_destroy(&attr
);
2848 /* Wait for the child to initialize. */
2849 pthread_cond_wait(&info
.cond
, &info
.mutex
);
2851 if (flags
& CLONE_PARENT_SETTID
)
2852 put_user_u32(ret
, parent_tidptr
);
2856 pthread_mutex_unlock(&info
.mutex
);
2857 pthread_cond_destroy(&info
.cond
);
2858 pthread_mutex_destroy(&info
.mutex
);
2859 pthread_mutex_unlock(&clone_lock
);
2861 if (flags
& CLONE_NPTL_FLAGS2
)
2863 /* This is probably going to die very quickly, but do it anyway. */
2865 ret
= __clone2(clone_func
, new_stack
+ NEW_STACK_SIZE
, flags
, new_env
);
2867 ret
= clone(clone_func
, new_stack
+ NEW_STACK_SIZE
, flags
, new_env
);
2871 /* if no CLONE_VM, we consider it is a fork */
2872 if ((flags
& ~(CSIGNAL
| CLONE_NPTL_FLAGS2
)) != 0)
2876 #if defined(USE_NPTL)
2877 /* There is a race condition here. The parent process could
2878 theoretically read the TID in the child process before the child
2879 tid is set. This would require using either ptrace
2880 (not implemented) or having *_tidptr to point at a shared memory
2881 mapping. We can't repeat the spinlock hack used above because
2882 the child process gets its own copy of the lock. */
2884 cpu_clone_regs(env
, newsp
);
2886 /* Child Process. */
2887 if (flags
& CLONE_CHILD_SETTID
)
2888 put_user_u32(gettid(), child_tidptr
);
2889 if (flags
& CLONE_PARENT_SETTID
)
2890 put_user_u32(gettid(), parent_tidptr
);
2891 ts
= (TaskState
*)env
->opaque
;
2892 if (flags
& CLONE_SETTLS
)
2893 cpu_set_tls (env
, newtls
);
2894 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2900 cpu_clone_regs(env
, newsp
);
2907 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
2910 struct target_flock
*target_fl
;
2911 struct flock64 fl64
;
2912 struct target_flock64
*target_fl64
;
2916 case TARGET_F_GETLK
:
2917 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
2918 return -TARGET_EFAULT
;
2919 fl
.l_type
= tswap16(target_fl
->l_type
);
2920 fl
.l_whence
= tswap16(target_fl
->l_whence
);
2921 fl
.l_start
= tswapl(target_fl
->l_start
);
2922 fl
.l_len
= tswapl(target_fl
->l_len
);
2923 fl
.l_pid
= tswapl(target_fl
->l_pid
);
2924 unlock_user_struct(target_fl
, arg
, 0);
2925 ret
= get_errno(fcntl(fd
, cmd
, &fl
));
2927 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg
, 0))
2928 return -TARGET_EFAULT
;
2929 target_fl
->l_type
= tswap16(fl
.l_type
);
2930 target_fl
->l_whence
= tswap16(fl
.l_whence
);
2931 target_fl
->l_start
= tswapl(fl
.l_start
);
2932 target_fl
->l_len
= tswapl(fl
.l_len
);
2933 target_fl
->l_pid
= tswapl(fl
.l_pid
);
2934 unlock_user_struct(target_fl
, arg
, 1);
2938 case TARGET_F_SETLK
:
2939 case TARGET_F_SETLKW
:
2940 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
2941 return -TARGET_EFAULT
;
2942 fl
.l_type
= tswap16(target_fl
->l_type
);
2943 fl
.l_whence
= tswap16(target_fl
->l_whence
);
2944 fl
.l_start
= tswapl(target_fl
->l_start
);
2945 fl
.l_len
= tswapl(target_fl
->l_len
);
2946 fl
.l_pid
= tswapl(target_fl
->l_pid
);
2947 unlock_user_struct(target_fl
, arg
, 0);
2948 ret
= get_errno(fcntl(fd
, cmd
, &fl
));
2951 case TARGET_F_GETLK64
:
2952 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
2953 return -TARGET_EFAULT
;
2954 fl64
.l_type
= tswap16(target_fl64
->l_type
) >> 1;
2955 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
2956 fl64
.l_start
= tswapl(target_fl64
->l_start
);
2957 fl64
.l_len
= tswapl(target_fl64
->l_len
);
2958 fl64
.l_pid
= tswap16(target_fl64
->l_pid
);
2959 unlock_user_struct(target_fl64
, arg
, 0);
2960 ret
= get_errno(fcntl(fd
, cmd
>> 1, &fl64
));
2962 if (!lock_user_struct(VERIFY_WRITE
, target_fl64
, arg
, 0))
2963 return -TARGET_EFAULT
;
2964 target_fl64
->l_type
= tswap16(fl64
.l_type
) >> 1;
2965 target_fl64
->l_whence
= tswap16(fl64
.l_whence
);
2966 target_fl64
->l_start
= tswapl(fl64
.l_start
);
2967 target_fl64
->l_len
= tswapl(fl64
.l_len
);
2968 target_fl64
->l_pid
= tswapl(fl64
.l_pid
);
2969 unlock_user_struct(target_fl64
, arg
, 1);
2972 case TARGET_F_SETLK64
:
2973 case TARGET_F_SETLKW64
:
2974 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
2975 return -TARGET_EFAULT
;
2976 fl64
.l_type
= tswap16(target_fl64
->l_type
) >> 1;
2977 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
2978 fl64
.l_start
= tswapl(target_fl64
->l_start
);
2979 fl64
.l_len
= tswapl(target_fl64
->l_len
);
2980 fl64
.l_pid
= tswap16(target_fl64
->l_pid
);
2981 unlock_user_struct(target_fl64
, arg
, 0);
2982 ret
= get_errno(fcntl(fd
, cmd
>> 1, &fl64
));
2986 ret
= get_errno(fcntl(fd
, cmd
, arg
));
2988 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
2993 ret
= get_errno(fcntl(fd
, cmd
, target_to_host_bitmask(arg
, fcntl_flags_tbl
)));
2997 ret
= get_errno(fcntl(fd
, cmd
, arg
));
3005 static inline int high2lowuid(int uid
)
3013 static inline int high2lowgid(int gid
)
3021 static inline int low2highuid(int uid
)
3023 if ((int16_t)uid
== -1)
3029 static inline int low2highgid(int gid
)
3031 if ((int16_t)gid
== -1)
3037 #endif /* USE_UID16 */
3039 void syscall_init(void)
3042 const argtype
*arg_type
;
3046 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3047 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
3048 #include "syscall_types.h"
3050 #undef STRUCT_SPECIAL
3052 /* we patch the ioctl size if necessary. We rely on the fact that
3053 no ioctl has all the bits at '1' in the size field */
3055 while (ie
->target_cmd
!= 0) {
3056 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
3057 TARGET_IOC_SIZEMASK
) {
3058 arg_type
= ie
->arg_type
;
3059 if (arg_type
[0] != TYPE_PTR
) {
3060 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
3065 size
= thunk_type_size(arg_type
, 0);
3066 ie
->target_cmd
= (ie
->target_cmd
&
3067 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
3068 (size
<< TARGET_IOC_SIZESHIFT
);
3071 /* Build target_to_host_errno_table[] table from
3072 * host_to_target_errno_table[]. */
3073 for (i
=0; i
< ERRNO_TABLE_SIZE
; i
++)
3074 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
3076 /* automatic consistency check if same arch */
3077 #if defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)
3078 if (ie
->target_cmd
!= ie
->host_cmd
) {
3079 fprintf(stderr
, "ERROR: ioctl: target=0x%x host=0x%x\n",
3080 ie
->target_cmd
, ie
->host_cmd
);
3087 #if TARGET_ABI_BITS == 32
3088 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
3090 #ifdef TARGET_WORDS_BIGENDIAN
3091 return ((uint64_t)word0
<< 32) | word1
;
3093 return ((uint64_t)word1
<< 32) | word0
;
3096 #else /* TARGET_ABI_BITS == 32 */
3097 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
3101 #endif /* TARGET_ABI_BITS != 32 */
3103 #ifdef TARGET_NR_truncate64
3104 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
3110 if (((CPUARMState
*)cpu_env
)->eabi
)
3116 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
3120 #ifdef TARGET_NR_ftruncate64
3121 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
3127 if (((CPUARMState
*)cpu_env
)->eabi
)
3133 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
3137 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
3138 abi_ulong target_addr
)
3140 struct target_timespec
*target_ts
;
3142 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
3143 return -TARGET_EFAULT
;
3144 host_ts
->tv_sec
= tswapl(target_ts
->tv_sec
);
3145 host_ts
->tv_nsec
= tswapl(target_ts
->tv_nsec
);
3146 unlock_user_struct(target_ts
, target_addr
, 0);
3150 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
3151 struct timespec
*host_ts
)
3153 struct target_timespec
*target_ts
;
3155 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
3156 return -TARGET_EFAULT
;
3157 target_ts
->tv_sec
= tswapl(host_ts
->tv_sec
);
3158 target_ts
->tv_nsec
= tswapl(host_ts
->tv_nsec
);
3159 unlock_user_struct(target_ts
, target_addr
, 1);
3163 #ifdef TARGET_NR_stat64
3164 static inline abi_long
host_to_target_stat64(void *cpu_env
,
3165 abi_ulong target_addr
,
3166 struct stat
*host_st
)
3169 if (((CPUARMState
*)cpu_env
)->eabi
) {
3170 struct target_eabi_stat64
*target_st
;
3172 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
3173 return -TARGET_EFAULT
;
3174 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
3175 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
3176 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
3177 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3178 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
3180 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
3181 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
3182 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
3183 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
3184 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
3185 __put_user(host_st
->st_size
, &target_st
->st_size
);
3186 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
3187 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
3188 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
3189 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
3190 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
3191 unlock_user_struct(target_st
, target_addr
, 1);
3195 struct target_stat64
*target_st
;
3197 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
3198 return -TARGET_EFAULT
;
3199 memset(target_st
, 0, sizeof(struct target_stat64
));
3200 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
3201 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
3202 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3203 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
3205 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
3206 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
3207 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
3208 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
3209 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
3210 /* XXX: better use of kernel struct */
3211 __put_user(host_st
->st_size
, &target_st
->st_size
);
3212 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
3213 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
3214 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
3215 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
3216 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
3217 unlock_user_struct(target_st
, target_addr
, 1);
3224 #if defined(USE_NPTL)
3225 /* ??? Using host futex calls even when target atomic operations
3226 are not really atomic probably breaks things. However implementing
3227 futexes locally would make futexes shared between multiple processes
3228 tricky. However they're probably useless because guest atomic
3229 operations won't work either. */
3230 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
3231 target_ulong uaddr2
, int val3
)
3233 struct timespec ts
, *pts
;
3235 /* ??? We assume FUTEX_* constants are the same on both host
3241 target_to_host_timespec(pts
, timeout
);
3245 return get_errno(sys_futex(g2h(uaddr
), FUTEX_WAIT
, tswap32(val
),
3248 return get_errno(sys_futex(g2h(uaddr
), FUTEX_WAKE
, val
, NULL
, NULL
, 0));
3250 return get_errno(sys_futex(g2h(uaddr
), FUTEX_FD
, val
, NULL
, NULL
, 0));
3252 return get_errno(sys_futex(g2h(uaddr
), FUTEX_REQUEUE
, val
,
3253 NULL
, g2h(uaddr2
), 0));
3254 case FUTEX_CMP_REQUEUE
:
3255 return get_errno(sys_futex(g2h(uaddr
), FUTEX_CMP_REQUEUE
, val
,
3256 NULL
, g2h(uaddr2
), tswap32(val3
)));
3258 return -TARGET_ENOSYS
;
3263 int get_osversion(void)
3265 static int osversion
;
3266 struct new_utsname buf
;
3271 if (qemu_uname_release
&& *qemu_uname_release
) {
3272 s
= qemu_uname_release
;
3274 if (sys_uname(&buf
))
3279 for (i
= 0; i
< 3; i
++) {
3281 while (*s
>= '0' && *s
<= '9') {
3286 tmp
= (tmp
<< 8) + n
;
3294 /* do_syscall() should always have a single exit point at the end so
3295 that actions, such as logging of syscall results, can be performed.
3296 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
3297 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
3298 abi_long arg2
, abi_long arg3
, abi_long arg4
,
3299 abi_long arg5
, abi_long arg6
)
3307 gemu_log("syscall %d", num
);
3310 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
3313 case TARGET_NR_exit
:
3317 gdb_exit(cpu_env
, arg1
);
3318 /* XXX: should free thread stack and CPU env */
3320 ret
= 0; /* avoid warning */
3322 case TARGET_NR_read
:
3323 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
3325 ret
= get_errno(read(arg1
, p
, arg3
));
3326 unlock_user(p
, arg2
, ret
);
3328 case TARGET_NR_write
:
3329 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
3331 ret
= get_errno(write(arg1
, p
, arg3
));
3332 unlock_user(p
, arg2
, 0);
3334 case TARGET_NR_open
:
3335 if (!(p
= lock_user_string(arg1
)))
3337 ret
= get_errno(open(path(p
),
3338 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
3340 unlock_user(p
, arg1
, 0);
3342 #if defined(TARGET_NR_openat) && defined(__NR_openat)
3343 case TARGET_NR_openat
:
3344 if (!(p
= lock_user_string(arg2
)))
3346 ret
= get_errno(sys_openat(arg1
,
3348 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
3350 unlock_user(p
, arg2
, 0);
3353 case TARGET_NR_close
:
3354 ret
= get_errno(close(arg1
));
3359 case TARGET_NR_fork
:
3360 ret
= get_errno(do_fork(cpu_env
, SIGCHLD
, 0, 0, 0, 0));
3362 #ifdef TARGET_NR_waitpid
3363 case TARGET_NR_waitpid
:
3366 ret
= get_errno(waitpid(arg1
, &status
, arg3
));
3367 if (!is_error(ret
) && arg2
3368 && put_user_s32(status
, arg2
))
3373 #ifdef TARGET_NR_waitid
3374 case TARGET_NR_waitid
:
3378 ret
= get_errno(waitid(arg1
, arg2
, &info
, arg4
));
3379 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
3380 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
3382 host_to_target_siginfo(p
, &info
);
3383 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
3388 #ifdef TARGET_NR_creat /* not on alpha */
3389 case TARGET_NR_creat
:
3390 if (!(p
= lock_user_string(arg1
)))
3392 ret
= get_errno(creat(p
, arg2
));
3393 unlock_user(p
, arg1
, 0);
3396 case TARGET_NR_link
:
3399 p
= lock_user_string(arg1
);
3400 p2
= lock_user_string(arg2
);
3402 ret
= -TARGET_EFAULT
;
3404 ret
= get_errno(link(p
, p2
));
3405 unlock_user(p2
, arg2
, 0);
3406 unlock_user(p
, arg1
, 0);
3409 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3410 case TARGET_NR_linkat
:
3415 p
= lock_user_string(arg2
);
3416 p2
= lock_user_string(arg4
);
3418 ret
= -TARGET_EFAULT
;
3420 ret
= get_errno(sys_linkat(arg1
, p
, arg3
, p2
, arg5
));
3421 unlock_user(p
, arg2
, 0);
3422 unlock_user(p2
, arg4
, 0);
3426 case TARGET_NR_unlink
:
3427 if (!(p
= lock_user_string(arg1
)))
3429 ret
= get_errno(unlink(p
));
3430 unlock_user(p
, arg1
, 0);
3432 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3433 case TARGET_NR_unlinkat
:
3434 if (!(p
= lock_user_string(arg2
)))
3436 ret
= get_errno(sys_unlinkat(arg1
, p
, arg3
));
3437 unlock_user(p
, arg2
, 0);
3440 case TARGET_NR_execve
:
3442 char **argp
, **envp
;
3445 abi_ulong guest_argp
;
3446 abi_ulong guest_envp
;
3452 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
3453 if (get_user_ual(addr
, gp
))
3461 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
3462 if (get_user_ual(addr
, gp
))
3469 argp
= alloca((argc
+ 1) * sizeof(void *));
3470 envp
= alloca((envc
+ 1) * sizeof(void *));
3472 for (gp
= guest_argp
, q
= argp
; gp
;
3473 gp
+= sizeof(abi_ulong
), q
++) {
3474 if (get_user_ual(addr
, gp
))
3478 if (!(*q
= lock_user_string(addr
)))
3483 for (gp
= guest_envp
, q
= envp
; gp
;
3484 gp
+= sizeof(abi_ulong
), q
++) {
3485 if (get_user_ual(addr
, gp
))
3489 if (!(*q
= lock_user_string(addr
)))
3494 if (!(p
= lock_user_string(arg1
)))
3496 ret
= get_errno(execve(p
, argp
, envp
));
3497 unlock_user(p
, arg1
, 0);
3502 ret
= -TARGET_EFAULT
;
3505 for (gp
= guest_argp
, q
= argp
; *q
;
3506 gp
+= sizeof(abi_ulong
), q
++) {
3507 if (get_user_ual(addr
, gp
)
3510 unlock_user(*q
, addr
, 0);
3512 for (gp
= guest_envp
, q
= envp
; *q
;
3513 gp
+= sizeof(abi_ulong
), q
++) {
3514 if (get_user_ual(addr
, gp
)
3517 unlock_user(*q
, addr
, 0);
3521 case TARGET_NR_chdir
:
3522 if (!(p
= lock_user_string(arg1
)))
3524 ret
= get_errno(chdir(p
));
3525 unlock_user(p
, arg1
, 0);
3527 #ifdef TARGET_NR_time
3528 case TARGET_NR_time
:
3531 ret
= get_errno(time(&host_time
));
3534 && put_user_sal(host_time
, arg1
))
3539 case TARGET_NR_mknod
:
3540 if (!(p
= lock_user_string(arg1
)))
3542 ret
= get_errno(mknod(p
, arg2
, arg3
));
3543 unlock_user(p
, arg1
, 0);
3545 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3546 case TARGET_NR_mknodat
:
3547 if (!(p
= lock_user_string(arg2
)))
3549 ret
= get_errno(sys_mknodat(arg1
, p
, arg3
, arg4
));
3550 unlock_user(p
, arg2
, 0);
3553 case TARGET_NR_chmod
:
3554 if (!(p
= lock_user_string(arg1
)))
3556 ret
= get_errno(chmod(p
, arg2
));
3557 unlock_user(p
, arg1
, 0);
3559 #ifdef TARGET_NR_break
3560 case TARGET_NR_break
:
3563 #ifdef TARGET_NR_oldstat
3564 case TARGET_NR_oldstat
:
3567 case TARGET_NR_lseek
:
3568 ret
= get_errno(lseek(arg1
, arg2
, arg3
));
3570 #ifdef TARGET_NR_getxpid
3571 case TARGET_NR_getxpid
:
3573 case TARGET_NR_getpid
:
3575 ret
= get_errno(getpid());
3577 case TARGET_NR_mount
:
3579 /* need to look at the data field */
3581 p
= lock_user_string(arg1
);
3582 p2
= lock_user_string(arg2
);
3583 p3
= lock_user_string(arg3
);
3584 if (!p
|| !p2
|| !p3
)
3585 ret
= -TARGET_EFAULT
;
3587 /* FIXME - arg5 should be locked, but it isn't clear how to
3588 * do that since it's not guaranteed to be a NULL-terminated
3591 ret
= get_errno(mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
)));
3592 unlock_user(p
, arg1
, 0);
3593 unlock_user(p2
, arg2
, 0);
3594 unlock_user(p3
, arg3
, 0);
3597 #ifdef TARGET_NR_umount
3598 case TARGET_NR_umount
:
3599 if (!(p
= lock_user_string(arg1
)))
3601 ret
= get_errno(umount(p
));
3602 unlock_user(p
, arg1
, 0);
3605 #ifdef TARGET_NR_stime /* not on alpha */
3606 case TARGET_NR_stime
:
3609 if (get_user_sal(host_time
, arg1
))
3611 ret
= get_errno(stime(&host_time
));
3615 case TARGET_NR_ptrace
:
3617 #ifdef TARGET_NR_alarm /* not on alpha */
3618 case TARGET_NR_alarm
:
3622 #ifdef TARGET_NR_oldfstat
3623 case TARGET_NR_oldfstat
:
3626 #ifdef TARGET_NR_pause /* not on alpha */
3627 case TARGET_NR_pause
:
3628 ret
= get_errno(pause());
3631 #ifdef TARGET_NR_utime
3632 case TARGET_NR_utime
:
3634 struct utimbuf tbuf
, *host_tbuf
;
3635 struct target_utimbuf
*target_tbuf
;
3637 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
3639 tbuf
.actime
= tswapl(target_tbuf
->actime
);
3640 tbuf
.modtime
= tswapl(target_tbuf
->modtime
);
3641 unlock_user_struct(target_tbuf
, arg2
, 0);
3646 if (!(p
= lock_user_string(arg1
)))
3648 ret
= get_errno(utime(p
, host_tbuf
));
3649 unlock_user(p
, arg1
, 0);
3653 case TARGET_NR_utimes
:
3655 struct timeval
*tvp
, tv
[2];
3657 if (copy_from_user_timeval(&tv
[0], arg2
)
3658 || copy_from_user_timeval(&tv
[1],
3659 arg2
+ sizeof(struct target_timeval
)))
3665 if (!(p
= lock_user_string(arg1
)))
3667 ret
= get_errno(utimes(p
, tvp
));
3668 unlock_user(p
, arg1
, 0);
3671 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
3672 case TARGET_NR_futimesat
:
3674 struct timeval
*tvp
, tv
[2];
3676 if (copy_from_user_timeval(&tv
[0], arg3
)
3677 || copy_from_user_timeval(&tv
[1],
3678 arg3
+ sizeof(struct target_timeval
)))
3684 if (!(p
= lock_user_string(arg2
)))
3686 ret
= get_errno(sys_futimesat(arg1
, path(p
), tvp
));
3687 unlock_user(p
, arg2
, 0);
3691 #ifdef TARGET_NR_stty
3692 case TARGET_NR_stty
:
3695 #ifdef TARGET_NR_gtty
3696 case TARGET_NR_gtty
:
3699 case TARGET_NR_access
:
3700 if (!(p
= lock_user_string(arg1
)))
3702 ret
= get_errno(access(p
, arg2
));
3703 unlock_user(p
, arg1
, 0);
3705 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3706 case TARGET_NR_faccessat
:
3707 if (!(p
= lock_user_string(arg2
)))
3709 ret
= get_errno(sys_faccessat(arg1
, p
, arg3
, arg4
));
3710 unlock_user(p
, arg2
, 0);
3713 #ifdef TARGET_NR_nice /* not on alpha */
3714 case TARGET_NR_nice
:
3715 ret
= get_errno(nice(arg1
));
3718 #ifdef TARGET_NR_ftime
3719 case TARGET_NR_ftime
:
3722 case TARGET_NR_sync
:
3726 case TARGET_NR_kill
:
3727 ret
= get_errno(kill(arg1
, target_to_host_signal(arg2
)));
3729 case TARGET_NR_rename
:
3732 p
= lock_user_string(arg1
);
3733 p2
= lock_user_string(arg2
);
3735 ret
= -TARGET_EFAULT
;
3737 ret
= get_errno(rename(p
, p2
));
3738 unlock_user(p2
, arg2
, 0);
3739 unlock_user(p
, arg1
, 0);
3742 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3743 case TARGET_NR_renameat
:
3746 p
= lock_user_string(arg2
);
3747 p2
= lock_user_string(arg4
);
3749 ret
= -TARGET_EFAULT
;
3751 ret
= get_errno(sys_renameat(arg1
, p
, arg3
, p2
));
3752 unlock_user(p2
, arg4
, 0);
3753 unlock_user(p
, arg2
, 0);
3757 case TARGET_NR_mkdir
:
3758 if (!(p
= lock_user_string(arg1
)))
3760 ret
= get_errno(mkdir(p
, arg2
));
3761 unlock_user(p
, arg1
, 0);
3763 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3764 case TARGET_NR_mkdirat
:
3765 if (!(p
= lock_user_string(arg2
)))
3767 ret
= get_errno(sys_mkdirat(arg1
, p
, arg3
));
3768 unlock_user(p
, arg2
, 0);
3771 case TARGET_NR_rmdir
:
3772 if (!(p
= lock_user_string(arg1
)))
3774 ret
= get_errno(rmdir(p
));
3775 unlock_user(p
, arg1
, 0);
3778 ret
= get_errno(dup(arg1
));
3780 case TARGET_NR_pipe
:
3783 ret
= get_errno(pipe(host_pipe
));
3784 if (!is_error(ret
)) {
3785 #if defined(TARGET_MIPS)
3786 CPUMIPSState
*env
= (CPUMIPSState
*)cpu_env
;
3787 env
->active_tc
.gpr
[3] = host_pipe
[1];
3789 #elif defined(TARGET_SH4)
3790 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
3793 if (put_user_s32(host_pipe
[0], arg1
)
3794 || put_user_s32(host_pipe
[1], arg1
+ sizeof(host_pipe
[0])))
3800 case TARGET_NR_times
:
3802 struct target_tms
*tmsp
;
3804 ret
= get_errno(times(&tms
));
3806 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
3809 tmsp
->tms_utime
= tswapl(host_to_target_clock_t(tms
.tms_utime
));
3810 tmsp
->tms_stime
= tswapl(host_to_target_clock_t(tms
.tms_stime
));
3811 tmsp
->tms_cutime
= tswapl(host_to_target_clock_t(tms
.tms_cutime
));
3812 tmsp
->tms_cstime
= tswapl(host_to_target_clock_t(tms
.tms_cstime
));
3815 ret
= host_to_target_clock_t(ret
);
3818 #ifdef TARGET_NR_prof
3819 case TARGET_NR_prof
:
3822 #ifdef TARGET_NR_signal
3823 case TARGET_NR_signal
:
3826 case TARGET_NR_acct
:
3827 if (!(p
= lock_user_string(arg1
)))
3829 ret
= get_errno(acct(path(p
)));
3830 unlock_user(p
, arg1
, 0);
3832 #ifdef TARGET_NR_umount2 /* not on alpha */
3833 case TARGET_NR_umount2
:
3834 if (!(p
= lock_user_string(arg1
)))
3836 ret
= get_errno(umount2(p
, arg2
));
3837 unlock_user(p
, arg1
, 0);
3840 #ifdef TARGET_NR_lock
3841 case TARGET_NR_lock
:
3844 case TARGET_NR_ioctl
:
3845 ret
= do_ioctl(arg1
, arg2
, arg3
);
3847 case TARGET_NR_fcntl
:
3848 ret
= do_fcntl(arg1
, arg2
, arg3
);
3850 #ifdef TARGET_NR_mpx
3854 case TARGET_NR_setpgid
:
3855 ret
= get_errno(setpgid(arg1
, arg2
));
3857 #ifdef TARGET_NR_ulimit
3858 case TARGET_NR_ulimit
:
3861 #ifdef TARGET_NR_oldolduname
3862 case TARGET_NR_oldolduname
:
3865 case TARGET_NR_umask
:
3866 ret
= get_errno(umask(arg1
));
3868 case TARGET_NR_chroot
:
3869 if (!(p
= lock_user_string(arg1
)))
3871 ret
= get_errno(chroot(p
));
3872 unlock_user(p
, arg1
, 0);
3874 case TARGET_NR_ustat
:
3876 case TARGET_NR_dup2
:
3877 ret
= get_errno(dup2(arg1
, arg2
));
3879 #ifdef TARGET_NR_getppid /* not on alpha */
3880 case TARGET_NR_getppid
:
3881 ret
= get_errno(getppid());
3884 case TARGET_NR_getpgrp
:
3885 ret
= get_errno(getpgrp());
3887 case TARGET_NR_setsid
:
3888 ret
= get_errno(setsid());
3890 #ifdef TARGET_NR_sigaction
3891 case TARGET_NR_sigaction
:
3893 #if !defined(TARGET_MIPS)
3894 struct target_old_sigaction
*old_act
;
3895 struct target_sigaction act
, oact
, *pact
;
3897 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
3899 act
._sa_handler
= old_act
->_sa_handler
;
3900 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
3901 act
.sa_flags
= old_act
->sa_flags
;
3902 act
.sa_restorer
= old_act
->sa_restorer
;
3903 unlock_user_struct(old_act
, arg2
, 0);
3908 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
3909 if (!is_error(ret
) && arg3
) {
3910 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
3912 old_act
->_sa_handler
= oact
._sa_handler
;
3913 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
3914 old_act
->sa_flags
= oact
.sa_flags
;
3915 old_act
->sa_restorer
= oact
.sa_restorer
;
3916 unlock_user_struct(old_act
, arg3
, 1);
3919 struct target_sigaction act
, oact
, *pact
, *old_act
;
3922 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
3924 act
._sa_handler
= old_act
->_sa_handler
;
3925 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
3926 act
.sa_flags
= old_act
->sa_flags
;
3927 unlock_user_struct(old_act
, arg2
, 0);
3933 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
3935 if (!is_error(ret
) && arg3
) {
3936 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
3938 old_act
->_sa_handler
= oact
._sa_handler
;
3939 old_act
->sa_flags
= oact
.sa_flags
;
3940 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
3941 old_act
->sa_mask
.sig
[1] = 0;
3942 old_act
->sa_mask
.sig
[2] = 0;
3943 old_act
->sa_mask
.sig
[3] = 0;
3944 unlock_user_struct(old_act
, arg3
, 1);
3950 case TARGET_NR_rt_sigaction
:
3952 struct target_sigaction
*act
;
3953 struct target_sigaction
*oact
;
3956 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1))
3961 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
3962 ret
= -TARGET_EFAULT
;
3963 goto rt_sigaction_fail
;
3967 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
3970 unlock_user_struct(act
, arg2
, 0);
3972 unlock_user_struct(oact
, arg3
, 1);
3975 #ifdef TARGET_NR_sgetmask /* not on alpha */
3976 case TARGET_NR_sgetmask
:
3979 abi_ulong target_set
;
3980 sigprocmask(0, NULL
, &cur_set
);
3981 host_to_target_old_sigset(&target_set
, &cur_set
);
3986 #ifdef TARGET_NR_ssetmask /* not on alpha */
3987 case TARGET_NR_ssetmask
:
3989 sigset_t set
, oset
, cur_set
;
3990 abi_ulong target_set
= arg1
;
3991 sigprocmask(0, NULL
, &cur_set
);
3992 target_to_host_old_sigset(&set
, &target_set
);
3993 sigorset(&set
, &set
, &cur_set
);
3994 sigprocmask(SIG_SETMASK
, &set
, &oset
);
3995 host_to_target_old_sigset(&target_set
, &oset
);
4000 #ifdef TARGET_NR_sigprocmask
4001 case TARGET_NR_sigprocmask
:
4004 sigset_t set
, oldset
, *set_ptr
;
4008 case TARGET_SIG_BLOCK
:
4011 case TARGET_SIG_UNBLOCK
:
4014 case TARGET_SIG_SETMASK
:
4018 ret
= -TARGET_EINVAL
;
4021 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
4023 target_to_host_old_sigset(&set
, p
);
4024 unlock_user(p
, arg2
, 0);
4030 ret
= get_errno(sigprocmask(arg1
, set_ptr
, &oldset
));
4031 if (!is_error(ret
) && arg3
) {
4032 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
4034 host_to_target_old_sigset(p
, &oldset
);
4035 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
4040 case TARGET_NR_rt_sigprocmask
:
4043 sigset_t set
, oldset
, *set_ptr
;
4047 case TARGET_SIG_BLOCK
:
4050 case TARGET_SIG_UNBLOCK
:
4053 case TARGET_SIG_SETMASK
:
4057 ret
= -TARGET_EINVAL
;
4060 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
4062 target_to_host_sigset(&set
, p
);
4063 unlock_user(p
, arg2
, 0);
4069 ret
= get_errno(sigprocmask(how
, set_ptr
, &oldset
));
4070 if (!is_error(ret
) && arg3
) {
4071 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
4073 host_to_target_sigset(p
, &oldset
);
4074 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
4078 #ifdef TARGET_NR_sigpending
4079 case TARGET_NR_sigpending
:
4082 ret
= get_errno(sigpending(&set
));
4083 if (!is_error(ret
)) {
4084 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
4086 host_to_target_old_sigset(p
, &set
);
4087 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
4092 case TARGET_NR_rt_sigpending
:
4095 ret
= get_errno(sigpending(&set
));
4096 if (!is_error(ret
)) {
4097 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
4099 host_to_target_sigset(p
, &set
);
4100 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
4104 #ifdef TARGET_NR_sigsuspend
4105 case TARGET_NR_sigsuspend
:
4108 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4110 target_to_host_old_sigset(&set
, p
);
4111 unlock_user(p
, arg1
, 0);
4112 ret
= get_errno(sigsuspend(&set
));
4116 case TARGET_NR_rt_sigsuspend
:
4119 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4121 target_to_host_sigset(&set
, p
);
4122 unlock_user(p
, arg1
, 0);
4123 ret
= get_errno(sigsuspend(&set
));
4126 case TARGET_NR_rt_sigtimedwait
:
4129 struct timespec uts
, *puts
;
4132 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4134 target_to_host_sigset(&set
, p
);
4135 unlock_user(p
, arg1
, 0);
4138 target_to_host_timespec(puts
, arg3
);
4142 ret
= get_errno(sigtimedwait(&set
, &uinfo
, puts
));
4143 if (!is_error(ret
) && arg2
) {
4144 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
), 0)))
4146 host_to_target_siginfo(p
, &uinfo
);
4147 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
4151 case TARGET_NR_rt_sigqueueinfo
:
4154 if (!(p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_sigset_t
), 1)))
4156 target_to_host_siginfo(&uinfo
, p
);
4157 unlock_user(p
, arg1
, 0);
4158 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
4161 #ifdef TARGET_NR_sigreturn
4162 case TARGET_NR_sigreturn
:
4163 /* NOTE: ret is eax, so not transcoding must be done */
4164 ret
= do_sigreturn(cpu_env
);
4167 case TARGET_NR_rt_sigreturn
:
4168 /* NOTE: ret is eax, so not transcoding must be done */
4169 ret
= do_rt_sigreturn(cpu_env
);
4171 case TARGET_NR_sethostname
:
4172 if (!(p
= lock_user_string(arg1
)))
4174 ret
= get_errno(sethostname(p
, arg2
));
4175 unlock_user(p
, arg1
, 0);
4177 case TARGET_NR_setrlimit
:
4179 /* XXX: convert resource ? */
4180 int resource
= arg1
;
4181 struct target_rlimit
*target_rlim
;
4183 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
4185 rlim
.rlim_cur
= tswapl(target_rlim
->rlim_cur
);
4186 rlim
.rlim_max
= tswapl(target_rlim
->rlim_max
);
4187 unlock_user_struct(target_rlim
, arg2
, 0);
4188 ret
= get_errno(setrlimit(resource
, &rlim
));
4191 case TARGET_NR_getrlimit
:
4193 /* XXX: convert resource ? */
4194 int resource
= arg1
;
4195 struct target_rlimit
*target_rlim
;
4198 ret
= get_errno(getrlimit(resource
, &rlim
));
4199 if (!is_error(ret
)) {
4200 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
4202 rlim
.rlim_cur
= tswapl(target_rlim
->rlim_cur
);
4203 rlim
.rlim_max
= tswapl(target_rlim
->rlim_max
);
4204 unlock_user_struct(target_rlim
, arg2
, 1);
4208 case TARGET_NR_getrusage
:
4210 struct rusage rusage
;
4211 ret
= get_errno(getrusage(arg1
, &rusage
));
4212 if (!is_error(ret
)) {
4213 host_to_target_rusage(arg2
, &rusage
);
4217 case TARGET_NR_gettimeofday
:
4220 ret
= get_errno(gettimeofday(&tv
, NULL
));
4221 if (!is_error(ret
)) {
4222 if (copy_to_user_timeval(arg1
, &tv
))
4227 case TARGET_NR_settimeofday
:
4230 if (copy_from_user_timeval(&tv
, arg1
))
4232 ret
= get_errno(settimeofday(&tv
, NULL
));
4235 #ifdef TARGET_NR_select
4236 case TARGET_NR_select
:
4238 struct target_sel_arg_struct
*sel
;
4239 abi_ulong inp
, outp
, exp
, tvp
;
4242 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1))
4244 nsel
= tswapl(sel
->n
);
4245 inp
= tswapl(sel
->inp
);
4246 outp
= tswapl(sel
->outp
);
4247 exp
= tswapl(sel
->exp
);
4248 tvp
= tswapl(sel
->tvp
);
4249 unlock_user_struct(sel
, arg1
, 0);
4250 ret
= do_select(nsel
, inp
, outp
, exp
, tvp
);
4254 case TARGET_NR_symlink
:
4257 p
= lock_user_string(arg1
);
4258 p2
= lock_user_string(arg2
);
4260 ret
= -TARGET_EFAULT
;
4262 ret
= get_errno(symlink(p
, p2
));
4263 unlock_user(p2
, arg2
, 0);
4264 unlock_user(p
, arg1
, 0);
4267 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4268 case TARGET_NR_symlinkat
:
4271 p
= lock_user_string(arg1
);
4272 p2
= lock_user_string(arg3
);
4274 ret
= -TARGET_EFAULT
;
4276 ret
= get_errno(sys_symlinkat(p
, arg2
, p2
));
4277 unlock_user(p2
, arg3
, 0);
4278 unlock_user(p
, arg1
, 0);
4282 #ifdef TARGET_NR_oldlstat
4283 case TARGET_NR_oldlstat
:
4286 case TARGET_NR_readlink
:
4289 p
= lock_user_string(arg1
);
4290 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
4292 ret
= -TARGET_EFAULT
;
4294 ret
= get_errno(readlink(path(p
), p2
, arg3
));
4295 unlock_user(p2
, arg2
, ret
);
4296 unlock_user(p
, arg1
, 0);
4299 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4300 case TARGET_NR_readlinkat
:
4303 p
= lock_user_string(arg2
);
4304 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
4306 ret
= -TARGET_EFAULT
;
4308 ret
= get_errno(sys_readlinkat(arg1
, path(p
), p2
, arg4
));
4309 unlock_user(p2
, arg3
, ret
);
4310 unlock_user(p
, arg2
, 0);
4314 #ifdef TARGET_NR_uselib
4315 case TARGET_NR_uselib
:
4318 #ifdef TARGET_NR_swapon
4319 case TARGET_NR_swapon
:
4320 if (!(p
= lock_user_string(arg1
)))
4322 ret
= get_errno(swapon(p
, arg2
));
4323 unlock_user(p
, arg1
, 0);
4326 case TARGET_NR_reboot
:
4328 #ifdef TARGET_NR_readdir
4329 case TARGET_NR_readdir
:
4332 #ifdef TARGET_NR_mmap
4333 case TARGET_NR_mmap
:
4334 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
4337 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
4338 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
4346 unlock_user(v
, arg1
, 0);
4347 ret
= get_errno(target_mmap(v1
, v2
, v3
,
4348 target_to_host_bitmask(v4
, mmap_flags_tbl
),
4352 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
4353 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
4359 #ifdef TARGET_NR_mmap2
4360 case TARGET_NR_mmap2
:
4362 #define MMAP_SHIFT 12
4364 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
4365 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
4367 arg6
<< MMAP_SHIFT
));
4370 case TARGET_NR_munmap
:
4371 ret
= get_errno(target_munmap(arg1
, arg2
));
4373 case TARGET_NR_mprotect
:
4374 ret
= get_errno(target_mprotect(arg1
, arg2
, arg3
));
4376 #ifdef TARGET_NR_mremap
4377 case TARGET_NR_mremap
:
4378 ret
= get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
4381 /* ??? msync/mlock/munlock are broken for softmmu. */
4382 #ifdef TARGET_NR_msync
4383 case TARGET_NR_msync
:
4384 ret
= get_errno(msync(g2h(arg1
), arg2
, arg3
));
4387 #ifdef TARGET_NR_mlock
4388 case TARGET_NR_mlock
:
4389 ret
= get_errno(mlock(g2h(arg1
), arg2
));
4392 #ifdef TARGET_NR_munlock
4393 case TARGET_NR_munlock
:
4394 ret
= get_errno(munlock(g2h(arg1
), arg2
));
4397 #ifdef TARGET_NR_mlockall
4398 case TARGET_NR_mlockall
:
4399 ret
= get_errno(mlockall(arg1
));
4402 #ifdef TARGET_NR_munlockall
4403 case TARGET_NR_munlockall
:
4404 ret
= get_errno(munlockall());
4407 case TARGET_NR_truncate
:
4408 if (!(p
= lock_user_string(arg1
)))
4410 ret
= get_errno(truncate(p
, arg2
));
4411 unlock_user(p
, arg1
, 0);
4413 case TARGET_NR_ftruncate
:
4414 ret
= get_errno(ftruncate(arg1
, arg2
));
4416 case TARGET_NR_fchmod
:
4417 ret
= get_errno(fchmod(arg1
, arg2
));
4419 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4420 case TARGET_NR_fchmodat
:
4421 if (!(p
= lock_user_string(arg2
)))
4423 ret
= get_errno(sys_fchmodat(arg1
, p
, arg3
, arg4
));
4424 unlock_user(p
, arg2
, 0);
4427 case TARGET_NR_getpriority
:
4428 /* libc does special remapping of the return value of
4429 * sys_getpriority() so it's just easiest to call
4430 * sys_getpriority() directly rather than through libc. */
4431 ret
= sys_getpriority(arg1
, arg2
);
4433 case TARGET_NR_setpriority
:
4434 ret
= get_errno(setpriority(arg1
, arg2
, arg3
));
4436 #ifdef TARGET_NR_profil
4437 case TARGET_NR_profil
:
4440 case TARGET_NR_statfs
:
4441 if (!(p
= lock_user_string(arg1
)))
4443 ret
= get_errno(statfs(path(p
), &stfs
));
4444 unlock_user(p
, arg1
, 0);
4446 if (!is_error(ret
)) {
4447 struct target_statfs
*target_stfs
;
4449 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
4451 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
4452 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
4453 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
4454 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
4455 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
4456 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
4457 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
4458 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
4459 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
4460 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
4461 unlock_user_struct(target_stfs
, arg2
, 1);
4464 case TARGET_NR_fstatfs
:
4465 ret
= get_errno(fstatfs(arg1
, &stfs
));
4466 goto convert_statfs
;
4467 #ifdef TARGET_NR_statfs64
4468 case TARGET_NR_statfs64
:
4469 if (!(p
= lock_user_string(arg1
)))
4471 ret
= get_errno(statfs(path(p
), &stfs
));
4472 unlock_user(p
, arg1
, 0);
4474 if (!is_error(ret
)) {
4475 struct target_statfs64
*target_stfs
;
4477 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
4479 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
4480 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
4481 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
4482 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
4483 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
4484 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
4485 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
4486 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
4487 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
4488 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
4489 unlock_user_struct(target_stfs
, arg3
, 1);
4492 case TARGET_NR_fstatfs64
:
4493 ret
= get_errno(fstatfs(arg1
, &stfs
));
4494 goto convert_statfs64
;
4496 #ifdef TARGET_NR_ioperm
4497 case TARGET_NR_ioperm
:
4500 #ifdef TARGET_NR_socketcall
4501 case TARGET_NR_socketcall
:
4502 ret
= do_socketcall(arg1
, arg2
);
4505 #ifdef TARGET_NR_accept
4506 case TARGET_NR_accept
:
4507 ret
= do_accept(arg1
, arg2
, arg3
);
4510 #ifdef TARGET_NR_bind
4511 case TARGET_NR_bind
:
4512 ret
= do_bind(arg1
, arg2
, arg3
);
4515 #ifdef TARGET_NR_connect
4516 case TARGET_NR_connect
:
4517 ret
= do_connect(arg1
, arg2
, arg3
);
4520 #ifdef TARGET_NR_getpeername
4521 case TARGET_NR_getpeername
:
4522 ret
= do_getpeername(arg1
, arg2
, arg3
);
4525 #ifdef TARGET_NR_getsockname
4526 case TARGET_NR_getsockname
:
4527 ret
= do_getsockname(arg1
, arg2
, arg3
);
4530 #ifdef TARGET_NR_getsockopt
4531 case TARGET_NR_getsockopt
:
4532 ret
= do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
4535 #ifdef TARGET_NR_listen
4536 case TARGET_NR_listen
:
4537 ret
= get_errno(listen(arg1
, arg2
));
4540 #ifdef TARGET_NR_recv
4541 case TARGET_NR_recv
:
4542 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
4545 #ifdef TARGET_NR_recvfrom
4546 case TARGET_NR_recvfrom
:
4547 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4550 #ifdef TARGET_NR_recvmsg
4551 case TARGET_NR_recvmsg
:
4552 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
4555 #ifdef TARGET_NR_send
4556 case TARGET_NR_send
:
4557 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
4560 #ifdef TARGET_NR_sendmsg
4561 case TARGET_NR_sendmsg
:
4562 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
4565 #ifdef TARGET_NR_sendto
4566 case TARGET_NR_sendto
:
4567 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4570 #ifdef TARGET_NR_shutdown
4571 case TARGET_NR_shutdown
:
4572 ret
= get_errno(shutdown(arg1
, arg2
));
4575 #ifdef TARGET_NR_socket
4576 case TARGET_NR_socket
:
4577 ret
= do_socket(arg1
, arg2
, arg3
);
4580 #ifdef TARGET_NR_socketpair
4581 case TARGET_NR_socketpair
:
4582 ret
= do_socketpair(arg1
, arg2
, arg3
, arg4
);
4585 #ifdef TARGET_NR_setsockopt
4586 case TARGET_NR_setsockopt
:
4587 ret
= do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
4591 case TARGET_NR_syslog
:
4592 if (!(p
= lock_user_string(arg2
)))
4594 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
4595 unlock_user(p
, arg2
, 0);
4598 case TARGET_NR_setitimer
:
4600 struct itimerval value
, ovalue
, *pvalue
;
4604 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
4605 || copy_from_user_timeval(&pvalue
->it_value
,
4606 arg2
+ sizeof(struct target_timeval
)))
4611 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
4612 if (!is_error(ret
) && arg3
) {
4613 if (copy_to_user_timeval(arg3
,
4614 &ovalue
.it_interval
)
4615 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
4621 case TARGET_NR_getitimer
:
4623 struct itimerval value
;
4625 ret
= get_errno(getitimer(arg1
, &value
));
4626 if (!is_error(ret
) && arg2
) {
4627 if (copy_to_user_timeval(arg2
,
4629 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
4635 case TARGET_NR_stat
:
4636 if (!(p
= lock_user_string(arg1
)))
4638 ret
= get_errno(stat(path(p
), &st
));
4639 unlock_user(p
, arg1
, 0);
4641 case TARGET_NR_lstat
:
4642 if (!(p
= lock_user_string(arg1
)))
4644 ret
= get_errno(lstat(path(p
), &st
));
4645 unlock_user(p
, arg1
, 0);
4647 case TARGET_NR_fstat
:
4649 ret
= get_errno(fstat(arg1
, &st
));
4651 if (!is_error(ret
)) {
4652 struct target_stat
*target_st
;
4654 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
4656 __put_user(st
.st_dev
, &target_st
->st_dev
);
4657 __put_user(st
.st_ino
, &target_st
->st_ino
);
4658 __put_user(st
.st_mode
, &target_st
->st_mode
);
4659 __put_user(st
.st_uid
, &target_st
->st_uid
);
4660 __put_user(st
.st_gid
, &target_st
->st_gid
);
4661 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
4662 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
4663 __put_user(st
.st_size
, &target_st
->st_size
);
4664 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
4665 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
4666 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
4667 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
4668 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
4669 unlock_user_struct(target_st
, arg2
, 1);
4673 #ifdef TARGET_NR_olduname
4674 case TARGET_NR_olduname
:
4677 #ifdef TARGET_NR_iopl
4678 case TARGET_NR_iopl
:
4681 case TARGET_NR_vhangup
:
4682 ret
= get_errno(vhangup());
4684 #ifdef TARGET_NR_idle
4685 case TARGET_NR_idle
:
4688 #ifdef TARGET_NR_syscall
4689 case TARGET_NR_syscall
:
4690 ret
= do_syscall(cpu_env
,arg1
& 0xffff,arg2
,arg3
,arg4
,arg5
,arg6
,0);
4693 case TARGET_NR_wait4
:
4696 abi_long status_ptr
= arg2
;
4697 struct rusage rusage
, *rusage_ptr
;
4698 abi_ulong target_rusage
= arg4
;
4700 rusage_ptr
= &rusage
;
4703 ret
= get_errno(wait4(arg1
, &status
, arg3
, rusage_ptr
));
4704 if (!is_error(ret
)) {
4706 if (put_user_s32(status
, status_ptr
))
4710 host_to_target_rusage(target_rusage
, &rusage
);
4714 #ifdef TARGET_NR_swapoff
4715 case TARGET_NR_swapoff
:
4716 if (!(p
= lock_user_string(arg1
)))
4718 ret
= get_errno(swapoff(p
));
4719 unlock_user(p
, arg1
, 0);
4722 case TARGET_NR_sysinfo
:
4724 struct target_sysinfo
*target_value
;
4725 struct sysinfo value
;
4726 ret
= get_errno(sysinfo(&value
));
4727 if (!is_error(ret
) && arg1
)
4729 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
4731 __put_user(value
.uptime
, &target_value
->uptime
);
4732 __put_user(value
.loads
[0], &target_value
->loads
[0]);
4733 __put_user(value
.loads
[1], &target_value
->loads
[1]);
4734 __put_user(value
.loads
[2], &target_value
->loads
[2]);
4735 __put_user(value
.totalram
, &target_value
->totalram
);
4736 __put_user(value
.freeram
, &target_value
->freeram
);
4737 __put_user(value
.sharedram
, &target_value
->sharedram
);
4738 __put_user(value
.bufferram
, &target_value
->bufferram
);
4739 __put_user(value
.totalswap
, &target_value
->totalswap
);
4740 __put_user(value
.freeswap
, &target_value
->freeswap
);
4741 __put_user(value
.procs
, &target_value
->procs
);
4742 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
4743 __put_user(value
.freehigh
, &target_value
->freehigh
);
4744 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
4745 unlock_user_struct(target_value
, arg1
, 1);
4749 #ifdef TARGET_NR_ipc
4751 ret
= do_ipc(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4754 case TARGET_NR_fsync
:
4755 ret
= get_errno(fsync(arg1
));
4757 case TARGET_NR_clone
:
4758 #if defined(TARGET_SH4)
4759 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
4761 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
4764 #ifdef __NR_exit_group
4765 /* new thread calls */
4766 case TARGET_NR_exit_group
:
4767 gdb_exit(cpu_env
, arg1
);
4768 ret
= get_errno(exit_group(arg1
));
4771 case TARGET_NR_setdomainname
:
4772 if (!(p
= lock_user_string(arg1
)))
4774 ret
= get_errno(setdomainname(p
, arg2
));
4775 unlock_user(p
, arg1
, 0);
4777 case TARGET_NR_uname
:
4778 /* no need to transcode because we use the linux syscall */
4780 struct new_utsname
* buf
;
4782 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
4784 ret
= get_errno(sys_uname(buf
));
4785 if (!is_error(ret
)) {
4786 /* Overrite the native machine name with whatever is being
4788 strcpy (buf
->machine
, UNAME_MACHINE
);
4789 /* Allow the user to override the reported release. */
4790 if (qemu_uname_release
&& *qemu_uname_release
)
4791 strcpy (buf
->release
, qemu_uname_release
);
4793 unlock_user_struct(buf
, arg1
, 1);
4797 case TARGET_NR_modify_ldt
:
4798 ret
= do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
4800 #if !defined(TARGET_X86_64)
4801 case TARGET_NR_vm86old
:
4803 case TARGET_NR_vm86
:
4804 ret
= do_vm86(cpu_env
, arg1
, arg2
);
4808 case TARGET_NR_adjtimex
:
4810 #ifdef TARGET_NR_create_module
4811 case TARGET_NR_create_module
:
4813 case TARGET_NR_init_module
:
4814 case TARGET_NR_delete_module
:
4815 #ifdef TARGET_NR_get_kernel_syms
4816 case TARGET_NR_get_kernel_syms
:
4819 case TARGET_NR_quotactl
:
4821 case TARGET_NR_getpgid
:
4822 ret
= get_errno(getpgid(arg1
));
4824 case TARGET_NR_fchdir
:
4825 ret
= get_errno(fchdir(arg1
));
4827 #ifdef TARGET_NR_bdflush /* not on x86_64 */
4828 case TARGET_NR_bdflush
:
4831 #ifdef TARGET_NR_sysfs
4832 case TARGET_NR_sysfs
:
4835 case TARGET_NR_personality
:
4836 ret
= get_errno(personality(arg1
));
4838 #ifdef TARGET_NR_afs_syscall
4839 case TARGET_NR_afs_syscall
:
4842 #ifdef TARGET_NR__llseek /* Not on alpha */
4843 case TARGET_NR__llseek
:
4845 #if defined (__x86_64__)
4846 ret
= get_errno(lseek(arg1
, ((uint64_t )arg2
<< 32) | arg3
, arg5
));
4847 if (put_user_s64(ret
, arg4
))
4851 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
4852 if (put_user_s64(res
, arg4
))
4858 case TARGET_NR_getdents
:
4859 #if TARGET_ABI_BITS != 32
4861 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4863 struct target_dirent
*target_dirp
;
4864 struct dirent
*dirp
;
4865 abi_long count
= arg3
;
4867 dirp
= malloc(count
);
4869 ret
= -TARGET_ENOMEM
;
4873 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
4874 if (!is_error(ret
)) {
4876 struct target_dirent
*tde
;
4878 int reclen
, treclen
;
4879 int count1
, tnamelen
;
4883 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
4887 reclen
= de
->d_reclen
;
4888 treclen
= reclen
- (2 * (sizeof(long) - sizeof(abi_long
)));
4889 tde
->d_reclen
= tswap16(treclen
);
4890 tde
->d_ino
= tswapl(de
->d_ino
);
4891 tde
->d_off
= tswapl(de
->d_off
);
4892 tnamelen
= treclen
- (2 * sizeof(abi_long
) + 2);
4895 /* XXX: may not be correct */
4896 strncpy(tde
->d_name
, de
->d_name
, tnamelen
);
4897 de
= (struct dirent
*)((char *)de
+ reclen
);
4899 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
4903 unlock_user(target_dirp
, arg2
, ret
);
4909 struct dirent
*dirp
;
4910 abi_long count
= arg3
;
4912 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
4914 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
4915 if (!is_error(ret
)) {
4921 reclen
= de
->d_reclen
;
4924 de
->d_reclen
= tswap16(reclen
);
4925 tswapls(&de
->d_ino
);
4926 tswapls(&de
->d_off
);
4927 de
= (struct dirent
*)((char *)de
+ reclen
);
4931 unlock_user(dirp
, arg2
, ret
);
4935 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
4936 case TARGET_NR_getdents64
:
4938 struct dirent64
*dirp
;
4939 abi_long count
= arg3
;
4940 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
4942 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
4943 if (!is_error(ret
)) {
4944 struct dirent64
*de
;
4949 reclen
= de
->d_reclen
;
4952 de
->d_reclen
= tswap16(reclen
);
4953 tswap64s((uint64_t *)&de
->d_ino
);
4954 tswap64s((uint64_t *)&de
->d_off
);
4955 de
= (struct dirent64
*)((char *)de
+ reclen
);
4959 unlock_user(dirp
, arg2
, ret
);
4962 #endif /* TARGET_NR_getdents64 */
4963 #ifdef TARGET_NR__newselect
4964 case TARGET_NR__newselect
:
4965 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
4968 #ifdef TARGET_NR_poll
4969 case TARGET_NR_poll
:
4971 struct target_pollfd
*target_pfd
;
4972 unsigned int nfds
= arg2
;
4977 target_pfd
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_pollfd
) * nfds
, 1);
4980 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
4981 for(i
= 0; i
< nfds
; i
++) {
4982 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
4983 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
4985 ret
= get_errno(poll(pfd
, nfds
, timeout
));
4986 if (!is_error(ret
)) {
4987 for(i
= 0; i
< nfds
; i
++) {
4988 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
4990 ret
+= nfds
* (sizeof(struct target_pollfd
)
4991 - sizeof(struct pollfd
));
4993 unlock_user(target_pfd
, arg1
, ret
);
4997 case TARGET_NR_flock
:
4998 /* NOTE: the flock constant seems to be the same for every
5000 ret
= get_errno(flock(arg1
, arg2
));
5002 case TARGET_NR_readv
:
5007 vec
= alloca(count
* sizeof(struct iovec
));
5008 if (lock_iovec(VERIFY_WRITE
, vec
, arg2
, count
, 0) < 0)
5010 ret
= get_errno(readv(arg1
, vec
, count
));
5011 unlock_iovec(vec
, arg2
, count
, 1);
5014 case TARGET_NR_writev
:
5019 vec
= alloca(count
* sizeof(struct iovec
));
5020 if (lock_iovec(VERIFY_READ
, vec
, arg2
, count
, 1) < 0)
5022 ret
= get_errno(writev(arg1
, vec
, count
));
5023 unlock_iovec(vec
, arg2
, count
, 0);
5026 case TARGET_NR_getsid
:
5027 ret
= get_errno(getsid(arg1
));
5029 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
5030 case TARGET_NR_fdatasync
:
5031 ret
= get_errno(fdatasync(arg1
));
5034 case TARGET_NR__sysctl
:
5035 /* We don't implement this, but ENOTDIR is always a safe
5037 ret
= -TARGET_ENOTDIR
;
5039 case TARGET_NR_sched_setparam
:
5041 struct sched_param
*target_schp
;
5042 struct sched_param schp
;
5044 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
5046 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
5047 unlock_user_struct(target_schp
, arg2
, 0);
5048 ret
= get_errno(sched_setparam(arg1
, &schp
));
5051 case TARGET_NR_sched_getparam
:
5053 struct sched_param
*target_schp
;
5054 struct sched_param schp
;
5055 ret
= get_errno(sched_getparam(arg1
, &schp
));
5056 if (!is_error(ret
)) {
5057 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
5059 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
5060 unlock_user_struct(target_schp
, arg2
, 1);
5064 case TARGET_NR_sched_setscheduler
:
5066 struct sched_param
*target_schp
;
5067 struct sched_param schp
;
5068 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
5070 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
5071 unlock_user_struct(target_schp
, arg3
, 0);
5072 ret
= get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
5075 case TARGET_NR_sched_getscheduler
:
5076 ret
= get_errno(sched_getscheduler(arg1
));
5078 case TARGET_NR_sched_yield
:
5079 ret
= get_errno(sched_yield());
5081 case TARGET_NR_sched_get_priority_max
:
5082 ret
= get_errno(sched_get_priority_max(arg1
));
5084 case TARGET_NR_sched_get_priority_min
:
5085 ret
= get_errno(sched_get_priority_min(arg1
));
5087 case TARGET_NR_sched_rr_get_interval
:
5090 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
5091 if (!is_error(ret
)) {
5092 host_to_target_timespec(arg2
, &ts
);
5096 case TARGET_NR_nanosleep
:
5098 struct timespec req
, rem
;
5099 target_to_host_timespec(&req
, arg1
);
5100 ret
= get_errno(nanosleep(&req
, &rem
));
5101 if (is_error(ret
) && arg2
) {
5102 host_to_target_timespec(arg2
, &rem
);
5106 #ifdef TARGET_NR_query_module
5107 case TARGET_NR_query_module
:
5110 #ifdef TARGET_NR_nfsservctl
5111 case TARGET_NR_nfsservctl
:
5114 case TARGET_NR_prctl
:
5117 case PR_GET_PDEATHSIG
:
5120 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
5121 if (!is_error(ret
) && arg2
5122 && put_user_ual(deathsig
, arg2
))
5127 ret
= get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
5131 #ifdef TARGET_NR_arch_prctl
5132 case TARGET_NR_arch_prctl
:
5133 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5134 ret
= do_arch_prctl(cpu_env
, arg1
, arg2
);
5140 #ifdef TARGET_NR_pread
5141 case TARGET_NR_pread
:
5143 if (((CPUARMState
*)cpu_env
)->eabi
)
5146 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
5148 ret
= get_errno(pread(arg1
, p
, arg3
, arg4
));
5149 unlock_user(p
, arg2
, ret
);
5151 case TARGET_NR_pwrite
:
5153 if (((CPUARMState
*)cpu_env
)->eabi
)
5156 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
5158 ret
= get_errno(pwrite(arg1
, p
, arg3
, arg4
));
5159 unlock_user(p
, arg2
, 0);
5162 #ifdef TARGET_NR_pread64
5163 case TARGET_NR_pread64
:
5164 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
5166 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
5167 unlock_user(p
, arg2
, ret
);
5169 case TARGET_NR_pwrite64
:
5170 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
5172 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
5173 unlock_user(p
, arg2
, 0);
5176 case TARGET_NR_getcwd
:
5177 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
5179 ret
= get_errno(sys_getcwd1(p
, arg2
));
5180 unlock_user(p
, arg1
, ret
);
5182 case TARGET_NR_capget
:
5184 case TARGET_NR_capset
:
5186 case TARGET_NR_sigaltstack
:
5187 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5188 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
5189 ret
= do_sigaltstack(arg1
, arg2
, get_sp_from_cpustate((CPUState
*)cpu_env
));
5194 case TARGET_NR_sendfile
:
5196 #ifdef TARGET_NR_getpmsg
5197 case TARGET_NR_getpmsg
:
5200 #ifdef TARGET_NR_putpmsg
5201 case TARGET_NR_putpmsg
:
5204 #ifdef TARGET_NR_vfork
5205 case TARGET_NR_vfork
:
5206 ret
= get_errno(do_fork(cpu_env
, CLONE_VFORK
| CLONE_VM
| SIGCHLD
,
5210 #ifdef TARGET_NR_ugetrlimit
5211 case TARGET_NR_ugetrlimit
:
5214 ret
= get_errno(getrlimit(arg1
, &rlim
));
5215 if (!is_error(ret
)) {
5216 struct target_rlimit
*target_rlim
;
5217 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
5219 target_rlim
->rlim_cur
= tswapl(rlim
.rlim_cur
);
5220 target_rlim
->rlim_max
= tswapl(rlim
.rlim_max
);
5221 unlock_user_struct(target_rlim
, arg2
, 1);
5226 #ifdef TARGET_NR_truncate64
5227 case TARGET_NR_truncate64
:
5228 if (!(p
= lock_user_string(arg1
)))
5230 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
5231 unlock_user(p
, arg1
, 0);
5234 #ifdef TARGET_NR_ftruncate64
5235 case TARGET_NR_ftruncate64
:
5236 ret
= target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
5239 #ifdef TARGET_NR_stat64
5240 case TARGET_NR_stat64
:
5241 if (!(p
= lock_user_string(arg1
)))
5243 ret
= get_errno(stat(path(p
), &st
));
5244 unlock_user(p
, arg1
, 0);
5246 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5249 #ifdef TARGET_NR_lstat64
5250 case TARGET_NR_lstat64
:
5251 if (!(p
= lock_user_string(arg1
)))
5253 ret
= get_errno(lstat(path(p
), &st
));
5254 unlock_user(p
, arg1
, 0);
5256 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5259 #ifdef TARGET_NR_fstat64
5260 case TARGET_NR_fstat64
:
5261 ret
= get_errno(fstat(arg1
, &st
));
5263 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5266 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
5267 case TARGET_NR_fstatat64
:
5268 if (!(p
= lock_user_string(arg2
)))
5270 ret
= get_errno(sys_fstatat64(arg1
, path(p
), &st
, arg4
));
5272 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
5276 case TARGET_NR_lchown
:
5277 if (!(p
= lock_user_string(arg1
)))
5279 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
5280 unlock_user(p
, arg1
, 0);
5282 case TARGET_NR_getuid
:
5283 ret
= get_errno(high2lowuid(getuid()));
5285 case TARGET_NR_getgid
:
5286 ret
= get_errno(high2lowgid(getgid()));
5288 case TARGET_NR_geteuid
:
5289 ret
= get_errno(high2lowuid(geteuid()));
5291 case TARGET_NR_getegid
:
5292 ret
= get_errno(high2lowgid(getegid()));
5294 case TARGET_NR_setreuid
:
5295 ret
= get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
5297 case TARGET_NR_setregid
:
5298 ret
= get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
5300 case TARGET_NR_getgroups
:
5302 int gidsetsize
= arg1
;
5303 uint16_t *target_grouplist
;
5307 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5308 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
5309 if (gidsetsize
== 0)
5311 if (!is_error(ret
)) {
5312 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 2, 0);
5313 if (!target_grouplist
)
5315 for(i
= 0;i
< ret
; i
++)
5316 target_grouplist
[i
] = tswap16(grouplist
[i
]);
5317 unlock_user(target_grouplist
, arg2
, gidsetsize
* 2);
5321 case TARGET_NR_setgroups
:
5323 int gidsetsize
= arg1
;
5324 uint16_t *target_grouplist
;
5328 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5329 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 2, 1);
5330 if (!target_grouplist
) {
5331 ret
= -TARGET_EFAULT
;
5334 for(i
= 0;i
< gidsetsize
; i
++)
5335 grouplist
[i
] = tswap16(target_grouplist
[i
]);
5336 unlock_user(target_grouplist
, arg2
, 0);
5337 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
5340 case TARGET_NR_fchown
:
5341 ret
= get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
5343 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5344 case TARGET_NR_fchownat
:
5345 if (!(p
= lock_user_string(arg2
)))
5347 ret
= get_errno(sys_fchownat(arg1
, p
, low2highuid(arg3
), low2highgid(arg4
), arg5
));
5348 unlock_user(p
, arg2
, 0);
5351 #ifdef TARGET_NR_setresuid
5352 case TARGET_NR_setresuid
:
5353 ret
= get_errno(setresuid(low2highuid(arg1
),
5355 low2highuid(arg3
)));
5358 #ifdef TARGET_NR_getresuid
5359 case TARGET_NR_getresuid
:
5361 uid_t ruid
, euid
, suid
;
5362 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
5363 if (!is_error(ret
)) {
5364 if (put_user_u16(high2lowuid(ruid
), arg1
)
5365 || put_user_u16(high2lowuid(euid
), arg2
)
5366 || put_user_u16(high2lowuid(suid
), arg3
))
5372 #ifdef TARGET_NR_getresgid
5373 case TARGET_NR_setresgid
:
5374 ret
= get_errno(setresgid(low2highgid(arg1
),
5376 low2highgid(arg3
)));
5379 #ifdef TARGET_NR_getresgid
5380 case TARGET_NR_getresgid
:
5382 gid_t rgid
, egid
, sgid
;
5383 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
5384 if (!is_error(ret
)) {
5385 if (put_user_u16(high2lowgid(rgid
), arg1
)
5386 || put_user_u16(high2lowgid(egid
), arg2
)
5387 || put_user_u16(high2lowgid(sgid
), arg3
))
5393 case TARGET_NR_chown
:
5394 if (!(p
= lock_user_string(arg1
)))
5396 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
5397 unlock_user(p
, arg1
, 0);
5399 case TARGET_NR_setuid
:
5400 ret
= get_errno(setuid(low2highuid(arg1
)));
5402 case TARGET_NR_setgid
:
5403 ret
= get_errno(setgid(low2highgid(arg1
)));
5405 case TARGET_NR_setfsuid
:
5406 ret
= get_errno(setfsuid(arg1
));
5408 case TARGET_NR_setfsgid
:
5409 ret
= get_errno(setfsgid(arg1
));
5411 #endif /* USE_UID16 */
5413 #ifdef TARGET_NR_lchown32
5414 case TARGET_NR_lchown32
:
5415 if (!(p
= lock_user_string(arg1
)))
5417 ret
= get_errno(lchown(p
, arg2
, arg3
));
5418 unlock_user(p
, arg1
, 0);
5421 #ifdef TARGET_NR_getuid32
5422 case TARGET_NR_getuid32
:
5423 ret
= get_errno(getuid());
5426 #ifdef TARGET_NR_getgid32
5427 case TARGET_NR_getgid32
:
5428 ret
= get_errno(getgid());
5431 #ifdef TARGET_NR_geteuid32
5432 case TARGET_NR_geteuid32
:
5433 ret
= get_errno(geteuid());
5436 #ifdef TARGET_NR_getegid32
5437 case TARGET_NR_getegid32
:
5438 ret
= get_errno(getegid());
5441 #ifdef TARGET_NR_setreuid32
5442 case TARGET_NR_setreuid32
:
5443 ret
= get_errno(setreuid(arg1
, arg2
));
5446 #ifdef TARGET_NR_setregid32
5447 case TARGET_NR_setregid32
:
5448 ret
= get_errno(setregid(arg1
, arg2
));
5451 #ifdef TARGET_NR_getgroups32
5452 case TARGET_NR_getgroups32
:
5454 int gidsetsize
= arg1
;
5455 uint32_t *target_grouplist
;
5459 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5460 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
5461 if (gidsetsize
== 0)
5463 if (!is_error(ret
)) {
5464 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
5465 if (!target_grouplist
) {
5466 ret
= -TARGET_EFAULT
;
5469 for(i
= 0;i
< ret
; i
++)
5470 target_grouplist
[i
] = tswap32(grouplist
[i
]);
5471 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
5476 #ifdef TARGET_NR_setgroups32
5477 case TARGET_NR_setgroups32
:
5479 int gidsetsize
= arg1
;
5480 uint32_t *target_grouplist
;
5484 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5485 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
5486 if (!target_grouplist
) {
5487 ret
= -TARGET_EFAULT
;
5490 for(i
= 0;i
< gidsetsize
; i
++)
5491 grouplist
[i
] = tswap32(target_grouplist
[i
]);
5492 unlock_user(target_grouplist
, arg2
, 0);
5493 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
5497 #ifdef TARGET_NR_fchown32
5498 case TARGET_NR_fchown32
:
5499 ret
= get_errno(fchown(arg1
, arg2
, arg3
));
5502 #ifdef TARGET_NR_setresuid32
5503 case TARGET_NR_setresuid32
:
5504 ret
= get_errno(setresuid(arg1
, arg2
, arg3
));
5507 #ifdef TARGET_NR_getresuid32
5508 case TARGET_NR_getresuid32
:
5510 uid_t ruid
, euid
, suid
;
5511 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
5512 if (!is_error(ret
)) {
5513 if (put_user_u32(ruid
, arg1
)
5514 || put_user_u32(euid
, arg2
)
5515 || put_user_u32(suid
, arg3
))
5521 #ifdef TARGET_NR_setresgid32
5522 case TARGET_NR_setresgid32
:
5523 ret
= get_errno(setresgid(arg1
, arg2
, arg3
));
5526 #ifdef TARGET_NR_getresgid32
5527 case TARGET_NR_getresgid32
:
5529 gid_t rgid
, egid
, sgid
;
5530 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
5531 if (!is_error(ret
)) {
5532 if (put_user_u32(rgid
, arg1
)
5533 || put_user_u32(egid
, arg2
)
5534 || put_user_u32(sgid
, arg3
))
5540 #ifdef TARGET_NR_chown32
5541 case TARGET_NR_chown32
:
5542 if (!(p
= lock_user_string(arg1
)))
5544 ret
= get_errno(chown(p
, arg2
, arg3
));
5545 unlock_user(p
, arg1
, 0);
5548 #ifdef TARGET_NR_setuid32
5549 case TARGET_NR_setuid32
:
5550 ret
= get_errno(setuid(arg1
));
5553 #ifdef TARGET_NR_setgid32
5554 case TARGET_NR_setgid32
:
5555 ret
= get_errno(setgid(arg1
));
5558 #ifdef TARGET_NR_setfsuid32
5559 case TARGET_NR_setfsuid32
:
5560 ret
= get_errno(setfsuid(arg1
));
5563 #ifdef TARGET_NR_setfsgid32
5564 case TARGET_NR_setfsgid32
:
5565 ret
= get_errno(setfsgid(arg1
));
5569 case TARGET_NR_pivot_root
:
5571 #ifdef TARGET_NR_mincore
5572 case TARGET_NR_mincore
:
5575 #ifdef TARGET_NR_madvise
5576 case TARGET_NR_madvise
:
5577 /* A straight passthrough may not be safe because qemu sometimes
5578 turns private flie-backed mappings into anonymous mappings.
5579 This will break MADV_DONTNEED.
5580 This is a hint, so ignoring and returning success is ok. */
5584 #if TARGET_ABI_BITS == 32
5585 case TARGET_NR_fcntl64
:
5589 struct target_flock64
*target_fl
;
5591 struct target_eabi_flock64
*target_efl
;
5595 case TARGET_F_GETLK64
:
5598 case TARGET_F_SETLK64
:
5601 case TARGET_F_SETLKW64
:
5610 case TARGET_F_GETLK64
:
5612 if (((CPUARMState
*)cpu_env
)->eabi
) {
5613 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
5615 fl
.l_type
= tswap16(target_efl
->l_type
);
5616 fl
.l_whence
= tswap16(target_efl
->l_whence
);
5617 fl
.l_start
= tswap64(target_efl
->l_start
);
5618 fl
.l_len
= tswap64(target_efl
->l_len
);
5619 fl
.l_pid
= tswapl(target_efl
->l_pid
);
5620 unlock_user_struct(target_efl
, arg3
, 0);
5624 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
5626 fl
.l_type
= tswap16(target_fl
->l_type
);
5627 fl
.l_whence
= tswap16(target_fl
->l_whence
);
5628 fl
.l_start
= tswap64(target_fl
->l_start
);
5629 fl
.l_len
= tswap64(target_fl
->l_len
);
5630 fl
.l_pid
= tswapl(target_fl
->l_pid
);
5631 unlock_user_struct(target_fl
, arg3
, 0);
5633 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
5636 if (((CPUARMState
*)cpu_env
)->eabi
) {
5637 if (!lock_user_struct(VERIFY_WRITE
, target_efl
, arg3
, 0))
5639 target_efl
->l_type
= tswap16(fl
.l_type
);
5640 target_efl
->l_whence
= tswap16(fl
.l_whence
);
5641 target_efl
->l_start
= tswap64(fl
.l_start
);
5642 target_efl
->l_len
= tswap64(fl
.l_len
);
5643 target_efl
->l_pid
= tswapl(fl
.l_pid
);
5644 unlock_user_struct(target_efl
, arg3
, 1);
5648 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg3
, 0))
5650 target_fl
->l_type
= tswap16(fl
.l_type
);
5651 target_fl
->l_whence
= tswap16(fl
.l_whence
);
5652 target_fl
->l_start
= tswap64(fl
.l_start
);
5653 target_fl
->l_len
= tswap64(fl
.l_len
);
5654 target_fl
->l_pid
= tswapl(fl
.l_pid
);
5655 unlock_user_struct(target_fl
, arg3
, 1);
5660 case TARGET_F_SETLK64
:
5661 case TARGET_F_SETLKW64
:
5663 if (((CPUARMState
*)cpu_env
)->eabi
) {
5664 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
5666 fl
.l_type
= tswap16(target_efl
->l_type
);
5667 fl
.l_whence
= tswap16(target_efl
->l_whence
);
5668 fl
.l_start
= tswap64(target_efl
->l_start
);
5669 fl
.l_len
= tswap64(target_efl
->l_len
);
5670 fl
.l_pid
= tswapl(target_efl
->l_pid
);
5671 unlock_user_struct(target_efl
, arg3
, 0);
5675 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
5677 fl
.l_type
= tswap16(target_fl
->l_type
);
5678 fl
.l_whence
= tswap16(target_fl
->l_whence
);
5679 fl
.l_start
= tswap64(target_fl
->l_start
);
5680 fl
.l_len
= tswap64(target_fl
->l_len
);
5681 fl
.l_pid
= tswapl(target_fl
->l_pid
);
5682 unlock_user_struct(target_fl
, arg3
, 0);
5684 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
5687 ret
= do_fcntl(arg1
, cmd
, arg3
);
5693 #ifdef TARGET_NR_cacheflush
5694 case TARGET_NR_cacheflush
:
5695 /* self-modifying code is handled automatically, so nothing needed */
5699 #ifdef TARGET_NR_security
5700 case TARGET_NR_security
:
5703 #ifdef TARGET_NR_getpagesize
5704 case TARGET_NR_getpagesize
:
5705 ret
= TARGET_PAGE_SIZE
;
5708 case TARGET_NR_gettid
:
5709 ret
= get_errno(gettid());
5711 #ifdef TARGET_NR_readahead
5712 case TARGET_NR_readahead
:
5715 #ifdef TARGET_NR_setxattr
5716 case TARGET_NR_setxattr
:
5717 case TARGET_NR_lsetxattr
:
5718 case TARGET_NR_fsetxattr
:
5719 case TARGET_NR_getxattr
:
5720 case TARGET_NR_lgetxattr
:
5721 case TARGET_NR_fgetxattr
:
5722 case TARGET_NR_listxattr
:
5723 case TARGET_NR_llistxattr
:
5724 case TARGET_NR_flistxattr
:
5725 case TARGET_NR_removexattr
:
5726 case TARGET_NR_lremovexattr
:
5727 case TARGET_NR_fremovexattr
:
5728 goto unimplemented_nowarn
;
5730 #ifdef TARGET_NR_set_thread_area
5731 case TARGET_NR_set_thread_area
:
5732 #if defined(TARGET_MIPS)
5733 ((CPUMIPSState
*) cpu_env
)->tls_value
= arg1
;
5736 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
5737 ret
= do_set_thread_area(cpu_env
, arg1
);
5740 goto unimplemented_nowarn
;
5743 #ifdef TARGET_NR_get_thread_area
5744 case TARGET_NR_get_thread_area
:
5745 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5746 ret
= do_get_thread_area(cpu_env
, arg1
);
5748 goto unimplemented_nowarn
;
5751 #ifdef TARGET_NR_getdomainname
5752 case TARGET_NR_getdomainname
:
5753 goto unimplemented_nowarn
;
5756 #ifdef TARGET_NR_clock_gettime
5757 case TARGET_NR_clock_gettime
:
5760 ret
= get_errno(clock_gettime(arg1
, &ts
));
5761 if (!is_error(ret
)) {
5762 host_to_target_timespec(arg2
, &ts
);
5767 #ifdef TARGET_NR_clock_getres
5768 case TARGET_NR_clock_getres
:
5771 ret
= get_errno(clock_getres(arg1
, &ts
));
5772 if (!is_error(ret
)) {
5773 host_to_target_timespec(arg2
, &ts
);
5778 #ifdef TARGET_NR_clock_nanosleep
5779 case TARGET_NR_clock_nanosleep
:
5782 target_to_host_timespec(&ts
, arg3
);
5783 ret
= get_errno(clock_nanosleep(arg1
, arg2
, &ts
, arg4
? &ts
: NULL
));
5785 host_to_target_timespec(arg4
, &ts
);
5790 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5791 case TARGET_NR_set_tid_address
:
5792 ret
= get_errno(set_tid_address((int *)g2h(arg1
)));
5796 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
5797 case TARGET_NR_tkill
:
5798 ret
= get_errno(sys_tkill((int)arg1
, target_to_host_signal(arg2
)));
5802 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
5803 case TARGET_NR_tgkill
:
5804 ret
= get_errno(sys_tgkill((int)arg1
, (int)arg2
,
5805 target_to_host_signal(arg3
)));
5809 #ifdef TARGET_NR_set_robust_list
5810 case TARGET_NR_set_robust_list
:
5811 goto unimplemented_nowarn
;
5814 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5815 case TARGET_NR_utimensat
:
5817 struct timespec ts
[2];
5818 target_to_host_timespec(ts
, arg3
);
5819 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
5821 ret
= get_errno(sys_utimensat(arg1
, NULL
, ts
, arg4
));
5823 if (!(p
= lock_user_string(arg2
))) {
5824 ret
= -TARGET_EFAULT
;
5827 ret
= get_errno(sys_utimensat(arg1
, path(p
), ts
, arg4
));
5828 unlock_user(p
, arg2
, 0);
5833 #if defined(USE_NPTL)
5834 case TARGET_NR_futex
:
5835 ret
= do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
5841 gemu_log("qemu: Unsupported syscall: %d\n", num
);
5842 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
5843 unimplemented_nowarn
:
5845 ret
= -TARGET_ENOSYS
;
5850 gemu_log(" = %ld\n", ret
);
5853 print_syscall_ret(num
, ret
);
5856 ret
= -TARGET_EFAULT
;