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.
31 #include <sys/types.h>
37 #include <sys/mount.h>
38 #include <sys/prctl.h>
39 #include <sys/resource.h>
44 #include <sys/socket.h>
47 #include <sys/times.h>
50 #include <sys/statfs.h>
52 #include <sys/sysinfo.h>
53 //#include <sys/user.h>
54 #include <netinet/ip.h>
55 #include <netinet/tcp.h>
56 #include <qemu-common.h>
58 #define termios host_termios
59 #define winsize host_winsize
60 #define termio host_termio
61 #define sgttyb host_sgttyb /* same as target */
62 #define tchars host_tchars /* same as target */
63 #define ltchars host_ltchars /* same as target */
65 #include <linux/termios.h>
66 #include <linux/unistd.h>
67 #include <linux/utsname.h>
68 #include <linux/cdrom.h>
69 #include <linux/hdreg.h>
70 #include <linux/soundcard.h>
72 #include <linux/mtio.h>
73 #include "linux_loop.h"
76 #include "qemu-common.h"
79 #include <linux/futex.h>
80 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
81 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
83 /* XXX: Hardcode the above values. */
84 #define CLONE_NPTL_FLAGS2 0
89 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
90 || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
91 /* 16 bit uid wrappers emulation */
95 //#include <linux/msdos_fs.h>
96 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
97 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
108 #define _syscall0(type,name) \
109 static type name (void) \
111 return syscall(__NR_##name); \
114 #define _syscall1(type,name,type1,arg1) \
115 static type name (type1 arg1) \
117 return syscall(__NR_##name, arg1); \
120 #define _syscall2(type,name,type1,arg1,type2,arg2) \
121 static type name (type1 arg1,type2 arg2) \
123 return syscall(__NR_##name, arg1, arg2); \
126 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
127 static type name (type1 arg1,type2 arg2,type3 arg3) \
129 return syscall(__NR_##name, arg1, arg2, arg3); \
132 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
133 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
135 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
138 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
140 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
142 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
146 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
147 type5,arg5,type6,arg6) \
148 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
151 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
155 #define __NR_sys_uname __NR_uname
156 #define __NR_sys_faccessat __NR_faccessat
157 #define __NR_sys_fchmodat __NR_fchmodat
158 #define __NR_sys_fchownat __NR_fchownat
159 #define __NR_sys_fstatat64 __NR_fstatat64
160 #define __NR_sys_futimesat __NR_futimesat
161 #define __NR_sys_getcwd1 __NR_getcwd
162 #define __NR_sys_getdents __NR_getdents
163 #define __NR_sys_getdents64 __NR_getdents64
164 #define __NR_sys_getpriority __NR_getpriority
165 #define __NR_sys_linkat __NR_linkat
166 #define __NR_sys_mkdirat __NR_mkdirat
167 #define __NR_sys_mknodat __NR_mknodat
168 #define __NR_sys_openat __NR_openat
169 #define __NR_sys_readlinkat __NR_readlinkat
170 #define __NR_sys_renameat __NR_renameat
171 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
172 #define __NR_sys_symlinkat __NR_symlinkat
173 #define __NR_sys_syslog __NR_syslog
174 #define __NR_sys_tgkill __NR_tgkill
175 #define __NR_sys_tkill __NR_tkill
176 #define __NR_sys_unlinkat __NR_unlinkat
177 #define __NR_sys_utimensat __NR_utimensat
178 #define __NR_sys_futex __NR_futex
179 #define __NR_sys_inotify_init __NR_inotify_init
180 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
181 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
183 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
184 #define __NR__llseek __NR_lseek
188 _syscall0(int, gettid
)
190 /* This is a replacement for the host gettid() and must return a host
192 static int gettid(void) {
196 _syscall1(int,sys_uname
,struct new_utsname
*,buf
)
197 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
198 _syscall4(int,sys_faccessat
,int,dirfd
,const char *,pathname
,int,mode
,int,flags
)
200 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
201 _syscall4(int,sys_fchmodat
,int,dirfd
,const char *,pathname
,
202 mode_t
,mode
,int,flags
)
204 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16)
205 _syscall5(int,sys_fchownat
,int,dirfd
,const char *,pathname
,
206 uid_t
,owner
,gid_t
,group
,int,flags
)
208 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
209 _syscall4(int,sys_fstatat64
,int,dirfd
,const char *,pathname
,
210 struct stat
*,buf
,int,flags
)
212 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
213 _syscall3(int,sys_futimesat
,int,dirfd
,const char *,pathname
,
214 const struct timeval
*,times
)
216 _syscall2(int,sys_getcwd1
,char *,buf
,size_t,size
)
217 #if TARGET_ABI_BITS == 32
218 _syscall3(int, sys_getdents
, uint
, fd
, struct linux_dirent
*, dirp
, uint
, count
);
220 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
221 _syscall3(int, sys_getdents64
, uint
, fd
, struct linux_dirent64
*, dirp
, uint
, count
);
223 _syscall2(int, sys_getpriority
, int, which
, int, who
);
224 #if !defined (__x86_64__)
225 _syscall5(int, _llseek
, uint
, fd
, ulong
, hi
, ulong
, lo
,
226 loff_t
*, res
, uint
, wh
);
228 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
229 _syscall5(int,sys_linkat
,int,olddirfd
,const char *,oldpath
,
230 int,newdirfd
,const char *,newpath
,int,flags
)
232 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
233 _syscall3(int,sys_mkdirat
,int,dirfd
,const char *,pathname
,mode_t
,mode
)
235 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
236 _syscall4(int,sys_mknodat
,int,dirfd
,const char *,pathname
,
237 mode_t
,mode
,dev_t
,dev
)
239 #if defined(TARGET_NR_openat) && defined(__NR_openat)
240 _syscall4(int,sys_openat
,int,dirfd
,const char *,pathname
,int,flags
,mode_t
,mode
)
242 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
243 _syscall4(int,sys_readlinkat
,int,dirfd
,const char *,pathname
,
244 char *,buf
,size_t,bufsize
)
246 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
247 _syscall4(int,sys_renameat
,int,olddirfd
,const char *,oldpath
,
248 int,newdirfd
,const char *,newpath
)
250 _syscall3(int,sys_rt_sigqueueinfo
,int,pid
,int,sig
,siginfo_t
*,uinfo
)
251 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
252 _syscall3(int,sys_symlinkat
,const char *,oldpath
,
253 int,newdirfd
,const char *,newpath
)
255 _syscall3(int,sys_syslog
,int,type
,char*,bufp
,int,len
)
256 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
257 _syscall3(int,sys_tgkill
,int,tgid
,int,pid
,int,sig
)
259 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
260 _syscall2(int,sys_tkill
,int,tid
,int,sig
)
262 #ifdef __NR_exit_group
263 _syscall1(int,exit_group
,int,error_code
)
265 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
266 _syscall1(int,set_tid_address
,int *,tidptr
)
268 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
269 _syscall3(int,sys_unlinkat
,int,dirfd
,const char *,pathname
,int,flags
)
271 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
272 _syscall4(int,sys_utimensat
,int,dirfd
,const char *,pathname
,
273 const struct timespec
*,tsp
,int,flags
)
275 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
276 _syscall0(int,sys_inotify_init
)
278 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
279 _syscall3(int,sys_inotify_add_watch
,int,fd
,const char *,pathname
,uint32_t,mask
)
281 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
282 _syscall2(int,sys_inotify_rm_watch
,int,fd
,uint32_t,wd
)
284 #if defined(USE_NPTL)
285 #if defined(TARGET_NR_futex) && defined(__NR_futex)
286 _syscall6(int,sys_futex
,int *,uaddr
,int,op
,int,val
,
287 const struct timespec
*,timeout
,int *,uaddr2
,int,val3
)
291 extern int personality(int);
292 extern int flock(int, int);
293 extern int setfsuid(int);
294 extern int setfsgid(int);
295 extern int setgroups(int, gid_t
*);
297 #define ERRNO_TABLE_SIZE 1200
299 /* target_to_host_errno_table[] is initialized from
300 * host_to_target_errno_table[] in syscall_init(). */
301 static uint16_t target_to_host_errno_table
[ERRNO_TABLE_SIZE
] = {
305 * This list is the union of errno values overridden in asm-<arch>/errno.h
306 * minus the errnos that are not actually generic to all archs.
308 static uint16_t host_to_target_errno_table
[ERRNO_TABLE_SIZE
] = {
309 [EIDRM
] = TARGET_EIDRM
,
310 [ECHRNG
] = TARGET_ECHRNG
,
311 [EL2NSYNC
] = TARGET_EL2NSYNC
,
312 [EL3HLT
] = TARGET_EL3HLT
,
313 [EL3RST
] = TARGET_EL3RST
,
314 [ELNRNG
] = TARGET_ELNRNG
,
315 [EUNATCH
] = TARGET_EUNATCH
,
316 [ENOCSI
] = TARGET_ENOCSI
,
317 [EL2HLT
] = TARGET_EL2HLT
,
318 [EDEADLK
] = TARGET_EDEADLK
,
319 [ENOLCK
] = TARGET_ENOLCK
,
320 [EBADE
] = TARGET_EBADE
,
321 [EBADR
] = TARGET_EBADR
,
322 [EXFULL
] = TARGET_EXFULL
,
323 [ENOANO
] = TARGET_ENOANO
,
324 [EBADRQC
] = TARGET_EBADRQC
,
325 [EBADSLT
] = TARGET_EBADSLT
,
326 [EBFONT
] = TARGET_EBFONT
,
327 [ENOSTR
] = TARGET_ENOSTR
,
328 [ENODATA
] = TARGET_ENODATA
,
329 [ETIME
] = TARGET_ETIME
,
330 [ENOSR
] = TARGET_ENOSR
,
331 [ENONET
] = TARGET_ENONET
,
332 [ENOPKG
] = TARGET_ENOPKG
,
333 [EREMOTE
] = TARGET_EREMOTE
,
334 [ENOLINK
] = TARGET_ENOLINK
,
335 [EADV
] = TARGET_EADV
,
336 [ESRMNT
] = TARGET_ESRMNT
,
337 [ECOMM
] = TARGET_ECOMM
,
338 [EPROTO
] = TARGET_EPROTO
,
339 [EDOTDOT
] = TARGET_EDOTDOT
,
340 [EMULTIHOP
] = TARGET_EMULTIHOP
,
341 [EBADMSG
] = TARGET_EBADMSG
,
342 [ENAMETOOLONG
] = TARGET_ENAMETOOLONG
,
343 [EOVERFLOW
] = TARGET_EOVERFLOW
,
344 [ENOTUNIQ
] = TARGET_ENOTUNIQ
,
345 [EBADFD
] = TARGET_EBADFD
,
346 [EREMCHG
] = TARGET_EREMCHG
,
347 [ELIBACC
] = TARGET_ELIBACC
,
348 [ELIBBAD
] = TARGET_ELIBBAD
,
349 [ELIBSCN
] = TARGET_ELIBSCN
,
350 [ELIBMAX
] = TARGET_ELIBMAX
,
351 [ELIBEXEC
] = TARGET_ELIBEXEC
,
352 [EILSEQ
] = TARGET_EILSEQ
,
353 [ENOSYS
] = TARGET_ENOSYS
,
354 [ELOOP
] = TARGET_ELOOP
,
355 [ERESTART
] = TARGET_ERESTART
,
356 [ESTRPIPE
] = TARGET_ESTRPIPE
,
357 [ENOTEMPTY
] = TARGET_ENOTEMPTY
,
358 [EUSERS
] = TARGET_EUSERS
,
359 [ENOTSOCK
] = TARGET_ENOTSOCK
,
360 [EDESTADDRREQ
] = TARGET_EDESTADDRREQ
,
361 [EMSGSIZE
] = TARGET_EMSGSIZE
,
362 [EPROTOTYPE
] = TARGET_EPROTOTYPE
,
363 [ENOPROTOOPT
] = TARGET_ENOPROTOOPT
,
364 [EPROTONOSUPPORT
] = TARGET_EPROTONOSUPPORT
,
365 [ESOCKTNOSUPPORT
] = TARGET_ESOCKTNOSUPPORT
,
366 [EOPNOTSUPP
] = TARGET_EOPNOTSUPP
,
367 [EPFNOSUPPORT
] = TARGET_EPFNOSUPPORT
,
368 [EAFNOSUPPORT
] = TARGET_EAFNOSUPPORT
,
369 [EADDRINUSE
] = TARGET_EADDRINUSE
,
370 [EADDRNOTAVAIL
] = TARGET_EADDRNOTAVAIL
,
371 [ENETDOWN
] = TARGET_ENETDOWN
,
372 [ENETUNREACH
] = TARGET_ENETUNREACH
,
373 [ENETRESET
] = TARGET_ENETRESET
,
374 [ECONNABORTED
] = TARGET_ECONNABORTED
,
375 [ECONNRESET
] = TARGET_ECONNRESET
,
376 [ENOBUFS
] = TARGET_ENOBUFS
,
377 [EISCONN
] = TARGET_EISCONN
,
378 [ENOTCONN
] = TARGET_ENOTCONN
,
379 [EUCLEAN
] = TARGET_EUCLEAN
,
380 [ENOTNAM
] = TARGET_ENOTNAM
,
381 [ENAVAIL
] = TARGET_ENAVAIL
,
382 [EISNAM
] = TARGET_EISNAM
,
383 [EREMOTEIO
] = TARGET_EREMOTEIO
,
384 [ESHUTDOWN
] = TARGET_ESHUTDOWN
,
385 [ETOOMANYREFS
] = TARGET_ETOOMANYREFS
,
386 [ETIMEDOUT
] = TARGET_ETIMEDOUT
,
387 [ECONNREFUSED
] = TARGET_ECONNREFUSED
,
388 [EHOSTDOWN
] = TARGET_EHOSTDOWN
,
389 [EHOSTUNREACH
] = TARGET_EHOSTUNREACH
,
390 [EALREADY
] = TARGET_EALREADY
,
391 [EINPROGRESS
] = TARGET_EINPROGRESS
,
392 [ESTALE
] = TARGET_ESTALE
,
393 [ECANCELED
] = TARGET_ECANCELED
,
394 [ENOMEDIUM
] = TARGET_ENOMEDIUM
,
395 [EMEDIUMTYPE
] = TARGET_EMEDIUMTYPE
,
397 [ENOKEY
] = TARGET_ENOKEY
,
400 [EKEYEXPIRED
] = TARGET_EKEYEXPIRED
,
403 [EKEYREVOKED
] = TARGET_EKEYREVOKED
,
406 [EKEYREJECTED
] = TARGET_EKEYREJECTED
,
409 [EOWNERDEAD
] = TARGET_EOWNERDEAD
,
411 #ifdef ENOTRECOVERABLE
412 [ENOTRECOVERABLE
] = TARGET_ENOTRECOVERABLE
,
416 static inline int host_to_target_errno(int err
)
418 if(host_to_target_errno_table
[err
])
419 return host_to_target_errno_table
[err
];
423 static inline int target_to_host_errno(int err
)
425 if (target_to_host_errno_table
[err
])
426 return target_to_host_errno_table
[err
];
430 static inline abi_long
get_errno(abi_long ret
)
433 return -host_to_target_errno(errno
);
438 static inline int is_error(abi_long ret
)
440 return (abi_ulong
)ret
>= (abi_ulong
)(-4096);
443 char *target_strerror(int err
)
445 return strerror(target_to_host_errno(err
));
448 static abi_ulong target_brk
;
449 static abi_ulong target_original_brk
;
451 void target_set_brk(abi_ulong new_brk
)
453 target_original_brk
= target_brk
= HOST_PAGE_ALIGN(new_brk
);
456 /* do_brk() must return target values and target errnos. */
457 abi_long
do_brk(abi_ulong new_brk
)
460 abi_long mapped_addr
;
465 if (new_brk
< target_original_brk
)
468 brk_page
= HOST_PAGE_ALIGN(target_brk
);
470 /* If the new brk is less than this, set it and we're done... */
471 if (new_brk
< brk_page
) {
472 target_brk
= new_brk
;
476 /* We need to allocate more memory after the brk... */
477 new_alloc_size
= HOST_PAGE_ALIGN(new_brk
- brk_page
+ 1);
478 mapped_addr
= get_errno(target_mmap(brk_page
, new_alloc_size
,
479 PROT_READ
|PROT_WRITE
,
480 MAP_ANON
|MAP_FIXED
|MAP_PRIVATE
, 0, 0));
482 if (!is_error(mapped_addr
))
483 target_brk
= new_brk
;
488 static inline abi_long
copy_from_user_fdset(fd_set
*fds
,
489 abi_ulong target_fds_addr
,
493 abi_ulong b
, *target_fds
;
495 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
496 if (!(target_fds
= lock_user(VERIFY_READ
,
498 sizeof(abi_ulong
) * nw
,
500 return -TARGET_EFAULT
;
504 for (i
= 0; i
< nw
; i
++) {
505 /* grab the abi_ulong */
506 __get_user(b
, &target_fds
[i
]);
507 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
508 /* check the bit inside the abi_ulong */
515 unlock_user(target_fds
, target_fds_addr
, 0);
520 static inline abi_long
copy_to_user_fdset(abi_ulong target_fds_addr
,
526 abi_ulong
*target_fds
;
528 nw
= (n
+ TARGET_ABI_BITS
- 1) / TARGET_ABI_BITS
;
529 if (!(target_fds
= lock_user(VERIFY_WRITE
,
531 sizeof(abi_ulong
) * nw
,
533 return -TARGET_EFAULT
;
536 for (i
= 0; i
< nw
; i
++) {
538 for (j
= 0; j
< TARGET_ABI_BITS
; j
++) {
539 v
|= ((FD_ISSET(k
, fds
) != 0) << j
);
542 __put_user(v
, &target_fds
[i
]);
545 unlock_user(target_fds
, target_fds_addr
, sizeof(abi_ulong
) * nw
);
550 #if defined(__alpha__)
556 static inline abi_long
host_to_target_clock_t(long ticks
)
558 #if HOST_HZ == TARGET_HZ
561 return ((int64_t)ticks
* TARGET_HZ
) / HOST_HZ
;
565 static inline abi_long
host_to_target_rusage(abi_ulong target_addr
,
566 const struct rusage
*rusage
)
568 struct target_rusage
*target_rusage
;
570 if (!lock_user_struct(VERIFY_WRITE
, target_rusage
, target_addr
, 0))
571 return -TARGET_EFAULT
;
572 target_rusage
->ru_utime
.tv_sec
= tswapl(rusage
->ru_utime
.tv_sec
);
573 target_rusage
->ru_utime
.tv_usec
= tswapl(rusage
->ru_utime
.tv_usec
);
574 target_rusage
->ru_stime
.tv_sec
= tswapl(rusage
->ru_stime
.tv_sec
);
575 target_rusage
->ru_stime
.tv_usec
= tswapl(rusage
->ru_stime
.tv_usec
);
576 target_rusage
->ru_maxrss
= tswapl(rusage
->ru_maxrss
);
577 target_rusage
->ru_ixrss
= tswapl(rusage
->ru_ixrss
);
578 target_rusage
->ru_idrss
= tswapl(rusage
->ru_idrss
);
579 target_rusage
->ru_isrss
= tswapl(rusage
->ru_isrss
);
580 target_rusage
->ru_minflt
= tswapl(rusage
->ru_minflt
);
581 target_rusage
->ru_majflt
= tswapl(rusage
->ru_majflt
);
582 target_rusage
->ru_nswap
= tswapl(rusage
->ru_nswap
);
583 target_rusage
->ru_inblock
= tswapl(rusage
->ru_inblock
);
584 target_rusage
->ru_oublock
= tswapl(rusage
->ru_oublock
);
585 target_rusage
->ru_msgsnd
= tswapl(rusage
->ru_msgsnd
);
586 target_rusage
->ru_msgrcv
= tswapl(rusage
->ru_msgrcv
);
587 target_rusage
->ru_nsignals
= tswapl(rusage
->ru_nsignals
);
588 target_rusage
->ru_nvcsw
= tswapl(rusage
->ru_nvcsw
);
589 target_rusage
->ru_nivcsw
= tswapl(rusage
->ru_nivcsw
);
590 unlock_user_struct(target_rusage
, target_addr
, 1);
595 static inline abi_long
copy_from_user_timeval(struct timeval
*tv
,
596 abi_ulong target_tv_addr
)
598 struct target_timeval
*target_tv
;
600 if (!lock_user_struct(VERIFY_READ
, target_tv
, target_tv_addr
, 1))
601 return -TARGET_EFAULT
;
603 __get_user(tv
->tv_sec
, &target_tv
->tv_sec
);
604 __get_user(tv
->tv_usec
, &target_tv
->tv_usec
);
606 unlock_user_struct(target_tv
, target_tv_addr
, 0);
611 static inline abi_long
copy_to_user_timeval(abi_ulong target_tv_addr
,
612 const struct timeval
*tv
)
614 struct target_timeval
*target_tv
;
616 if (!lock_user_struct(VERIFY_WRITE
, target_tv
, target_tv_addr
, 0))
617 return -TARGET_EFAULT
;
619 __put_user(tv
->tv_sec
, &target_tv
->tv_sec
);
620 __put_user(tv
->tv_usec
, &target_tv
->tv_usec
);
622 unlock_user_struct(target_tv
, target_tv_addr
, 1);
628 /* do_select() must return target values and target errnos. */
629 static abi_long
do_select(int n
,
630 abi_ulong rfd_addr
, abi_ulong wfd_addr
,
631 abi_ulong efd_addr
, abi_ulong target_tv_addr
)
633 fd_set rfds
, wfds
, efds
;
634 fd_set
*rfds_ptr
, *wfds_ptr
, *efds_ptr
;
635 struct timeval tv
, *tv_ptr
;
639 if (copy_from_user_fdset(&rfds
, rfd_addr
, n
))
640 return -TARGET_EFAULT
;
646 if (copy_from_user_fdset(&wfds
, wfd_addr
, n
))
647 return -TARGET_EFAULT
;
653 if (copy_from_user_fdset(&efds
, efd_addr
, n
))
654 return -TARGET_EFAULT
;
660 if (target_tv_addr
) {
661 if (copy_from_user_timeval(&tv
, target_tv_addr
))
662 return -TARGET_EFAULT
;
668 ret
= get_errno(select(n
, rfds_ptr
, wfds_ptr
, efds_ptr
, tv_ptr
));
670 if (!is_error(ret
)) {
671 if (rfd_addr
&& copy_to_user_fdset(rfd_addr
, &rfds
, n
))
672 return -TARGET_EFAULT
;
673 if (wfd_addr
&& copy_to_user_fdset(wfd_addr
, &wfds
, n
))
674 return -TARGET_EFAULT
;
675 if (efd_addr
&& copy_to_user_fdset(efd_addr
, &efds
, n
))
676 return -TARGET_EFAULT
;
678 if (target_tv_addr
&& copy_to_user_timeval(target_tv_addr
, &tv
))
679 return -TARGET_EFAULT
;
685 static inline abi_long
target_to_host_sockaddr(struct sockaddr
*addr
,
686 abi_ulong target_addr
,
689 struct target_sockaddr
*target_saddr
;
691 target_saddr
= lock_user(VERIFY_READ
, target_addr
, len
, 1);
693 return -TARGET_EFAULT
;
694 memcpy(addr
, target_saddr
, len
);
695 addr
->sa_family
= tswap16(target_saddr
->sa_family
);
696 unlock_user(target_saddr
, target_addr
, 0);
701 static inline abi_long
host_to_target_sockaddr(abi_ulong target_addr
,
702 struct sockaddr
*addr
,
705 struct target_sockaddr
*target_saddr
;
707 target_saddr
= lock_user(VERIFY_WRITE
, target_addr
, len
, 0);
709 return -TARGET_EFAULT
;
710 memcpy(target_saddr
, addr
, len
);
711 target_saddr
->sa_family
= tswap16(addr
->sa_family
);
712 unlock_user(target_saddr
, target_addr
, len
);
717 /* ??? Should this also swap msgh->name? */
718 static inline abi_long
target_to_host_cmsg(struct msghdr
*msgh
,
719 struct target_msghdr
*target_msgh
)
721 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
722 abi_long msg_controllen
;
723 abi_ulong target_cmsg_addr
;
724 struct target_cmsghdr
*target_cmsg
;
727 msg_controllen
= tswapl(target_msgh
->msg_controllen
);
728 if (msg_controllen
< sizeof (struct target_cmsghdr
))
730 target_cmsg_addr
= tswapl(target_msgh
->msg_control
);
731 target_cmsg
= lock_user(VERIFY_READ
, target_cmsg_addr
, msg_controllen
, 1);
733 return -TARGET_EFAULT
;
735 while (cmsg
&& target_cmsg
) {
736 void *data
= CMSG_DATA(cmsg
);
737 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
739 int len
= tswapl(target_cmsg
->cmsg_len
)
740 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr
));
742 space
+= CMSG_SPACE(len
);
743 if (space
> msgh
->msg_controllen
) {
744 space
-= CMSG_SPACE(len
);
745 gemu_log("Host cmsg overflow\n");
749 cmsg
->cmsg_level
= tswap32(target_cmsg
->cmsg_level
);
750 cmsg
->cmsg_type
= tswap32(target_cmsg
->cmsg_type
);
751 cmsg
->cmsg_len
= CMSG_LEN(len
);
753 if (cmsg
->cmsg_level
!= TARGET_SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
754 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg
->cmsg_level
, cmsg
->cmsg_type
);
755 memcpy(data
, target_data
, len
);
757 int *fd
= (int *)data
;
758 int *target_fd
= (int *)target_data
;
759 int i
, numfds
= len
/ sizeof(int);
761 for (i
= 0; i
< numfds
; i
++)
762 fd
[i
] = tswap32(target_fd
[i
]);
765 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
766 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
);
768 unlock_user(target_cmsg
, target_cmsg_addr
, 0);
770 msgh
->msg_controllen
= space
;
774 /* ??? Should this also swap msgh->name? */
775 static inline abi_long
host_to_target_cmsg(struct target_msghdr
*target_msgh
,
778 struct cmsghdr
*cmsg
= CMSG_FIRSTHDR(msgh
);
779 abi_long msg_controllen
;
780 abi_ulong target_cmsg_addr
;
781 struct target_cmsghdr
*target_cmsg
;
784 msg_controllen
= tswapl(target_msgh
->msg_controllen
);
785 if (msg_controllen
< sizeof (struct target_cmsghdr
))
787 target_cmsg_addr
= tswapl(target_msgh
->msg_control
);
788 target_cmsg
= lock_user(VERIFY_WRITE
, target_cmsg_addr
, msg_controllen
, 0);
790 return -TARGET_EFAULT
;
792 while (cmsg
&& target_cmsg
) {
793 void *data
= CMSG_DATA(cmsg
);
794 void *target_data
= TARGET_CMSG_DATA(target_cmsg
);
796 int len
= cmsg
->cmsg_len
- CMSG_ALIGN(sizeof (struct cmsghdr
));
798 space
+= TARGET_CMSG_SPACE(len
);
799 if (space
> msg_controllen
) {
800 space
-= TARGET_CMSG_SPACE(len
);
801 gemu_log("Target cmsg overflow\n");
805 target_cmsg
->cmsg_level
= tswap32(cmsg
->cmsg_level
);
806 target_cmsg
->cmsg_type
= tswap32(cmsg
->cmsg_type
);
807 target_cmsg
->cmsg_len
= tswapl(TARGET_CMSG_LEN(len
));
809 if (cmsg
->cmsg_level
!= TARGET_SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
810 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg
->cmsg_level
, cmsg
->cmsg_type
);
811 memcpy(target_data
, data
, len
);
813 int *fd
= (int *)data
;
814 int *target_fd
= (int *)target_data
;
815 int i
, numfds
= len
/ sizeof(int);
817 for (i
= 0; i
< numfds
; i
++)
818 target_fd
[i
] = tswap32(fd
[i
]);
821 cmsg
= CMSG_NXTHDR(msgh
, cmsg
);
822 target_cmsg
= TARGET_CMSG_NXTHDR(target_msgh
, target_cmsg
);
824 unlock_user(target_cmsg
, target_cmsg_addr
, space
);
826 target_msgh
->msg_controllen
= tswapl(space
);
830 /* do_setsockopt() Must return target values and target errnos. */
831 static abi_long
do_setsockopt(int sockfd
, int level
, int optname
,
832 abi_ulong optval_addr
, socklen_t optlen
)
839 /* TCP options all take an 'int' value. */
840 if (optlen
< sizeof(uint32_t))
841 return -TARGET_EINVAL
;
843 if (get_user_u32(val
, optval_addr
))
844 return -TARGET_EFAULT
;
845 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
852 case IP_ROUTER_ALERT
:
856 case IP_MTU_DISCOVER
:
862 case IP_MULTICAST_TTL
:
863 case IP_MULTICAST_LOOP
:
865 if (optlen
>= sizeof(uint32_t)) {
866 if (get_user_u32(val
, optval_addr
))
867 return -TARGET_EFAULT
;
868 } else if (optlen
>= 1) {
869 if (get_user_u8(val
, optval_addr
))
870 return -TARGET_EFAULT
;
872 ret
= get_errno(setsockopt(sockfd
, level
, optname
, &val
, sizeof(val
)));
878 case TARGET_SOL_SOCKET
:
880 /* Options with 'int' argument. */
881 case TARGET_SO_DEBUG
:
884 case TARGET_SO_REUSEADDR
:
885 optname
= SO_REUSEADDR
;
890 case TARGET_SO_ERROR
:
893 case TARGET_SO_DONTROUTE
:
894 optname
= SO_DONTROUTE
;
896 case TARGET_SO_BROADCAST
:
897 optname
= SO_BROADCAST
;
899 case TARGET_SO_SNDBUF
:
902 case TARGET_SO_RCVBUF
:
905 case TARGET_SO_KEEPALIVE
:
906 optname
= SO_KEEPALIVE
;
908 case TARGET_SO_OOBINLINE
:
909 optname
= SO_OOBINLINE
;
911 case TARGET_SO_NO_CHECK
:
912 optname
= SO_NO_CHECK
;
914 case TARGET_SO_PRIORITY
:
915 optname
= SO_PRIORITY
;
918 case TARGET_SO_BSDCOMPAT
:
919 optname
= SO_BSDCOMPAT
;
922 case TARGET_SO_PASSCRED
:
923 optname
= SO_PASSCRED
;
925 case TARGET_SO_TIMESTAMP
:
926 optname
= SO_TIMESTAMP
;
928 case TARGET_SO_RCVLOWAT
:
929 optname
= SO_RCVLOWAT
;
931 case TARGET_SO_RCVTIMEO
:
932 optname
= SO_RCVTIMEO
;
934 case TARGET_SO_SNDTIMEO
:
935 optname
= SO_SNDTIMEO
;
941 if (optlen
< sizeof(uint32_t))
942 return -TARGET_EINVAL
;
944 if (get_user_u32(val
, optval_addr
))
945 return -TARGET_EFAULT
;
946 ret
= get_errno(setsockopt(sockfd
, SOL_SOCKET
, optname
, &val
, sizeof(val
)));
950 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level
, optname
);
951 ret
= -TARGET_ENOPROTOOPT
;
956 /* do_getsockopt() Must return target values and target errnos. */
957 static abi_long
do_getsockopt(int sockfd
, int level
, int optname
,
958 abi_ulong optval_addr
, abi_ulong optlen
)
965 case TARGET_SOL_SOCKET
:
968 case TARGET_SO_LINGER
:
969 case TARGET_SO_RCVTIMEO
:
970 case TARGET_SO_SNDTIMEO
:
971 case TARGET_SO_PEERCRED
:
972 case TARGET_SO_PEERNAME
:
973 /* These don't just return a single integer */
980 /* TCP options all take an 'int' value. */
982 if (get_user_u32(len
, optlen
))
983 return -TARGET_EFAULT
;
985 return -TARGET_EINVAL
;
987 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
994 if (put_user_u32(val
, optval_addr
))
995 return -TARGET_EFAULT
;
997 if (put_user_u8(val
, optval_addr
))
998 return -TARGET_EFAULT
;
1000 if (put_user_u32(len
, optlen
))
1001 return -TARGET_EFAULT
;
1008 case IP_ROUTER_ALERT
:
1012 case IP_MTU_DISCOVER
:
1018 case IP_MULTICAST_TTL
:
1019 case IP_MULTICAST_LOOP
:
1020 if (get_user_u32(len
, optlen
))
1021 return -TARGET_EFAULT
;
1023 return -TARGET_EINVAL
;
1025 ret
= get_errno(getsockopt(sockfd
, level
, optname
, &val
, &lv
));
1028 if (len
< sizeof(int) && len
> 0 && val
>= 0 && val
< 255) {
1030 if (put_user_u32(len
, optlen
)
1031 || put_user_u8(val
, optval_addr
))
1032 return -TARGET_EFAULT
;
1034 if (len
> sizeof(int))
1036 if (put_user_u32(len
, optlen
)
1037 || put_user_u32(val
, optval_addr
))
1038 return -TARGET_EFAULT
;
1042 ret
= -TARGET_ENOPROTOOPT
;
1048 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1050 ret
= -TARGET_EOPNOTSUPP
;
1057 * lock_iovec()/unlock_iovec() have a return code of 0 for success where
1058 * other lock functions have a return code of 0 for failure.
1060 static abi_long
lock_iovec(int type
, struct iovec
*vec
, abi_ulong target_addr
,
1061 int count
, int copy
)
1063 struct target_iovec
*target_vec
;
1067 target_vec
= lock_user(VERIFY_READ
, target_addr
, count
* sizeof(struct target_iovec
), 1);
1069 return -TARGET_EFAULT
;
1070 for(i
= 0;i
< count
; i
++) {
1071 base
= tswapl(target_vec
[i
].iov_base
);
1072 vec
[i
].iov_len
= tswapl(target_vec
[i
].iov_len
);
1073 if (vec
[i
].iov_len
!= 0) {
1074 vec
[i
].iov_base
= lock_user(type
, base
, vec
[i
].iov_len
, copy
);
1075 if (!vec
[i
].iov_base
&& vec
[i
].iov_len
)
1078 /* zero length pointer is ignored */
1079 vec
[i
].iov_base
= NULL
;
1082 unlock_user (target_vec
, target_addr
, 0);
1085 /* failure - unwind locks */
1086 for (j
= 0; j
< i
; j
++) {
1087 base
= tswapl(target_vec
[j
].iov_base
);
1088 unlock_user(vec
[j
].iov_base
, base
, 0);
1090 unlock_user (target_vec
, target_addr
, 0);
1091 return -TARGET_EFAULT
;
1094 static abi_long
unlock_iovec(struct iovec
*vec
, abi_ulong target_addr
,
1095 int count
, int copy
)
1097 struct target_iovec
*target_vec
;
1101 target_vec
= lock_user(VERIFY_READ
, target_addr
, count
* sizeof(struct target_iovec
), 1);
1103 return -TARGET_EFAULT
;
1104 for(i
= 0;i
< count
; i
++) {
1105 base
= tswapl(target_vec
[i
].iov_base
);
1106 unlock_user(vec
[i
].iov_base
, base
, copy
? vec
[i
].iov_len
: 0);
1108 unlock_user (target_vec
, target_addr
, 0);
1113 /* do_socket() Must return target values and target errnos. */
1114 static abi_long
do_socket(int domain
, int type
, int protocol
)
1116 #if defined(TARGET_MIPS)
1118 case TARGET_SOCK_DGRAM
:
1121 case TARGET_SOCK_STREAM
:
1124 case TARGET_SOCK_RAW
:
1127 case TARGET_SOCK_RDM
:
1130 case TARGET_SOCK_SEQPACKET
:
1131 type
= SOCK_SEQPACKET
;
1133 case TARGET_SOCK_PACKET
:
1138 if (domain
== PF_NETLINK
)
1139 return -EAFNOSUPPORT
; /* do not NETLINK socket connections possible */
1140 return get_errno(socket(domain
, type
, protocol
));
1143 /* do_bind() Must return target values and target errnos. */
1144 static abi_long
do_bind(int sockfd
, abi_ulong target_addr
,
1147 void *addr
= alloca(addrlen
);
1149 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1150 return get_errno(bind(sockfd
, addr
, addrlen
));
1153 /* do_connect() Must return target values and target errnos. */
1154 static abi_long
do_connect(int sockfd
, abi_ulong target_addr
,
1157 void *addr
= alloca(addrlen
);
1159 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1160 return get_errno(connect(sockfd
, addr
, addrlen
));
1163 /* do_sendrecvmsg() Must return target values and target errnos. */
1164 static abi_long
do_sendrecvmsg(int fd
, abi_ulong target_msg
,
1165 int flags
, int send
)
1168 struct target_msghdr
*msgp
;
1172 abi_ulong target_vec
;
1175 if (!lock_user_struct(send
? VERIFY_READ
: VERIFY_WRITE
,
1179 return -TARGET_EFAULT
;
1180 if (msgp
->msg_name
) {
1181 msg
.msg_namelen
= tswap32(msgp
->msg_namelen
);
1182 msg
.msg_name
= alloca(msg
.msg_namelen
);
1183 target_to_host_sockaddr(msg
.msg_name
, tswapl(msgp
->msg_name
),
1186 msg
.msg_name
= NULL
;
1187 msg
.msg_namelen
= 0;
1189 msg
.msg_controllen
= 2 * tswapl(msgp
->msg_controllen
);
1190 msg
.msg_control
= alloca(msg
.msg_controllen
);
1191 msg
.msg_flags
= tswap32(msgp
->msg_flags
);
1193 count
= tswapl(msgp
->msg_iovlen
);
1194 vec
= alloca(count
* sizeof(struct iovec
));
1195 target_vec
= tswapl(msgp
->msg_iov
);
1196 lock_iovec(send
? VERIFY_READ
: VERIFY_WRITE
, vec
, target_vec
, count
, send
);
1197 msg
.msg_iovlen
= count
;
1201 ret
= target_to_host_cmsg(&msg
, msgp
);
1203 ret
= get_errno(sendmsg(fd
, &msg
, flags
));
1205 ret
= get_errno(recvmsg(fd
, &msg
, flags
));
1207 ret
= host_to_target_cmsg(msgp
, &msg
);
1209 unlock_iovec(vec
, target_vec
, count
, !send
);
1210 unlock_user_struct(msgp
, target_msg
, send
? 0 : 1);
1214 /* do_accept() Must return target values and target errnos. */
1215 static abi_long
do_accept(int fd
, abi_ulong target_addr
,
1216 abi_ulong target_addrlen_addr
)
1222 if (get_user_u32(addrlen
, target_addrlen_addr
))
1223 return -TARGET_EFAULT
;
1225 addr
= alloca(addrlen
);
1227 ret
= get_errno(accept(fd
, addr
, &addrlen
));
1228 if (!is_error(ret
)) {
1229 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1230 if (put_user_u32(addrlen
, target_addrlen_addr
))
1231 ret
= -TARGET_EFAULT
;
1236 /* do_getpeername() Must return target values and target errnos. */
1237 static abi_long
do_getpeername(int fd
, abi_ulong target_addr
,
1238 abi_ulong target_addrlen_addr
)
1244 if (get_user_u32(addrlen
, target_addrlen_addr
))
1245 return -TARGET_EFAULT
;
1247 addr
= alloca(addrlen
);
1249 ret
= get_errno(getpeername(fd
, addr
, &addrlen
));
1250 if (!is_error(ret
)) {
1251 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1252 if (put_user_u32(addrlen
, target_addrlen_addr
))
1253 ret
= -TARGET_EFAULT
;
1258 /* do_getsockname() Must return target values and target errnos. */
1259 static abi_long
do_getsockname(int fd
, abi_ulong target_addr
,
1260 abi_ulong target_addrlen_addr
)
1266 if (get_user_u32(addrlen
, target_addrlen_addr
))
1267 return -TARGET_EFAULT
;
1269 addr
= alloca(addrlen
);
1271 ret
= get_errno(getsockname(fd
, addr
, &addrlen
));
1272 if (!is_error(ret
)) {
1273 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1274 if (put_user_u32(addrlen
, target_addrlen_addr
))
1275 ret
= -TARGET_EFAULT
;
1280 /* do_socketpair() Must return target values and target errnos. */
1281 static abi_long
do_socketpair(int domain
, int type
, int protocol
,
1282 abi_ulong target_tab_addr
)
1287 ret
= get_errno(socketpair(domain
, type
, protocol
, tab
));
1288 if (!is_error(ret
)) {
1289 if (put_user_s32(tab
[0], target_tab_addr
)
1290 || put_user_s32(tab
[1], target_tab_addr
+ sizeof(tab
[0])))
1291 ret
= -TARGET_EFAULT
;
1296 /* do_sendto() Must return target values and target errnos. */
1297 static abi_long
do_sendto(int fd
, abi_ulong msg
, size_t len
, int flags
,
1298 abi_ulong target_addr
, socklen_t addrlen
)
1304 host_msg
= lock_user(VERIFY_READ
, msg
, len
, 1);
1306 return -TARGET_EFAULT
;
1308 addr
= alloca(addrlen
);
1309 target_to_host_sockaddr(addr
, target_addr
, addrlen
);
1310 ret
= get_errno(sendto(fd
, host_msg
, len
, flags
, addr
, addrlen
));
1312 ret
= get_errno(send(fd
, host_msg
, len
, flags
));
1314 unlock_user(host_msg
, msg
, 0);
1318 /* do_recvfrom() Must return target values and target errnos. */
1319 static abi_long
do_recvfrom(int fd
, abi_ulong msg
, size_t len
, int flags
,
1320 abi_ulong target_addr
,
1321 abi_ulong target_addrlen
)
1328 host_msg
= lock_user(VERIFY_WRITE
, msg
, len
, 0);
1330 return -TARGET_EFAULT
;
1332 if (get_user_u32(addrlen
, target_addrlen
)) {
1333 ret
= -TARGET_EFAULT
;
1336 addr
= alloca(addrlen
);
1337 ret
= get_errno(recvfrom(fd
, host_msg
, len
, flags
, addr
, &addrlen
));
1339 addr
= NULL
; /* To keep compiler quiet. */
1340 ret
= get_errno(recv(fd
, host_msg
, len
, flags
));
1342 if (!is_error(ret
)) {
1344 host_to_target_sockaddr(target_addr
, addr
, addrlen
);
1345 if (put_user_u32(addrlen
, target_addrlen
)) {
1346 ret
= -TARGET_EFAULT
;
1350 unlock_user(host_msg
, msg
, len
);
1353 unlock_user(host_msg
, msg
, 0);
1358 #ifdef TARGET_NR_socketcall
1359 /* do_socketcall() Must return target values and target errnos. */
1360 static abi_long
do_socketcall(int num
, abi_ulong vptr
)
1363 const int n
= sizeof(abi_ulong
);
1368 int domain
, type
, protocol
;
1370 if (get_user_s32(domain
, vptr
)
1371 || get_user_s32(type
, vptr
+ n
)
1372 || get_user_s32(protocol
, vptr
+ 2 * n
))
1373 return -TARGET_EFAULT
;
1375 ret
= do_socket(domain
, type
, protocol
);
1381 abi_ulong target_addr
;
1384 if (get_user_s32(sockfd
, vptr
)
1385 || get_user_ual(target_addr
, vptr
+ n
)
1386 || get_user_u32(addrlen
, vptr
+ 2 * n
))
1387 return -TARGET_EFAULT
;
1389 ret
= do_bind(sockfd
, target_addr
, addrlen
);
1392 case SOCKOP_connect
:
1395 abi_ulong target_addr
;
1398 if (get_user_s32(sockfd
, vptr
)
1399 || get_user_ual(target_addr
, vptr
+ n
)
1400 || get_user_u32(addrlen
, vptr
+ 2 * n
))
1401 return -TARGET_EFAULT
;
1403 ret
= do_connect(sockfd
, target_addr
, addrlen
);
1408 int sockfd
, backlog
;
1410 if (get_user_s32(sockfd
, vptr
)
1411 || get_user_s32(backlog
, vptr
+ n
))
1412 return -TARGET_EFAULT
;
1414 ret
= get_errno(listen(sockfd
, backlog
));
1420 abi_ulong target_addr
, target_addrlen
;
1422 if (get_user_s32(sockfd
, vptr
)
1423 || get_user_ual(target_addr
, vptr
+ n
)
1424 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1425 return -TARGET_EFAULT
;
1427 ret
= do_accept(sockfd
, target_addr
, target_addrlen
);
1430 case SOCKOP_getsockname
:
1433 abi_ulong target_addr
, target_addrlen
;
1435 if (get_user_s32(sockfd
, vptr
)
1436 || get_user_ual(target_addr
, vptr
+ n
)
1437 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1438 return -TARGET_EFAULT
;
1440 ret
= do_getsockname(sockfd
, target_addr
, target_addrlen
);
1443 case SOCKOP_getpeername
:
1446 abi_ulong target_addr
, target_addrlen
;
1448 if (get_user_s32(sockfd
, vptr
)
1449 || get_user_ual(target_addr
, vptr
+ n
)
1450 || get_user_u32(target_addrlen
, vptr
+ 2 * n
))
1451 return -TARGET_EFAULT
;
1453 ret
= do_getpeername(sockfd
, target_addr
, target_addrlen
);
1456 case SOCKOP_socketpair
:
1458 int domain
, type
, protocol
;
1461 if (get_user_s32(domain
, vptr
)
1462 || get_user_s32(type
, vptr
+ n
)
1463 || get_user_s32(protocol
, vptr
+ 2 * n
)
1464 || get_user_ual(tab
, vptr
+ 3 * n
))
1465 return -TARGET_EFAULT
;
1467 ret
= do_socketpair(domain
, type
, protocol
, tab
);
1477 if (get_user_s32(sockfd
, vptr
)
1478 || get_user_ual(msg
, vptr
+ n
)
1479 || get_user_ual(len
, vptr
+ 2 * n
)
1480 || get_user_s32(flags
, vptr
+ 3 * n
))
1481 return -TARGET_EFAULT
;
1483 ret
= do_sendto(sockfd
, msg
, len
, flags
, 0, 0);
1493 if (get_user_s32(sockfd
, vptr
)
1494 || get_user_ual(msg
, vptr
+ n
)
1495 || get_user_ual(len
, vptr
+ 2 * n
)
1496 || get_user_s32(flags
, vptr
+ 3 * n
))
1497 return -TARGET_EFAULT
;
1499 ret
= do_recvfrom(sockfd
, msg
, len
, flags
, 0, 0);
1511 if (get_user_s32(sockfd
, vptr
)
1512 || get_user_ual(msg
, vptr
+ n
)
1513 || get_user_ual(len
, vptr
+ 2 * n
)
1514 || get_user_s32(flags
, vptr
+ 3 * n
)
1515 || get_user_ual(addr
, vptr
+ 4 * n
)
1516 || get_user_u32(addrlen
, vptr
+ 5 * n
))
1517 return -TARGET_EFAULT
;
1519 ret
= do_sendto(sockfd
, msg
, len
, flags
, addr
, addrlen
);
1522 case SOCKOP_recvfrom
:
1531 if (get_user_s32(sockfd
, vptr
)
1532 || get_user_ual(msg
, vptr
+ n
)
1533 || get_user_ual(len
, vptr
+ 2 * n
)
1534 || get_user_s32(flags
, vptr
+ 3 * n
)
1535 || get_user_ual(addr
, vptr
+ 4 * n
)
1536 || get_user_u32(addrlen
, vptr
+ 5 * n
))
1537 return -TARGET_EFAULT
;
1539 ret
= do_recvfrom(sockfd
, msg
, len
, flags
, addr
, addrlen
);
1542 case SOCKOP_shutdown
:
1546 if (get_user_s32(sockfd
, vptr
)
1547 || get_user_s32(how
, vptr
+ n
))
1548 return -TARGET_EFAULT
;
1550 ret
= get_errno(shutdown(sockfd
, how
));
1553 case SOCKOP_sendmsg
:
1554 case SOCKOP_recvmsg
:
1557 abi_ulong target_msg
;
1560 if (get_user_s32(fd
, vptr
)
1561 || get_user_ual(target_msg
, vptr
+ n
)
1562 || get_user_s32(flags
, vptr
+ 2 * n
))
1563 return -TARGET_EFAULT
;
1565 ret
= do_sendrecvmsg(fd
, target_msg
, flags
,
1566 (num
== SOCKOP_sendmsg
));
1569 case SOCKOP_setsockopt
:
1577 if (get_user_s32(sockfd
, vptr
)
1578 || get_user_s32(level
, vptr
+ n
)
1579 || get_user_s32(optname
, vptr
+ 2 * n
)
1580 || get_user_ual(optval
, vptr
+ 3 * n
)
1581 || get_user_u32(optlen
, vptr
+ 4 * n
))
1582 return -TARGET_EFAULT
;
1584 ret
= do_setsockopt(sockfd
, level
, optname
, optval
, optlen
);
1587 case SOCKOP_getsockopt
:
1595 if (get_user_s32(sockfd
, vptr
)
1596 || get_user_s32(level
, vptr
+ n
)
1597 || get_user_s32(optname
, vptr
+ 2 * n
)
1598 || get_user_ual(optval
, vptr
+ 3 * n
)
1599 || get_user_u32(optlen
, vptr
+ 4 * n
))
1600 return -TARGET_EFAULT
;
1602 ret
= do_getsockopt(sockfd
, level
, optname
, optval
, optlen
);
1606 gemu_log("Unsupported socketcall: %d\n", num
);
1607 ret
= -TARGET_ENOSYS
;
1614 #define N_SHM_REGIONS 32
1616 static struct shm_region
{
1619 } shm_regions
[N_SHM_REGIONS
];
1621 struct target_ipc_perm
1628 unsigned short int mode
;
1629 unsigned short int __pad1
;
1630 unsigned short int __seq
;
1631 unsigned short int __pad2
;
1632 abi_ulong __unused1
;
1633 abi_ulong __unused2
;
1636 struct target_semid_ds
1638 struct target_ipc_perm sem_perm
;
1639 abi_ulong sem_otime
;
1640 abi_ulong __unused1
;
1641 abi_ulong sem_ctime
;
1642 abi_ulong __unused2
;
1643 abi_ulong sem_nsems
;
1644 abi_ulong __unused3
;
1645 abi_ulong __unused4
;
1648 static inline abi_long
target_to_host_ipc_perm(struct ipc_perm
*host_ip
,
1649 abi_ulong target_addr
)
1651 struct target_ipc_perm
*target_ip
;
1652 struct target_semid_ds
*target_sd
;
1654 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
1655 return -TARGET_EFAULT
;
1656 target_ip
=&(target_sd
->sem_perm
);
1657 host_ip
->__key
= tswapl(target_ip
->__key
);
1658 host_ip
->uid
= tswapl(target_ip
->uid
);
1659 host_ip
->gid
= tswapl(target_ip
->gid
);
1660 host_ip
->cuid
= tswapl(target_ip
->cuid
);
1661 host_ip
->cgid
= tswapl(target_ip
->cgid
);
1662 host_ip
->mode
= tswapl(target_ip
->mode
);
1663 unlock_user_struct(target_sd
, target_addr
, 0);
1667 static inline abi_long
host_to_target_ipc_perm(abi_ulong target_addr
,
1668 struct ipc_perm
*host_ip
)
1670 struct target_ipc_perm
*target_ip
;
1671 struct target_semid_ds
*target_sd
;
1673 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
1674 return -TARGET_EFAULT
;
1675 target_ip
= &(target_sd
->sem_perm
);
1676 target_ip
->__key
= tswapl(host_ip
->__key
);
1677 target_ip
->uid
= tswapl(host_ip
->uid
);
1678 target_ip
->gid
= tswapl(host_ip
->gid
);
1679 target_ip
->cuid
= tswapl(host_ip
->cuid
);
1680 target_ip
->cgid
= tswapl(host_ip
->cgid
);
1681 target_ip
->mode
= tswapl(host_ip
->mode
);
1682 unlock_user_struct(target_sd
, target_addr
, 1);
1686 static inline abi_long
target_to_host_semid_ds(struct semid_ds
*host_sd
,
1687 abi_ulong target_addr
)
1689 struct target_semid_ds
*target_sd
;
1691 if (!lock_user_struct(VERIFY_READ
, target_sd
, target_addr
, 1))
1692 return -TARGET_EFAULT
;
1693 target_to_host_ipc_perm(&(host_sd
->sem_perm
),target_addr
);
1694 host_sd
->sem_nsems
= tswapl(target_sd
->sem_nsems
);
1695 host_sd
->sem_otime
= tswapl(target_sd
->sem_otime
);
1696 host_sd
->sem_ctime
= tswapl(target_sd
->sem_ctime
);
1697 unlock_user_struct(target_sd
, target_addr
, 0);
1701 static inline abi_long
host_to_target_semid_ds(abi_ulong target_addr
,
1702 struct semid_ds
*host_sd
)
1704 struct target_semid_ds
*target_sd
;
1706 if (!lock_user_struct(VERIFY_WRITE
, target_sd
, target_addr
, 0))
1707 return -TARGET_EFAULT
;
1708 host_to_target_ipc_perm(target_addr
,&(host_sd
->sem_perm
));
1709 target_sd
->sem_nsems
= tswapl(host_sd
->sem_nsems
);
1710 target_sd
->sem_otime
= tswapl(host_sd
->sem_otime
);
1711 target_sd
->sem_ctime
= tswapl(host_sd
->sem_ctime
);
1712 unlock_user_struct(target_sd
, target_addr
, 1);
1718 struct semid_ds
*buf
;
1719 unsigned short *array
;
1722 union target_semun
{
1725 unsigned short int *array
;
1728 static inline abi_long
target_to_host_semun(int cmd
,
1729 union semun
*host_su
,
1730 abi_ulong target_addr
,
1731 struct semid_ds
*ds
)
1733 union target_semun
*target_su
;
1738 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1739 return -TARGET_EFAULT
;
1740 target_to_host_semid_ds(ds
,target_su
->buf
);
1742 unlock_user_struct(target_su
, target_addr
, 0);
1746 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1747 return -TARGET_EFAULT
;
1748 host_su
->val
= tswapl(target_su
->val
);
1749 unlock_user_struct(target_su
, target_addr
, 0);
1753 if (!lock_user_struct(VERIFY_READ
, target_su
, target_addr
, 1))
1754 return -TARGET_EFAULT
;
1755 *host_su
->array
= tswap16(*target_su
->array
);
1756 unlock_user_struct(target_su
, target_addr
, 0);
1759 gemu_log("semun operation not fully supported: %d\n", (int)cmd
);
1764 static inline abi_long
host_to_target_semun(int cmd
,
1765 abi_ulong target_addr
,
1766 union semun
*host_su
,
1767 struct semid_ds
*ds
)
1769 union target_semun
*target_su
;
1774 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1775 return -TARGET_EFAULT
;
1776 host_to_target_semid_ds(target_su
->buf
,ds
);
1777 unlock_user_struct(target_su
, target_addr
, 1);
1781 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1782 return -TARGET_EFAULT
;
1783 target_su
->val
= tswapl(host_su
->val
);
1784 unlock_user_struct(target_su
, target_addr
, 1);
1788 if (lock_user_struct(VERIFY_WRITE
, target_su
, target_addr
, 0))
1789 return -TARGET_EFAULT
;
1790 *target_su
->array
= tswap16(*host_su
->array
);
1791 unlock_user_struct(target_su
, target_addr
, 1);
1794 gemu_log("semun operation not fully supported: %d\n", (int)cmd
);
1799 static inline abi_long
do_semctl(int first
, int second
, int third
,
1803 struct semid_ds dsarg
;
1804 int cmd
= third
&0xff;
1809 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1810 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1811 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1814 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1815 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1816 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1819 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1820 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1821 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1824 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1825 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1826 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1829 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1830 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1831 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1834 target_to_host_semun(cmd
,&arg
,ptr
,&dsarg
);
1835 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1836 host_to_target_semun(cmd
,ptr
,&arg
,&dsarg
);
1839 ret
= get_errno(semctl(first
, second
, cmd
, arg
));
1845 struct target_msqid_ds
1847 struct target_ipc_perm msg_perm
;
1848 abi_ulong msg_stime
;
1849 #if TARGET_ABI_BITS == 32
1850 abi_ulong __unused1
;
1852 abi_ulong msg_rtime
;
1853 #if TARGET_ABI_BITS == 32
1854 abi_ulong __unused2
;
1856 abi_ulong msg_ctime
;
1857 #if TARGET_ABI_BITS == 32
1858 abi_ulong __unused3
;
1860 abi_ulong __msg_cbytes
;
1862 abi_ulong msg_qbytes
;
1863 abi_ulong msg_lspid
;
1864 abi_ulong msg_lrpid
;
1865 abi_ulong __unused4
;
1866 abi_ulong __unused5
;
1869 static inline abi_long
target_to_host_msqid_ds(struct msqid_ds
*host_md
,
1870 abi_ulong target_addr
)
1872 struct target_msqid_ds
*target_md
;
1874 if (!lock_user_struct(VERIFY_READ
, target_md
, target_addr
, 1))
1875 return -TARGET_EFAULT
;
1876 if (target_to_host_ipc_perm(&(host_md
->msg_perm
),target_addr
))
1877 return -TARGET_EFAULT
;
1878 host_md
->msg_stime
= tswapl(target_md
->msg_stime
);
1879 host_md
->msg_rtime
= tswapl(target_md
->msg_rtime
);
1880 host_md
->msg_ctime
= tswapl(target_md
->msg_ctime
);
1881 host_md
->__msg_cbytes
= tswapl(target_md
->__msg_cbytes
);
1882 host_md
->msg_qnum
= tswapl(target_md
->msg_qnum
);
1883 host_md
->msg_qbytes
= tswapl(target_md
->msg_qbytes
);
1884 host_md
->msg_lspid
= tswapl(target_md
->msg_lspid
);
1885 host_md
->msg_lrpid
= tswapl(target_md
->msg_lrpid
);
1886 unlock_user_struct(target_md
, target_addr
, 0);
1890 static inline abi_long
host_to_target_msqid_ds(abi_ulong target_addr
,
1891 struct msqid_ds
*host_md
)
1893 struct target_msqid_ds
*target_md
;
1895 if (!lock_user_struct(VERIFY_WRITE
, target_md
, target_addr
, 0))
1896 return -TARGET_EFAULT
;
1897 if (host_to_target_ipc_perm(target_addr
,&(host_md
->msg_perm
)))
1898 return -TARGET_EFAULT
;
1899 target_md
->msg_stime
= tswapl(host_md
->msg_stime
);
1900 target_md
->msg_rtime
= tswapl(host_md
->msg_rtime
);
1901 target_md
->msg_ctime
= tswapl(host_md
->msg_ctime
);
1902 target_md
->__msg_cbytes
= tswapl(host_md
->__msg_cbytes
);
1903 target_md
->msg_qnum
= tswapl(host_md
->msg_qnum
);
1904 target_md
->msg_qbytes
= tswapl(host_md
->msg_qbytes
);
1905 target_md
->msg_lspid
= tswapl(host_md
->msg_lspid
);
1906 target_md
->msg_lrpid
= tswapl(host_md
->msg_lrpid
);
1907 unlock_user_struct(target_md
, target_addr
, 1);
1911 struct target_msginfo
{
1919 unsigned short int msgseg
;
1922 static inline abi_long
host_to_target_msginfo(abi_ulong target_addr
,
1923 struct msginfo
*host_msginfo
)
1925 struct target_msginfo
*target_msginfo
;
1926 if (!lock_user_struct(VERIFY_WRITE
, target_msginfo
, target_addr
, 0))
1927 return -TARGET_EFAULT
;
1928 __put_user(host_msginfo
->msgpool
, &target_msginfo
->msgpool
);
1929 __put_user(host_msginfo
->msgmap
, &target_msginfo
->msgmap
);
1930 __put_user(host_msginfo
->msgmax
, &target_msginfo
->msgmax
);
1931 __put_user(host_msginfo
->msgmnb
, &target_msginfo
->msgmnb
);
1932 __put_user(host_msginfo
->msgmni
, &target_msginfo
->msgmni
);
1933 __put_user(host_msginfo
->msgssz
, &target_msginfo
->msgssz
);
1934 __put_user(host_msginfo
->msgtql
, &target_msginfo
->msgtql
);
1935 __put_user(host_msginfo
->msgseg
, &target_msginfo
->msgseg
);
1936 unlock_user_struct(target_msginfo
, target_addr
, 1);
1940 static inline abi_long
do_msgctl(int msgid
, int cmd
, abi_long ptr
)
1942 struct msqid_ds dsarg
;
1943 struct msginfo msginfo
;
1944 abi_long ret
= -TARGET_EINVAL
;
1952 if (target_to_host_msqid_ds(&dsarg
,ptr
))
1953 return -TARGET_EFAULT
;
1954 ret
= get_errno(msgctl(msgid
, cmd
, &dsarg
));
1955 if (host_to_target_msqid_ds(ptr
,&dsarg
))
1956 return -TARGET_EFAULT
;
1959 ret
= get_errno(msgctl(msgid
, cmd
, NULL
));
1963 ret
= get_errno(msgctl(msgid
, cmd
, (struct msqid_ds
*)&msginfo
));
1964 if (host_to_target_msginfo(ptr
, &msginfo
))
1965 return -TARGET_EFAULT
;
1972 struct target_msgbuf
{
1977 static inline abi_long
do_msgsnd(int msqid
, abi_long msgp
,
1978 unsigned int msgsz
, int msgflg
)
1980 struct target_msgbuf
*target_mb
;
1981 struct msgbuf
*host_mb
;
1984 if (!lock_user_struct(VERIFY_READ
, target_mb
, msgp
, 0))
1985 return -TARGET_EFAULT
;
1986 host_mb
= malloc(msgsz
+sizeof(long));
1987 host_mb
->mtype
= (abi_long
) tswapl(target_mb
->mtype
);
1988 memcpy(host_mb
->mtext
, target_mb
->mtext
, msgsz
);
1989 ret
= get_errno(msgsnd(msqid
, host_mb
, msgsz
, msgflg
));
1991 unlock_user_struct(target_mb
, msgp
, 0);
1996 static inline abi_long
do_msgrcv(int msqid
, abi_long msgp
,
1997 unsigned int msgsz
, abi_long msgtyp
,
2000 struct target_msgbuf
*target_mb
;
2002 struct msgbuf
*host_mb
;
2005 if (!lock_user_struct(VERIFY_WRITE
, target_mb
, msgp
, 0))
2006 return -TARGET_EFAULT
;
2008 host_mb
= malloc(msgsz
+sizeof(long));
2009 ret
= get_errno(msgrcv(msqid
, host_mb
, msgsz
, tswapl(msgtyp
), msgflg
));
2012 abi_ulong target_mtext_addr
= msgp
+ sizeof(abi_ulong
);
2013 target_mtext
= lock_user(VERIFY_WRITE
, target_mtext_addr
, ret
, 0);
2014 if (!target_mtext
) {
2015 ret
= -TARGET_EFAULT
;
2018 memcpy(target_mb
->mtext
, host_mb
->mtext
, ret
);
2019 unlock_user(target_mtext
, target_mtext_addr
, ret
);
2022 target_mb
->mtype
= tswapl(host_mb
->mtype
);
2027 unlock_user_struct(target_mb
, msgp
, 1);
2031 #ifdef TARGET_NR_ipc
2032 /* ??? This only works with linear mappings. */
2033 /* do_ipc() must return target values and target errnos. */
2034 static abi_long
do_ipc(unsigned int call
, int first
,
2035 int second
, int third
,
2036 abi_long ptr
, abi_long fifth
)
2040 struct shmid_ds shm_info
;
2043 version
= call
>> 16;
2048 ret
= get_errno(semop(first
,(struct sembuf
*)g2h(ptr
), second
));
2052 ret
= get_errno(semget(first
, second
, third
));
2056 ret
= do_semctl(first
, second
, third
, ptr
);
2059 case IPCOP_semtimedop
:
2060 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
2061 ret
= -TARGET_ENOSYS
;
2065 ret
= get_errno(msgget(first
, second
));
2069 ret
= do_msgsnd(first
, ptr
, second
, third
);
2073 ret
= do_msgctl(first
, second
, ptr
);
2080 struct target_ipc_kludge
{
2085 if (!lock_user_struct(VERIFY_READ
, tmp
, ptr
, 1)) {
2086 ret
= -TARGET_EFAULT
;
2090 ret
= do_msgrcv(first
, tmp
->msgp
, second
, tmp
->msgtyp
, third
);
2092 unlock_user_struct(tmp
, ptr
, 0);
2096 ret
= do_msgrcv(first
, ptr
, second
, fifth
, third
);
2104 /* SHM_* flags are the same on all linux platforms */
2105 host_addr
= shmat(first
, (void *)g2h(ptr
), second
);
2106 if (host_addr
== (void *)-1) {
2107 ret
= get_errno((long)host_addr
);
2110 raddr
= h2g((unsigned long)host_addr
);
2111 /* find out the length of the shared memory segment */
2113 ret
= get_errno(shmctl(first
, IPC_STAT
, &shm_info
));
2114 if (is_error(ret
)) {
2115 /* can't get length, bail out */
2119 page_set_flags(raddr
, raddr
+ shm_info
.shm_segsz
,
2120 PAGE_VALID
| PAGE_READ
|
2121 ((second
& SHM_RDONLY
)? 0: PAGE_WRITE
));
2122 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
2123 if (shm_regions
[i
].start
== 0) {
2124 shm_regions
[i
].start
= raddr
;
2125 shm_regions
[i
].size
= shm_info
.shm_segsz
;
2129 if (put_user_ual(raddr
, third
))
2130 return -TARGET_EFAULT
;
2135 for (i
= 0; i
< N_SHM_REGIONS
; ++i
) {
2136 if (shm_regions
[i
].start
== ptr
) {
2137 shm_regions
[i
].start
= 0;
2138 page_set_flags(ptr
, shm_regions
[i
].size
, 0);
2142 ret
= get_errno(shmdt((void *)g2h(ptr
)));
2146 /* IPC_* flag values are the same on all linux platforms */
2147 ret
= get_errno(shmget(first
, second
, third
));
2150 /* IPC_* and SHM_* command values are the same on all linux platforms */
2156 ret
= get_errno(shmctl(first
, second
, NULL
));
2164 gemu_log("Unsupported ipc call: %d (version %d)\n", call
, version
);
2165 ret
= -TARGET_ENOSYS
;
2172 /* kernel structure types definitions */
2175 #define STRUCT(name, list...) STRUCT_ ## name,
2176 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
2178 #include "syscall_types.h"
2181 #undef STRUCT_SPECIAL
2183 #define STRUCT(name, list...) static const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2184 #define STRUCT_SPECIAL(name)
2185 #include "syscall_types.h"
2187 #undef STRUCT_SPECIAL
2189 typedef struct IOCTLEntry
{
2190 unsigned int target_cmd
;
2191 unsigned int host_cmd
;
2194 const argtype arg_type
[5];
2197 #define IOC_R 0x0001
2198 #define IOC_W 0x0002
2199 #define IOC_RW (IOC_R | IOC_W)
2201 #define MAX_STRUCT_SIZE 4096
2203 static IOCTLEntry ioctl_entries
[] = {
2204 #define IOCTL(cmd, access, types...) \
2205 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2210 /* ??? Implement proper locking for ioctls. */
2211 /* do_ioctl() Must return target values and target errnos. */
2212 static abi_long
do_ioctl(int fd
, abi_long cmd
, abi_long arg
)
2214 const IOCTLEntry
*ie
;
2215 const argtype
*arg_type
;
2217 uint8_t buf_temp
[MAX_STRUCT_SIZE
];
2223 if (ie
->target_cmd
== 0) {
2224 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd
);
2225 return -TARGET_ENOSYS
;
2227 if (ie
->target_cmd
== cmd
)
2231 arg_type
= ie
->arg_type
;
2233 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd
, ie
->name
);
2235 switch(arg_type
[0]) {
2238 ret
= get_errno(ioctl(fd
, ie
->host_cmd
));
2243 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, arg
));
2247 target_size
= thunk_type_size(arg_type
, 0);
2248 switch(ie
->access
) {
2250 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2251 if (!is_error(ret
)) {
2252 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
2254 return -TARGET_EFAULT
;
2255 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
2256 unlock_user(argptr
, arg
, target_size
);
2260 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
2262 return -TARGET_EFAULT
;
2263 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
2264 unlock_user(argptr
, arg
, 0);
2265 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2269 argptr
= lock_user(VERIFY_READ
, arg
, target_size
, 1);
2271 return -TARGET_EFAULT
;
2272 thunk_convert(buf_temp
, argptr
, arg_type
, THUNK_HOST
);
2273 unlock_user(argptr
, arg
, 0);
2274 ret
= get_errno(ioctl(fd
, ie
->host_cmd
, buf_temp
));
2275 if (!is_error(ret
)) {
2276 argptr
= lock_user(VERIFY_WRITE
, arg
, target_size
, 0);
2278 return -TARGET_EFAULT
;
2279 thunk_convert(argptr
, buf_temp
, arg_type
, THUNK_TARGET
);
2280 unlock_user(argptr
, arg
, target_size
);
2286 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2287 (long)cmd
, arg_type
[0]);
2288 ret
= -TARGET_ENOSYS
;
2294 static const bitmask_transtbl iflag_tbl
[] = {
2295 { TARGET_IGNBRK
, TARGET_IGNBRK
, IGNBRK
, IGNBRK
},
2296 { TARGET_BRKINT
, TARGET_BRKINT
, BRKINT
, BRKINT
},
2297 { TARGET_IGNPAR
, TARGET_IGNPAR
, IGNPAR
, IGNPAR
},
2298 { TARGET_PARMRK
, TARGET_PARMRK
, PARMRK
, PARMRK
},
2299 { TARGET_INPCK
, TARGET_INPCK
, INPCK
, INPCK
},
2300 { TARGET_ISTRIP
, TARGET_ISTRIP
, ISTRIP
, ISTRIP
},
2301 { TARGET_INLCR
, TARGET_INLCR
, INLCR
, INLCR
},
2302 { TARGET_IGNCR
, TARGET_IGNCR
, IGNCR
, IGNCR
},
2303 { TARGET_ICRNL
, TARGET_ICRNL
, ICRNL
, ICRNL
},
2304 { TARGET_IUCLC
, TARGET_IUCLC
, IUCLC
, IUCLC
},
2305 { TARGET_IXON
, TARGET_IXON
, IXON
, IXON
},
2306 { TARGET_IXANY
, TARGET_IXANY
, IXANY
, IXANY
},
2307 { TARGET_IXOFF
, TARGET_IXOFF
, IXOFF
, IXOFF
},
2308 { TARGET_IMAXBEL
, TARGET_IMAXBEL
, IMAXBEL
, IMAXBEL
},
2312 static const bitmask_transtbl oflag_tbl
[] = {
2313 { TARGET_OPOST
, TARGET_OPOST
, OPOST
, OPOST
},
2314 { TARGET_OLCUC
, TARGET_OLCUC
, OLCUC
, OLCUC
},
2315 { TARGET_ONLCR
, TARGET_ONLCR
, ONLCR
, ONLCR
},
2316 { TARGET_OCRNL
, TARGET_OCRNL
, OCRNL
, OCRNL
},
2317 { TARGET_ONOCR
, TARGET_ONOCR
, ONOCR
, ONOCR
},
2318 { TARGET_ONLRET
, TARGET_ONLRET
, ONLRET
, ONLRET
},
2319 { TARGET_OFILL
, TARGET_OFILL
, OFILL
, OFILL
},
2320 { TARGET_OFDEL
, TARGET_OFDEL
, OFDEL
, OFDEL
},
2321 { TARGET_NLDLY
, TARGET_NL0
, NLDLY
, NL0
},
2322 { TARGET_NLDLY
, TARGET_NL1
, NLDLY
, NL1
},
2323 { TARGET_CRDLY
, TARGET_CR0
, CRDLY
, CR0
},
2324 { TARGET_CRDLY
, TARGET_CR1
, CRDLY
, CR1
},
2325 { TARGET_CRDLY
, TARGET_CR2
, CRDLY
, CR2
},
2326 { TARGET_CRDLY
, TARGET_CR3
, CRDLY
, CR3
},
2327 { TARGET_TABDLY
, TARGET_TAB0
, TABDLY
, TAB0
},
2328 { TARGET_TABDLY
, TARGET_TAB1
, TABDLY
, TAB1
},
2329 { TARGET_TABDLY
, TARGET_TAB2
, TABDLY
, TAB2
},
2330 { TARGET_TABDLY
, TARGET_TAB3
, TABDLY
, TAB3
},
2331 { TARGET_BSDLY
, TARGET_BS0
, BSDLY
, BS0
},
2332 { TARGET_BSDLY
, TARGET_BS1
, BSDLY
, BS1
},
2333 { TARGET_VTDLY
, TARGET_VT0
, VTDLY
, VT0
},
2334 { TARGET_VTDLY
, TARGET_VT1
, VTDLY
, VT1
},
2335 { TARGET_FFDLY
, TARGET_FF0
, FFDLY
, FF0
},
2336 { TARGET_FFDLY
, TARGET_FF1
, FFDLY
, FF1
},
2340 static const bitmask_transtbl cflag_tbl
[] = {
2341 { TARGET_CBAUD
, TARGET_B0
, CBAUD
, B0
},
2342 { TARGET_CBAUD
, TARGET_B50
, CBAUD
, B50
},
2343 { TARGET_CBAUD
, TARGET_B75
, CBAUD
, B75
},
2344 { TARGET_CBAUD
, TARGET_B110
, CBAUD
, B110
},
2345 { TARGET_CBAUD
, TARGET_B134
, CBAUD
, B134
},
2346 { TARGET_CBAUD
, TARGET_B150
, CBAUD
, B150
},
2347 { TARGET_CBAUD
, TARGET_B200
, CBAUD
, B200
},
2348 { TARGET_CBAUD
, TARGET_B300
, CBAUD
, B300
},
2349 { TARGET_CBAUD
, TARGET_B600
, CBAUD
, B600
},
2350 { TARGET_CBAUD
, TARGET_B1200
, CBAUD
, B1200
},
2351 { TARGET_CBAUD
, TARGET_B1800
, CBAUD
, B1800
},
2352 { TARGET_CBAUD
, TARGET_B2400
, CBAUD
, B2400
},
2353 { TARGET_CBAUD
, TARGET_B4800
, CBAUD
, B4800
},
2354 { TARGET_CBAUD
, TARGET_B9600
, CBAUD
, B9600
},
2355 { TARGET_CBAUD
, TARGET_B19200
, CBAUD
, B19200
},
2356 { TARGET_CBAUD
, TARGET_B38400
, CBAUD
, B38400
},
2357 { TARGET_CBAUD
, TARGET_B57600
, CBAUD
, B57600
},
2358 { TARGET_CBAUD
, TARGET_B115200
, CBAUD
, B115200
},
2359 { TARGET_CBAUD
, TARGET_B230400
, CBAUD
, B230400
},
2360 { TARGET_CBAUD
, TARGET_B460800
, CBAUD
, B460800
},
2361 { TARGET_CSIZE
, TARGET_CS5
, CSIZE
, CS5
},
2362 { TARGET_CSIZE
, TARGET_CS6
, CSIZE
, CS6
},
2363 { TARGET_CSIZE
, TARGET_CS7
, CSIZE
, CS7
},
2364 { TARGET_CSIZE
, TARGET_CS8
, CSIZE
, CS8
},
2365 { TARGET_CSTOPB
, TARGET_CSTOPB
, CSTOPB
, CSTOPB
},
2366 { TARGET_CREAD
, TARGET_CREAD
, CREAD
, CREAD
},
2367 { TARGET_PARENB
, TARGET_PARENB
, PARENB
, PARENB
},
2368 { TARGET_PARODD
, TARGET_PARODD
, PARODD
, PARODD
},
2369 { TARGET_HUPCL
, TARGET_HUPCL
, HUPCL
, HUPCL
},
2370 { TARGET_CLOCAL
, TARGET_CLOCAL
, CLOCAL
, CLOCAL
},
2371 { TARGET_CRTSCTS
, TARGET_CRTSCTS
, CRTSCTS
, CRTSCTS
},
2375 static const bitmask_transtbl lflag_tbl
[] = {
2376 { TARGET_ISIG
, TARGET_ISIG
, ISIG
, ISIG
},
2377 { TARGET_ICANON
, TARGET_ICANON
, ICANON
, ICANON
},
2378 { TARGET_XCASE
, TARGET_XCASE
, XCASE
, XCASE
},
2379 { TARGET_ECHO
, TARGET_ECHO
, ECHO
, ECHO
},
2380 { TARGET_ECHOE
, TARGET_ECHOE
, ECHOE
, ECHOE
},
2381 { TARGET_ECHOK
, TARGET_ECHOK
, ECHOK
, ECHOK
},
2382 { TARGET_ECHONL
, TARGET_ECHONL
, ECHONL
, ECHONL
},
2383 { TARGET_NOFLSH
, TARGET_NOFLSH
, NOFLSH
, NOFLSH
},
2384 { TARGET_TOSTOP
, TARGET_TOSTOP
, TOSTOP
, TOSTOP
},
2385 { TARGET_ECHOCTL
, TARGET_ECHOCTL
, ECHOCTL
, ECHOCTL
},
2386 { TARGET_ECHOPRT
, TARGET_ECHOPRT
, ECHOPRT
, ECHOPRT
},
2387 { TARGET_ECHOKE
, TARGET_ECHOKE
, ECHOKE
, ECHOKE
},
2388 { TARGET_FLUSHO
, TARGET_FLUSHO
, FLUSHO
, FLUSHO
},
2389 { TARGET_PENDIN
, TARGET_PENDIN
, PENDIN
, PENDIN
},
2390 { TARGET_IEXTEN
, TARGET_IEXTEN
, IEXTEN
, IEXTEN
},
2394 static void target_to_host_termios (void *dst
, const void *src
)
2396 struct host_termios
*host
= dst
;
2397 const struct target_termios
*target
= src
;
2400 target_to_host_bitmask(tswap32(target
->c_iflag
), iflag_tbl
);
2402 target_to_host_bitmask(tswap32(target
->c_oflag
), oflag_tbl
);
2404 target_to_host_bitmask(tswap32(target
->c_cflag
), cflag_tbl
);
2406 target_to_host_bitmask(tswap32(target
->c_lflag
), lflag_tbl
);
2407 host
->c_line
= target
->c_line
;
2409 host
->c_cc
[VINTR
] = target
->c_cc
[TARGET_VINTR
];
2410 host
->c_cc
[VQUIT
] = target
->c_cc
[TARGET_VQUIT
];
2411 host
->c_cc
[VERASE
] = target
->c_cc
[TARGET_VERASE
];
2412 host
->c_cc
[VKILL
] = target
->c_cc
[TARGET_VKILL
];
2413 host
->c_cc
[VEOF
] = target
->c_cc
[TARGET_VEOF
];
2414 host
->c_cc
[VTIME
] = target
->c_cc
[TARGET_VTIME
];
2415 host
->c_cc
[VMIN
] = target
->c_cc
[TARGET_VMIN
];
2416 host
->c_cc
[VSWTC
] = target
->c_cc
[TARGET_VSWTC
];
2417 host
->c_cc
[VSTART
] = target
->c_cc
[TARGET_VSTART
];
2418 host
->c_cc
[VSTOP
] = target
->c_cc
[TARGET_VSTOP
];
2419 host
->c_cc
[VSUSP
] = target
->c_cc
[TARGET_VSUSP
];
2420 host
->c_cc
[VEOL
] = target
->c_cc
[TARGET_VEOL
];
2421 host
->c_cc
[VREPRINT
] = target
->c_cc
[TARGET_VREPRINT
];
2422 host
->c_cc
[VDISCARD
] = target
->c_cc
[TARGET_VDISCARD
];
2423 host
->c_cc
[VWERASE
] = target
->c_cc
[TARGET_VWERASE
];
2424 host
->c_cc
[VLNEXT
] = target
->c_cc
[TARGET_VLNEXT
];
2425 host
->c_cc
[VEOL2
] = target
->c_cc
[TARGET_VEOL2
];
2428 static void host_to_target_termios (void *dst
, const void *src
)
2430 struct target_termios
*target
= dst
;
2431 const struct host_termios
*host
= src
;
2434 tswap32(host_to_target_bitmask(host
->c_iflag
, iflag_tbl
));
2436 tswap32(host_to_target_bitmask(host
->c_oflag
, oflag_tbl
));
2438 tswap32(host_to_target_bitmask(host
->c_cflag
, cflag_tbl
));
2440 tswap32(host_to_target_bitmask(host
->c_lflag
, lflag_tbl
));
2441 target
->c_line
= host
->c_line
;
2443 target
->c_cc
[TARGET_VINTR
] = host
->c_cc
[VINTR
];
2444 target
->c_cc
[TARGET_VQUIT
] = host
->c_cc
[VQUIT
];
2445 target
->c_cc
[TARGET_VERASE
] = host
->c_cc
[VERASE
];
2446 target
->c_cc
[TARGET_VKILL
] = host
->c_cc
[VKILL
];
2447 target
->c_cc
[TARGET_VEOF
] = host
->c_cc
[VEOF
];
2448 target
->c_cc
[TARGET_VTIME
] = host
->c_cc
[VTIME
];
2449 target
->c_cc
[TARGET_VMIN
] = host
->c_cc
[VMIN
];
2450 target
->c_cc
[TARGET_VSWTC
] = host
->c_cc
[VSWTC
];
2451 target
->c_cc
[TARGET_VSTART
] = host
->c_cc
[VSTART
];
2452 target
->c_cc
[TARGET_VSTOP
] = host
->c_cc
[VSTOP
];
2453 target
->c_cc
[TARGET_VSUSP
] = host
->c_cc
[VSUSP
];
2454 target
->c_cc
[TARGET_VEOL
] = host
->c_cc
[VEOL
];
2455 target
->c_cc
[TARGET_VREPRINT
] = host
->c_cc
[VREPRINT
];
2456 target
->c_cc
[TARGET_VDISCARD
] = host
->c_cc
[VDISCARD
];
2457 target
->c_cc
[TARGET_VWERASE
] = host
->c_cc
[VWERASE
];
2458 target
->c_cc
[TARGET_VLNEXT
] = host
->c_cc
[VLNEXT
];
2459 target
->c_cc
[TARGET_VEOL2
] = host
->c_cc
[VEOL2
];
2462 static const StructEntry struct_termios_def
= {
2463 .convert
= { host_to_target_termios
, target_to_host_termios
},
2464 .size
= { sizeof(struct target_termios
), sizeof(struct host_termios
) },
2465 .align
= { __alignof__(struct target_termios
), __alignof__(struct host_termios
) },
2468 static bitmask_transtbl mmap_flags_tbl
[] = {
2469 { TARGET_MAP_SHARED
, TARGET_MAP_SHARED
, MAP_SHARED
, MAP_SHARED
},
2470 { TARGET_MAP_PRIVATE
, TARGET_MAP_PRIVATE
, MAP_PRIVATE
, MAP_PRIVATE
},
2471 { TARGET_MAP_FIXED
, TARGET_MAP_FIXED
, MAP_FIXED
, MAP_FIXED
},
2472 { TARGET_MAP_ANONYMOUS
, TARGET_MAP_ANONYMOUS
, MAP_ANONYMOUS
, MAP_ANONYMOUS
},
2473 { TARGET_MAP_GROWSDOWN
, TARGET_MAP_GROWSDOWN
, MAP_GROWSDOWN
, MAP_GROWSDOWN
},
2474 { TARGET_MAP_DENYWRITE
, TARGET_MAP_DENYWRITE
, MAP_DENYWRITE
, MAP_DENYWRITE
},
2475 { TARGET_MAP_EXECUTABLE
, TARGET_MAP_EXECUTABLE
, MAP_EXECUTABLE
, MAP_EXECUTABLE
},
2476 { TARGET_MAP_LOCKED
, TARGET_MAP_LOCKED
, MAP_LOCKED
, MAP_LOCKED
},
2480 static bitmask_transtbl fcntl_flags_tbl
[] = {
2481 { TARGET_O_ACCMODE
, TARGET_O_WRONLY
, O_ACCMODE
, O_WRONLY
, },
2482 { TARGET_O_ACCMODE
, TARGET_O_RDWR
, O_ACCMODE
, O_RDWR
, },
2483 { TARGET_O_CREAT
, TARGET_O_CREAT
, O_CREAT
, O_CREAT
, },
2484 { TARGET_O_EXCL
, TARGET_O_EXCL
, O_EXCL
, O_EXCL
, },
2485 { TARGET_O_NOCTTY
, TARGET_O_NOCTTY
, O_NOCTTY
, O_NOCTTY
, },
2486 { TARGET_O_TRUNC
, TARGET_O_TRUNC
, O_TRUNC
, O_TRUNC
, },
2487 { TARGET_O_APPEND
, TARGET_O_APPEND
, O_APPEND
, O_APPEND
, },
2488 { TARGET_O_NONBLOCK
, TARGET_O_NONBLOCK
, O_NONBLOCK
, O_NONBLOCK
, },
2489 { TARGET_O_SYNC
, TARGET_O_SYNC
, O_SYNC
, O_SYNC
, },
2490 { TARGET_FASYNC
, TARGET_FASYNC
, FASYNC
, FASYNC
, },
2491 { TARGET_O_DIRECTORY
, TARGET_O_DIRECTORY
, O_DIRECTORY
, O_DIRECTORY
, },
2492 { TARGET_O_NOFOLLOW
, TARGET_O_NOFOLLOW
, O_NOFOLLOW
, O_NOFOLLOW
, },
2493 { TARGET_O_LARGEFILE
, TARGET_O_LARGEFILE
, O_LARGEFILE
, O_LARGEFILE
, },
2494 #if defined(O_DIRECT)
2495 { TARGET_O_DIRECT
, TARGET_O_DIRECT
, O_DIRECT
, O_DIRECT
, },
2500 #if defined(TARGET_I386)
2502 /* NOTE: there is really one LDT for all the threads */
2503 static uint8_t *ldt_table
;
2505 static abi_long
read_ldt(abi_ulong ptr
, unsigned long bytecount
)
2512 size
= TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
;
2513 if (size
> bytecount
)
2515 p
= lock_user(VERIFY_WRITE
, ptr
, size
, 0);
2517 return -TARGET_EFAULT
;
2518 /* ??? Should this by byteswapped? */
2519 memcpy(p
, ldt_table
, size
);
2520 unlock_user(p
, ptr
, size
);
2524 /* XXX: add locking support */
2525 static abi_long
write_ldt(CPUX86State
*env
,
2526 abi_ulong ptr
, unsigned long bytecount
, int oldmode
)
2528 struct target_modify_ldt_ldt_s ldt_info
;
2529 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2530 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
2531 int seg_not_present
, useable
, lm
;
2532 uint32_t *lp
, entry_1
, entry_2
;
2534 if (bytecount
!= sizeof(ldt_info
))
2535 return -TARGET_EINVAL
;
2536 if (!lock_user_struct(VERIFY_READ
, target_ldt_info
, ptr
, 1))
2537 return -TARGET_EFAULT
;
2538 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
2539 ldt_info
.base_addr
= tswapl(target_ldt_info
->base_addr
);
2540 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
2541 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
2542 unlock_user_struct(target_ldt_info
, ptr
, 0);
2544 if (ldt_info
.entry_number
>= TARGET_LDT_ENTRIES
)
2545 return -TARGET_EINVAL
;
2546 seg_32bit
= ldt_info
.flags
& 1;
2547 contents
= (ldt_info
.flags
>> 1) & 3;
2548 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
2549 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
2550 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
2551 useable
= (ldt_info
.flags
>> 6) & 1;
2555 lm
= (ldt_info
.flags
>> 7) & 1;
2557 if (contents
== 3) {
2559 return -TARGET_EINVAL
;
2560 if (seg_not_present
== 0)
2561 return -TARGET_EINVAL
;
2563 /* allocate the LDT */
2565 ldt_table
= malloc(TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
2567 return -TARGET_ENOMEM
;
2568 memset(ldt_table
, 0, TARGET_LDT_ENTRIES
* TARGET_LDT_ENTRY_SIZE
);
2569 env
->ldt
.base
= h2g((unsigned long)ldt_table
);
2570 env
->ldt
.limit
= 0xffff;
2573 /* NOTE: same code as Linux kernel */
2574 /* Allow LDTs to be cleared by the user. */
2575 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
2578 read_exec_only
== 1 &&
2580 limit_in_pages
== 0 &&
2581 seg_not_present
== 1 &&
2589 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
2590 (ldt_info
.limit
& 0x0ffff);
2591 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
2592 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
2593 (ldt_info
.limit
& 0xf0000) |
2594 ((read_exec_only
^ 1) << 9) |
2596 ((seg_not_present
^ 1) << 15) |
2598 (limit_in_pages
<< 23) |
2602 entry_2
|= (useable
<< 20);
2604 /* Install the new entry ... */
2606 lp
= (uint32_t *)(ldt_table
+ (ldt_info
.entry_number
<< 3));
2607 lp
[0] = tswap32(entry_1
);
2608 lp
[1] = tswap32(entry_2
);
2612 /* specific and weird i386 syscalls */
2613 static abi_long
do_modify_ldt(CPUX86State
*env
, int func
, abi_ulong ptr
,
2614 unsigned long bytecount
)
2620 ret
= read_ldt(ptr
, bytecount
);
2623 ret
= write_ldt(env
, ptr
, bytecount
, 1);
2626 ret
= write_ldt(env
, ptr
, bytecount
, 0);
2629 ret
= -TARGET_ENOSYS
;
2635 #if defined(TARGET_I386) && defined(TARGET_ABI32)
2636 static abi_long
do_set_thread_area(CPUX86State
*env
, abi_ulong ptr
)
2638 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
2639 struct target_modify_ldt_ldt_s ldt_info
;
2640 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2641 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
;
2642 int seg_not_present
, useable
, lm
;
2643 uint32_t *lp
, entry_1
, entry_2
;
2646 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
2647 if (!target_ldt_info
)
2648 return -TARGET_EFAULT
;
2649 ldt_info
.entry_number
= tswap32(target_ldt_info
->entry_number
);
2650 ldt_info
.base_addr
= tswapl(target_ldt_info
->base_addr
);
2651 ldt_info
.limit
= tswap32(target_ldt_info
->limit
);
2652 ldt_info
.flags
= tswap32(target_ldt_info
->flags
);
2653 if (ldt_info
.entry_number
== -1) {
2654 for (i
=TARGET_GDT_ENTRY_TLS_MIN
; i
<=TARGET_GDT_ENTRY_TLS_MAX
; i
++) {
2655 if (gdt_table
[i
] == 0) {
2656 ldt_info
.entry_number
= i
;
2657 target_ldt_info
->entry_number
= tswap32(i
);
2662 unlock_user_struct(target_ldt_info
, ptr
, 1);
2664 if (ldt_info
.entry_number
< TARGET_GDT_ENTRY_TLS_MIN
||
2665 ldt_info
.entry_number
> TARGET_GDT_ENTRY_TLS_MAX
)
2666 return -TARGET_EINVAL
;
2667 seg_32bit
= ldt_info
.flags
& 1;
2668 contents
= (ldt_info
.flags
>> 1) & 3;
2669 read_exec_only
= (ldt_info
.flags
>> 3) & 1;
2670 limit_in_pages
= (ldt_info
.flags
>> 4) & 1;
2671 seg_not_present
= (ldt_info
.flags
>> 5) & 1;
2672 useable
= (ldt_info
.flags
>> 6) & 1;
2676 lm
= (ldt_info
.flags
>> 7) & 1;
2679 if (contents
== 3) {
2680 if (seg_not_present
== 0)
2681 return -TARGET_EINVAL
;
2684 /* NOTE: same code as Linux kernel */
2685 /* Allow LDTs to be cleared by the user. */
2686 if (ldt_info
.base_addr
== 0 && ldt_info
.limit
== 0) {
2687 if ((contents
== 0 &&
2688 read_exec_only
== 1 &&
2690 limit_in_pages
== 0 &&
2691 seg_not_present
== 1 &&
2699 entry_1
= ((ldt_info
.base_addr
& 0x0000ffff) << 16) |
2700 (ldt_info
.limit
& 0x0ffff);
2701 entry_2
= (ldt_info
.base_addr
& 0xff000000) |
2702 ((ldt_info
.base_addr
& 0x00ff0000) >> 16) |
2703 (ldt_info
.limit
& 0xf0000) |
2704 ((read_exec_only
^ 1) << 9) |
2706 ((seg_not_present
^ 1) << 15) |
2708 (limit_in_pages
<< 23) |
2713 /* Install the new entry ... */
2715 lp
= (uint32_t *)(gdt_table
+ ldt_info
.entry_number
);
2716 lp
[0] = tswap32(entry_1
);
2717 lp
[1] = tswap32(entry_2
);
2721 static abi_long
do_get_thread_area(CPUX86State
*env
, abi_ulong ptr
)
2723 struct target_modify_ldt_ldt_s
*target_ldt_info
;
2724 uint64_t *gdt_table
= g2h(env
->gdt
.base
);
2725 uint32_t base_addr
, limit
, flags
;
2726 int seg_32bit
, contents
, read_exec_only
, limit_in_pages
, idx
;
2727 int seg_not_present
, useable
, lm
;
2728 uint32_t *lp
, entry_1
, entry_2
;
2730 lock_user_struct(VERIFY_WRITE
, target_ldt_info
, ptr
, 1);
2731 if (!target_ldt_info
)
2732 return -TARGET_EFAULT
;
2733 idx
= tswap32(target_ldt_info
->entry_number
);
2734 if (idx
< TARGET_GDT_ENTRY_TLS_MIN
||
2735 idx
> TARGET_GDT_ENTRY_TLS_MAX
) {
2736 unlock_user_struct(target_ldt_info
, ptr
, 1);
2737 return -TARGET_EINVAL
;
2739 lp
= (uint32_t *)(gdt_table
+ idx
);
2740 entry_1
= tswap32(lp
[0]);
2741 entry_2
= tswap32(lp
[1]);
2743 read_exec_only
= ((entry_2
>> 9) & 1) ^ 1;
2744 contents
= (entry_2
>> 10) & 3;
2745 seg_not_present
= ((entry_2
>> 15) & 1) ^ 1;
2746 seg_32bit
= (entry_2
>> 22) & 1;
2747 limit_in_pages
= (entry_2
>> 23) & 1;
2748 useable
= (entry_2
>> 20) & 1;
2752 lm
= (entry_2
>> 21) & 1;
2754 flags
= (seg_32bit
<< 0) | (contents
<< 1) |
2755 (read_exec_only
<< 3) | (limit_in_pages
<< 4) |
2756 (seg_not_present
<< 5) | (useable
<< 6) | (lm
<< 7);
2757 limit
= (entry_1
& 0xffff) | (entry_2
& 0xf0000);
2758 base_addr
= (entry_1
>> 16) |
2759 (entry_2
& 0xff000000) |
2760 ((entry_2
& 0xff) << 16);
2761 target_ldt_info
->base_addr
= tswapl(base_addr
);
2762 target_ldt_info
->limit
= tswap32(limit
);
2763 target_ldt_info
->flags
= tswap32(flags
);
2764 unlock_user_struct(target_ldt_info
, ptr
, 1);
2767 #endif /* TARGET_I386 && TARGET_ABI32 */
2769 #ifndef TARGET_ABI32
2770 static abi_long
do_arch_prctl(CPUX86State
*env
, int code
, abi_ulong addr
)
2777 case TARGET_ARCH_SET_GS
:
2778 case TARGET_ARCH_SET_FS
:
2779 if (code
== TARGET_ARCH_SET_GS
)
2783 cpu_x86_load_seg(env
, idx
, 0);
2784 env
->segs
[idx
].base
= addr
;
2786 case TARGET_ARCH_GET_GS
:
2787 case TARGET_ARCH_GET_FS
:
2788 if (code
== TARGET_ARCH_GET_GS
)
2792 val
= env
->segs
[idx
].base
;
2793 if (put_user(val
, addr
, abi_ulong
))
2794 return -TARGET_EFAULT
;
2797 ret
= -TARGET_EINVAL
;
2804 #endif /* defined(TARGET_I386) */
2806 #if defined(USE_NPTL)
2808 #define NEW_STACK_SIZE PTHREAD_STACK_MIN
2810 static pthread_mutex_t clone_lock
= PTHREAD_MUTEX_INITIALIZER
;
2813 pthread_mutex_t mutex
;
2814 pthread_cond_t cond
;
2817 abi_ulong child_tidptr
;
2818 abi_ulong parent_tidptr
;
2822 static void *clone_func(void *arg
)
2824 new_thread_info
*info
= arg
;
2829 info
->tid
= gettid();
2830 if (info
->child_tidptr
)
2831 put_user_u32(info
->tid
, info
->child_tidptr
);
2832 if (info
->parent_tidptr
)
2833 put_user_u32(info
->tid
, info
->parent_tidptr
);
2834 /* Enable signals. */
2835 sigprocmask(SIG_SETMASK
, &info
->sigmask
, NULL
);
2836 /* Signal to the parent that we're ready. */
2837 pthread_mutex_lock(&info
->mutex
);
2838 pthread_cond_broadcast(&info
->cond
);
2839 pthread_mutex_unlock(&info
->mutex
);
2840 /* Wait until the parent has finshed initializing the tls state. */
2841 pthread_mutex_lock(&clone_lock
);
2842 pthread_mutex_unlock(&clone_lock
);
2848 /* this stack is the equivalent of the kernel stack associated with a
2850 #define NEW_STACK_SIZE 8192
2852 static int clone_func(void *arg
)
2854 CPUState
*env
= arg
;
2861 /* do_fork() Must return host values and target errnos (unlike most
2862 do_*() functions). */
2863 static int do_fork(CPUState
*env
, unsigned int flags
, abi_ulong newsp
,
2864 abi_ulong parent_tidptr
, target_ulong newtls
,
2865 abi_ulong child_tidptr
)
2871 #if defined(USE_NPTL)
2872 unsigned int nptl_flags
;
2876 /* Emulate vfork() with fork() */
2877 if (flags
& CLONE_VFORK
)
2878 flags
&= ~(CLONE_VFORK
| CLONE_VM
);
2880 if (flags
& CLONE_VM
) {
2881 #if defined(USE_NPTL)
2882 new_thread_info info
;
2883 pthread_attr_t attr
;
2885 ts
= qemu_mallocz(sizeof(TaskState
) + NEW_STACK_SIZE
);
2886 init_task_state(ts
);
2887 new_stack
= ts
->stack
;
2888 /* we create a new CPU instance. */
2889 new_env
= cpu_copy(env
);
2890 /* Init regs that differ from the parent. */
2891 cpu_clone_regs(new_env
, newsp
);
2892 new_env
->opaque
= ts
;
2893 #if defined(USE_NPTL)
2895 flags
&= ~CLONE_NPTL_FLAGS2
;
2897 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2898 if (nptl_flags
& CLONE_SETTLS
)
2899 cpu_set_tls (new_env
, newtls
);
2901 /* Grab a mutex so that thread setup appears atomic. */
2902 pthread_mutex_lock(&clone_lock
);
2904 memset(&info
, 0, sizeof(info
));
2905 pthread_mutex_init(&info
.mutex
, NULL
);
2906 pthread_mutex_lock(&info
.mutex
);
2907 pthread_cond_init(&info
.cond
, NULL
);
2909 if (nptl_flags
& CLONE_CHILD_SETTID
)
2910 info
.child_tidptr
= child_tidptr
;
2911 if (nptl_flags
& CLONE_PARENT_SETTID
)
2912 info
.parent_tidptr
= parent_tidptr
;
2914 ret
= pthread_attr_init(&attr
);
2915 ret
= pthread_attr_setstack(&attr
, new_stack
, NEW_STACK_SIZE
);
2916 /* It is not safe to deliver signals until the child has finished
2917 initializing, so temporarily block all signals. */
2918 sigfillset(&sigmask
);
2919 sigprocmask(SIG_BLOCK
, &sigmask
, &info
.sigmask
);
2921 ret
= pthread_create(&info
.thread
, &attr
, clone_func
, &info
);
2923 sigprocmask(SIG_SETMASK
, &info
.sigmask
, NULL
);
2924 pthread_attr_destroy(&attr
);
2926 /* Wait for the child to initialize. */
2927 pthread_cond_wait(&info
.cond
, &info
.mutex
);
2929 if (flags
& CLONE_PARENT_SETTID
)
2930 put_user_u32(ret
, parent_tidptr
);
2934 pthread_mutex_unlock(&info
.mutex
);
2935 pthread_cond_destroy(&info
.cond
);
2936 pthread_mutex_destroy(&info
.mutex
);
2937 pthread_mutex_unlock(&clone_lock
);
2939 if (flags
& CLONE_NPTL_FLAGS2
)
2941 /* This is probably going to die very quickly, but do it anyway. */
2943 ret
= __clone2(clone_func
, new_stack
+ NEW_STACK_SIZE
, flags
, new_env
);
2945 ret
= clone(clone_func
, new_stack
+ NEW_STACK_SIZE
, flags
, new_env
);
2949 /* if no CLONE_VM, we consider it is a fork */
2950 if ((flags
& ~(CSIGNAL
| CLONE_NPTL_FLAGS2
)) != 0)
2954 #if defined(USE_NPTL)
2955 /* There is a race condition here. The parent process could
2956 theoretically read the TID in the child process before the child
2957 tid is set. This would require using either ptrace
2958 (not implemented) or having *_tidptr to point at a shared memory
2959 mapping. We can't repeat the spinlock hack used above because
2960 the child process gets its own copy of the lock. */
2962 cpu_clone_regs(env
, newsp
);
2964 /* Child Process. */
2965 if (flags
& CLONE_CHILD_SETTID
)
2966 put_user_u32(gettid(), child_tidptr
);
2967 if (flags
& CLONE_PARENT_SETTID
)
2968 put_user_u32(gettid(), parent_tidptr
);
2969 ts
= (TaskState
*)env
->opaque
;
2970 if (flags
& CLONE_SETTLS
)
2971 cpu_set_tls (env
, newtls
);
2972 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2978 cpu_clone_regs(env
, newsp
);
2985 static abi_long
do_fcntl(int fd
, int cmd
, abi_ulong arg
)
2988 struct target_flock
*target_fl
;
2989 struct flock64 fl64
;
2990 struct target_flock64
*target_fl64
;
2994 case TARGET_F_GETLK
:
2995 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
2996 return -TARGET_EFAULT
;
2997 fl
.l_type
= tswap16(target_fl
->l_type
);
2998 fl
.l_whence
= tswap16(target_fl
->l_whence
);
2999 fl
.l_start
= tswapl(target_fl
->l_start
);
3000 fl
.l_len
= tswapl(target_fl
->l_len
);
3001 fl
.l_pid
= tswapl(target_fl
->l_pid
);
3002 unlock_user_struct(target_fl
, arg
, 0);
3003 ret
= get_errno(fcntl(fd
, cmd
, &fl
));
3005 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg
, 0))
3006 return -TARGET_EFAULT
;
3007 target_fl
->l_type
= tswap16(fl
.l_type
);
3008 target_fl
->l_whence
= tswap16(fl
.l_whence
);
3009 target_fl
->l_start
= tswapl(fl
.l_start
);
3010 target_fl
->l_len
= tswapl(fl
.l_len
);
3011 target_fl
->l_pid
= tswapl(fl
.l_pid
);
3012 unlock_user_struct(target_fl
, arg
, 1);
3016 case TARGET_F_SETLK
:
3017 case TARGET_F_SETLKW
:
3018 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg
, 1))
3019 return -TARGET_EFAULT
;
3020 fl
.l_type
= tswap16(target_fl
->l_type
);
3021 fl
.l_whence
= tswap16(target_fl
->l_whence
);
3022 fl
.l_start
= tswapl(target_fl
->l_start
);
3023 fl
.l_len
= tswapl(target_fl
->l_len
);
3024 fl
.l_pid
= tswapl(target_fl
->l_pid
);
3025 unlock_user_struct(target_fl
, arg
, 0);
3026 ret
= get_errno(fcntl(fd
, cmd
, &fl
));
3029 case TARGET_F_GETLK64
:
3030 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
3031 return -TARGET_EFAULT
;
3032 fl64
.l_type
= tswap16(target_fl64
->l_type
) >> 1;
3033 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
3034 fl64
.l_start
= tswapl(target_fl64
->l_start
);
3035 fl64
.l_len
= tswapl(target_fl64
->l_len
);
3036 fl64
.l_pid
= tswap16(target_fl64
->l_pid
);
3037 unlock_user_struct(target_fl64
, arg
, 0);
3038 ret
= get_errno(fcntl(fd
, cmd
>> 1, &fl64
));
3040 if (!lock_user_struct(VERIFY_WRITE
, target_fl64
, arg
, 0))
3041 return -TARGET_EFAULT
;
3042 target_fl64
->l_type
= tswap16(fl64
.l_type
) >> 1;
3043 target_fl64
->l_whence
= tswap16(fl64
.l_whence
);
3044 target_fl64
->l_start
= tswapl(fl64
.l_start
);
3045 target_fl64
->l_len
= tswapl(fl64
.l_len
);
3046 target_fl64
->l_pid
= tswapl(fl64
.l_pid
);
3047 unlock_user_struct(target_fl64
, arg
, 1);
3050 case TARGET_F_SETLK64
:
3051 case TARGET_F_SETLKW64
:
3052 if (!lock_user_struct(VERIFY_READ
, target_fl64
, arg
, 1))
3053 return -TARGET_EFAULT
;
3054 fl64
.l_type
= tswap16(target_fl64
->l_type
) >> 1;
3055 fl64
.l_whence
= tswap16(target_fl64
->l_whence
);
3056 fl64
.l_start
= tswapl(target_fl64
->l_start
);
3057 fl64
.l_len
= tswapl(target_fl64
->l_len
);
3058 fl64
.l_pid
= tswap16(target_fl64
->l_pid
);
3059 unlock_user_struct(target_fl64
, arg
, 0);
3060 ret
= get_errno(fcntl(fd
, cmd
>> 1, &fl64
));
3064 ret
= get_errno(fcntl(fd
, cmd
, arg
));
3066 ret
= host_to_target_bitmask(ret
, fcntl_flags_tbl
);
3071 ret
= get_errno(fcntl(fd
, cmd
, target_to_host_bitmask(arg
, fcntl_flags_tbl
)));
3075 ret
= get_errno(fcntl(fd
, cmd
, arg
));
3083 static inline int high2lowuid(int uid
)
3091 static inline int high2lowgid(int gid
)
3099 static inline int low2highuid(int uid
)
3101 if ((int16_t)uid
== -1)
3107 static inline int low2highgid(int gid
)
3109 if ((int16_t)gid
== -1)
3115 #endif /* USE_UID16 */
3117 void syscall_init(void)
3120 const argtype
*arg_type
;
3124 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3125 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
3126 #include "syscall_types.h"
3128 #undef STRUCT_SPECIAL
3130 /* we patch the ioctl size if necessary. We rely on the fact that
3131 no ioctl has all the bits at '1' in the size field */
3133 while (ie
->target_cmd
!= 0) {
3134 if (((ie
->target_cmd
>> TARGET_IOC_SIZESHIFT
) & TARGET_IOC_SIZEMASK
) ==
3135 TARGET_IOC_SIZEMASK
) {
3136 arg_type
= ie
->arg_type
;
3137 if (arg_type
[0] != TYPE_PTR
) {
3138 fprintf(stderr
, "cannot patch size for ioctl 0x%x\n",
3143 size
= thunk_type_size(arg_type
, 0);
3144 ie
->target_cmd
= (ie
->target_cmd
&
3145 ~(TARGET_IOC_SIZEMASK
<< TARGET_IOC_SIZESHIFT
)) |
3146 (size
<< TARGET_IOC_SIZESHIFT
);
3149 /* Build target_to_host_errno_table[] table from
3150 * host_to_target_errno_table[]. */
3151 for (i
=0; i
< ERRNO_TABLE_SIZE
; i
++)
3152 target_to_host_errno_table
[host_to_target_errno_table
[i
]] = i
;
3154 /* automatic consistency check if same arch */
3155 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
3156 (defined(__x86_64__) && defined(TARGET_X86_64))
3157 if (unlikely(ie
->target_cmd
!= ie
->host_cmd
)) {
3158 fprintf(stderr
, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
3159 ie
->name
, ie
->target_cmd
, ie
->host_cmd
);
3166 #if TARGET_ABI_BITS == 32
3167 static inline uint64_t target_offset64(uint32_t word0
, uint32_t word1
)
3169 #ifdef TARGET_WORDS_BIGENDIAN
3170 return ((uint64_t)word0
<< 32) | word1
;
3172 return ((uint64_t)word1
<< 32) | word0
;
3175 #else /* TARGET_ABI_BITS == 32 */
3176 static inline uint64_t target_offset64(uint64_t word0
, uint64_t word1
)
3180 #endif /* TARGET_ABI_BITS != 32 */
3182 #ifdef TARGET_NR_truncate64
3183 static inline abi_long
target_truncate64(void *cpu_env
, const char *arg1
,
3189 if (((CPUARMState
*)cpu_env
)->eabi
)
3195 return get_errno(truncate64(arg1
, target_offset64(arg2
, arg3
)));
3199 #ifdef TARGET_NR_ftruncate64
3200 static inline abi_long
target_ftruncate64(void *cpu_env
, abi_long arg1
,
3206 if (((CPUARMState
*)cpu_env
)->eabi
)
3212 return get_errno(ftruncate64(arg1
, target_offset64(arg2
, arg3
)));
3216 static inline abi_long
target_to_host_timespec(struct timespec
*host_ts
,
3217 abi_ulong target_addr
)
3219 struct target_timespec
*target_ts
;
3221 if (!lock_user_struct(VERIFY_READ
, target_ts
, target_addr
, 1))
3222 return -TARGET_EFAULT
;
3223 host_ts
->tv_sec
= tswapl(target_ts
->tv_sec
);
3224 host_ts
->tv_nsec
= tswapl(target_ts
->tv_nsec
);
3225 unlock_user_struct(target_ts
, target_addr
, 0);
3229 static inline abi_long
host_to_target_timespec(abi_ulong target_addr
,
3230 struct timespec
*host_ts
)
3232 struct target_timespec
*target_ts
;
3234 if (!lock_user_struct(VERIFY_WRITE
, target_ts
, target_addr
, 0))
3235 return -TARGET_EFAULT
;
3236 target_ts
->tv_sec
= tswapl(host_ts
->tv_sec
);
3237 target_ts
->tv_nsec
= tswapl(host_ts
->tv_nsec
);
3238 unlock_user_struct(target_ts
, target_addr
, 1);
3242 #ifdef TARGET_NR_stat64
3243 static inline abi_long
host_to_target_stat64(void *cpu_env
,
3244 abi_ulong target_addr
,
3245 struct stat
*host_st
)
3248 if (((CPUARMState
*)cpu_env
)->eabi
) {
3249 struct target_eabi_stat64
*target_st
;
3251 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
3252 return -TARGET_EFAULT
;
3253 memset(target_st
, 0, sizeof(struct target_eabi_stat64
));
3254 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
3255 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
3256 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3257 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
3259 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
3260 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
3261 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
3262 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
3263 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
3264 __put_user(host_st
->st_size
, &target_st
->st_size
);
3265 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
3266 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
3267 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
3268 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
3269 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
3270 unlock_user_struct(target_st
, target_addr
, 1);
3274 struct target_stat64
*target_st
;
3276 if (!lock_user_struct(VERIFY_WRITE
, target_st
, target_addr
, 0))
3277 return -TARGET_EFAULT
;
3278 memset(target_st
, 0, sizeof(struct target_stat64
));
3279 __put_user(host_st
->st_dev
, &target_st
->st_dev
);
3280 __put_user(host_st
->st_ino
, &target_st
->st_ino
);
3281 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3282 __put_user(host_st
->st_ino
, &target_st
->__st_ino
);
3284 __put_user(host_st
->st_mode
, &target_st
->st_mode
);
3285 __put_user(host_st
->st_nlink
, &target_st
->st_nlink
);
3286 __put_user(host_st
->st_uid
, &target_st
->st_uid
);
3287 __put_user(host_st
->st_gid
, &target_st
->st_gid
);
3288 __put_user(host_st
->st_rdev
, &target_st
->st_rdev
);
3289 /* XXX: better use of kernel struct */
3290 __put_user(host_st
->st_size
, &target_st
->st_size
);
3291 __put_user(host_st
->st_blksize
, &target_st
->st_blksize
);
3292 __put_user(host_st
->st_blocks
, &target_st
->st_blocks
);
3293 __put_user(host_st
->st_atime
, &target_st
->target_st_atime
);
3294 __put_user(host_st
->st_mtime
, &target_st
->target_st_mtime
);
3295 __put_user(host_st
->st_ctime
, &target_st
->target_st_ctime
);
3296 unlock_user_struct(target_st
, target_addr
, 1);
3303 #if defined(USE_NPTL)
3304 /* ??? Using host futex calls even when target atomic operations
3305 are not really atomic probably breaks things. However implementing
3306 futexes locally would make futexes shared between multiple processes
3307 tricky. However they're probably useless because guest atomic
3308 operations won't work either. */
3309 static int do_futex(target_ulong uaddr
, int op
, int val
, target_ulong timeout
,
3310 target_ulong uaddr2
, int val3
)
3312 struct timespec ts
, *pts
;
3314 /* ??? We assume FUTEX_* constants are the same on both host
3320 target_to_host_timespec(pts
, timeout
);
3324 return get_errno(sys_futex(g2h(uaddr
), FUTEX_WAIT
, tswap32(val
),
3327 return get_errno(sys_futex(g2h(uaddr
), FUTEX_WAKE
, val
, NULL
, NULL
, 0));
3329 return get_errno(sys_futex(g2h(uaddr
), FUTEX_FD
, val
, NULL
, NULL
, 0));
3331 return get_errno(sys_futex(g2h(uaddr
), FUTEX_REQUEUE
, val
,
3332 NULL
, g2h(uaddr2
), 0));
3333 case FUTEX_CMP_REQUEUE
:
3334 return get_errno(sys_futex(g2h(uaddr
), FUTEX_CMP_REQUEUE
, val
,
3335 NULL
, g2h(uaddr2
), tswap32(val3
)));
3337 return -TARGET_ENOSYS
;
3342 int get_osversion(void)
3344 static int osversion
;
3345 struct new_utsname buf
;
3350 if (qemu_uname_release
&& *qemu_uname_release
) {
3351 s
= qemu_uname_release
;
3353 if (sys_uname(&buf
))
3358 for (i
= 0; i
< 3; i
++) {
3360 while (*s
>= '0' && *s
<= '9') {
3365 tmp
= (tmp
<< 8) + n
;
3373 /* do_syscall() should always have a single exit point at the end so
3374 that actions, such as logging of syscall results, can be performed.
3375 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
3376 abi_long
do_syscall(void *cpu_env
, int num
, abi_long arg1
,
3377 abi_long arg2
, abi_long arg3
, abi_long arg4
,
3378 abi_long arg5
, abi_long arg6
)
3386 gemu_log("syscall %d", num
);
3389 print_syscall(num
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
3392 case TARGET_NR_exit
:
3396 gdb_exit(cpu_env
, arg1
);
3397 /* XXX: should free thread stack and CPU env */
3399 ret
= 0; /* avoid warning */
3401 case TARGET_NR_read
:
3402 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
3404 ret
= get_errno(read(arg1
, p
, arg3
));
3405 unlock_user(p
, arg2
, ret
);
3407 case TARGET_NR_write
:
3408 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
3410 ret
= get_errno(write(arg1
, p
, arg3
));
3411 unlock_user(p
, arg2
, 0);
3413 case TARGET_NR_open
:
3414 if (!(p
= lock_user_string(arg1
)))
3416 ret
= get_errno(open(path(p
),
3417 target_to_host_bitmask(arg2
, fcntl_flags_tbl
),
3419 unlock_user(p
, arg1
, 0);
3421 #if defined(TARGET_NR_openat) && defined(__NR_openat)
3422 case TARGET_NR_openat
:
3423 if (!(p
= lock_user_string(arg2
)))
3425 ret
= get_errno(sys_openat(arg1
,
3427 target_to_host_bitmask(arg3
, fcntl_flags_tbl
),
3429 unlock_user(p
, arg2
, 0);
3432 case TARGET_NR_close
:
3433 ret
= get_errno(close(arg1
));
3438 case TARGET_NR_fork
:
3439 ret
= get_errno(do_fork(cpu_env
, SIGCHLD
, 0, 0, 0, 0));
3441 #ifdef TARGET_NR_waitpid
3442 case TARGET_NR_waitpid
:
3445 ret
= get_errno(waitpid(arg1
, &status
, arg3
));
3446 if (!is_error(ret
) && arg2
3447 && put_user_s32(status
, arg2
))
3452 #ifdef TARGET_NR_waitid
3453 case TARGET_NR_waitid
:
3457 ret
= get_errno(waitid(arg1
, arg2
, &info
, arg4
));
3458 if (!is_error(ret
) && arg3
&& info
.si_pid
!= 0) {
3459 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_siginfo_t
), 0)))
3461 host_to_target_siginfo(p
, &info
);
3462 unlock_user(p
, arg3
, sizeof(target_siginfo_t
));
3467 #ifdef TARGET_NR_creat /* not on alpha */
3468 case TARGET_NR_creat
:
3469 if (!(p
= lock_user_string(arg1
)))
3471 ret
= get_errno(creat(p
, arg2
));
3472 unlock_user(p
, arg1
, 0);
3475 case TARGET_NR_link
:
3478 p
= lock_user_string(arg1
);
3479 p2
= lock_user_string(arg2
);
3481 ret
= -TARGET_EFAULT
;
3483 ret
= get_errno(link(p
, p2
));
3484 unlock_user(p2
, arg2
, 0);
3485 unlock_user(p
, arg1
, 0);
3488 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3489 case TARGET_NR_linkat
:
3494 p
= lock_user_string(arg2
);
3495 p2
= lock_user_string(arg4
);
3497 ret
= -TARGET_EFAULT
;
3499 ret
= get_errno(sys_linkat(arg1
, p
, arg3
, p2
, arg5
));
3500 unlock_user(p
, arg2
, 0);
3501 unlock_user(p2
, arg4
, 0);
3505 case TARGET_NR_unlink
:
3506 if (!(p
= lock_user_string(arg1
)))
3508 ret
= get_errno(unlink(p
));
3509 unlock_user(p
, arg1
, 0);
3511 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3512 case TARGET_NR_unlinkat
:
3513 if (!(p
= lock_user_string(arg2
)))
3515 ret
= get_errno(sys_unlinkat(arg1
, p
, arg3
));
3516 unlock_user(p
, arg2
, 0);
3519 case TARGET_NR_execve
:
3521 char **argp
, **envp
;
3524 abi_ulong guest_argp
;
3525 abi_ulong guest_envp
;
3531 for (gp
= guest_argp
; gp
; gp
+= sizeof(abi_ulong
)) {
3532 if (get_user_ual(addr
, gp
))
3540 for (gp
= guest_envp
; gp
; gp
+= sizeof(abi_ulong
)) {
3541 if (get_user_ual(addr
, gp
))
3548 argp
= alloca((argc
+ 1) * sizeof(void *));
3549 envp
= alloca((envc
+ 1) * sizeof(void *));
3551 for (gp
= guest_argp
, q
= argp
; gp
;
3552 gp
+= sizeof(abi_ulong
), q
++) {
3553 if (get_user_ual(addr
, gp
))
3557 if (!(*q
= lock_user_string(addr
)))
3562 for (gp
= guest_envp
, q
= envp
; gp
;
3563 gp
+= sizeof(abi_ulong
), q
++) {
3564 if (get_user_ual(addr
, gp
))
3568 if (!(*q
= lock_user_string(addr
)))
3573 if (!(p
= lock_user_string(arg1
)))
3575 ret
= get_errno(execve(p
, argp
, envp
));
3576 unlock_user(p
, arg1
, 0);
3581 ret
= -TARGET_EFAULT
;
3584 for (gp
= guest_argp
, q
= argp
; *q
;
3585 gp
+= sizeof(abi_ulong
), q
++) {
3586 if (get_user_ual(addr
, gp
)
3589 unlock_user(*q
, addr
, 0);
3591 for (gp
= guest_envp
, q
= envp
; *q
;
3592 gp
+= sizeof(abi_ulong
), q
++) {
3593 if (get_user_ual(addr
, gp
)
3596 unlock_user(*q
, addr
, 0);
3600 case TARGET_NR_chdir
:
3601 if (!(p
= lock_user_string(arg1
)))
3603 ret
= get_errno(chdir(p
));
3604 unlock_user(p
, arg1
, 0);
3606 #ifdef TARGET_NR_time
3607 case TARGET_NR_time
:
3610 ret
= get_errno(time(&host_time
));
3613 && put_user_sal(host_time
, arg1
))
3618 case TARGET_NR_mknod
:
3619 if (!(p
= lock_user_string(arg1
)))
3621 ret
= get_errno(mknod(p
, arg2
, arg3
));
3622 unlock_user(p
, arg1
, 0);
3624 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3625 case TARGET_NR_mknodat
:
3626 if (!(p
= lock_user_string(arg2
)))
3628 ret
= get_errno(sys_mknodat(arg1
, p
, arg3
, arg4
));
3629 unlock_user(p
, arg2
, 0);
3632 case TARGET_NR_chmod
:
3633 if (!(p
= lock_user_string(arg1
)))
3635 ret
= get_errno(chmod(p
, arg2
));
3636 unlock_user(p
, arg1
, 0);
3638 #ifdef TARGET_NR_break
3639 case TARGET_NR_break
:
3642 #ifdef TARGET_NR_oldstat
3643 case TARGET_NR_oldstat
:
3646 case TARGET_NR_lseek
:
3647 ret
= get_errno(lseek(arg1
, arg2
, arg3
));
3649 #ifdef TARGET_NR_getxpid
3650 case TARGET_NR_getxpid
:
3652 case TARGET_NR_getpid
:
3654 ret
= get_errno(getpid());
3656 case TARGET_NR_mount
:
3658 /* need to look at the data field */
3660 p
= lock_user_string(arg1
);
3661 p2
= lock_user_string(arg2
);
3662 p3
= lock_user_string(arg3
);
3663 if (!p
|| !p2
|| !p3
)
3664 ret
= -TARGET_EFAULT
;
3666 /* FIXME - arg5 should be locked, but it isn't clear how to
3667 * do that since it's not guaranteed to be a NULL-terminated
3670 ret
= get_errno(mount(p
, p2
, p3
, (unsigned long)arg4
, g2h(arg5
)));
3671 unlock_user(p
, arg1
, 0);
3672 unlock_user(p2
, arg2
, 0);
3673 unlock_user(p3
, arg3
, 0);
3676 #ifdef TARGET_NR_umount
3677 case TARGET_NR_umount
:
3678 if (!(p
= lock_user_string(arg1
)))
3680 ret
= get_errno(umount(p
));
3681 unlock_user(p
, arg1
, 0);
3684 #ifdef TARGET_NR_stime /* not on alpha */
3685 case TARGET_NR_stime
:
3688 if (get_user_sal(host_time
, arg1
))
3690 ret
= get_errno(stime(&host_time
));
3694 case TARGET_NR_ptrace
:
3696 #ifdef TARGET_NR_alarm /* not on alpha */
3697 case TARGET_NR_alarm
:
3701 #ifdef TARGET_NR_oldfstat
3702 case TARGET_NR_oldfstat
:
3705 #ifdef TARGET_NR_pause /* not on alpha */
3706 case TARGET_NR_pause
:
3707 ret
= get_errno(pause());
3710 #ifdef TARGET_NR_utime
3711 case TARGET_NR_utime
:
3713 struct utimbuf tbuf
, *host_tbuf
;
3714 struct target_utimbuf
*target_tbuf
;
3716 if (!lock_user_struct(VERIFY_READ
, target_tbuf
, arg2
, 1))
3718 tbuf
.actime
= tswapl(target_tbuf
->actime
);
3719 tbuf
.modtime
= tswapl(target_tbuf
->modtime
);
3720 unlock_user_struct(target_tbuf
, arg2
, 0);
3725 if (!(p
= lock_user_string(arg1
)))
3727 ret
= get_errno(utime(p
, host_tbuf
));
3728 unlock_user(p
, arg1
, 0);
3732 case TARGET_NR_utimes
:
3734 struct timeval
*tvp
, tv
[2];
3736 if (copy_from_user_timeval(&tv
[0], arg2
)
3737 || copy_from_user_timeval(&tv
[1],
3738 arg2
+ sizeof(struct target_timeval
)))
3744 if (!(p
= lock_user_string(arg1
)))
3746 ret
= get_errno(utimes(p
, tvp
));
3747 unlock_user(p
, arg1
, 0);
3750 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
3751 case TARGET_NR_futimesat
:
3753 struct timeval
*tvp
, tv
[2];
3755 if (copy_from_user_timeval(&tv
[0], arg3
)
3756 || copy_from_user_timeval(&tv
[1],
3757 arg3
+ sizeof(struct target_timeval
)))
3763 if (!(p
= lock_user_string(arg2
)))
3765 ret
= get_errno(sys_futimesat(arg1
, path(p
), tvp
));
3766 unlock_user(p
, arg2
, 0);
3770 #ifdef TARGET_NR_stty
3771 case TARGET_NR_stty
:
3774 #ifdef TARGET_NR_gtty
3775 case TARGET_NR_gtty
:
3778 case TARGET_NR_access
:
3779 if (!(p
= lock_user_string(arg1
)))
3781 ret
= get_errno(access(p
, arg2
));
3782 unlock_user(p
, arg1
, 0);
3784 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3785 case TARGET_NR_faccessat
:
3786 if (!(p
= lock_user_string(arg2
)))
3788 ret
= get_errno(sys_faccessat(arg1
, p
, arg3
, arg4
));
3789 unlock_user(p
, arg2
, 0);
3792 #ifdef TARGET_NR_nice /* not on alpha */
3793 case TARGET_NR_nice
:
3794 ret
= get_errno(nice(arg1
));
3797 #ifdef TARGET_NR_ftime
3798 case TARGET_NR_ftime
:
3801 case TARGET_NR_sync
:
3805 case TARGET_NR_kill
:
3806 ret
= get_errno(kill(arg1
, target_to_host_signal(arg2
)));
3808 case TARGET_NR_rename
:
3811 p
= lock_user_string(arg1
);
3812 p2
= lock_user_string(arg2
);
3814 ret
= -TARGET_EFAULT
;
3816 ret
= get_errno(rename(p
, p2
));
3817 unlock_user(p2
, arg2
, 0);
3818 unlock_user(p
, arg1
, 0);
3821 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3822 case TARGET_NR_renameat
:
3825 p
= lock_user_string(arg2
);
3826 p2
= lock_user_string(arg4
);
3828 ret
= -TARGET_EFAULT
;
3830 ret
= get_errno(sys_renameat(arg1
, p
, arg3
, p2
));
3831 unlock_user(p2
, arg4
, 0);
3832 unlock_user(p
, arg2
, 0);
3836 case TARGET_NR_mkdir
:
3837 if (!(p
= lock_user_string(arg1
)))
3839 ret
= get_errno(mkdir(p
, arg2
));
3840 unlock_user(p
, arg1
, 0);
3842 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3843 case TARGET_NR_mkdirat
:
3844 if (!(p
= lock_user_string(arg2
)))
3846 ret
= get_errno(sys_mkdirat(arg1
, p
, arg3
));
3847 unlock_user(p
, arg2
, 0);
3850 case TARGET_NR_rmdir
:
3851 if (!(p
= lock_user_string(arg1
)))
3853 ret
= get_errno(rmdir(p
));
3854 unlock_user(p
, arg1
, 0);
3857 ret
= get_errno(dup(arg1
));
3859 case TARGET_NR_pipe
:
3862 ret
= get_errno(pipe(host_pipe
));
3863 if (!is_error(ret
)) {
3864 #if defined(TARGET_MIPS)
3865 CPUMIPSState
*env
= (CPUMIPSState
*)cpu_env
;
3866 env
->active_tc
.gpr
[3] = host_pipe
[1];
3868 #elif defined(TARGET_SH4)
3869 ((CPUSH4State
*)cpu_env
)->gregs
[1] = host_pipe
[1];
3872 if (put_user_s32(host_pipe
[0], arg1
)
3873 || put_user_s32(host_pipe
[1], arg1
+ sizeof(host_pipe
[0])))
3879 case TARGET_NR_times
:
3881 struct target_tms
*tmsp
;
3883 ret
= get_errno(times(&tms
));
3885 tmsp
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_tms
), 0);
3888 tmsp
->tms_utime
= tswapl(host_to_target_clock_t(tms
.tms_utime
));
3889 tmsp
->tms_stime
= tswapl(host_to_target_clock_t(tms
.tms_stime
));
3890 tmsp
->tms_cutime
= tswapl(host_to_target_clock_t(tms
.tms_cutime
));
3891 tmsp
->tms_cstime
= tswapl(host_to_target_clock_t(tms
.tms_cstime
));
3894 ret
= host_to_target_clock_t(ret
);
3897 #ifdef TARGET_NR_prof
3898 case TARGET_NR_prof
:
3901 #ifdef TARGET_NR_signal
3902 case TARGET_NR_signal
:
3905 case TARGET_NR_acct
:
3906 if (!(p
= lock_user_string(arg1
)))
3908 ret
= get_errno(acct(path(p
)));
3909 unlock_user(p
, arg1
, 0);
3911 #ifdef TARGET_NR_umount2 /* not on alpha */
3912 case TARGET_NR_umount2
:
3913 if (!(p
= lock_user_string(arg1
)))
3915 ret
= get_errno(umount2(p
, arg2
));
3916 unlock_user(p
, arg1
, 0);
3919 #ifdef TARGET_NR_lock
3920 case TARGET_NR_lock
:
3923 case TARGET_NR_ioctl
:
3924 ret
= do_ioctl(arg1
, arg2
, arg3
);
3926 case TARGET_NR_fcntl
:
3927 ret
= do_fcntl(arg1
, arg2
, arg3
);
3929 #ifdef TARGET_NR_mpx
3933 case TARGET_NR_setpgid
:
3934 ret
= get_errno(setpgid(arg1
, arg2
));
3936 #ifdef TARGET_NR_ulimit
3937 case TARGET_NR_ulimit
:
3940 #ifdef TARGET_NR_oldolduname
3941 case TARGET_NR_oldolduname
:
3944 case TARGET_NR_umask
:
3945 ret
= get_errno(umask(arg1
));
3947 case TARGET_NR_chroot
:
3948 if (!(p
= lock_user_string(arg1
)))
3950 ret
= get_errno(chroot(p
));
3951 unlock_user(p
, arg1
, 0);
3953 case TARGET_NR_ustat
:
3955 case TARGET_NR_dup2
:
3956 ret
= get_errno(dup2(arg1
, arg2
));
3958 #ifdef TARGET_NR_getppid /* not on alpha */
3959 case TARGET_NR_getppid
:
3960 ret
= get_errno(getppid());
3963 case TARGET_NR_getpgrp
:
3964 ret
= get_errno(getpgrp());
3966 case TARGET_NR_setsid
:
3967 ret
= get_errno(setsid());
3969 #ifdef TARGET_NR_sigaction
3970 case TARGET_NR_sigaction
:
3972 #if !defined(TARGET_MIPS)
3973 struct target_old_sigaction
*old_act
;
3974 struct target_sigaction act
, oact
, *pact
;
3976 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
3978 act
._sa_handler
= old_act
->_sa_handler
;
3979 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
);
3980 act
.sa_flags
= old_act
->sa_flags
;
3981 act
.sa_restorer
= old_act
->sa_restorer
;
3982 unlock_user_struct(old_act
, arg2
, 0);
3987 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
3988 if (!is_error(ret
) && arg3
) {
3989 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
3991 old_act
->_sa_handler
= oact
._sa_handler
;
3992 old_act
->sa_mask
= oact
.sa_mask
.sig
[0];
3993 old_act
->sa_flags
= oact
.sa_flags
;
3994 old_act
->sa_restorer
= oact
.sa_restorer
;
3995 unlock_user_struct(old_act
, arg3
, 1);
3998 struct target_sigaction act
, oact
, *pact
, *old_act
;
4001 if (!lock_user_struct(VERIFY_READ
, old_act
, arg2
, 1))
4003 act
._sa_handler
= old_act
->_sa_handler
;
4004 target_siginitset(&act
.sa_mask
, old_act
->sa_mask
.sig
[0]);
4005 act
.sa_flags
= old_act
->sa_flags
;
4006 unlock_user_struct(old_act
, arg2
, 0);
4012 ret
= get_errno(do_sigaction(arg1
, pact
, &oact
));
4014 if (!is_error(ret
) && arg3
) {
4015 if (!lock_user_struct(VERIFY_WRITE
, old_act
, arg3
, 0))
4017 old_act
->_sa_handler
= oact
._sa_handler
;
4018 old_act
->sa_flags
= oact
.sa_flags
;
4019 old_act
->sa_mask
.sig
[0] = oact
.sa_mask
.sig
[0];
4020 old_act
->sa_mask
.sig
[1] = 0;
4021 old_act
->sa_mask
.sig
[2] = 0;
4022 old_act
->sa_mask
.sig
[3] = 0;
4023 unlock_user_struct(old_act
, arg3
, 1);
4029 case TARGET_NR_rt_sigaction
:
4031 struct target_sigaction
*act
;
4032 struct target_sigaction
*oact
;
4035 if (!lock_user_struct(VERIFY_READ
, act
, arg2
, 1))
4040 if (!lock_user_struct(VERIFY_WRITE
, oact
, arg3
, 0)) {
4041 ret
= -TARGET_EFAULT
;
4042 goto rt_sigaction_fail
;
4046 ret
= get_errno(do_sigaction(arg1
, act
, oact
));
4049 unlock_user_struct(act
, arg2
, 0);
4051 unlock_user_struct(oact
, arg3
, 1);
4054 #ifdef TARGET_NR_sgetmask /* not on alpha */
4055 case TARGET_NR_sgetmask
:
4058 abi_ulong target_set
;
4059 sigprocmask(0, NULL
, &cur_set
);
4060 host_to_target_old_sigset(&target_set
, &cur_set
);
4065 #ifdef TARGET_NR_ssetmask /* not on alpha */
4066 case TARGET_NR_ssetmask
:
4068 sigset_t set
, oset
, cur_set
;
4069 abi_ulong target_set
= arg1
;
4070 sigprocmask(0, NULL
, &cur_set
);
4071 target_to_host_old_sigset(&set
, &target_set
);
4072 sigorset(&set
, &set
, &cur_set
);
4073 sigprocmask(SIG_SETMASK
, &set
, &oset
);
4074 host_to_target_old_sigset(&target_set
, &oset
);
4079 #ifdef TARGET_NR_sigprocmask
4080 case TARGET_NR_sigprocmask
:
4083 sigset_t set
, oldset
, *set_ptr
;
4087 case TARGET_SIG_BLOCK
:
4090 case TARGET_SIG_UNBLOCK
:
4093 case TARGET_SIG_SETMASK
:
4097 ret
= -TARGET_EINVAL
;
4100 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
4102 target_to_host_old_sigset(&set
, p
);
4103 unlock_user(p
, arg2
, 0);
4109 ret
= get_errno(sigprocmask(arg1
, set_ptr
, &oldset
));
4110 if (!is_error(ret
) && arg3
) {
4111 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
4113 host_to_target_old_sigset(p
, &oldset
);
4114 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
4119 case TARGET_NR_rt_sigprocmask
:
4122 sigset_t set
, oldset
, *set_ptr
;
4126 case TARGET_SIG_BLOCK
:
4129 case TARGET_SIG_UNBLOCK
:
4132 case TARGET_SIG_SETMASK
:
4136 ret
= -TARGET_EINVAL
;
4139 if (!(p
= lock_user(VERIFY_READ
, arg2
, sizeof(target_sigset_t
), 1)))
4141 target_to_host_sigset(&set
, p
);
4142 unlock_user(p
, arg2
, 0);
4148 ret
= get_errno(sigprocmask(how
, set_ptr
, &oldset
));
4149 if (!is_error(ret
) && arg3
) {
4150 if (!(p
= lock_user(VERIFY_WRITE
, arg3
, sizeof(target_sigset_t
), 0)))
4152 host_to_target_sigset(p
, &oldset
);
4153 unlock_user(p
, arg3
, sizeof(target_sigset_t
));
4157 #ifdef TARGET_NR_sigpending
4158 case TARGET_NR_sigpending
:
4161 ret
= get_errno(sigpending(&set
));
4162 if (!is_error(ret
)) {
4163 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
4165 host_to_target_old_sigset(p
, &set
);
4166 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
4171 case TARGET_NR_rt_sigpending
:
4174 ret
= get_errno(sigpending(&set
));
4175 if (!is_error(ret
)) {
4176 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, sizeof(target_sigset_t
), 0)))
4178 host_to_target_sigset(p
, &set
);
4179 unlock_user(p
, arg1
, sizeof(target_sigset_t
));
4183 #ifdef TARGET_NR_sigsuspend
4184 case TARGET_NR_sigsuspend
:
4187 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4189 target_to_host_old_sigset(&set
, p
);
4190 unlock_user(p
, arg1
, 0);
4191 ret
= get_errno(sigsuspend(&set
));
4195 case TARGET_NR_rt_sigsuspend
:
4198 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4200 target_to_host_sigset(&set
, p
);
4201 unlock_user(p
, arg1
, 0);
4202 ret
= get_errno(sigsuspend(&set
));
4205 case TARGET_NR_rt_sigtimedwait
:
4208 struct timespec uts
, *puts
;
4211 if (!(p
= lock_user(VERIFY_READ
, arg1
, sizeof(target_sigset_t
), 1)))
4213 target_to_host_sigset(&set
, p
);
4214 unlock_user(p
, arg1
, 0);
4217 target_to_host_timespec(puts
, arg3
);
4221 ret
= get_errno(sigtimedwait(&set
, &uinfo
, puts
));
4222 if (!is_error(ret
) && arg2
) {
4223 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, sizeof(target_siginfo_t
), 0)))
4225 host_to_target_siginfo(p
, &uinfo
);
4226 unlock_user(p
, arg2
, sizeof(target_siginfo_t
));
4230 case TARGET_NR_rt_sigqueueinfo
:
4233 if (!(p
= lock_user(VERIFY_READ
, arg3
, sizeof(target_sigset_t
), 1)))
4235 target_to_host_siginfo(&uinfo
, p
);
4236 unlock_user(p
, arg1
, 0);
4237 ret
= get_errno(sys_rt_sigqueueinfo(arg1
, arg2
, &uinfo
));
4240 #ifdef TARGET_NR_sigreturn
4241 case TARGET_NR_sigreturn
:
4242 /* NOTE: ret is eax, so not transcoding must be done */
4243 ret
= do_sigreturn(cpu_env
);
4246 case TARGET_NR_rt_sigreturn
:
4247 /* NOTE: ret is eax, so not transcoding must be done */
4248 ret
= do_rt_sigreturn(cpu_env
);
4250 case TARGET_NR_sethostname
:
4251 if (!(p
= lock_user_string(arg1
)))
4253 ret
= get_errno(sethostname(p
, arg2
));
4254 unlock_user(p
, arg1
, 0);
4256 case TARGET_NR_setrlimit
:
4258 /* XXX: convert resource ? */
4259 int resource
= arg1
;
4260 struct target_rlimit
*target_rlim
;
4262 if (!lock_user_struct(VERIFY_READ
, target_rlim
, arg2
, 1))
4264 rlim
.rlim_cur
= tswapl(target_rlim
->rlim_cur
);
4265 rlim
.rlim_max
= tswapl(target_rlim
->rlim_max
);
4266 unlock_user_struct(target_rlim
, arg2
, 0);
4267 ret
= get_errno(setrlimit(resource
, &rlim
));
4270 case TARGET_NR_getrlimit
:
4272 /* XXX: convert resource ? */
4273 int resource
= arg1
;
4274 struct target_rlimit
*target_rlim
;
4277 ret
= get_errno(getrlimit(resource
, &rlim
));
4278 if (!is_error(ret
)) {
4279 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
4281 rlim
.rlim_cur
= tswapl(target_rlim
->rlim_cur
);
4282 rlim
.rlim_max
= tswapl(target_rlim
->rlim_max
);
4283 unlock_user_struct(target_rlim
, arg2
, 1);
4287 case TARGET_NR_getrusage
:
4289 struct rusage rusage
;
4290 ret
= get_errno(getrusage(arg1
, &rusage
));
4291 if (!is_error(ret
)) {
4292 host_to_target_rusage(arg2
, &rusage
);
4296 case TARGET_NR_gettimeofday
:
4299 ret
= get_errno(gettimeofday(&tv
, NULL
));
4300 if (!is_error(ret
)) {
4301 if (copy_to_user_timeval(arg1
, &tv
))
4306 case TARGET_NR_settimeofday
:
4309 if (copy_from_user_timeval(&tv
, arg1
))
4311 ret
= get_errno(settimeofday(&tv
, NULL
));
4314 #ifdef TARGET_NR_select
4315 case TARGET_NR_select
:
4317 struct target_sel_arg_struct
*sel
;
4318 abi_ulong inp
, outp
, exp
, tvp
;
4321 if (!lock_user_struct(VERIFY_READ
, sel
, arg1
, 1))
4323 nsel
= tswapl(sel
->n
);
4324 inp
= tswapl(sel
->inp
);
4325 outp
= tswapl(sel
->outp
);
4326 exp
= tswapl(sel
->exp
);
4327 tvp
= tswapl(sel
->tvp
);
4328 unlock_user_struct(sel
, arg1
, 0);
4329 ret
= do_select(nsel
, inp
, outp
, exp
, tvp
);
4333 case TARGET_NR_symlink
:
4336 p
= lock_user_string(arg1
);
4337 p2
= lock_user_string(arg2
);
4339 ret
= -TARGET_EFAULT
;
4341 ret
= get_errno(symlink(p
, p2
));
4342 unlock_user(p2
, arg2
, 0);
4343 unlock_user(p
, arg1
, 0);
4346 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4347 case TARGET_NR_symlinkat
:
4350 p
= lock_user_string(arg1
);
4351 p2
= lock_user_string(arg3
);
4353 ret
= -TARGET_EFAULT
;
4355 ret
= get_errno(sys_symlinkat(p
, arg2
, p2
));
4356 unlock_user(p2
, arg3
, 0);
4357 unlock_user(p
, arg1
, 0);
4361 #ifdef TARGET_NR_oldlstat
4362 case TARGET_NR_oldlstat
:
4365 case TARGET_NR_readlink
:
4368 p
= lock_user_string(arg1
);
4369 p2
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0);
4371 ret
= -TARGET_EFAULT
;
4373 ret
= get_errno(readlink(path(p
), p2
, arg3
));
4374 unlock_user(p2
, arg2
, ret
);
4375 unlock_user(p
, arg1
, 0);
4378 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4379 case TARGET_NR_readlinkat
:
4382 p
= lock_user_string(arg2
);
4383 p2
= lock_user(VERIFY_WRITE
, arg3
, arg4
, 0);
4385 ret
= -TARGET_EFAULT
;
4387 ret
= get_errno(sys_readlinkat(arg1
, path(p
), p2
, arg4
));
4388 unlock_user(p2
, arg3
, ret
);
4389 unlock_user(p
, arg2
, 0);
4393 #ifdef TARGET_NR_uselib
4394 case TARGET_NR_uselib
:
4397 #ifdef TARGET_NR_swapon
4398 case TARGET_NR_swapon
:
4399 if (!(p
= lock_user_string(arg1
)))
4401 ret
= get_errno(swapon(p
, arg2
));
4402 unlock_user(p
, arg1
, 0);
4405 case TARGET_NR_reboot
:
4407 #ifdef TARGET_NR_readdir
4408 case TARGET_NR_readdir
:
4411 #ifdef TARGET_NR_mmap
4412 case TARGET_NR_mmap
:
4413 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
4416 abi_ulong v1
, v2
, v3
, v4
, v5
, v6
;
4417 if (!(v
= lock_user(VERIFY_READ
, arg1
, 6 * sizeof(abi_ulong
), 1)))
4425 unlock_user(v
, arg1
, 0);
4426 ret
= get_errno(target_mmap(v1
, v2
, v3
,
4427 target_to_host_bitmask(v4
, mmap_flags_tbl
),
4431 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
4432 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
4438 #ifdef TARGET_NR_mmap2
4439 case TARGET_NR_mmap2
:
4441 #define MMAP_SHIFT 12
4443 ret
= get_errno(target_mmap(arg1
, arg2
, arg3
,
4444 target_to_host_bitmask(arg4
, mmap_flags_tbl
),
4446 arg6
<< MMAP_SHIFT
));
4449 case TARGET_NR_munmap
:
4450 ret
= get_errno(target_munmap(arg1
, arg2
));
4452 case TARGET_NR_mprotect
:
4453 ret
= get_errno(target_mprotect(arg1
, arg2
, arg3
));
4455 #ifdef TARGET_NR_mremap
4456 case TARGET_NR_mremap
:
4457 ret
= get_errno(target_mremap(arg1
, arg2
, arg3
, arg4
, arg5
));
4460 /* ??? msync/mlock/munlock are broken for softmmu. */
4461 #ifdef TARGET_NR_msync
4462 case TARGET_NR_msync
:
4463 ret
= get_errno(msync(g2h(arg1
), arg2
, arg3
));
4466 #ifdef TARGET_NR_mlock
4467 case TARGET_NR_mlock
:
4468 ret
= get_errno(mlock(g2h(arg1
), arg2
));
4471 #ifdef TARGET_NR_munlock
4472 case TARGET_NR_munlock
:
4473 ret
= get_errno(munlock(g2h(arg1
), arg2
));
4476 #ifdef TARGET_NR_mlockall
4477 case TARGET_NR_mlockall
:
4478 ret
= get_errno(mlockall(arg1
));
4481 #ifdef TARGET_NR_munlockall
4482 case TARGET_NR_munlockall
:
4483 ret
= get_errno(munlockall());
4486 case TARGET_NR_truncate
:
4487 if (!(p
= lock_user_string(arg1
)))
4489 ret
= get_errno(truncate(p
, arg2
));
4490 unlock_user(p
, arg1
, 0);
4492 case TARGET_NR_ftruncate
:
4493 ret
= get_errno(ftruncate(arg1
, arg2
));
4495 case TARGET_NR_fchmod
:
4496 ret
= get_errno(fchmod(arg1
, arg2
));
4498 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4499 case TARGET_NR_fchmodat
:
4500 if (!(p
= lock_user_string(arg2
)))
4502 ret
= get_errno(sys_fchmodat(arg1
, p
, arg3
, arg4
));
4503 unlock_user(p
, arg2
, 0);
4506 case TARGET_NR_getpriority
:
4507 /* libc does special remapping of the return value of
4508 * sys_getpriority() so it's just easiest to call
4509 * sys_getpriority() directly rather than through libc. */
4510 ret
= sys_getpriority(arg1
, arg2
);
4512 case TARGET_NR_setpriority
:
4513 ret
= get_errno(setpriority(arg1
, arg2
, arg3
));
4515 #ifdef TARGET_NR_profil
4516 case TARGET_NR_profil
:
4519 case TARGET_NR_statfs
:
4520 if (!(p
= lock_user_string(arg1
)))
4522 ret
= get_errno(statfs(path(p
), &stfs
));
4523 unlock_user(p
, arg1
, 0);
4525 if (!is_error(ret
)) {
4526 struct target_statfs
*target_stfs
;
4528 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg2
, 0))
4530 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
4531 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
4532 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
4533 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
4534 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
4535 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
4536 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
4537 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
4538 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
4539 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
4540 unlock_user_struct(target_stfs
, arg2
, 1);
4543 case TARGET_NR_fstatfs
:
4544 ret
= get_errno(fstatfs(arg1
, &stfs
));
4545 goto convert_statfs
;
4546 #ifdef TARGET_NR_statfs64
4547 case TARGET_NR_statfs64
:
4548 if (!(p
= lock_user_string(arg1
)))
4550 ret
= get_errno(statfs(path(p
), &stfs
));
4551 unlock_user(p
, arg1
, 0);
4553 if (!is_error(ret
)) {
4554 struct target_statfs64
*target_stfs
;
4556 if (!lock_user_struct(VERIFY_WRITE
, target_stfs
, arg3
, 0))
4558 __put_user(stfs
.f_type
, &target_stfs
->f_type
);
4559 __put_user(stfs
.f_bsize
, &target_stfs
->f_bsize
);
4560 __put_user(stfs
.f_blocks
, &target_stfs
->f_blocks
);
4561 __put_user(stfs
.f_bfree
, &target_stfs
->f_bfree
);
4562 __put_user(stfs
.f_bavail
, &target_stfs
->f_bavail
);
4563 __put_user(stfs
.f_files
, &target_stfs
->f_files
);
4564 __put_user(stfs
.f_ffree
, &target_stfs
->f_ffree
);
4565 __put_user(stfs
.f_fsid
.__val
[0], &target_stfs
->f_fsid
.val
[0]);
4566 __put_user(stfs
.f_fsid
.__val
[1], &target_stfs
->f_fsid
.val
[1]);
4567 __put_user(stfs
.f_namelen
, &target_stfs
->f_namelen
);
4568 unlock_user_struct(target_stfs
, arg3
, 1);
4571 case TARGET_NR_fstatfs64
:
4572 ret
= get_errno(fstatfs(arg1
, &stfs
));
4573 goto convert_statfs64
;
4575 #ifdef TARGET_NR_ioperm
4576 case TARGET_NR_ioperm
:
4579 #ifdef TARGET_NR_socketcall
4580 case TARGET_NR_socketcall
:
4581 ret
= do_socketcall(arg1
, arg2
);
4584 #ifdef TARGET_NR_accept
4585 case TARGET_NR_accept
:
4586 ret
= do_accept(arg1
, arg2
, arg3
);
4589 #ifdef TARGET_NR_bind
4590 case TARGET_NR_bind
:
4591 ret
= do_bind(arg1
, arg2
, arg3
);
4594 #ifdef TARGET_NR_connect
4595 case TARGET_NR_connect
:
4596 ret
= do_connect(arg1
, arg2
, arg3
);
4599 #ifdef TARGET_NR_getpeername
4600 case TARGET_NR_getpeername
:
4601 ret
= do_getpeername(arg1
, arg2
, arg3
);
4604 #ifdef TARGET_NR_getsockname
4605 case TARGET_NR_getsockname
:
4606 ret
= do_getsockname(arg1
, arg2
, arg3
);
4609 #ifdef TARGET_NR_getsockopt
4610 case TARGET_NR_getsockopt
:
4611 ret
= do_getsockopt(arg1
, arg2
, arg3
, arg4
, arg5
);
4614 #ifdef TARGET_NR_listen
4615 case TARGET_NR_listen
:
4616 ret
= get_errno(listen(arg1
, arg2
));
4619 #ifdef TARGET_NR_recv
4620 case TARGET_NR_recv
:
4621 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, 0, 0);
4624 #ifdef TARGET_NR_recvfrom
4625 case TARGET_NR_recvfrom
:
4626 ret
= do_recvfrom(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4629 #ifdef TARGET_NR_recvmsg
4630 case TARGET_NR_recvmsg
:
4631 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 0);
4634 #ifdef TARGET_NR_send
4635 case TARGET_NR_send
:
4636 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, 0, 0);
4639 #ifdef TARGET_NR_sendmsg
4640 case TARGET_NR_sendmsg
:
4641 ret
= do_sendrecvmsg(arg1
, arg2
, arg3
, 1);
4644 #ifdef TARGET_NR_sendto
4645 case TARGET_NR_sendto
:
4646 ret
= do_sendto(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4649 #ifdef TARGET_NR_shutdown
4650 case TARGET_NR_shutdown
:
4651 ret
= get_errno(shutdown(arg1
, arg2
));
4654 #ifdef TARGET_NR_socket
4655 case TARGET_NR_socket
:
4656 ret
= do_socket(arg1
, arg2
, arg3
);
4659 #ifdef TARGET_NR_socketpair
4660 case TARGET_NR_socketpair
:
4661 ret
= do_socketpair(arg1
, arg2
, arg3
, arg4
);
4664 #ifdef TARGET_NR_setsockopt
4665 case TARGET_NR_setsockopt
:
4666 ret
= do_setsockopt(arg1
, arg2
, arg3
, arg4
, (socklen_t
) arg5
);
4670 case TARGET_NR_syslog
:
4671 if (!(p
= lock_user_string(arg2
)))
4673 ret
= get_errno(sys_syslog((int)arg1
, p
, (int)arg3
));
4674 unlock_user(p
, arg2
, 0);
4677 case TARGET_NR_setitimer
:
4679 struct itimerval value
, ovalue
, *pvalue
;
4683 if (copy_from_user_timeval(&pvalue
->it_interval
, arg2
)
4684 || copy_from_user_timeval(&pvalue
->it_value
,
4685 arg2
+ sizeof(struct target_timeval
)))
4690 ret
= get_errno(setitimer(arg1
, pvalue
, &ovalue
));
4691 if (!is_error(ret
) && arg3
) {
4692 if (copy_to_user_timeval(arg3
,
4693 &ovalue
.it_interval
)
4694 || copy_to_user_timeval(arg3
+ sizeof(struct target_timeval
),
4700 case TARGET_NR_getitimer
:
4702 struct itimerval value
;
4704 ret
= get_errno(getitimer(arg1
, &value
));
4705 if (!is_error(ret
) && arg2
) {
4706 if (copy_to_user_timeval(arg2
,
4708 || copy_to_user_timeval(arg2
+ sizeof(struct target_timeval
),
4714 case TARGET_NR_stat
:
4715 if (!(p
= lock_user_string(arg1
)))
4717 ret
= get_errno(stat(path(p
), &st
));
4718 unlock_user(p
, arg1
, 0);
4720 case TARGET_NR_lstat
:
4721 if (!(p
= lock_user_string(arg1
)))
4723 ret
= get_errno(lstat(path(p
), &st
));
4724 unlock_user(p
, arg1
, 0);
4726 case TARGET_NR_fstat
:
4728 ret
= get_errno(fstat(arg1
, &st
));
4730 if (!is_error(ret
)) {
4731 struct target_stat
*target_st
;
4733 if (!lock_user_struct(VERIFY_WRITE
, target_st
, arg2
, 0))
4735 __put_user(st
.st_dev
, &target_st
->st_dev
);
4736 __put_user(st
.st_ino
, &target_st
->st_ino
);
4737 __put_user(st
.st_mode
, &target_st
->st_mode
);
4738 __put_user(st
.st_uid
, &target_st
->st_uid
);
4739 __put_user(st
.st_gid
, &target_st
->st_gid
);
4740 __put_user(st
.st_nlink
, &target_st
->st_nlink
);
4741 __put_user(st
.st_rdev
, &target_st
->st_rdev
);
4742 __put_user(st
.st_size
, &target_st
->st_size
);
4743 __put_user(st
.st_blksize
, &target_st
->st_blksize
);
4744 __put_user(st
.st_blocks
, &target_st
->st_blocks
);
4745 __put_user(st
.st_atime
, &target_st
->target_st_atime
);
4746 __put_user(st
.st_mtime
, &target_st
->target_st_mtime
);
4747 __put_user(st
.st_ctime
, &target_st
->target_st_ctime
);
4748 unlock_user_struct(target_st
, arg2
, 1);
4752 #ifdef TARGET_NR_olduname
4753 case TARGET_NR_olduname
:
4756 #ifdef TARGET_NR_iopl
4757 case TARGET_NR_iopl
:
4760 case TARGET_NR_vhangup
:
4761 ret
= get_errno(vhangup());
4763 #ifdef TARGET_NR_idle
4764 case TARGET_NR_idle
:
4767 #ifdef TARGET_NR_syscall
4768 case TARGET_NR_syscall
:
4769 ret
= do_syscall(cpu_env
,arg1
& 0xffff,arg2
,arg3
,arg4
,arg5
,arg6
,0);
4772 case TARGET_NR_wait4
:
4775 abi_long status_ptr
= arg2
;
4776 struct rusage rusage
, *rusage_ptr
;
4777 abi_ulong target_rusage
= arg4
;
4779 rusage_ptr
= &rusage
;
4782 ret
= get_errno(wait4(arg1
, &status
, arg3
, rusage_ptr
));
4783 if (!is_error(ret
)) {
4785 if (put_user_s32(status
, status_ptr
))
4789 host_to_target_rusage(target_rusage
, &rusage
);
4793 #ifdef TARGET_NR_swapoff
4794 case TARGET_NR_swapoff
:
4795 if (!(p
= lock_user_string(arg1
)))
4797 ret
= get_errno(swapoff(p
));
4798 unlock_user(p
, arg1
, 0);
4801 case TARGET_NR_sysinfo
:
4803 struct target_sysinfo
*target_value
;
4804 struct sysinfo value
;
4805 ret
= get_errno(sysinfo(&value
));
4806 if (!is_error(ret
) && arg1
)
4808 if (!lock_user_struct(VERIFY_WRITE
, target_value
, arg1
, 0))
4810 __put_user(value
.uptime
, &target_value
->uptime
);
4811 __put_user(value
.loads
[0], &target_value
->loads
[0]);
4812 __put_user(value
.loads
[1], &target_value
->loads
[1]);
4813 __put_user(value
.loads
[2], &target_value
->loads
[2]);
4814 __put_user(value
.totalram
, &target_value
->totalram
);
4815 __put_user(value
.freeram
, &target_value
->freeram
);
4816 __put_user(value
.sharedram
, &target_value
->sharedram
);
4817 __put_user(value
.bufferram
, &target_value
->bufferram
);
4818 __put_user(value
.totalswap
, &target_value
->totalswap
);
4819 __put_user(value
.freeswap
, &target_value
->freeswap
);
4820 __put_user(value
.procs
, &target_value
->procs
);
4821 __put_user(value
.totalhigh
, &target_value
->totalhigh
);
4822 __put_user(value
.freehigh
, &target_value
->freehigh
);
4823 __put_user(value
.mem_unit
, &target_value
->mem_unit
);
4824 unlock_user_struct(target_value
, arg1
, 1);
4828 #ifdef TARGET_NR_ipc
4830 ret
= do_ipc(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
4834 #ifdef TARGET_NR_msgctl
4835 case TARGET_NR_msgctl
:
4836 ret
= do_msgctl(arg1
, arg2
, arg3
);
4839 #ifdef TARGET_NR_msgget
4840 case TARGET_NR_msgget
:
4841 ret
= get_errno(msgget(arg1
, arg2
));
4844 #ifdef TARGET_NR_msgrcv
4845 case TARGET_NR_msgrcv
:
4846 ret
= do_msgrcv(arg1
, arg2
, arg3
, arg4
, arg5
);
4849 #ifdef TARGET_NR_msgsnd
4850 case TARGET_NR_msgsnd
:
4851 ret
= do_msgsnd(arg1
, arg2
, arg3
, arg4
);
4854 case TARGET_NR_fsync
:
4855 ret
= get_errno(fsync(arg1
));
4857 case TARGET_NR_clone
:
4858 #if defined(TARGET_SH4)
4859 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg5
, arg4
));
4861 ret
= get_errno(do_fork(cpu_env
, arg1
, arg2
, arg3
, arg4
, arg5
));
4864 #ifdef __NR_exit_group
4865 /* new thread calls */
4866 case TARGET_NR_exit_group
:
4867 gdb_exit(cpu_env
, arg1
);
4868 ret
= get_errno(exit_group(arg1
));
4871 case TARGET_NR_setdomainname
:
4872 if (!(p
= lock_user_string(arg1
)))
4874 ret
= get_errno(setdomainname(p
, arg2
));
4875 unlock_user(p
, arg1
, 0);
4877 case TARGET_NR_uname
:
4878 /* no need to transcode because we use the linux syscall */
4880 struct new_utsname
* buf
;
4882 if (!lock_user_struct(VERIFY_WRITE
, buf
, arg1
, 0))
4884 ret
= get_errno(sys_uname(buf
));
4885 if (!is_error(ret
)) {
4886 /* Overrite the native machine name with whatever is being
4888 strcpy (buf
->machine
, UNAME_MACHINE
);
4889 /* Allow the user to override the reported release. */
4890 if (qemu_uname_release
&& *qemu_uname_release
)
4891 strcpy (buf
->release
, qemu_uname_release
);
4893 unlock_user_struct(buf
, arg1
, 1);
4897 case TARGET_NR_modify_ldt
:
4898 ret
= do_modify_ldt(cpu_env
, arg1
, arg2
, arg3
);
4900 #if !defined(TARGET_X86_64)
4901 case TARGET_NR_vm86old
:
4903 case TARGET_NR_vm86
:
4904 ret
= do_vm86(cpu_env
, arg1
, arg2
);
4908 case TARGET_NR_adjtimex
:
4910 #ifdef TARGET_NR_create_module
4911 case TARGET_NR_create_module
:
4913 case TARGET_NR_init_module
:
4914 case TARGET_NR_delete_module
:
4915 #ifdef TARGET_NR_get_kernel_syms
4916 case TARGET_NR_get_kernel_syms
:
4919 case TARGET_NR_quotactl
:
4921 case TARGET_NR_getpgid
:
4922 ret
= get_errno(getpgid(arg1
));
4924 case TARGET_NR_fchdir
:
4925 ret
= get_errno(fchdir(arg1
));
4927 #ifdef TARGET_NR_bdflush /* not on x86_64 */
4928 case TARGET_NR_bdflush
:
4931 #ifdef TARGET_NR_sysfs
4932 case TARGET_NR_sysfs
:
4935 case TARGET_NR_personality
:
4936 ret
= get_errno(personality(arg1
));
4938 #ifdef TARGET_NR_afs_syscall
4939 case TARGET_NR_afs_syscall
:
4942 #ifdef TARGET_NR__llseek /* Not on alpha */
4943 case TARGET_NR__llseek
:
4945 #if defined (__x86_64__)
4946 ret
= get_errno(lseek(arg1
, ((uint64_t )arg2
<< 32) | arg3
, arg5
));
4947 if (put_user_s64(ret
, arg4
))
4951 ret
= get_errno(_llseek(arg1
, arg2
, arg3
, &res
, arg5
));
4952 if (put_user_s64(res
, arg4
))
4958 case TARGET_NR_getdents
:
4959 #if TARGET_ABI_BITS != 32
4961 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4963 struct target_dirent
*target_dirp
;
4964 struct linux_dirent
*dirp
;
4965 abi_long count
= arg3
;
4967 dirp
= malloc(count
);
4969 ret
= -TARGET_ENOMEM
;
4973 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
4974 if (!is_error(ret
)) {
4975 struct linux_dirent
*de
;
4976 struct target_dirent
*tde
;
4978 int reclen
, treclen
;
4979 int count1
, tnamelen
;
4983 if (!(target_dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
4987 reclen
= de
->d_reclen
;
4988 treclen
= reclen
- (2 * (sizeof(long) - sizeof(abi_long
)));
4989 tde
->d_reclen
= tswap16(treclen
);
4990 tde
->d_ino
= tswapl(de
->d_ino
);
4991 tde
->d_off
= tswapl(de
->d_off
);
4992 tnamelen
= treclen
- (2 * sizeof(abi_long
) + 2);
4995 /* XXX: may not be correct */
4996 pstrcpy(tde
->d_name
, tnamelen
, de
->d_name
);
4997 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
4999 tde
= (struct target_dirent
*)((char *)tde
+ treclen
);
5003 unlock_user(target_dirp
, arg2
, ret
);
5009 struct linux_dirent
*dirp
;
5010 abi_long count
= arg3
;
5012 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
5014 ret
= get_errno(sys_getdents(arg1
, dirp
, count
));
5015 if (!is_error(ret
)) {
5016 struct linux_dirent
*de
;
5021 reclen
= de
->d_reclen
;
5024 de
->d_reclen
= tswap16(reclen
);
5025 tswapls(&de
->d_ino
);
5026 tswapls(&de
->d_off
);
5027 de
= (struct linux_dirent
*)((char *)de
+ reclen
);
5031 unlock_user(dirp
, arg2
, ret
);
5035 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
5036 case TARGET_NR_getdents64
:
5038 struct linux_dirent64
*dirp
;
5039 abi_long count
= arg3
;
5040 if (!(dirp
= lock_user(VERIFY_WRITE
, arg2
, count
, 0)))
5042 ret
= get_errno(sys_getdents64(arg1
, dirp
, count
));
5043 if (!is_error(ret
)) {
5044 struct linux_dirent64
*de
;
5049 reclen
= de
->d_reclen
;
5052 de
->d_reclen
= tswap16(reclen
);
5053 tswap64s((uint64_t *)&de
->d_ino
);
5054 tswap64s((uint64_t *)&de
->d_off
);
5055 de
= (struct linux_dirent64
*)((char *)de
+ reclen
);
5059 unlock_user(dirp
, arg2
, ret
);
5062 #endif /* TARGET_NR_getdents64 */
5063 #ifdef TARGET_NR__newselect
5064 case TARGET_NR__newselect
:
5065 ret
= do_select(arg1
, arg2
, arg3
, arg4
, arg5
);
5068 #ifdef TARGET_NR_poll
5069 case TARGET_NR_poll
:
5071 struct target_pollfd
*target_pfd
;
5072 unsigned int nfds
= arg2
;
5077 target_pfd
= lock_user(VERIFY_WRITE
, arg1
, sizeof(struct target_pollfd
) * nfds
, 1);
5080 pfd
= alloca(sizeof(struct pollfd
) * nfds
);
5081 for(i
= 0; i
< nfds
; i
++) {
5082 pfd
[i
].fd
= tswap32(target_pfd
[i
].fd
);
5083 pfd
[i
].events
= tswap16(target_pfd
[i
].events
);
5085 ret
= get_errno(poll(pfd
, nfds
, timeout
));
5086 if (!is_error(ret
)) {
5087 for(i
= 0; i
< nfds
; i
++) {
5088 target_pfd
[i
].revents
= tswap16(pfd
[i
].revents
);
5090 ret
+= nfds
* (sizeof(struct target_pollfd
)
5091 - sizeof(struct pollfd
));
5093 unlock_user(target_pfd
, arg1
, ret
);
5097 case TARGET_NR_flock
:
5098 /* NOTE: the flock constant seems to be the same for every
5100 ret
= get_errno(flock(arg1
, arg2
));
5102 case TARGET_NR_readv
:
5107 vec
= alloca(count
* sizeof(struct iovec
));
5108 if (lock_iovec(VERIFY_WRITE
, vec
, arg2
, count
, 0) < 0)
5110 ret
= get_errno(readv(arg1
, vec
, count
));
5111 unlock_iovec(vec
, arg2
, count
, 1);
5114 case TARGET_NR_writev
:
5119 vec
= alloca(count
* sizeof(struct iovec
));
5120 if (lock_iovec(VERIFY_READ
, vec
, arg2
, count
, 1) < 0)
5122 ret
= get_errno(writev(arg1
, vec
, count
));
5123 unlock_iovec(vec
, arg2
, count
, 0);
5126 case TARGET_NR_getsid
:
5127 ret
= get_errno(getsid(arg1
));
5129 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
5130 case TARGET_NR_fdatasync
:
5131 ret
= get_errno(fdatasync(arg1
));
5134 case TARGET_NR__sysctl
:
5135 /* We don't implement this, but ENOTDIR is always a safe
5137 ret
= -TARGET_ENOTDIR
;
5139 case TARGET_NR_sched_setparam
:
5141 struct sched_param
*target_schp
;
5142 struct sched_param schp
;
5144 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg2
, 1))
5146 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
5147 unlock_user_struct(target_schp
, arg2
, 0);
5148 ret
= get_errno(sched_setparam(arg1
, &schp
));
5151 case TARGET_NR_sched_getparam
:
5153 struct sched_param
*target_schp
;
5154 struct sched_param schp
;
5155 ret
= get_errno(sched_getparam(arg1
, &schp
));
5156 if (!is_error(ret
)) {
5157 if (!lock_user_struct(VERIFY_WRITE
, target_schp
, arg2
, 0))
5159 target_schp
->sched_priority
= tswap32(schp
.sched_priority
);
5160 unlock_user_struct(target_schp
, arg2
, 1);
5164 case TARGET_NR_sched_setscheduler
:
5166 struct sched_param
*target_schp
;
5167 struct sched_param schp
;
5168 if (!lock_user_struct(VERIFY_READ
, target_schp
, arg3
, 1))
5170 schp
.sched_priority
= tswap32(target_schp
->sched_priority
);
5171 unlock_user_struct(target_schp
, arg3
, 0);
5172 ret
= get_errno(sched_setscheduler(arg1
, arg2
, &schp
));
5175 case TARGET_NR_sched_getscheduler
:
5176 ret
= get_errno(sched_getscheduler(arg1
));
5178 case TARGET_NR_sched_yield
:
5179 ret
= get_errno(sched_yield());
5181 case TARGET_NR_sched_get_priority_max
:
5182 ret
= get_errno(sched_get_priority_max(arg1
));
5184 case TARGET_NR_sched_get_priority_min
:
5185 ret
= get_errno(sched_get_priority_min(arg1
));
5187 case TARGET_NR_sched_rr_get_interval
:
5190 ret
= get_errno(sched_rr_get_interval(arg1
, &ts
));
5191 if (!is_error(ret
)) {
5192 host_to_target_timespec(arg2
, &ts
);
5196 case TARGET_NR_nanosleep
:
5198 struct timespec req
, rem
;
5199 target_to_host_timespec(&req
, arg1
);
5200 ret
= get_errno(nanosleep(&req
, &rem
));
5201 if (is_error(ret
) && arg2
) {
5202 host_to_target_timespec(arg2
, &rem
);
5206 #ifdef TARGET_NR_query_module
5207 case TARGET_NR_query_module
:
5210 #ifdef TARGET_NR_nfsservctl
5211 case TARGET_NR_nfsservctl
:
5214 case TARGET_NR_prctl
:
5217 case PR_GET_PDEATHSIG
:
5220 ret
= get_errno(prctl(arg1
, &deathsig
, arg3
, arg4
, arg5
));
5221 if (!is_error(ret
) && arg2
5222 && put_user_ual(deathsig
, arg2
))
5227 ret
= get_errno(prctl(arg1
, arg2
, arg3
, arg4
, arg5
));
5231 #ifdef TARGET_NR_arch_prctl
5232 case TARGET_NR_arch_prctl
:
5233 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5234 ret
= do_arch_prctl(cpu_env
, arg1
, arg2
);
5240 #ifdef TARGET_NR_pread
5241 case TARGET_NR_pread
:
5243 if (((CPUARMState
*)cpu_env
)->eabi
)
5246 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
5248 ret
= get_errno(pread(arg1
, p
, arg3
, arg4
));
5249 unlock_user(p
, arg2
, ret
);
5251 case TARGET_NR_pwrite
:
5253 if (((CPUARMState
*)cpu_env
)->eabi
)
5256 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
5258 ret
= get_errno(pwrite(arg1
, p
, arg3
, arg4
));
5259 unlock_user(p
, arg2
, 0);
5262 #ifdef TARGET_NR_pread64
5263 case TARGET_NR_pread64
:
5264 if (!(p
= lock_user(VERIFY_WRITE
, arg2
, arg3
, 0)))
5266 ret
= get_errno(pread64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
5267 unlock_user(p
, arg2
, ret
);
5269 case TARGET_NR_pwrite64
:
5270 if (!(p
= lock_user(VERIFY_READ
, arg2
, arg3
, 1)))
5272 ret
= get_errno(pwrite64(arg1
, p
, arg3
, target_offset64(arg4
, arg5
)));
5273 unlock_user(p
, arg2
, 0);
5276 case TARGET_NR_getcwd
:
5277 if (!(p
= lock_user(VERIFY_WRITE
, arg1
, arg2
, 0)))
5279 ret
= get_errno(sys_getcwd1(p
, arg2
));
5280 unlock_user(p
, arg1
, ret
);
5282 case TARGET_NR_capget
:
5284 case TARGET_NR_capset
:
5286 case TARGET_NR_sigaltstack
:
5287 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5288 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
5289 ret
= do_sigaltstack(arg1
, arg2
, get_sp_from_cpustate((CPUState
*)cpu_env
));
5294 case TARGET_NR_sendfile
:
5296 #ifdef TARGET_NR_getpmsg
5297 case TARGET_NR_getpmsg
:
5300 #ifdef TARGET_NR_putpmsg
5301 case TARGET_NR_putpmsg
:
5304 #ifdef TARGET_NR_vfork
5305 case TARGET_NR_vfork
:
5306 ret
= get_errno(do_fork(cpu_env
, CLONE_VFORK
| CLONE_VM
| SIGCHLD
,
5310 #ifdef TARGET_NR_ugetrlimit
5311 case TARGET_NR_ugetrlimit
:
5314 ret
= get_errno(getrlimit(arg1
, &rlim
));
5315 if (!is_error(ret
)) {
5316 struct target_rlimit
*target_rlim
;
5317 if (!lock_user_struct(VERIFY_WRITE
, target_rlim
, arg2
, 0))
5319 target_rlim
->rlim_cur
= tswapl(rlim
.rlim_cur
);
5320 target_rlim
->rlim_max
= tswapl(rlim
.rlim_max
);
5321 unlock_user_struct(target_rlim
, arg2
, 1);
5326 #ifdef TARGET_NR_truncate64
5327 case TARGET_NR_truncate64
:
5328 if (!(p
= lock_user_string(arg1
)))
5330 ret
= target_truncate64(cpu_env
, p
, arg2
, arg3
, arg4
);
5331 unlock_user(p
, arg1
, 0);
5334 #ifdef TARGET_NR_ftruncate64
5335 case TARGET_NR_ftruncate64
:
5336 ret
= target_ftruncate64(cpu_env
, arg1
, arg2
, arg3
, arg4
);
5339 #ifdef TARGET_NR_stat64
5340 case TARGET_NR_stat64
:
5341 if (!(p
= lock_user_string(arg1
)))
5343 ret
= get_errno(stat(path(p
), &st
));
5344 unlock_user(p
, arg1
, 0);
5346 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5349 #ifdef TARGET_NR_lstat64
5350 case TARGET_NR_lstat64
:
5351 if (!(p
= lock_user_string(arg1
)))
5353 ret
= get_errno(lstat(path(p
), &st
));
5354 unlock_user(p
, arg1
, 0);
5356 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5359 #ifdef TARGET_NR_fstat64
5360 case TARGET_NR_fstat64
:
5361 ret
= get_errno(fstat(arg1
, &st
));
5363 ret
= host_to_target_stat64(cpu_env
, arg2
, &st
);
5366 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
5367 case TARGET_NR_fstatat64
:
5368 if (!(p
= lock_user_string(arg2
)))
5370 ret
= get_errno(sys_fstatat64(arg1
, path(p
), &st
, arg4
));
5372 ret
= host_to_target_stat64(cpu_env
, arg3
, &st
);
5376 case TARGET_NR_lchown
:
5377 if (!(p
= lock_user_string(arg1
)))
5379 ret
= get_errno(lchown(p
, low2highuid(arg2
), low2highgid(arg3
)));
5380 unlock_user(p
, arg1
, 0);
5382 case TARGET_NR_getuid
:
5383 ret
= get_errno(high2lowuid(getuid()));
5385 case TARGET_NR_getgid
:
5386 ret
= get_errno(high2lowgid(getgid()));
5388 case TARGET_NR_geteuid
:
5389 ret
= get_errno(high2lowuid(geteuid()));
5391 case TARGET_NR_getegid
:
5392 ret
= get_errno(high2lowgid(getegid()));
5394 case TARGET_NR_setreuid
:
5395 ret
= get_errno(setreuid(low2highuid(arg1
), low2highuid(arg2
)));
5397 case TARGET_NR_setregid
:
5398 ret
= get_errno(setregid(low2highgid(arg1
), low2highgid(arg2
)));
5400 case TARGET_NR_getgroups
:
5402 int gidsetsize
= arg1
;
5403 uint16_t *target_grouplist
;
5407 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5408 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
5409 if (gidsetsize
== 0)
5411 if (!is_error(ret
)) {
5412 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 2, 0);
5413 if (!target_grouplist
)
5415 for(i
= 0;i
< ret
; i
++)
5416 target_grouplist
[i
] = tswap16(grouplist
[i
]);
5417 unlock_user(target_grouplist
, arg2
, gidsetsize
* 2);
5421 case TARGET_NR_setgroups
:
5423 int gidsetsize
= arg1
;
5424 uint16_t *target_grouplist
;
5428 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5429 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 2, 1);
5430 if (!target_grouplist
) {
5431 ret
= -TARGET_EFAULT
;
5434 for(i
= 0;i
< gidsetsize
; i
++)
5435 grouplist
[i
] = tswap16(target_grouplist
[i
]);
5436 unlock_user(target_grouplist
, arg2
, 0);
5437 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
5440 case TARGET_NR_fchown
:
5441 ret
= get_errno(fchown(arg1
, low2highuid(arg2
), low2highgid(arg3
)));
5443 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5444 case TARGET_NR_fchownat
:
5445 if (!(p
= lock_user_string(arg2
)))
5447 ret
= get_errno(sys_fchownat(arg1
, p
, low2highuid(arg3
), low2highgid(arg4
), arg5
));
5448 unlock_user(p
, arg2
, 0);
5451 #ifdef TARGET_NR_setresuid
5452 case TARGET_NR_setresuid
:
5453 ret
= get_errno(setresuid(low2highuid(arg1
),
5455 low2highuid(arg3
)));
5458 #ifdef TARGET_NR_getresuid
5459 case TARGET_NR_getresuid
:
5461 uid_t ruid
, euid
, suid
;
5462 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
5463 if (!is_error(ret
)) {
5464 if (put_user_u16(high2lowuid(ruid
), arg1
)
5465 || put_user_u16(high2lowuid(euid
), arg2
)
5466 || put_user_u16(high2lowuid(suid
), arg3
))
5472 #ifdef TARGET_NR_getresgid
5473 case TARGET_NR_setresgid
:
5474 ret
= get_errno(setresgid(low2highgid(arg1
),
5476 low2highgid(arg3
)));
5479 #ifdef TARGET_NR_getresgid
5480 case TARGET_NR_getresgid
:
5482 gid_t rgid
, egid
, sgid
;
5483 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
5484 if (!is_error(ret
)) {
5485 if (put_user_u16(high2lowgid(rgid
), arg1
)
5486 || put_user_u16(high2lowgid(egid
), arg2
)
5487 || put_user_u16(high2lowgid(sgid
), arg3
))
5493 case TARGET_NR_chown
:
5494 if (!(p
= lock_user_string(arg1
)))
5496 ret
= get_errno(chown(p
, low2highuid(arg2
), low2highgid(arg3
)));
5497 unlock_user(p
, arg1
, 0);
5499 case TARGET_NR_setuid
:
5500 ret
= get_errno(setuid(low2highuid(arg1
)));
5502 case TARGET_NR_setgid
:
5503 ret
= get_errno(setgid(low2highgid(arg1
)));
5505 case TARGET_NR_setfsuid
:
5506 ret
= get_errno(setfsuid(arg1
));
5508 case TARGET_NR_setfsgid
:
5509 ret
= get_errno(setfsgid(arg1
));
5511 #endif /* USE_UID16 */
5513 #ifdef TARGET_NR_lchown32
5514 case TARGET_NR_lchown32
:
5515 if (!(p
= lock_user_string(arg1
)))
5517 ret
= get_errno(lchown(p
, arg2
, arg3
));
5518 unlock_user(p
, arg1
, 0);
5521 #ifdef TARGET_NR_getuid32
5522 case TARGET_NR_getuid32
:
5523 ret
= get_errno(getuid());
5526 #ifdef TARGET_NR_getgid32
5527 case TARGET_NR_getgid32
:
5528 ret
= get_errno(getgid());
5531 #ifdef TARGET_NR_geteuid32
5532 case TARGET_NR_geteuid32
:
5533 ret
= get_errno(geteuid());
5536 #ifdef TARGET_NR_getegid32
5537 case TARGET_NR_getegid32
:
5538 ret
= get_errno(getegid());
5541 #ifdef TARGET_NR_setreuid32
5542 case TARGET_NR_setreuid32
:
5543 ret
= get_errno(setreuid(arg1
, arg2
));
5546 #ifdef TARGET_NR_setregid32
5547 case TARGET_NR_setregid32
:
5548 ret
= get_errno(setregid(arg1
, arg2
));
5551 #ifdef TARGET_NR_getgroups32
5552 case TARGET_NR_getgroups32
:
5554 int gidsetsize
= arg1
;
5555 uint32_t *target_grouplist
;
5559 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5560 ret
= get_errno(getgroups(gidsetsize
, grouplist
));
5561 if (gidsetsize
== 0)
5563 if (!is_error(ret
)) {
5564 target_grouplist
= lock_user(VERIFY_WRITE
, arg2
, gidsetsize
* 4, 0);
5565 if (!target_grouplist
) {
5566 ret
= -TARGET_EFAULT
;
5569 for(i
= 0;i
< ret
; i
++)
5570 target_grouplist
[i
] = tswap32(grouplist
[i
]);
5571 unlock_user(target_grouplist
, arg2
, gidsetsize
* 4);
5576 #ifdef TARGET_NR_setgroups32
5577 case TARGET_NR_setgroups32
:
5579 int gidsetsize
= arg1
;
5580 uint32_t *target_grouplist
;
5584 grouplist
= alloca(gidsetsize
* sizeof(gid_t
));
5585 target_grouplist
= lock_user(VERIFY_READ
, arg2
, gidsetsize
* 4, 1);
5586 if (!target_grouplist
) {
5587 ret
= -TARGET_EFAULT
;
5590 for(i
= 0;i
< gidsetsize
; i
++)
5591 grouplist
[i
] = tswap32(target_grouplist
[i
]);
5592 unlock_user(target_grouplist
, arg2
, 0);
5593 ret
= get_errno(setgroups(gidsetsize
, grouplist
));
5597 #ifdef TARGET_NR_fchown32
5598 case TARGET_NR_fchown32
:
5599 ret
= get_errno(fchown(arg1
, arg2
, arg3
));
5602 #ifdef TARGET_NR_setresuid32
5603 case TARGET_NR_setresuid32
:
5604 ret
= get_errno(setresuid(arg1
, arg2
, arg3
));
5607 #ifdef TARGET_NR_getresuid32
5608 case TARGET_NR_getresuid32
:
5610 uid_t ruid
, euid
, suid
;
5611 ret
= get_errno(getresuid(&ruid
, &euid
, &suid
));
5612 if (!is_error(ret
)) {
5613 if (put_user_u32(ruid
, arg1
)
5614 || put_user_u32(euid
, arg2
)
5615 || put_user_u32(suid
, arg3
))
5621 #ifdef TARGET_NR_setresgid32
5622 case TARGET_NR_setresgid32
:
5623 ret
= get_errno(setresgid(arg1
, arg2
, arg3
));
5626 #ifdef TARGET_NR_getresgid32
5627 case TARGET_NR_getresgid32
:
5629 gid_t rgid
, egid
, sgid
;
5630 ret
= get_errno(getresgid(&rgid
, &egid
, &sgid
));
5631 if (!is_error(ret
)) {
5632 if (put_user_u32(rgid
, arg1
)
5633 || put_user_u32(egid
, arg2
)
5634 || put_user_u32(sgid
, arg3
))
5640 #ifdef TARGET_NR_chown32
5641 case TARGET_NR_chown32
:
5642 if (!(p
= lock_user_string(arg1
)))
5644 ret
= get_errno(chown(p
, arg2
, arg3
));
5645 unlock_user(p
, arg1
, 0);
5648 #ifdef TARGET_NR_setuid32
5649 case TARGET_NR_setuid32
:
5650 ret
= get_errno(setuid(arg1
));
5653 #ifdef TARGET_NR_setgid32
5654 case TARGET_NR_setgid32
:
5655 ret
= get_errno(setgid(arg1
));
5658 #ifdef TARGET_NR_setfsuid32
5659 case TARGET_NR_setfsuid32
:
5660 ret
= get_errno(setfsuid(arg1
));
5663 #ifdef TARGET_NR_setfsgid32
5664 case TARGET_NR_setfsgid32
:
5665 ret
= get_errno(setfsgid(arg1
));
5669 case TARGET_NR_pivot_root
:
5671 #ifdef TARGET_NR_mincore
5672 case TARGET_NR_mincore
:
5675 ret
= -TARGET_EFAULT
;
5676 if (!(a
= lock_user(VERIFY_READ
, arg1
,arg2
, 0)))
5678 if (!(p
= lock_user_string(arg3
)))
5680 ret
= get_errno(mincore(a
, arg2
, p
));
5681 unlock_user(p
, arg3
, ret
);
5683 unlock_user(a
, arg1
, 0);
5687 #ifdef TARGET_NR_arm_fadvise64_64
5688 case TARGET_NR_arm_fadvise64_64
:
5691 * arm_fadvise64_64 looks like fadvise64_64 but
5692 * with different argument order
5700 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64)
5701 #ifdef TARGET_NR_fadvise64_64
5702 case TARGET_NR_fadvise64_64
:
5704 /* This is a hint, so ignoring and returning success is ok. */
5708 #ifdef TARGET_NR_madvise
5709 case TARGET_NR_madvise
:
5710 /* A straight passthrough may not be safe because qemu sometimes
5711 turns private flie-backed mappings into anonymous mappings.
5712 This will break MADV_DONTNEED.
5713 This is a hint, so ignoring and returning success is ok. */
5717 #if TARGET_ABI_BITS == 32
5718 case TARGET_NR_fcntl64
:
5722 struct target_flock64
*target_fl
;
5724 struct target_eabi_flock64
*target_efl
;
5728 case TARGET_F_GETLK64
:
5731 case TARGET_F_SETLK64
:
5734 case TARGET_F_SETLKW64
:
5743 case TARGET_F_GETLK64
:
5745 if (((CPUARMState
*)cpu_env
)->eabi
) {
5746 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
5748 fl
.l_type
= tswap16(target_efl
->l_type
);
5749 fl
.l_whence
= tswap16(target_efl
->l_whence
);
5750 fl
.l_start
= tswap64(target_efl
->l_start
);
5751 fl
.l_len
= tswap64(target_efl
->l_len
);
5752 fl
.l_pid
= tswapl(target_efl
->l_pid
);
5753 unlock_user_struct(target_efl
, arg3
, 0);
5757 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
5759 fl
.l_type
= tswap16(target_fl
->l_type
);
5760 fl
.l_whence
= tswap16(target_fl
->l_whence
);
5761 fl
.l_start
= tswap64(target_fl
->l_start
);
5762 fl
.l_len
= tswap64(target_fl
->l_len
);
5763 fl
.l_pid
= tswapl(target_fl
->l_pid
);
5764 unlock_user_struct(target_fl
, arg3
, 0);
5766 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
5769 if (((CPUARMState
*)cpu_env
)->eabi
) {
5770 if (!lock_user_struct(VERIFY_WRITE
, target_efl
, arg3
, 0))
5772 target_efl
->l_type
= tswap16(fl
.l_type
);
5773 target_efl
->l_whence
= tswap16(fl
.l_whence
);
5774 target_efl
->l_start
= tswap64(fl
.l_start
);
5775 target_efl
->l_len
= tswap64(fl
.l_len
);
5776 target_efl
->l_pid
= tswapl(fl
.l_pid
);
5777 unlock_user_struct(target_efl
, arg3
, 1);
5781 if (!lock_user_struct(VERIFY_WRITE
, target_fl
, arg3
, 0))
5783 target_fl
->l_type
= tswap16(fl
.l_type
);
5784 target_fl
->l_whence
= tswap16(fl
.l_whence
);
5785 target_fl
->l_start
= tswap64(fl
.l_start
);
5786 target_fl
->l_len
= tswap64(fl
.l_len
);
5787 target_fl
->l_pid
= tswapl(fl
.l_pid
);
5788 unlock_user_struct(target_fl
, arg3
, 1);
5793 case TARGET_F_SETLK64
:
5794 case TARGET_F_SETLKW64
:
5796 if (((CPUARMState
*)cpu_env
)->eabi
) {
5797 if (!lock_user_struct(VERIFY_READ
, target_efl
, arg3
, 1))
5799 fl
.l_type
= tswap16(target_efl
->l_type
);
5800 fl
.l_whence
= tswap16(target_efl
->l_whence
);
5801 fl
.l_start
= tswap64(target_efl
->l_start
);
5802 fl
.l_len
= tswap64(target_efl
->l_len
);
5803 fl
.l_pid
= tswapl(target_efl
->l_pid
);
5804 unlock_user_struct(target_efl
, arg3
, 0);
5808 if (!lock_user_struct(VERIFY_READ
, target_fl
, arg3
, 1))
5810 fl
.l_type
= tswap16(target_fl
->l_type
);
5811 fl
.l_whence
= tswap16(target_fl
->l_whence
);
5812 fl
.l_start
= tswap64(target_fl
->l_start
);
5813 fl
.l_len
= tswap64(target_fl
->l_len
);
5814 fl
.l_pid
= tswapl(target_fl
->l_pid
);
5815 unlock_user_struct(target_fl
, arg3
, 0);
5817 ret
= get_errno(fcntl(arg1
, cmd
, &fl
));
5820 ret
= do_fcntl(arg1
, cmd
, arg3
);
5826 #ifdef TARGET_NR_cacheflush
5827 case TARGET_NR_cacheflush
:
5828 /* self-modifying code is handled automatically, so nothing needed */
5832 #ifdef TARGET_NR_security
5833 case TARGET_NR_security
:
5836 #ifdef TARGET_NR_getpagesize
5837 case TARGET_NR_getpagesize
:
5838 ret
= TARGET_PAGE_SIZE
;
5841 case TARGET_NR_gettid
:
5842 ret
= get_errno(gettid());
5844 #ifdef TARGET_NR_readahead
5845 case TARGET_NR_readahead
:
5846 #if TARGET_ABI_BITS == 32
5848 if (((CPUARMState
*)cpu_env
)->eabi
)
5855 ret
= get_errno(readahead(arg1
, ((off64_t
)arg3
<< 32) | arg2
, arg4
));
5857 ret
= get_errno(readahead(arg1
, arg2
, arg3
));
5861 #ifdef TARGET_NR_setxattr
5862 case TARGET_NR_setxattr
:
5863 case TARGET_NR_lsetxattr
:
5864 case TARGET_NR_fsetxattr
:
5865 case TARGET_NR_getxattr
:
5866 case TARGET_NR_lgetxattr
:
5867 case TARGET_NR_fgetxattr
:
5868 case TARGET_NR_listxattr
:
5869 case TARGET_NR_llistxattr
:
5870 case TARGET_NR_flistxattr
:
5871 case TARGET_NR_removexattr
:
5872 case TARGET_NR_lremovexattr
:
5873 case TARGET_NR_fremovexattr
:
5874 goto unimplemented_nowarn
;
5876 #ifdef TARGET_NR_set_thread_area
5877 case TARGET_NR_set_thread_area
:
5878 #if defined(TARGET_MIPS)
5879 ((CPUMIPSState
*) cpu_env
)->tls_value
= arg1
;
5882 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
5883 ret
= do_set_thread_area(cpu_env
, arg1
);
5886 goto unimplemented_nowarn
;
5889 #ifdef TARGET_NR_get_thread_area
5890 case TARGET_NR_get_thread_area
:
5891 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5892 ret
= do_get_thread_area(cpu_env
, arg1
);
5894 goto unimplemented_nowarn
;
5897 #ifdef TARGET_NR_getdomainname
5898 case TARGET_NR_getdomainname
:
5899 goto unimplemented_nowarn
;
5902 #ifdef TARGET_NR_clock_gettime
5903 case TARGET_NR_clock_gettime
:
5906 ret
= get_errno(clock_gettime(arg1
, &ts
));
5907 if (!is_error(ret
)) {
5908 host_to_target_timespec(arg2
, &ts
);
5913 #ifdef TARGET_NR_clock_getres
5914 case TARGET_NR_clock_getres
:
5917 ret
= get_errno(clock_getres(arg1
, &ts
));
5918 if (!is_error(ret
)) {
5919 host_to_target_timespec(arg2
, &ts
);
5924 #ifdef TARGET_NR_clock_nanosleep
5925 case TARGET_NR_clock_nanosleep
:
5928 target_to_host_timespec(&ts
, arg3
);
5929 ret
= get_errno(clock_nanosleep(arg1
, arg2
, &ts
, arg4
? &ts
: NULL
));
5931 host_to_target_timespec(arg4
, &ts
);
5936 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5937 case TARGET_NR_set_tid_address
:
5938 ret
= get_errno(set_tid_address((int *)g2h(arg1
)));
5942 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
5943 case TARGET_NR_tkill
:
5944 ret
= get_errno(sys_tkill((int)arg1
, target_to_host_signal(arg2
)));
5948 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
5949 case TARGET_NR_tgkill
:
5950 ret
= get_errno(sys_tgkill((int)arg1
, (int)arg2
,
5951 target_to_host_signal(arg3
)));
5955 #ifdef TARGET_NR_set_robust_list
5956 case TARGET_NR_set_robust_list
:
5957 goto unimplemented_nowarn
;
5960 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5961 case TARGET_NR_utimensat
:
5963 struct timespec ts
[2];
5964 target_to_host_timespec(ts
, arg3
);
5965 target_to_host_timespec(ts
+1, arg3
+sizeof(struct target_timespec
));
5967 ret
= get_errno(sys_utimensat(arg1
, NULL
, ts
, arg4
));
5969 if (!(p
= lock_user_string(arg2
))) {
5970 ret
= -TARGET_EFAULT
;
5973 ret
= get_errno(sys_utimensat(arg1
, path(p
), ts
, arg4
));
5974 unlock_user(p
, arg2
, 0);
5979 #if defined(USE_NPTL)
5980 case TARGET_NR_futex
:
5981 ret
= do_futex(arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
5984 #ifdef TARGET_NR_inotify_init
5985 case TARGET_NR_inotify_init
:
5986 ret
= get_errno(sys_inotify_init());
5989 #ifdef TARGET_NR_inotify_add_watch
5990 case TARGET_NR_inotify_add_watch
:
5991 p
= lock_user_string(arg2
);
5992 ret
= get_errno(sys_inotify_add_watch(arg1
, path(p
), arg3
));
5993 unlock_user(p
, arg2
, 0);
5996 #ifdef TARGET_NR_inotify_rm_watch
5997 case TARGET_NR_inotify_rm_watch
:
5998 ret
= get_errno(sys_inotify_rm_watch(arg1
, arg2
));
6004 gemu_log("qemu: Unsupported syscall: %d\n", num
);
6005 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
6006 unimplemented_nowarn
:
6008 ret
= -TARGET_ENOSYS
;
6013 gemu_log(" = %ld\n", ret
);
6016 print_syscall_ret(num
, ret
);
6019 ret
= -TARGET_EFAULT
;