]> git.proxmox.com Git - mirror_qemu.git/blame - linux-user/syscall.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mips socket calls (initial patch by Raphael Rigo)
[mirror_qemu.git] / linux-user / syscall.c
CommitLineData
31e31b8a
FB		 1/*
2 * Linux syscalls
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20#include <stdlib.h>
21#include <stdio.h>
22#include <stdarg.h>
04369ff2 23#include <string.h>
31e31b8a
FB		 24#include <elf.h>
25#include <endian.h>
26#include <errno.h>
27#include <unistd.h>
28#include <fcntl.h>
7854b056 29#include <time.h>
31e31b8a
FB		 30#include <sys/types.h>
31#include <sys/wait.h>
32#include <sys/time.h>
33#include <sys/stat.h>
34#include <sys/mount.h>
35#include <sys/resource.h>
36#include <sys/mman.h>
37#include <sys/swap.h>
38#include <signal.h>
39#include <sched.h>
40#include <sys/socket.h>
41#include <sys/uio.h>
9de5e440 42#include <sys/poll.h>
32f36bce 43#include <sys/times.h>
8853f86e 44#include <sys/shm.h>
56c8f68f 45#include <sys/statfs.h>
ebc05488 46#include <utime.h>
a5448a7d 47#include <sys/sysinfo.h>
72f03900 48//#include <sys/user.h>
8853f86e 49#include <netinet/ip.h>
7854b056 50#include <netinet/tcp.h>
31e31b8a
FB		 51
52#define termios host_termios
53#define winsize host_winsize
54#define termio host_termio
04369ff2
FB		 55#define sgttyb host_sgttyb /* same as target */
56#define tchars host_tchars /* same as target */
57#define ltchars host_ltchars /* same as target */
31e31b8a
FB		 58
59#include <linux/termios.h>
60#include <linux/unistd.h>
61#include <linux/utsname.h>
62#include <linux/cdrom.h>
63#include <linux/hdreg.h>
64#include <linux/soundcard.h>
dab2ed99 65#include <linux/dirent.h>
19b84f3c 66#include <linux/kd.h>
31e31b8a 67
3ef693a0 68#include "qemu.h"
31e31b8a 69
72f03900 70//#define DEBUG
31e31b8a 71
67867308
FB		 72#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC)
73/* 16 bit uid wrappers emulation */
74#define USE_UID16
75#endif
76
1a9353d2
FB		 77//#include <linux/msdos_fs.h>
78#define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2])
79#define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2])
80
70a194b9 81
70a194b9
FB		 82#undef _syscall0
83#undef _syscall1
84#undef _syscall2
85#undef _syscall3
86#undef _syscall4
87#undef _syscall5
83fcb515 88#undef _syscall6
70a194b9 89
83fcb515
FB		 90#define _syscall0(type,name) \
91type name (void) \
92{ \
93 return syscall(__NR_##name); \
94}
70a194b9 95
83fcb515
FB		 96#define _syscall1(type,name,type1,arg1) \
97type name (type1 arg1) \
98{ \
99 return syscall(__NR_##name, arg1); \
70a194b9
FB		 100}
101
83fcb515
FB		 102#define _syscall2(type,name,type1,arg1,type2,arg2) \
103type name (type1 arg1,type2 arg2) \
104{ \
105 return syscall(__NR_##name, arg1, arg2); \
70a194b9
FB		 106}
107
83fcb515
FB		 108#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
109type name (type1 arg1,type2 arg2,type3 arg3) \
110{ \
111 return syscall(__NR_##name, arg1, arg2, arg3); \
70a194b9
FB		 112}
113
83fcb515
FB		 114#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
115type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
116{ \
117 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
70a194b9
FB		 118}
119
83fcb515
FB		 120#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
121 type5,arg5) \
122type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
123{ \
124 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
70a194b9
FB		 125}
126
83fcb515
FB		 127
128#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
129 type5,arg5,type6,arg6) \
130type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
131{ \
132 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
70a194b9 133}
83fcb515 134
70a194b9 135
31e31b8a 136#define __NR_sys_uname __NR_uname
72f03900 137#define __NR_sys_getcwd1 __NR_getcwd
72f03900 138#define __NR_sys_getdents __NR_getdents
dab2ed99 139#define __NR_sys_getdents64 __NR_getdents64
66fb9763 140#define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
31e31b8a 141
bc51c5c9 142#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
9af9eaaa
FB		 143#define __NR__llseek __NR_lseek
144#endif
145
72f03900 146#ifdef __NR_gettid
31e31b8a 147_syscall0(int, gettid)
72f03900
FB		 148#else
149static int gettid(void) {
150 return -ENOSYS;
151}
152#endif
31e31b8a 153_syscall1(int,sys_uname,struct new_utsname *,buf)
72f03900
FB		 154_syscall2(int,sys_getcwd1,char *,buf,size_t,size)
155_syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count);
dab2ed99 156_syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count);
31e31b8a
FB		 157_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
158 loff_t *, res, uint, wh);
66fb9763 159_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
ec86b0fb
FB		 160#ifdef __NR_exit_group
161_syscall1(int,exit_group,int,error_code)
162#endif
66fb9763
FB		 163
164extern int personality(int);
9de5e440
FB		 165extern int flock(int, int);
166extern int setfsuid(int);
167extern int setfsgid(int);
5cd4393b
FB		 168extern int setresuid(uid_t, uid_t, uid_t);
169extern int getresuid(uid_t *, uid_t *, uid_t *);
170extern int setresgid(gid_t, gid_t, gid_t);
171extern int getresgid(gid_t *, gid_t *, gid_t *);
19b84f3c 172extern int setgroups(int, gid_t *);
31e31b8a
FB		 173
174static inline long get_errno(long ret)
175{
176 if (ret == -1)
177 return -errno;
178 else
179 return ret;
180}
181
182static inline int is_error(long ret)
183{
184 return (unsigned long)ret >= (unsigned long)(-4096);
185}
186
53a5960a
PB		 187static target_ulong target_brk;
188static target_ulong target_original_brk;
31e31b8a 189
53a5960a 190void target_set_brk(target_ulong new_brk)
31e31b8a 191{
53a5960a 192 target_original_brk = target_brk = new_brk;
31e31b8a
FB		 193}
194
53a5960a 195long do_brk(target_ulong new_brk)
31e31b8a 196{
53a5960a 197 target_ulong brk_page;
31e31b8a
FB		 198 long mapped_addr;
199 int new_alloc_size;
200
201 if (!new_brk)
53a5960a 202 return target_brk;
31e31b8a
FB		 203 if (new_brk < target_original_brk)
204 return -ENOMEM;
205
53a5960a 206 brk_page = HOST_PAGE_ALIGN(target_brk);
31e31b8a
FB		 207
208 /* If the new brk is less than this, set it and we're done... */
209 if (new_brk < brk_page) {
210 target_brk = new_brk;
53a5960a 211 return target_brk;
31e31b8a
FB		 212 }
213
214 /* We need to allocate more memory after the brk... */
54936004 215 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
53a5960a 216 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
54936004
FB		 217 PROT_READ|PROT_WRITE,
218 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));
31e31b8a
FB		 219 if (is_error(mapped_addr)) {
220 return mapped_addr;
221 } else {
222 target_brk = new_brk;
53a5960a 223 return target_brk;
31e31b8a
FB		 224 }
225}
226
227static inline fd_set *target_to_host_fds(fd_set *fds,
228 target_long *target_fds, int n)
229{
7854b056 230#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
31e31b8a
FB		 231 return (fd_set *)target_fds;
232#else
233 int i, b;
234 if (target_fds) {
235 FD_ZERO(fds);
236 for(i = 0;i < n; i++) {
237 b = (tswapl(target_fds[i / TARGET_LONG_BITS]) >>
238 (i & (TARGET_LONG_BITS - 1))) & 1;
239 if (b)
240 FD_SET(i, fds);
241 }
242 return fds;
243 } else {
244 return NULL;
245 }
246#endif
247}
248
249static inline void host_to_target_fds(target_long *target_fds,
250 fd_set *fds, int n)
251{
7854b056 252#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
31e31b8a
FB		 253 /* nothing to do */
254#else
255 int i, nw, j, k;
256 target_long v;
257
258 if (target_fds) {
8853f86e 259 nw = (n + TARGET_LONG_BITS - 1) / TARGET_LONG_BITS;
31e31b8a
FB		 260 k = 0;
261 for(i = 0;i < nw; i++) {
262 v = 0;
263 for(j = 0; j < TARGET_LONG_BITS; j++) {
264 v |= ((FD_ISSET(k, fds) != 0) << j);
265 k++;
266 }
267 target_fds[i] = tswapl(v);
268 }
269 }
270#endif
271}
272
c596ed17
FB		 273#if defined(__alpha__)
274#define HOST_HZ 1024
275#else
276#define HOST_HZ 100
277#endif
278
279static inline long host_to_target_clock_t(long ticks)
280{
281#if HOST_HZ == TARGET_HZ
282 return ticks;
283#else
284 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
285#endif
286}
287
53a5960a 288static inline void host_to_target_rusage(target_ulong target_addr,
b409186b
FB		 289 const struct rusage *rusage)
290{
53a5960a
PB		 291 struct target_rusage *target_rusage;
292
293 lock_user_struct(target_rusage, target_addr, 0);
b409186b
FB		 294 target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec);
295 target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec);
296 target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec);
297 target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec);
298 target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss);
299 target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss);
300 target_rusage->ru_idrss = tswapl(rusage->ru_idrss);
301 target_rusage->ru_isrss = tswapl(rusage->ru_isrss);
302 target_rusage->ru_minflt = tswapl(rusage->ru_minflt);
303 target_rusage->ru_majflt = tswapl(rusage->ru_majflt);
304 target_rusage->ru_nswap = tswapl(rusage->ru_nswap);
305 target_rusage->ru_inblock = tswapl(rusage->ru_inblock);
306 target_rusage->ru_oublock = tswapl(rusage->ru_oublock);
307 target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd);
308 target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv);
309 target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals);
310 target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw);
311 target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw);
53a5960a 312 unlock_user_struct(target_rusage, target_addr, 1);
b409186b
FB		 313}
314
53a5960a
PB		 315static inline void target_to_host_timeval(struct timeval *tv,
316 target_ulong target_addr)
31e31b8a 317{
53a5960a
PB		 318 struct target_timeval *target_tv;
319
320 lock_user_struct(target_tv, target_addr, 1);
66fb9763
FB		 321 tv->tv_sec = tswapl(target_tv->tv_sec);
322 tv->tv_usec = tswapl(target_tv->tv_usec);
53a5960a 323 unlock_user_struct(target_tv, target_addr, 0);
31e31b8a
FB		 324}
325
53a5960a 326static inline void host_to_target_timeval(target_ulong target_addr,
5cd4393b 327 const struct timeval *tv)
31e31b8a 328{
53a5960a
PB		 329 struct target_timeval *target_tv;
330
331 lock_user_struct(target_tv, target_addr, 0);
66fb9763
FB		 332 target_tv->tv_sec = tswapl(tv->tv_sec);
333 target_tv->tv_usec = tswapl(tv->tv_usec);
53a5960a 334 unlock_user_struct(target_tv, target_addr, 1);
31e31b8a
FB		 335}
336
337
338static long do_select(long n,
53a5960a
PB		 339 target_ulong rfd_p, target_ulong wfd_p,
340 target_ulong efd_p, target_ulong target_tv)
31e31b8a
FB		 341{
342 fd_set rfds, wfds, efds;
343 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
53a5960a 344 target_long *target_rfds, *target_wfds, *target_efds;
31e31b8a
FB		 345 struct timeval tv, *tv_ptr;
346 long ret;
53a5960a 347 int ok;
31e31b8a 348
53a5960a
PB		 349 if (rfd_p) {
350 target_rfds = lock_user(rfd_p, sizeof(target_long) * n, 1);
351 rfds_ptr = target_to_host_fds(&rfds, target_rfds, n);
352 } else {
353 target_rfds = NULL;
354 rfds_ptr = NULL;
355 }
356 if (wfd_p) {
357 target_wfds = lock_user(wfd_p, sizeof(target_long) * n, 1);
358 wfds_ptr = target_to_host_fds(&wfds, target_wfds, n);
359 } else {
360 target_wfds = NULL;
361 wfds_ptr = NULL;
362 }
363 if (efd_p) {
364 target_efds = lock_user(efd_p, sizeof(target_long) * n, 1);
365 efds_ptr = target_to_host_fds(&efds, target_efds, n);
366 } else {
367 target_efds = NULL;
368 efds_ptr = NULL;
369 }
31e31b8a
FB		 370
371 if (target_tv) {
5cd4393b 372 target_to_host_timeval(&tv, target_tv);
31e31b8a
FB		 373 tv_ptr = &tv;
374 } else {
375 tv_ptr = NULL;
376 }
377 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
53a5960a
PB		 378 ok = !is_error(ret);
379
380 if (ok) {
31e31b8a
FB		 381 host_to_target_fds(target_rfds, rfds_ptr, n);
382 host_to_target_fds(target_wfds, wfds_ptr, n);
383 host_to_target_fds(target_efds, efds_ptr, n);
384
385 if (target_tv) {
5cd4393b 386 host_to_target_timeval(target_tv, &tv);
31e31b8a
FB		 387 }
388 }
53a5960a
PB		 389 if (target_rfds)
390 unlock_user(target_rfds, rfd_p, ok ? sizeof(target_long) * n : 0);
391 if (target_wfds)
392 unlock_user(target_wfds, wfd_p, ok ? sizeof(target_long) * n : 0);
393 if (target_efds)
394 unlock_user(target_efds, efd_p, ok ? sizeof(target_long) * n : 0);
395
31e31b8a
FB		 396 return ret;
397}
398
7854b056 399static inline void target_to_host_sockaddr(struct sockaddr *addr,
53a5960a 400 target_ulong target_addr,
7854b056
FB		 401 socklen_t len)
402{
53a5960a
PB		 403 struct target_sockaddr *target_saddr;
404
405 target_saddr = lock_user(target_addr, len, 1);
406 memcpy(addr, target_saddr, len);
407 addr->sa_family = tswap16(target_saddr->sa_family);
408 unlock_user(target_saddr, target_addr, 0);
7854b056
FB		 409}
410
53a5960a 411static inline void host_to_target_sockaddr(target_ulong target_addr,
7854b056
FB		 412 struct sockaddr *addr,
413 socklen_t len)
414{
53a5960a
PB		 415 struct target_sockaddr *target_saddr;
416
417 target_saddr = lock_user(target_addr, len, 0);
418 memcpy(target_saddr, addr, len);
419 target_saddr->sa_family = tswap16(addr->sa_family);
420 unlock_user(target_saddr, target_addr, len);
7854b056
FB		 421}
422
53a5960a 423/* ??? Should this also swap msgh->name? */
7854b056
FB		 424static inline void target_to_host_cmsg(struct msghdr *msgh,
425 struct target_msghdr *target_msgh)
426{
427 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
428 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
429 socklen_t space = 0;
430
431 while (cmsg && target_cmsg) {
432 void *data = CMSG_DATA(cmsg);
433 void *target_data = TARGET_CMSG_DATA(target_cmsg);
434
435 int len = tswapl(target_cmsg->cmsg_len)
436 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
437
438 space += CMSG_SPACE(len);
439 if (space > msgh->msg_controllen) {
440 space -= CMSG_SPACE(len);
31febb71 441 gemu_log("Host cmsg overflow\n");
7854b056
FB		 442 break;
443 }
444
445 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
446 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
447 cmsg->cmsg_len = CMSG_LEN(len);
448
3532fa74 449 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
7854b056
FB		 450 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
451 memcpy(data, target_data, len);
452 } else {
453 int *fd = (int *)data;
454 int *target_fd = (int *)target_data;
455 int i, numfds = len / sizeof(int);
456
457 for (i = 0; i < numfds; i++)
458 fd[i] = tswap32(target_fd[i]);
459 }
460
461 cmsg = CMSG_NXTHDR(msgh, cmsg);
462 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
463 }
464
465 msgh->msg_controllen = space;
466}
467
53a5960a 468/* ??? Should this also swap msgh->name? */
7854b056
FB		 469static inline void host_to_target_cmsg(struct target_msghdr *target_msgh,
470 struct msghdr *msgh)
471{
472 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
473 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
474 socklen_t space = 0;
475
476 while (cmsg && target_cmsg) {
477 void *data = CMSG_DATA(cmsg);
478 void *target_data = TARGET_CMSG_DATA(target_cmsg);
479
480 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
481
482 space += TARGET_CMSG_SPACE(len);
483 if (space > tswapl(target_msgh->msg_controllen)) {
484 space -= TARGET_CMSG_SPACE(len);
31febb71 485 gemu_log("Target cmsg overflow\n");
7854b056
FB		 486 break;
487 }
488
489 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
490 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
491 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
492
3532fa74 493 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
7854b056
FB		 494 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
495 memcpy(target_data, data, len);
496 } else {
497 int *fd = (int *)data;
498 int *target_fd = (int *)target_data;
499 int i, numfds = len / sizeof(int);
500
501 for (i = 0; i < numfds; i++)
502 target_fd[i] = tswap32(fd[i]);
503 }
504
505 cmsg = CMSG_NXTHDR(msgh, cmsg);
506 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
507 }
508
509 msgh->msg_controllen = tswapl(space);
510}
511
512static long do_setsockopt(int sockfd, int level, int optname,
53a5960a 513 target_ulong optval, socklen_t optlen)
7854b056 514{
8853f86e
FB		 515 int val, ret;
516
517 switch(level) {
518 case SOL_TCP:
7854b056 519 /* TCP options all take an 'int' value. */
7854b056
FB		 520 if (optlen < sizeof(uint32_t))
521 return -EINVAL;
8853f86e 522
53a5960a 523 val = tget32(optval);
8853f86e
FB		 524 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
525 break;
526 case SOL_IP:
527 switch(optname) {
2efbe911
FB		 528 case IP_TOS:
529 case IP_TTL:
8853f86e 530 case IP_HDRINCL:
2efbe911
FB		 531 case IP_ROUTER_ALERT:
532 case IP_RECVOPTS:
533 case IP_RETOPTS:
534 case IP_PKTINFO:
535 case IP_MTU_DISCOVER:
536 case IP_RECVERR:
537 case IP_RECVTOS:
538#ifdef IP_FREEBIND
539 case IP_FREEBIND:
540#endif
541 case IP_MULTICAST_TTL:
542 case IP_MULTICAST_LOOP:
8853f86e
FB		 543 val = 0;
544 if (optlen >= sizeof(uint32_t)) {
53a5960a 545 val = tget32(optval);
8853f86e 546 } else if (optlen >= 1) {
53a5960a 547 val = tget8(optval);
8853f86e
FB		 548 }
549 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
550 break;
551 default:
552 goto unimplemented;
553 }
554 break;
3532fa74 555 case TARGET_SOL_SOCKET:
8853f86e
FB		 556 switch (optname) {
557 /* Options with 'int' argument. */
3532fa74
FB		 558 case TARGET_SO_DEBUG:
559 optname = SO_DEBUG;
560 break;
561 case TARGET_SO_REUSEADDR:
562 optname = SO_REUSEADDR;
563 break;
564 case TARGET_SO_TYPE:
565 optname = SO_TYPE;
566 break;
567 case TARGET_SO_ERROR:
568 optname = SO_ERROR;
569 break;
570 case TARGET_SO_DONTROUTE:
571 optname = SO_DONTROUTE;
572 break;
573 case TARGET_SO_BROADCAST:
574 optname = SO_BROADCAST;
575 break;
576 case TARGET_SO_SNDBUF:
577 optname = SO_SNDBUF;
578 break;
579 case TARGET_SO_RCVBUF:
580 optname = SO_RCVBUF;
581 break;
582 case TARGET_SO_KEEPALIVE:
583 optname = SO_KEEPALIVE;
584 break;
585 case TARGET_SO_OOBINLINE:
586 optname = SO_OOBINLINE;
587 break;
588 case TARGET_SO_NO_CHECK:
589 optname = SO_NO_CHECK;
590 break;
591 case TARGET_SO_PRIORITY:
592 optname = SO_PRIORITY;
593 break;
5e83e8e3 594#ifdef SO_BSDCOMPAT
3532fa74
FB		 595 case TARGET_SO_BSDCOMPAT:
596 optname = SO_BSDCOMPAT;
597 break;
5e83e8e3 598#endif
3532fa74
FB		 599 case TARGET_SO_PASSCRED:
600 optname = SO_PASSCRED;
601 break;
602 case TARGET_SO_TIMESTAMP:
603 optname = SO_TIMESTAMP;
604 break;
605 case TARGET_SO_RCVLOWAT:
606 optname = SO_RCVLOWAT;
607 break;
608 case TARGET_SO_RCVTIMEO:
609 optname = SO_RCVTIMEO;
610 break;
611 case TARGET_SO_SNDTIMEO:
612 optname = SO_SNDTIMEO;
613 break;
8853f86e
FB		 614 break;
615 default:
616 goto unimplemented;
617 }
3532fa74
FB		 618 if (optlen < sizeof(uint32_t))
619 return -EINVAL;
620
621 val = tget32(optval);
622 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
8853f86e 623 break;
7854b056 624 default:
8853f86e
FB		 625 unimplemented:
626 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
627 ret = -ENOSYS;
7854b056 628 }
8853f86e 629 return ret;
7854b056
FB		 630}
631
632static long do_getsockopt(int sockfd, int level, int optname,
53a5960a 633 target_ulong optval, target_ulong optlen)
7854b056 634{
8853f86e
FB		 635 int len, lv, val, ret;
636
637 switch(level) {
3532fa74
FB		 638 case TARGET_SOL_SOCKET:
639 level = SOL_SOCKET;
8853f86e 640 switch (optname) {
3532fa74
FB		 641 case TARGET_SO_LINGER:
642 case TARGET_SO_RCVTIMEO:
643 case TARGET_SO_SNDTIMEO:
644 case TARGET_SO_PEERCRED:
645 case TARGET_SO_PEERNAME:
8853f86e
FB		 646 /* These don't just return a single integer */
647 goto unimplemented;
648 default:
2efbe911
FB		 649 goto int_case;
650 }
651 break;
652 case SOL_TCP:
653 /* TCP options all take an 'int' value. */
654 int_case:
53a5960a 655 len = tget32(optlen);
2efbe911
FB		 656 if (len < 0)
657 return -EINVAL;
658 lv = sizeof(int);
659 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
660 if (ret < 0)
661 return ret;
662 val = tswap32(val);
663 if (len > lv)
664 len = lv;
53a5960a
PB		 665 if (len == 4)
666 tput32(optval, val);
667 else
668 tput8(optval, val);
669 tput32(optlen, len);
2efbe911
FB		 670 break;
671 case SOL_IP:
672 switch(optname) {
673 case IP_TOS:
674 case IP_TTL:
675 case IP_HDRINCL:
676 case IP_ROUTER_ALERT:
677 case IP_RECVOPTS:
678 case IP_RETOPTS:
679 case IP_PKTINFO:
680 case IP_MTU_DISCOVER:
681 case IP_RECVERR:
682 case IP_RECVTOS:
683#ifdef IP_FREEBIND
684 case IP_FREEBIND:
685#endif
686 case IP_MULTICAST_TTL:
687 case IP_MULTICAST_LOOP:
53a5960a 688 len = tget32(optlen);
8853f86e
FB		 689 if (len < 0)
690 return -EINVAL;
691 lv = sizeof(int);
692 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
693 if (ret < 0)
694 return ret;
2efbe911 695 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2efbe911 696 len = 1;
53a5960a
PB		 697 tput32(optlen, len);
698 tput8(optval, val);
2efbe911 699 } else {
2efbe911
FB		 700 if (len > sizeof(int))
701 len = sizeof(int);
53a5960a
PB		 702 tput32(optlen, len);
703 tput32(optval, val);
2efbe911 704 }
8853f86e 705 break;
2efbe911
FB		 706 default:
707 goto unimplemented;
8853f86e
FB		 708 }
709 break;
710 default:
711 unimplemented:
712 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
713 level, optname);
714 ret = -ENOSYS;
715 break;
716 }
717 return ret;
7854b056
FB		 718}
719
53a5960a
PB		 720static void lock_iovec(struct iovec *vec, target_ulong target_addr,
721 int count, int copy)
722{
723 struct target_iovec *target_vec;
724 target_ulong base;
725 int i;
726
727 target_vec = lock_user(target_addr, count * sizeof(struct target_iovec), 1);
728 for(i = 0;i < count; i++) {
729 base = tswapl(target_vec[i].iov_base);
730 vec[i].iov_len = tswapl(target_vec[i].iov_len);
731 vec[i].iov_base = lock_user(base, vec[i].iov_len, copy);
732 }
733 unlock_user (target_vec, target_addr, 0);
734}
735
736static void unlock_iovec(struct iovec *vec, target_ulong target_addr,
737 int count, int copy)
738{
739 struct target_iovec *target_vec;
740 target_ulong base;
741 int i;
742
743 target_vec = lock_user(target_addr, count * sizeof(struct target_iovec), 1);
744 for(i = 0;i < count; i++) {
745 base = tswapl(target_vec[i].iov_base);
746 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
747 }
748 unlock_user (target_vec, target_addr, 0);
749}
750
3532fa74
FB		 751static long do_socket(int domain, int type, int protocol)
752{
753#if defined(TARGET_MIPS)
754 switch(type) {
755 case TARGET_SOCK_DGRAM:
756 type = SOCK_DGRAM;
757 break;
758 case TARGET_SOCK_STREAM:
759 type = SOCK_STREAM;
760 break;
761 case TARGET_SOCK_RAW:
762 type = SOCK_RAW;
763 break;
764 case TARGET_SOCK_RDM:
765 type = SOCK_RDM;
766 break;
767 case TARGET_SOCK_SEQPACKET:
768 type = SOCK_SEQPACKET;
769 break;
770 case TARGET_SOCK_PACKET:
771 type = SOCK_PACKET;
772 break;
773 }
774#endif
775 return get_errno(socket(domain, type, protocol));
776}
777
778static long do_bind(int sockfd, target_ulong target_addr,
779 socklen_t addrlen)
780{
781 void *addr = alloca(addrlen);
782
783 target_to_host_sockaddr(addr, target_addr, addrlen);
784 return get_errno(bind(sockfd, addr, addrlen));
785}
786
787static long do_connect(int sockfd, target_ulong target_addr,
788 socklen_t addrlen)
789{
790 void *addr = alloca(addrlen);
791
792 target_to_host_sockaddr(addr, target_addr, addrlen);
793 return get_errno(connect(sockfd, addr, addrlen));
794}
795
796static long do_sendrecvmsg(int fd, target_ulong target_msg,
797 int flags, int send)
798{
799 long ret;
800 struct target_msghdr *msgp;
801 struct msghdr msg;
802 int count;
803 struct iovec *vec;
804 target_ulong target_vec;
805
806 lock_user_struct(msgp, target_msg, 1);
807 if (msgp->msg_name) {
808 msg.msg_namelen = tswap32(msgp->msg_namelen);
809 msg.msg_name = alloca(msg.msg_namelen);
810 target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name),
811 msg.msg_namelen);
812 } else {
813 msg.msg_name = NULL;
814 msg.msg_namelen = 0;
815 }
816 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
817 msg.msg_control = alloca(msg.msg_controllen);
818 msg.msg_flags = tswap32(msgp->msg_flags);
819
820 count = tswapl(msgp->msg_iovlen);
821 vec = alloca(count * sizeof(struct iovec));
822 target_vec = tswapl(msgp->msg_iov);
823 lock_iovec(vec, target_vec, count, send);
824 msg.msg_iovlen = count;
825 msg.msg_iov = vec;
826
827 if (send) {
828 target_to_host_cmsg(&msg, msgp);
829 ret = get_errno(sendmsg(fd, &msg, flags));
830 } else {
831 ret = get_errno(recvmsg(fd, &msg, flags));
832 if (!is_error(ret))
833 host_to_target_cmsg(msgp, &msg);
834 }
835 unlock_iovec(vec, target_vec, count, !send);
836 return ret;
837}
838
53a5960a 839static long do_socketcall(int num, target_ulong vptr)
31e31b8a
FB		 840{
841 long ret;
53a5960a 842 const int n = sizeof(target_ulong);
31e31b8a
FB		 843
844 switch(num) {
845 case SOCKOP_socket:
7854b056 846 {
53a5960a
PB		 847 int domain = tgetl(vptr);
848 int type = tgetl(vptr + n);
849 int protocol = tgetl(vptr + 2 * n);
3532fa74 850 ret = do_socket(domain, type, protocol);
7854b056 851 }
31e31b8a
FB		 852 break;
853 case SOCKOP_bind:
7854b056 854 {
53a5960a
PB		 855 int sockfd = tgetl(vptr);
856 target_ulong target_addr = tgetl(vptr + n);
857 socklen_t addrlen = tgetl(vptr + 2 * n);
3532fa74 858 ret = do_bind(sockfd, target_addr, addrlen);
7854b056 859 }
31e31b8a
FB		 860 break;
861 case SOCKOP_connect:
7854b056 862 {
53a5960a
PB		 863 int sockfd = tgetl(vptr);
864 target_ulong target_addr = tgetl(vptr + n);
865 socklen_t addrlen = tgetl(vptr + 2 * n);
3532fa74 866 ret = do_connect(sockfd, target_addr, addrlen);
7854b056 867 }
31e31b8a
FB		 868 break;
869 case SOCKOP_listen:
7854b056 870 {
53a5960a
PB		 871 int sockfd = tgetl(vptr);
872 int backlog = tgetl(vptr + n);
7854b056
FB		 873 ret = get_errno(listen(sockfd, backlog));
874 }
31e31b8a
FB		 875 break;
876 case SOCKOP_accept:
877 {
53a5960a
PB		 878 int sockfd = tgetl(vptr);
879 target_ulong target_addr = tgetl(vptr + n);
880 target_ulong target_addrlen = tgetl(vptr + 2 * n);
881 socklen_t addrlen = tget32(target_addrlen);
7854b056
FB		 882 void *addr = alloca(addrlen);
883
884 ret = get_errno(accept(sockfd, addr, &addrlen));
885 if (!is_error(ret)) {
886 host_to_target_sockaddr(target_addr, addr, addrlen);
53a5960a 887 tput32(target_addrlen, addrlen);
7854b056 888 }
31e31b8a
FB		 889 }
890 break;
891 case SOCKOP_getsockname:
892 {
53a5960a
PB		 893 int sockfd = tgetl(vptr);
894 target_ulong target_addr = tgetl(vptr + n);
895 target_ulong target_addrlen = tgetl(vptr + 2 * n);
896 socklen_t addrlen = tget32(target_addrlen);
7854b056
FB		 897 void *addr = alloca(addrlen);
898
899 ret = get_errno(getsockname(sockfd, addr, &addrlen));
900 if (!is_error(ret)) {
901 host_to_target_sockaddr(target_addr, addr, addrlen);
53a5960a 902 tput32(target_addrlen, addrlen);
7854b056 903 }
31e31b8a
FB		 904 }
905 break;
906 case SOCKOP_getpeername:
907 {
53a5960a
PB		 908 int sockfd = tgetl(vptr);
909 target_ulong target_addr = tgetl(vptr + n);
910 target_ulong target_addrlen = tgetl(vptr + 2 * n);
911 socklen_t addrlen = tget32(target_addrlen);
7854b056
FB		 912 void *addr = alloca(addrlen);
913
914 ret = get_errno(getpeername(sockfd, addr, &addrlen));
915 if (!is_error(ret)) {
916 host_to_target_sockaddr(target_addr, addr, addrlen);
53a5960a 917 tput32(target_addrlen, addrlen);
7854b056 918 }
31e31b8a
FB		 919 }
920 break;
921 case SOCKOP_socketpair:
922 {
53a5960a
PB		 923 int domain = tgetl(vptr);
924 int type = tgetl(vptr + n);
925 int protocol = tgetl(vptr + 2 * n);
926 target_ulong target_tab = tgetl(vptr + 3 * n);
31e31b8a 927 int tab[2];
7854b056
FB		 928
929 ret = get_errno(socketpair(domain, type, protocol, tab));
31e31b8a 930 if (!is_error(ret)) {
53a5960a
PB		 931 tput32(target_tab, tab[0]);
932 tput32(target_tab + 4, tab[1]);
31e31b8a
FB		 933 }
934 }
935 break;
936 case SOCKOP_send:
7854b056 937 {
53a5960a
PB		 938 int sockfd = tgetl(vptr);
939 target_ulong msg = tgetl(vptr + n);
940 size_t len = tgetl(vptr + 2 * n);
941 int flags = tgetl(vptr + 3 * n);
942 void *host_msg;
7854b056 943
53a5960a
PB		 944 host_msg = lock_user(msg, len, 1);
945 ret = get_errno(send(sockfd, host_msg, len, flags));
946 unlock_user(host_msg, msg, 0);
7854b056 947 }
31e31b8a
FB		 948 break;
949 case SOCKOP_recv:
7854b056 950 {
53a5960a
PB		 951 int sockfd = tgetl(vptr);
952 target_ulong msg = tgetl(vptr + n);
953 size_t len = tgetl(vptr + 2 * n);
954 int flags = tgetl(vptr + 3 * n);
955 void *host_msg;
7854b056 956
53a5960a
PB		 957 host_msg = lock_user(msg, len, 0);
958 ret = get_errno(recv(sockfd, host_msg, len, flags));
959 unlock_user(host_msg, msg, ret);
7854b056 960 }
31e31b8a
FB		 961 break;
962 case SOCKOP_sendto:
7854b056 963 {
53a5960a
PB		 964 int sockfd = tgetl(vptr);
965 target_ulong msg = tgetl(vptr + n);
966 size_t len = tgetl(vptr + 2 * n);
967 int flags = tgetl(vptr + 3 * n);
968 target_ulong target_addr = tgetl(vptr + 4 * n);
969 socklen_t addrlen = tgetl(vptr + 5 * n);
7854b056 970 void *addr = alloca(addrlen);
53a5960a 971 void *host_msg;
7854b056 972
53a5960a 973 host_msg = lock_user(msg, len, 1);
7854b056 974 target_to_host_sockaddr(addr, target_addr, addrlen);
53a5960a
PB		 975 ret = get_errno(sendto(sockfd, host_msg, len, flags, addr, addrlen));
976 unlock_user(host_msg, msg, 0);
7854b056 977 }
31e31b8a
FB		 978 break;
979 case SOCKOP_recvfrom:
980 {
53a5960a
PB		 981 int sockfd = tgetl(vptr);
982 target_ulong msg = tgetl(vptr + n);
983 size_t len = tgetl(vptr + 2 * n);
984 int flags = tgetl(vptr + 3 * n);
985 target_ulong target_addr = tgetl(vptr + 4 * n);
986 target_ulong target_addrlen = tgetl(vptr + 5 * n);
987 socklen_t addrlen = tget32(target_addrlen);
7854b056 988 void *addr = alloca(addrlen);
53a5960a 989 void *host_msg;
7854b056 990
53a5960a
PB		 991 host_msg = lock_user(msg, len, 0);
992 ret = get_errno(recvfrom(sockfd, host_msg, len, flags, addr, &addrlen));
7854b056
FB		 993 if (!is_error(ret)) {
994 host_to_target_sockaddr(target_addr, addr, addrlen);
53a5960a
PB		 995 tput32(target_addrlen, addrlen);
996 unlock_user(host_msg, msg, len);
997 } else {
998 unlock_user(host_msg, msg, 0);
7854b056 999 }
31e31b8a
FB		 1000 }
1001 break;
1002 case SOCKOP_shutdown:
7854b056 1003 {
53a5960a
PB		 1004 int sockfd = tgetl(vptr);
1005 int how = tgetl(vptr + n);
7854b056
FB		 1006
1007 ret = get_errno(shutdown(sockfd, how));
1008 }
31e31b8a
FB		 1009 break;
1010 case SOCKOP_sendmsg:
1011 case SOCKOP_recvmsg:
1a9353d2
FB		 1012 {
1013 int fd;
53a5960a 1014 target_ulong target_msg;
3532fa74 1015 int flags;
1a9353d2 1016
53a5960a 1017 fd = tgetl(vptr);
3532fa74 1018 target_msg = tgetl(vptr + n);
53a5960a 1019 flags = tgetl(vptr + 2 * n);
3532fa74
FB		 1020
1021 ret = do_sendrecvmsg(fd, target_msg, flags,
1022 (num == SOCKOP_sendmsg));
1a9353d2
FB		 1023 }
1024 break;
31e31b8a 1025 case SOCKOP_setsockopt:
7854b056 1026 {
53a5960a
PB		 1027 int sockfd = tgetl(vptr);
1028 int level = tgetl(vptr + n);
1029 int optname = tgetl(vptr + 2 * n);
1030 target_ulong optval = tgetl(vptr + 3 * n);
1031 socklen_t optlen = tgetl(vptr + 4 * n);
7854b056
FB		 1032
1033 ret = do_setsockopt(sockfd, level, optname, optval, optlen);
1034 }
1035 break;
31e31b8a 1036 case SOCKOP_getsockopt:
7854b056 1037 {
53a5960a
PB		 1038 int sockfd = tgetl(vptr);
1039 int level = tgetl(vptr + n);
1040 int optname = tgetl(vptr + 2 * n);
1041 target_ulong optval = tgetl(vptr + 3 * n);
1042 target_ulong poptlen = tgetl(vptr + 4 * n);
7854b056 1043
8853f86e 1044 ret = do_getsockopt(sockfd, level, optname, optval, poptlen);
7854b056
FB		 1045 }
1046 break;
31e31b8a
FB		 1047 default:
1048 gemu_log("Unsupported socketcall: %d\n", num);
1049 ret = -ENOSYS;
1050 break;
1051 }
1052 return ret;
1053}
1054
3532fa74
FB		 1055/* XXX: suppress this function and call directly the related socket
1056 functions */
1057static long do_socketcallwrapper(int num, long arg1, long arg2, long arg3,
1058 long arg4, long arg5, long arg6)
1059{
1060 target_long args[6];
1061
1062 tputl(args, arg1);
1063 tputl(args+1, arg2);
1064 tputl(args+2, arg3);
1065 tputl(args+3, arg4);
1066 tputl(args+4, arg5);
1067 tputl(args+5, arg6);
1068
1069 return do_socketcall(num, (target_ulong) args);
1070}
8853f86e
FB		 1071
1072#define N_SHM_REGIONS 32
1073
1074static struct shm_region {
1075 uint32_t start;
1076 uint32_t size;
1077} shm_regions[N_SHM_REGIONS];
1078
53a5960a 1079/* ??? This only works with linear mappings. */
8853f86e
FB		 1080static long do_ipc(long call, long first, long second, long third,
1081 long ptr, long fifth)
1082{
1083 int version;
1084 long ret = 0;
1085 unsigned long raddr;
1086 struct shmid_ds shm_info;
1087 int i;
1088
1089 version = call >> 16;
1090 call &= 0xffff;
1091
1092 switch (call) {
1093 case IPCOP_shmat:
1094 /* SHM_* flags are the same on all linux platforms */
1095 ret = get_errno((long) shmat(first, (void *) ptr, second));
1096 if (is_error(ret))
1097 break;
1098 raddr = ret;
1099 /* find out the length of the shared memory segment */
1100
1101 ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
1102 if (is_error(ret)) {
1103 /* can't get length, bail out */
1104 shmdt((void *) raddr);
1105 break;
1106 }
1107 page_set_flags(raddr, raddr + shm_info.shm_segsz,
1108 PAGE_VALID | PAGE_READ |
1109 ((second & SHM_RDONLY)? 0: PAGE_WRITE));
1110 for (i = 0; i < N_SHM_REGIONS; ++i) {
1111 if (shm_regions[i].start == 0) {
1112 shm_regions[i].start = raddr;
1113 shm_regions[i].size = shm_info.shm_segsz;
1114 break;
1115 }
1116 }
1117 if (put_user(raddr, (uint32_t *)third))
1118 return -EFAULT;
1119 ret = 0;
1120 break;
1121 case IPCOP_shmdt:
1122 for (i = 0; i < N_SHM_REGIONS; ++i) {
1123 if (shm_regions[i].start == ptr) {
1124 shm_regions[i].start = 0;
1125 page_set_flags(ptr, shm_regions[i].size, 0);
1126 break;
1127 }
1128 }
1129 ret = get_errno(shmdt((void *) ptr));
1130 break;
1131
1132 case IPCOP_shmget:
1133 /* IPC_* flag values are the same on all linux platforms */
1134 ret = get_errno(shmget(first, second, third));
1135 break;
1136
1137 /* IPC_* and SHM_* command values are the same on all linux platforms */
1138 case IPCOP_shmctl:
1139 switch(second) {
1140 case IPC_RMID:
1141 case SHM_LOCK:
1142 case SHM_UNLOCK:
1143 ret = get_errno(shmctl(first, second, NULL));
1144 break;
1145 default:
1146 goto unimplemented;
1147 }
1148 break;
1149 default:
1150 unimplemented:
1151 gemu_log("Unsupported ipc call: %ld (version %d)\n", call, version);
1152 ret = -ENOSYS;
1153 break;
1154 }
1155 return ret;
1156}
1157
31e31b8a
FB		 1158/* kernel structure types definitions */
1159#define IFNAMSIZ 16
1160
1161#define STRUCT(name, list...) STRUCT_ ## name,
1162#define STRUCT_SPECIAL(name) STRUCT_ ## name,
1163enum {
1164#include "syscall_types.h"
1165};
1166#undef STRUCT
1167#undef STRUCT_SPECIAL
1168
1169#define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
1170#define STRUCT_SPECIAL(name)
1171#include "syscall_types.h"
1172#undef STRUCT
1173#undef STRUCT_SPECIAL
1174
1175typedef struct IOCTLEntry {
2ab83ea7
FB		 1176 unsigned int target_cmd;
1177 unsigned int host_cmd;
31e31b8a
FB		 1178 const char *name;
1179 int access;
1a9353d2 1180 const argtype arg_type[5];
31e31b8a
FB		 1181} IOCTLEntry;
1182
1183#define IOC_R 0x0001
1184#define IOC_W 0x0002
1185#define IOC_RW (IOC_R | IOC_W)
1186
1187#define MAX_STRUCT_SIZE 4096
1188
2ab83ea7 1189IOCTLEntry ioctl_entries[] = {
31e31b8a
FB		 1190#define IOCTL(cmd, access, types...) \
1191 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
1192#include "ioctls.h"
1193 { 0, 0, },
1194};
1195
53a5960a 1196/* ??? Implement proper locking for ioctls. */
31e31b8a
FB		 1197static long do_ioctl(long fd, long cmd, long arg)
1198{
1199 const IOCTLEntry *ie;
1200 const argtype *arg_type;
1201 long ret;
1202 uint8_t buf_temp[MAX_STRUCT_SIZE];
53a5960a
PB		 1203 int target_size;
1204 void *argptr;
31e31b8a
FB		 1205
1206 ie = ioctl_entries;
1207 for(;;) {
1208 if (ie->target_cmd == 0) {
1209 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", cmd);
1210 return -ENOSYS;
1211 }
1212 if (ie->target_cmd == cmd)
1213 break;
1214 ie++;
1215 }
1216 arg_type = ie->arg_type;
9de5e440 1217#if defined(DEBUG)
72f03900
FB		 1218 gemu_log("ioctl: cmd=0x%04lx (%s)\n", cmd, ie->name);
1219#endif
31e31b8a
FB		 1220 switch(arg_type[0]) {
1221 case TYPE_NULL:
1222 /* no argument */
1223 ret = get_errno(ioctl(fd, ie->host_cmd));
1224 break;
1225 case TYPE_PTRVOID:
1226 case TYPE_INT:
1227 /* int argment */
1228 ret = get_errno(ioctl(fd, ie->host_cmd, arg));
1229 break;
1230 case TYPE_PTR:
1231 arg_type++;
53a5960a 1232 target_size = thunk_type_size(arg_type, 0);
31e31b8a
FB		 1233 switch(ie->access) {
1234 case IOC_R:
1235 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1236 if (!is_error(ret)) {
53a5960a
PB		 1237 argptr = lock_user(arg, target_size, 0);
1238 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
1239 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 1240 }
1241 break;
1242 case IOC_W:
53a5960a
PB		 1243 argptr = lock_user(arg, target_size, 1);
1244 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
1245 unlock_user(argptr, arg, 0);
31e31b8a
FB		 1246 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1247 break;
1248 default:
1249 case IOC_RW:
53a5960a
PB		 1250 argptr = lock_user(arg, target_size, 1);
1251 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
1252 unlock_user(argptr, arg, 0);
31e31b8a
FB		 1253 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1254 if (!is_error(ret)) {
53a5960a
PB		 1255 argptr = lock_user(arg, target_size, 0);
1256 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
1257 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 1258 }
1259 break;
1260 }
1261 break;
1262 default:
1263 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", cmd, arg_type[0]);
1264 ret = -ENOSYS;
1265 break;
1266 }
1267 return ret;
1268}
1269
1270bitmask_transtbl iflag_tbl[] = {
1271 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
1272 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
1273 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
1274 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
1275 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
1276 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
1277 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
1278 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
1279 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
1280 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
1281 { TARGET_IXON, TARGET_IXON, IXON, IXON },
1282 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
1283 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
1284 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
1285 { 0, 0, 0, 0 }
1286};
1287
1288bitmask_transtbl oflag_tbl[] = {
1289 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
1290 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
1291 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
1292 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
1293 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
1294 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
1295 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
1296 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
1297 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
1298 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
1299 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
1300 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
1301 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
1302 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
1303 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
1304 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
1305 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
1306 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
1307 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
1308 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
1309 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
1310 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
1311 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
1312 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
1313 { 0, 0, 0, 0 }
1314};
1315
1316bitmask_transtbl cflag_tbl[] = {
1317 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
1318 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
1319 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
1320 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
1321 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
1322 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
1323 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
1324 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
1325 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
1326 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
1327 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
1328 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
1329 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
1330 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
1331 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
1332 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
1333 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
1334 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
1335 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
1336 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
1337 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
1338 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
1339 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
1340 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
1341 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
1342 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
1343 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
1344 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
1345 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
1346 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
1347 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
1348 { 0, 0, 0, 0 }
1349};
1350
1351bitmask_transtbl lflag_tbl[] = {
1352 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
1353 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
1354 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
1355 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
1356 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
1357 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
1358 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
1359 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
1360 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
1361 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
1362 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
1363 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
1364 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
1365 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
1366 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
1367 { 0, 0, 0, 0 }
1368};
1369
1370static void target_to_host_termios (void *dst, const void *src)
1371{
1372 struct host_termios *host = dst;
1373 const struct target_termios *target = src;
1374
1375 host->c_iflag =
1376 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
1377 host->c_oflag =
1378 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
1379 host->c_cflag =
1380 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
1381 host->c_lflag =
1382 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
1383 host->c_line = target->c_line;
1384
1385 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
1386 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
1387 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
1388 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
1389 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
1390 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
1391 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
1392 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
1393 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
1394 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
1395 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
1396 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
1397 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
1398 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
1399 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
1400 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
1401 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
1402}
1403
1404static void host_to_target_termios (void *dst, const void *src)
1405{
1406 struct target_termios *target = dst;
1407 const struct host_termios *host = src;
1408
1409 target->c_iflag =
1410 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
1411 target->c_oflag =
1412 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
1413 target->c_cflag =
1414 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
1415 target->c_lflag =
1416 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
1417 target->c_line = host->c_line;
1418
1419 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
1420 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
1421 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
1422 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
1423 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
1424 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
1425 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
1426 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
1427 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
1428 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
1429 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
1430 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
1431 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
1432 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
1433 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
1434 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
1435 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
1436}
1437
1438StructEntry struct_termios_def = {
1439 .convert = { host_to_target_termios, target_to_host_termios },
1440 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
1441 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
1442};
1443
5286db75
FB		 1444static bitmask_transtbl mmap_flags_tbl[] = {
1445 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
1446 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
1447 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
1448 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
1449 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
1450 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
1451 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
1452 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
1453 { 0, 0, 0, 0 }
1454};
1455
ffa65c3b
FB		 1456static bitmask_transtbl fcntl_flags_tbl[] = {
1457 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
1458 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
1459 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
1460 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
1461 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
1462 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
1463 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
1464 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
1465 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
1466 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
1467 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
1468 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
1469 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
121061dc 1470#if defined(O_DIRECT)
ffa65c3b 1471 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
121061dc 1472#endif
ffa65c3b
FB		 1473 { 0, 0, 0, 0 }
1474};
1475
2ab83ea7 1476#if defined(TARGET_I386)
6dbad63e
FB		 1477
1478/* NOTE: there is really one LDT for all the threads */
1479uint8_t *ldt_table;
1480
53a5960a 1481static int read_ldt(target_ulong ptr, unsigned long bytecount)
6dbad63e
FB		 1482{
1483 int size;
53a5960a 1484 void *p;
6dbad63e
FB		 1485
1486 if (!ldt_table)
1487 return 0;
1488 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
1489 if (size > bytecount)
1490 size = bytecount;
53a5960a
PB		 1491 p = lock_user(ptr, size, 0);
1492 /* ??? Shoudl this by byteswapped? */
1493 memcpy(p, ldt_table, size);
1494 unlock_user(p, ptr, size);
6dbad63e
FB		 1495 return size;
1496}
1497
1498/* XXX: add locking support */
1499static int write_ldt(CPUX86State *env,
53a5960a 1500 target_ulong ptr, unsigned long bytecount, int oldmode)
6dbad63e
FB		 1501{
1502 struct target_modify_ldt_ldt_s ldt_info;
53a5960a 1503 struct target_modify_ldt_ldt_s *target_ldt_info;
6dbad63e
FB		 1504 int seg_32bit, contents, read_exec_only, limit_in_pages;
1505 int seg_not_present, useable;
1506 uint32_t *lp, entry_1, entry_2;
1507
1508 if (bytecount != sizeof(ldt_info))
1509 return -EINVAL;
53a5960a
PB		 1510 lock_user_struct(target_ldt_info, ptr, 1);
1511 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
1512 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
1513 ldt_info.limit = tswap32(target_ldt_info->limit);
1514 ldt_info.flags = tswap32(target_ldt_info->flags);
1515 unlock_user_struct(target_ldt_info, ptr, 0);
6dbad63e
FB		 1516
1517 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
1518 return -EINVAL;
1519 seg_32bit = ldt_info.flags & 1;
1520 contents = (ldt_info.flags >> 1) & 3;
1521 read_exec_only = (ldt_info.flags >> 3) & 1;
1522 limit_in_pages = (ldt_info.flags >> 4) & 1;
1523 seg_not_present = (ldt_info.flags >> 5) & 1;
1524 useable = (ldt_info.flags >> 6) & 1;
1525
1526 if (contents == 3) {
1527 if (oldmode)
1528 return -EINVAL;
1529 if (seg_not_present == 0)
1530 return -EINVAL;
1531 }
1532 /* allocate the LDT */
1533 if (!ldt_table) {
1534 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
1535 if (!ldt_table)
1536 return -ENOMEM;
1537 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
53a5960a 1538 env->ldt.base = h2g(ldt_table);
6dbad63e
FB		 1539 env->ldt.limit = 0xffff;
1540 }
1541
1542 /* NOTE: same code as Linux kernel */
1543 /* Allow LDTs to be cleared by the user. */
1544 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
1545 if (oldmode ||
1546 (contents == 0 &&
1547 read_exec_only == 1 &&
1548 seg_32bit == 0 &&
1549 limit_in_pages == 0 &&
1550 seg_not_present == 1 &&
1551 useable == 0 )) {
1552 entry_1 = 0;
1553 entry_2 = 0;
1554 goto install;
1555 }
1556 }
1557
1558 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
1559 (ldt_info.limit & 0x0ffff);
1560 entry_2 = (ldt_info.base_addr & 0xff000000) |
1561 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
1562 (ldt_info.limit & 0xf0000) |
1563 ((read_exec_only ^ 1) << 9) |
1564 (contents << 10) |
1565 ((seg_not_present ^ 1) << 15) |
1566 (seg_32bit << 22) |
1567 (limit_in_pages << 23) |
1568 0x7000;
1569 if (!oldmode)
1570 entry_2 |= (useable << 20);
14ae3ba7 1571
6dbad63e
FB		 1572 /* Install the new entry ... */
1573install:
1574 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
1575 lp[0] = tswap32(entry_1);
1576 lp[1] = tswap32(entry_2);
1577 return 0;
1578}
1579
1580/* specific and weird i386 syscalls */
53a5960a 1581int do_modify_ldt(CPUX86State *env, int func, target_ulong ptr, unsigned long bytecount)
6dbad63e
FB		 1582{
1583 int ret = -ENOSYS;
1584
1585 switch (func) {
1586 case 0:
1587 ret = read_ldt(ptr, bytecount);
1588 break;
1589 case 1:
1590 ret = write_ldt(env, ptr, bytecount, 1);
1591 break;
1592 case 0x11:
1593 ret = write_ldt(env, ptr, bytecount, 0);
1594 break;
1595 }
1596 return ret;
1597}
1b6b029e 1598
2ab83ea7
FB		 1599#endif /* defined(TARGET_I386) */
1600
1b6b029e
FB		 1601/* this stack is the equivalent of the kernel stack associated with a
1602 thread/process */
1603#define NEW_STACK_SIZE 8192
1604
1605static int clone_func(void *arg)
1606{
2ab83ea7 1607 CPUState *env = arg;
1b6b029e
FB		 1608 cpu_loop(env);
1609 /* never exits */
1610 return 0;
1611}
1612
2ab83ea7 1613int do_fork(CPUState *env, unsigned int flags, unsigned long newsp)
1b6b029e
FB		 1614{
1615 int ret;
5cd4393b 1616 TaskState *ts;
1b6b029e 1617 uint8_t *new_stack;
2ab83ea7 1618 CPUState *new_env;
1b6b029e
FB		 1619
1620 if (flags & CLONE_VM) {
5cd4393b
FB		 1621 ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);
1622 memset(ts, 0, sizeof(TaskState));
1623 new_stack = ts->stack;
1624 ts->used = 1;
1625 /* add in task state list */
1626 ts->next = first_task_state;
1627 first_task_state = ts;
1b6b029e 1628 /* we create a new CPU instance. */
2ab83ea7
FB		 1629 new_env = cpu_init();
1630 memcpy(new_env, env, sizeof(CPUState));
1631#if defined(TARGET_I386)
1632 if (!newsp)
1633 newsp = env->regs[R_ESP];
1b6b029e
FB		 1634 new_env->regs[R_ESP] = newsp;
1635 new_env->regs[R_EAX] = 0;
2ab83ea7
FB		 1636#elif defined(TARGET_ARM)
1637 if (!newsp)
1638 newsp = env->regs[13];
1639 new_env->regs[13] = newsp;
1640 new_env->regs[0] = 0;
ebc05488 1641#elif defined(TARGET_SPARC)
48dc41eb
FB		 1642 if (!newsp)
1643 newsp = env->regwptr[22];
1644 new_env->regwptr[22] = newsp;
1645 new_env->regwptr[0] = 0;
1646 /* XXXXX */
67867308 1647 printf ("HELPME: %s:%d\n", __FILE__, __LINE__);
048f6b4d
FB		 1648#elif defined(TARGET_MIPS)
1649 printf ("HELPME: %s:%d\n", __FILE__, __LINE__);
67867308
FB		 1650#elif defined(TARGET_PPC)
1651 if (!newsp)
1652 newsp = env->gpr[1];
1653 new_env->gpr[1] = newsp;
1654 {
1655 int i;
1656 for (i = 7; i < 32; i++)
1657 new_env->gpr[i] = 0;
1658 }
fdf9b3e8
FB		 1659#elif defined(TARGET_SH4)
1660 if (!newsp)
1661 newsp = env->gregs[15];
1662 new_env->gregs[15] = newsp;
1663 /* XXXXX */
2ab83ea7
FB		 1664#else
1665#error unsupported target CPU
1666#endif
5cd4393b 1667 new_env->opaque = ts;
27725c1d 1668#ifdef __ia64__
fd4a43e4 1669 ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
27725c1d
FB		 1670#else
1671 ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
1672#endif
1b6b029e
FB		 1673 } else {
1674 /* if no CLONE_VM, we consider it is a fork */
1675 if ((flags & ~CSIGNAL) != 0)
1676 return -EINVAL;
1677 ret = fork();
1678 }
1679 return ret;
1680}
1681
53a5960a 1682static long do_fcntl(int fd, int cmd, target_ulong arg)
7775e9ec
FB		 1683{
1684 struct flock fl;
53a5960a 1685 struct target_flock *target_fl;
7775e9ec 1686 long ret;
53a5960a 1687
7775e9ec
FB		 1688 switch(cmd) {
1689 case TARGET_F_GETLK:
1690 ret = fcntl(fd, cmd, &fl);
1691 if (ret == 0) {
53a5960a 1692 lock_user_struct(target_fl, arg, 0);
7775e9ec
FB		 1693 target_fl->l_type = tswap16(fl.l_type);
1694 target_fl->l_whence = tswap16(fl.l_whence);
1695 target_fl->l_start = tswapl(fl.l_start);
1696 target_fl->l_len = tswapl(fl.l_len);
1697 target_fl->l_pid = tswapl(fl.l_pid);
53a5960a 1698 unlock_user_struct(target_fl, arg, 1);
7775e9ec
FB		 1699 }
1700 break;
1701
1702 case TARGET_F_SETLK:
1703 case TARGET_F_SETLKW:
53a5960a 1704 lock_user_struct(target_fl, arg, 1);
7775e9ec
FB		 1705 fl.l_type = tswap16(target_fl->l_type);
1706 fl.l_whence = tswap16(target_fl->l_whence);
1707 fl.l_start = tswapl(target_fl->l_start);
1708 fl.l_len = tswapl(target_fl->l_len);
1709 fl.l_pid = tswapl(target_fl->l_pid);
53a5960a 1710 unlock_user_struct(target_fl, arg, 0);
7775e9ec
FB		 1711 ret = fcntl(fd, cmd, &fl);
1712 break;
1713
1714 case TARGET_F_GETLK64:
1715 case TARGET_F_SETLK64:
1716 case TARGET_F_SETLKW64:
1717 ret = -1;
1718 errno = EINVAL;
1719 break;
1720
ffa65c3b
FB		 1721 case F_GETFL:
1722 ret = fcntl(fd, cmd, arg);
1723 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
1724 break;
1725
1726 case F_SETFL:
1727 ret = fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl));
1728 break;
1729
7775e9ec
FB		 1730 default:
1731 ret = fcntl(fd, cmd, arg);
1732 break;
1733 }
1734 return ret;
1735}
1736
67867308 1737#ifdef USE_UID16
7775e9ec 1738
67867308
FB		 1739static inline int high2lowuid(int uid)
1740{
1741 if (uid > 65535)
1742 return 65534;
1743 else
1744 return uid;
1745}
1746
1747static inline int high2lowgid(int gid)
1748{
1749 if (gid > 65535)
1750 return 65534;
1751 else
1752 return gid;
1753}
1754
1755static inline int low2highuid(int uid)
1756{
1757 if ((int16_t)uid == -1)
1758 return -1;
1759 else
1760 return uid;
1761}
1762
1763static inline int low2highgid(int gid)
1764{
1765 if ((int16_t)gid == -1)
1766 return -1;
1767 else
1768 return gid;
1769}
1770
1771#endif /* USE_UID16 */
1b6b029e 1772
31e31b8a
FB		 1773void syscall_init(void)
1774{
2ab83ea7
FB		 1775 IOCTLEntry *ie;
1776 const argtype *arg_type;
1777 int size;
1778
31e31b8a
FB		 1779#define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
1780#define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
1781#include "syscall_types.h"
1782#undef STRUCT
1783#undef STRUCT_SPECIAL
2ab83ea7
FB		 1784
1785 /* we patch the ioctl size if necessary. We rely on the fact that
1786 no ioctl has all the bits at '1' in the size field */
1787 ie = ioctl_entries;
1788 while (ie->target_cmd != 0) {
1789 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
1790 TARGET_IOC_SIZEMASK) {
1791 arg_type = ie->arg_type;
1792 if (arg_type[0] != TYPE_PTR) {
1793 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
1794 ie->target_cmd);
1795 exit(1);
1796 }
1797 arg_type++;
1798 size = thunk_type_size(arg_type, 0);
1799 ie->target_cmd = (ie->target_cmd &
1800 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
1801 (size << TARGET_IOC_SIZESHIFT);
1802 }
1803 /* automatic consistency check if same arch */
1804#if defined(__i386__) && defined(TARGET_I386)
1805 if (ie->target_cmd != ie->host_cmd) {
1806 fprintf(stderr, "ERROR: ioctl: target=0x%x host=0x%x\n",
1807 ie->target_cmd, ie->host_cmd);
1808 }
1809#endif
1810 ie++;
1811 }
31e31b8a 1812}
c573ff67 1813
ce4defa0
PB		 1814static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
1815{
1816#ifdef TARGET_WORDS_BIG_ENDIAN
1817 return ((uint64_t)word0 << 32) | word1;
1818#else
1819 return ((uint64_t)word1 << 32) | word0;
1820#endif
1821}
1822
1823#ifdef TARGET_NR_truncate64
1824static inline long target_truncate64(void *cpu_env, const char *arg1,
1825 long arg2, long arg3, long arg4)
1826{
1827#ifdef TARGET_ARM
1828 if (((CPUARMState *)cpu_env)->eabi)
1829 {
1830 arg2 = arg3;
1831 arg3 = arg4;
1832 }
1833#endif
1834 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
1835}
1836#endif
1837
1838#ifdef TARGET_NR_ftruncate64
1839static inline long target_ftruncate64(void *cpu_env, long arg1, long arg2,
1840 long arg3, long arg4)
1841{
1842#ifdef TARGET_ARM
1843 if (((CPUARMState *)cpu_env)->eabi)
1844 {
1845 arg2 = arg3;
1846 arg3 = arg4;
1847 }
1848#endif
1849 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
1850}
1851#endif
1852
53a5960a
PB		 1853static inline void target_to_host_timespec(struct timespec *host_ts,
1854 target_ulong target_addr)
1855{
1856 struct target_timespec *target_ts;
1857
1858 lock_user_struct(target_ts, target_addr, 1);
1859 host_ts->tv_sec = tswapl(target_ts->tv_sec);
1860 host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
1861 unlock_user_struct(target_ts, target_addr, 0);
1862}
1863
1864static inline void host_to_target_timespec(target_ulong target_addr,
1865 struct timespec *host_ts)
1866{
1867 struct target_timespec *target_ts;
1868
1869 lock_user_struct(target_ts, target_addr, 0);
1870 target_ts->tv_sec = tswapl(host_ts->tv_sec);
1871 target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
1872 unlock_user_struct(target_ts, target_addr, 1);
1873}
1874
6dbad63e 1875long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
31e31b8a
FB		 1876 long arg4, long arg5, long arg6)
1877{
1878 long ret;
1879 struct stat st;
56c8f68f 1880 struct statfs stfs;
53a5960a 1881 void *p;
31e31b8a 1882
72f03900 1883#ifdef DEBUG
c573ff67 1884 gemu_log("syscall %d", num);
72f03900 1885#endif
31e31b8a
FB		 1886 switch(num) {
1887 case TARGET_NR_exit:
7d13299d
FB		 1888#ifdef HAVE_GPROF
1889 _mcleanup();
1890#endif
e9009676 1891 gdb_exit(cpu_env, arg1);
1b6b029e 1892 /* XXX: should free thread stack and CPU env */
31e31b8a
FB		 1893 _exit(arg1);
1894 ret = 0; /* avoid warning */
1895 break;
1896 case TARGET_NR_read:
53a5960a
PB		 1897 page_unprotect_range(arg2, arg3);
1898 p = lock_user(arg2, arg3, 0);
1899 ret = get_errno(read(arg1, p, arg3));
1900 unlock_user(p, arg2, ret);
31e31b8a
FB		 1901 break;
1902 case TARGET_NR_write:
53a5960a
PB		 1903 p = lock_user(arg2, arg3, 1);
1904 ret = get_errno(write(arg1, p, arg3));
1905 unlock_user(p, arg2, 0);
31e31b8a
FB		 1906 break;
1907 case TARGET_NR_open:
53a5960a
PB		 1908 p = lock_user_string(arg1);
1909 ret = get_errno(open(path(p),
ffa65c3b
FB		 1910 target_to_host_bitmask(arg2, fcntl_flags_tbl),
1911 arg3));
53a5960a 1912 unlock_user(p, arg1, 0);
31e31b8a
FB		 1913 break;
1914 case TARGET_NR_close:
1915 ret = get_errno(close(arg1));
1916 break;
1917 case TARGET_NR_brk:
53a5960a 1918 ret = do_brk(arg1);
31e31b8a
FB		 1919 break;
1920 case TARGET_NR_fork:
1b6b029e 1921 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
31e31b8a
FB		 1922 break;
1923 case TARGET_NR_waitpid:
1924 {
53a5960a
PB		 1925 int status;
1926 ret = get_errno(waitpid(arg1, &status, arg3));
1927 if (!is_error(ret) && arg2)
1928 tput32(arg2, status);
31e31b8a
FB		 1929 }
1930 break;
1931 case TARGET_NR_creat:
53a5960a
PB		 1932 p = lock_user_string(arg1);
1933 ret = get_errno(creat(p, arg2));
1934 unlock_user(p, arg1, 0);
31e31b8a
FB		 1935 break;
1936 case TARGET_NR_link:
53a5960a
PB		 1937 {
1938 void * p2;
1939 p = lock_user_string(arg1);
1940 p2 = lock_user_string(arg2);
1941 ret = get_errno(link(p, p2));
1942 unlock_user(p2, arg2, 0);
1943 unlock_user(p, arg1, 0);
1944 }
31e31b8a
FB		 1945 break;
1946 case TARGET_NR_unlink:
53a5960a
PB		 1947 p = lock_user_string(arg1);
1948 ret = get_errno(unlink(p));
1949 unlock_user(p, arg1, 0);
31e31b8a
FB		 1950 break;
1951 case TARGET_NR_execve:
7854b056
FB		 1952 {
1953 char **argp, **envp;
f7341ff4 1954 int argc, envc;
53a5960a
PB		 1955 target_ulong gp;
1956 target_ulong guest_argp;
1957 target_ulong guest_envp;
1958 target_ulong addr;
7854b056
FB		 1959 char **q;
1960
f7341ff4 1961 argc = 0;
53a5960a
PB		 1962 guest_argp = arg2;
1963 for (gp = guest_argp; tgetl(gp); gp++)
7854b056 1964 argc++;
f7341ff4 1965 envc = 0;
53a5960a
PB		 1966 guest_envp = arg3;
1967 for (gp = guest_envp; tgetl(gp); gp++)
7854b056
FB		 1968 envc++;
1969
f7341ff4
FB		 1970 argp = alloca((argc + 1) * sizeof(void *));
1971 envp = alloca((envc + 1) * sizeof(void *));
7854b056 1972
53a5960a
PB		 1973 for (gp = guest_argp, q = argp; ;
1974 gp += sizeof(target_ulong), q++) {
1975 addr = tgetl(gp);
1976 if (!addr)
1977 break;
1978 *q = lock_user_string(addr);
1979 }
f7341ff4
FB		 1980 *q = NULL;
1981
53a5960a
PB		 1982 for (gp = guest_envp, q = envp; ;
1983 gp += sizeof(target_ulong), q++) {
1984 addr = tgetl(gp);
1985 if (!addr)
1986 break;
1987 *q = lock_user_string(addr);
1988 }
f7341ff4 1989 *q = NULL;
7854b056 1990
53a5960a
PB		 1991 p = lock_user_string(arg1);
1992 ret = get_errno(execve(p, argp, envp));
1993 unlock_user(p, arg1, 0);
1994
1995 for (gp = guest_argp, q = argp; *q;
1996 gp += sizeof(target_ulong), q++) {
1997 addr = tgetl(gp);
1998 unlock_user(*q, addr, 0);
1999 }
2000 for (gp = guest_envp, q = envp; *q;
2001 gp += sizeof(target_ulong), q++) {
2002 addr = tgetl(gp);
2003 unlock_user(*q, addr, 0);
2004 }
7854b056 2005 }
31e31b8a
FB		 2006 break;
2007 case TARGET_NR_chdir:
53a5960a
PB		 2008 p = lock_user_string(arg1);
2009 ret = get_errno(chdir(p));
2010 unlock_user(p, arg1, 0);
31e31b8a 2011 break;
a315a145 2012#ifdef TARGET_NR_time
31e31b8a
FB		 2013 case TARGET_NR_time:
2014 {
53a5960a
PB		 2015 time_t host_time;
2016 ret = get_errno(time(&host_time));
2017 if (!is_error(ret) && arg1)
2018 tputl(arg1, host_time);
31e31b8a
FB		 2019 }
2020 break;
a315a145 2021#endif
31e31b8a 2022 case TARGET_NR_mknod:
53a5960a
PB		 2023 p = lock_user_string(arg1);
2024 ret = get_errno(mknod(p, arg2, arg3));
2025 unlock_user(p, arg1, 0);
31e31b8a
FB		 2026 break;
2027 case TARGET_NR_chmod:
53a5960a
PB		 2028 p = lock_user_string(arg1);
2029 ret = get_errno(chmod(p, arg2));
2030 unlock_user(p, arg1, 0);
31e31b8a 2031 break;
ebc05488 2032#ifdef TARGET_NR_break
31e31b8a
FB		 2033 case TARGET_NR_break:
2034 goto unimplemented;
ebc05488
FB		 2035#endif
2036#ifdef TARGET_NR_oldstat
31e31b8a
FB		 2037 case TARGET_NR_oldstat:
2038 goto unimplemented;
ebc05488 2039#endif
31e31b8a
FB		 2040 case TARGET_NR_lseek:
2041 ret = get_errno(lseek(arg1, arg2, arg3));
2042 break;
2043 case TARGET_NR_getpid:
2044 ret = get_errno(getpid());
2045 break;
2046 case TARGET_NR_mount:
2047 /* need to look at the data field */
2048 goto unimplemented;
2049 case TARGET_NR_umount:
53a5960a
PB		 2050 p = lock_user_string(arg1);
2051 ret = get_errno(umount(p));
2052 unlock_user(p, arg1, 0);
31e31b8a 2053 break;
31e31b8a
FB		 2054 case TARGET_NR_stime:
2055 {
53a5960a
PB		 2056 time_t host_time;
2057 host_time = tgetl(arg1);
2058 ret = get_errno(stime(&host_time));
31e31b8a
FB		 2059 }
2060 break;
2061 case TARGET_NR_ptrace:
2062 goto unimplemented;
2063 case TARGET_NR_alarm:
2064 ret = alarm(arg1);
2065 break;
ebc05488 2066#ifdef TARGET_NR_oldfstat
31e31b8a
FB		 2067 case TARGET_NR_oldfstat:
2068 goto unimplemented;
ebc05488 2069#endif
31e31b8a
FB		 2070 case TARGET_NR_pause:
2071 ret = get_errno(pause());
2072 break;
2073 case TARGET_NR_utime:
ebc05488 2074 {
53a5960a
PB		 2075 struct utimbuf tbuf, *host_tbuf;
2076 struct target_utimbuf *target_tbuf;
2077 if (arg2) {
2078 lock_user_struct(target_tbuf, arg2, 1);
2079 tbuf.actime = tswapl(target_tbuf->actime);
2080 tbuf.modtime = tswapl(target_tbuf->modtime);
2081 unlock_user_struct(target_tbuf, arg2, 0);
2082 host_tbuf = &tbuf;
f72e8ff4 2083 } else {
53a5960a 2084 host_tbuf = NULL;
f72e8ff4 2085 }
53a5960a
PB		 2086 p = lock_user_string(arg1);
2087 ret = get_errno(utime(p, host_tbuf));
2088 unlock_user(p, arg1, 0);
ebc05488
FB		 2089 }
2090 break;
978a66ff
FB		 2091 case TARGET_NR_utimes:
2092 {
978a66ff 2093 struct timeval *tvp, tv[2];
53a5960a
PB		 2094 if (arg2) {
2095 target_to_host_timeval(&tv[0], arg2);
2096 target_to_host_timeval(&tv[1],
2097 arg2 + sizeof (struct target_timeval));
978a66ff
FB		 2098 tvp = tv;
2099 } else {
2100 tvp = NULL;
2101 }
53a5960a
PB		 2102 p = lock_user_string(arg1);
2103 ret = get_errno(utimes(p, tvp));
2104 unlock_user(p, arg1, 0);
978a66ff
FB		 2105 }
2106 break;
ebc05488 2107#ifdef TARGET_NR_stty
31e31b8a
FB		 2108 case TARGET_NR_stty:
2109 goto unimplemented;
ebc05488
FB		 2110#endif
2111#ifdef TARGET_NR_gtty
31e31b8a
FB		 2112 case TARGET_NR_gtty:
2113 goto unimplemented;
ebc05488 2114#endif
31e31b8a 2115 case TARGET_NR_access:
53a5960a
PB		 2116 p = lock_user_string(arg1);
2117 ret = get_errno(access(p, arg2));
2118 unlock_user(p, arg1, 0);
31e31b8a
FB		 2119 break;
2120 case TARGET_NR_nice:
2121 ret = get_errno(nice(arg1));
2122 break;
ebc05488 2123#ifdef TARGET_NR_ftime
31e31b8a
FB		 2124 case TARGET_NR_ftime:
2125 goto unimplemented;
ebc05488 2126#endif
31e31b8a 2127 case TARGET_NR_sync:
04369ff2
FB		 2128 sync();
2129 ret = 0;
31e31b8a
FB		 2130 break;
2131 case TARGET_NR_kill:
2132 ret = get_errno(kill(arg1, arg2));
2133 break;
2134 case TARGET_NR_rename:
53a5960a
PB		 2135 {
2136 void *p2;
2137 p = lock_user_string(arg1);
2138 p2 = lock_user_string(arg2);
2139 ret = get_errno(rename(p, p2));
2140 unlock_user(p2, arg2, 0);
2141 unlock_user(p, arg1, 0);
2142 }
31e31b8a
FB		 2143 break;
2144 case TARGET_NR_mkdir:
53a5960a
PB		 2145 p = lock_user_string(arg1);
2146 ret = get_errno(mkdir(p, arg2));
2147 unlock_user(p, arg1, 0);
31e31b8a
FB		 2148 break;
2149 case TARGET_NR_rmdir:
53a5960a
PB		 2150 p = lock_user_string(arg1);
2151 ret = get_errno(rmdir(p));
2152 unlock_user(p, arg1, 0);
31e31b8a
FB		 2153 break;
2154 case TARGET_NR_dup:
2155 ret = get_errno(dup(arg1));
2156 break;
2157 case TARGET_NR_pipe:
2158 {
53a5960a
PB		 2159 int host_pipe[2];
2160 ret = get_errno(pipe(host_pipe));
31e31b8a 2161 if (!is_error(ret)) {
53a5960a
PB		 2162 tput32(arg1, host_pipe[0]);
2163 tput32(arg1 + 4, host_pipe[1]);
31e31b8a
FB		 2164 }
2165 }
2166 break;
2167 case TARGET_NR_times:
32f36bce 2168 {
53a5960a 2169 struct target_tms *tmsp;
32f36bce
FB		 2170 struct tms tms;
2171 ret = get_errno(times(&tms));
53a5960a
PB		 2172 if (arg1) {
2173 tmsp = lock_user(arg1, sizeof(struct target_tms), 0);
c596ed17
FB		 2174 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
2175 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
2176 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
2177 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
32f36bce 2178 }
c596ed17
FB		 2179 if (!is_error(ret))
2180 ret = host_to_target_clock_t(ret);
32f36bce
FB		 2181 }
2182 break;
ebc05488 2183#ifdef TARGET_NR_prof
31e31b8a
FB		 2184 case TARGET_NR_prof:
2185 goto unimplemented;
ebc05488 2186#endif
31e31b8a
FB		 2187 case TARGET_NR_signal:
2188 goto unimplemented;
67867308 2189
31e31b8a 2190 case TARGET_NR_acct:
24836689
PB		 2191 p = lock_user_string(arg1);
2192 ret = get_errno(acct(path(p)));
2193 unlock_user(p, arg1, 0);
2194 break;
31e31b8a 2195 case TARGET_NR_umount2:
53a5960a
PB		 2196 p = lock_user_string(arg1);
2197 ret = get_errno(umount2(p, arg2));
2198 unlock_user(p, arg1, 0);
31e31b8a 2199 break;
ebc05488 2200#ifdef TARGET_NR_lock
31e31b8a
FB		 2201 case TARGET_NR_lock:
2202 goto unimplemented;
ebc05488 2203#endif
31e31b8a
FB		 2204 case TARGET_NR_ioctl:
2205 ret = do_ioctl(arg1, arg2, arg3);
2206 break;
2207 case TARGET_NR_fcntl:
7775e9ec 2208 ret = get_errno(do_fcntl(arg1, arg2, arg3));
31e31b8a 2209 break;
ebc05488 2210#ifdef TARGET_NR_mpx
31e31b8a
FB		 2211 case TARGET_NR_mpx:
2212 goto unimplemented;
ebc05488 2213#endif
31e31b8a
FB		 2214 case TARGET_NR_setpgid:
2215 ret = get_errno(setpgid(arg1, arg2));
2216 break;
ebc05488 2217#ifdef TARGET_NR_ulimit
31e31b8a
FB		 2218 case TARGET_NR_ulimit:
2219 goto unimplemented;
ebc05488
FB		 2220#endif
2221#ifdef TARGET_NR_oldolduname
31e31b8a
FB		 2222 case TARGET_NR_oldolduname:
2223 goto unimplemented;
ebc05488 2224#endif
31e31b8a
FB		 2225 case TARGET_NR_umask:
2226 ret = get_errno(umask(arg1));
2227 break;
2228 case TARGET_NR_chroot:
53a5960a
PB		 2229 p = lock_user_string(arg1);
2230 ret = get_errno(chroot(p));
2231 unlock_user(p, arg1, 0);
31e31b8a
FB		 2232 break;
2233 case TARGET_NR_ustat:
2234 goto unimplemented;
2235 case TARGET_NR_dup2:
2236 ret = get_errno(dup2(arg1, arg2));
2237 break;
2238 case TARGET_NR_getppid:
2239 ret = get_errno(getppid());
2240 break;
2241 case TARGET_NR_getpgrp:
2242 ret = get_errno(getpgrp());
2243 break;
2244 case TARGET_NR_setsid:
2245 ret = get_errno(setsid());
2246 break;
2247 case TARGET_NR_sigaction:
31e31b8a 2248 {
53a5960a 2249 struct target_old_sigaction *old_act;
66fb9763 2250 struct target_sigaction act, oact, *pact;
53a5960a
PB		 2251 if (arg2) {
2252 lock_user_struct(old_act, arg2, 1);
66fb9763
FB		 2253 act._sa_handler = old_act->_sa_handler;
2254 target_siginitset(&act.sa_mask, old_act->sa_mask);
2255 act.sa_flags = old_act->sa_flags;
2256 act.sa_restorer = old_act->sa_restorer;
53a5960a 2257 unlock_user_struct(old_act, arg2, 0);
66fb9763
FB		 2258 pact = &act;
2259 } else {
2260 pact = NULL;
2261 }
2262 ret = get_errno(do_sigaction(arg1, pact, &oact));
53a5960a
PB		 2263 if (!is_error(ret) && arg3) {
2264 lock_user_struct(old_act, arg3, 0);
2265 old_act->_sa_handler = oact._sa_handler;
2266 old_act->sa_mask = oact.sa_mask.sig[0];
2267 old_act->sa_flags = oact.sa_flags;
2268 old_act->sa_restorer = oact.sa_restorer;
2269 unlock_user_struct(old_act, arg3, 1);
66fb9763 2270 }
31e31b8a
FB		 2271 }
2272 break;
66fb9763 2273 case TARGET_NR_rt_sigaction:
53a5960a
PB		 2274 {
2275 struct target_sigaction *act;
2276 struct target_sigaction *oact;
2277
2278 if (arg2)
2279 lock_user_struct(act, arg2, 1);
2280 else
2281 act = NULL;
2282 if (arg3)
2283 lock_user_struct(oact, arg3, 0);
2284 else
2285 oact = NULL;
2286 ret = get_errno(do_sigaction(arg1, act, oact));
2287 if (arg2)
2288 unlock_user_struct(act, arg2, 0);
2289 if (arg3)
2290 unlock_user_struct(oact, arg3, 1);
2291 }
66fb9763 2292 break;
31e31b8a 2293 case TARGET_NR_sgetmask:
66fb9763
FB		 2294 {
2295 sigset_t cur_set;
2296 target_ulong target_set;
2297 sigprocmask(0, NULL, &cur_set);
2298 host_to_target_old_sigset(&target_set, &cur_set);
2299 ret = target_set;
2300 }
2301 break;
31e31b8a 2302 case TARGET_NR_ssetmask:
66fb9763
FB		 2303 {
2304 sigset_t set, oset, cur_set;
2305 target_ulong target_set = arg1;
2306 sigprocmask(0, NULL, &cur_set);
2307 target_to_host_old_sigset(&set, &target_set);
2308 sigorset(&set, &set, &cur_set);
2309 sigprocmask(SIG_SETMASK, &set, &oset);
2310 host_to_target_old_sigset(&target_set, &oset);
2311 ret = target_set;
2312 }
2313 break;
2314 case TARGET_NR_sigprocmask:
2315 {
2316 int how = arg1;
2317 sigset_t set, oldset, *set_ptr;
66fb9763 2318
53a5960a 2319 if (arg2) {
66fb9763
FB		 2320 switch(how) {
2321 case TARGET_SIG_BLOCK:
2322 how = SIG_BLOCK;
2323 break;
2324 case TARGET_SIG_UNBLOCK:
2325 how = SIG_UNBLOCK;
2326 break;
2327 case TARGET_SIG_SETMASK:
2328 how = SIG_SETMASK;
2329 break;
2330 default:
2331 ret = -EINVAL;
2332 goto fail;
2333 }
53a5960a
PB		 2334 p = lock_user(arg2, sizeof(target_sigset_t), 1);
2335 target_to_host_old_sigset(&set, p);
2336 unlock_user(p, arg2, 0);
66fb9763
FB		 2337 set_ptr = &set;
2338 } else {
2339 how = 0;
2340 set_ptr = NULL;
2341 }
2342 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
53a5960a
PB		 2343 if (!is_error(ret) && arg3) {
2344 p = lock_user(arg3, sizeof(target_sigset_t), 0);
2345 host_to_target_old_sigset(p, &oldset);
2346 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 2347 }
2348 }
2349 break;
2350 case TARGET_NR_rt_sigprocmask:
2351 {
2352 int how = arg1;
2353 sigset_t set, oldset, *set_ptr;
66fb9763 2354
53a5960a 2355 if (arg2) {
66fb9763
FB		 2356 switch(how) {
2357 case TARGET_SIG_BLOCK:
2358 how = SIG_BLOCK;
2359 break;
2360 case TARGET_SIG_UNBLOCK:
2361 how = SIG_UNBLOCK;
2362 break;
2363 case TARGET_SIG_SETMASK:
2364 how = SIG_SETMASK;
2365 break;
2366 default:
2367 ret = -EINVAL;
2368 goto fail;
2369 }
53a5960a
PB		 2370 p = lock_user(arg2, sizeof(target_sigset_t), 1);
2371 target_to_host_sigset(&set, p);
2372 unlock_user(p, arg2, 0);
66fb9763
FB		 2373 set_ptr = &set;
2374 } else {
2375 how = 0;
2376 set_ptr = NULL;
2377 }
2378 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
53a5960a
PB		 2379 if (!is_error(ret) && arg3) {
2380 p = lock_user(arg3, sizeof(target_sigset_t), 0);
2381 host_to_target_sigset(p, &oldset);
2382 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 2383 }
2384 }
2385 break;
2386 case TARGET_NR_sigpending:
2387 {
2388 sigset_t set;
2389 ret = get_errno(sigpending(&set));
2390 if (!is_error(ret)) {
53a5960a
PB		 2391 p = lock_user(arg1, sizeof(target_sigset_t), 0);
2392 host_to_target_old_sigset(p, &set);
2393 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 2394 }
2395 }
2396 break;
2397 case TARGET_NR_rt_sigpending:
2398 {
2399 sigset_t set;
2400 ret = get_errno(sigpending(&set));
2401 if (!is_error(ret)) {
53a5960a
PB		 2402 p = lock_user(arg1, sizeof(target_sigset_t), 0);
2403 host_to_target_sigset(p, &set);
2404 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 2405 }
2406 }
2407 break;
2408 case TARGET_NR_sigsuspend:
2409 {
2410 sigset_t set;
53a5960a
PB		 2411 p = lock_user(arg1, sizeof(target_sigset_t), 1);
2412 target_to_host_old_sigset(&set, p);
2413 unlock_user(p, arg1, 0);
66fb9763
FB		 2414 ret = get_errno(sigsuspend(&set));
2415 }
2416 break;
2417 case TARGET_NR_rt_sigsuspend:
2418 {
2419 sigset_t set;
53a5960a
PB		 2420 p = lock_user(arg1, sizeof(target_sigset_t), 1);
2421 target_to_host_sigset(&set, p);
2422 unlock_user(p, arg1, 0);
66fb9763
FB		 2423 ret = get_errno(sigsuspend(&set));
2424 }
2425 break;
2426 case TARGET_NR_rt_sigtimedwait:
2427 {
66fb9763
FB		 2428 sigset_t set;
2429 struct timespec uts, *puts;
2430 siginfo_t uinfo;
2431
53a5960a
PB		 2432 p = lock_user(arg1, sizeof(target_sigset_t), 1);
2433 target_to_host_sigset(&set, p);
2434 unlock_user(p, arg1, 0);
2435 if (arg3) {
66fb9763 2436 puts = &uts;
53a5960a 2437 target_to_host_timespec(puts, arg3);
66fb9763
FB		 2438 } else {
2439 puts = NULL;
2440 }
2441 ret = get_errno(sigtimedwait(&set, &uinfo, puts));
53a5960a
PB		 2442 if (!is_error(ret) && arg2) {
2443 p = lock_user(arg2, sizeof(target_sigset_t), 0);
2444 host_to_target_siginfo(p, &uinfo);
2445 unlock_user(p, arg2, sizeof(target_sigset_t));
66fb9763
FB		 2446 }
2447 }
2448 break;
2449 case TARGET_NR_rt_sigqueueinfo:
2450 {
2451 siginfo_t uinfo;
53a5960a
PB		 2452 p = lock_user(arg3, sizeof(target_sigset_t), 1);
2453 target_to_host_siginfo(&uinfo, p);
2454 unlock_user(p, arg1, 0);
66fb9763
FB		 2455 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
2456 }
2457 break;
2458 case TARGET_NR_sigreturn:
2459 /* NOTE: ret is eax, so not transcoding must be done */
2460 ret = do_sigreturn(cpu_env);
2461 break;
2462 case TARGET_NR_rt_sigreturn:
2463 /* NOTE: ret is eax, so not transcoding must be done */
2464 ret = do_rt_sigreturn(cpu_env);
2465 break;
31e31b8a 2466 case TARGET_NR_sethostname:
53a5960a
PB		 2467 p = lock_user_string(arg1);
2468 ret = get_errno(sethostname(p, arg2));
2469 unlock_user(p, arg1, 0);
31e31b8a
FB		 2470 break;
2471 case TARGET_NR_setrlimit:
9de5e440
FB		 2472 {
2473 /* XXX: convert resource ? */
2474 int resource = arg1;
53a5960a 2475 struct target_rlimit *target_rlim;
9de5e440 2476 struct rlimit rlim;
53a5960a 2477 lock_user_struct(target_rlim, arg2, 1);
9de5e440
FB		 2478 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
2479 rlim.rlim_max = tswapl(target_rlim->rlim_max);
53a5960a 2480 unlock_user_struct(target_rlim, arg2, 0);
9de5e440
FB		 2481 ret = get_errno(setrlimit(resource, &rlim));
2482 }
2483 break;
31e31b8a 2484 case TARGET_NR_getrlimit:
9de5e440
FB		 2485 {
2486 /* XXX: convert resource ? */
2487 int resource = arg1;
53a5960a 2488 struct target_rlimit *target_rlim;
9de5e440
FB		 2489 struct rlimit rlim;
2490
2491 ret = get_errno(getrlimit(resource, &rlim));
2492 if (!is_error(ret)) {
53a5960a
PB		 2493 lock_user_struct(target_rlim, arg2, 0);
2494 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
2495 rlim.rlim_max = tswapl(target_rlim->rlim_max);
2496 unlock_user_struct(target_rlim, arg2, 1);
9de5e440
FB		 2497 }
2498 }
2499 break;
31e31b8a 2500 case TARGET_NR_getrusage:
b409186b
FB		 2501 {
2502 struct rusage rusage;
b409186b
FB		 2503 ret = get_errno(getrusage(arg1, &rusage));
2504 if (!is_error(ret)) {
53a5960a 2505 host_to_target_rusage(arg2, &rusage);
b409186b
FB		 2506 }
2507 }
2508 break;
31e31b8a
FB		 2509 case TARGET_NR_gettimeofday:
2510 {
31e31b8a
FB		 2511 struct timeval tv;
2512 ret = get_errno(gettimeofday(&tv, NULL));
2513 if (!is_error(ret)) {
53a5960a 2514 host_to_target_timeval(arg1, &tv);
31e31b8a
FB		 2515 }
2516 }
2517 break;
2518 case TARGET_NR_settimeofday:
2519 {
31e31b8a 2520 struct timeval tv;
53a5960a 2521 target_to_host_timeval(&tv, arg1);
31e31b8a
FB		 2522 ret = get_errno(settimeofday(&tv, NULL));
2523 }
2524 break;
048f6b4d 2525#ifdef TARGET_NR_select
31e31b8a 2526 case TARGET_NR_select:
f2674e31 2527 {
53a5960a
PB		 2528 struct target_sel_arg_struct *sel;
2529 target_ulong inp, outp, exp, tvp;
2530 long nsel;
2531
2532 lock_user_struct(sel, arg1, 1);
2533 nsel = tswapl(sel->n);
2534 inp = tswapl(sel->inp);
2535 outp = tswapl(sel->outp);
2536 exp = tswapl(sel->exp);
2537 tvp = tswapl(sel->tvp);
2538 unlock_user_struct(sel, arg1, 0);
2539 ret = do_select(nsel, inp, outp, exp, tvp);
f2674e31
FB		 2540 }
2541 break;
048f6b4d 2542#endif
31e31b8a 2543 case TARGET_NR_symlink:
53a5960a
PB		 2544 {
2545 void *p2;
2546 p = lock_user_string(arg1);
2547 p2 = lock_user_string(arg2);
2548 ret = get_errno(symlink(p, p2));
2549 unlock_user(p2, arg2, 0);
2550 unlock_user(p, arg1, 0);
2551 }
31e31b8a 2552 break;
ebc05488 2553#ifdef TARGET_NR_oldlstat
31e31b8a
FB		 2554 case TARGET_NR_oldlstat:
2555 goto unimplemented;
ebc05488 2556#endif
31e31b8a 2557 case TARGET_NR_readlink:
53a5960a
PB		 2558 {
2559 void *p2;
2560 p = lock_user_string(arg1);
2561 p2 = lock_user(arg2, arg3, 0);
2562 ret = get_errno(readlink(path(p), p2, arg3));
2563 unlock_user(p2, arg2, ret);
2564 unlock_user(p, arg1, 0);
2565 }
31e31b8a
FB		 2566 break;
2567 case TARGET_NR_uselib:
2568 goto unimplemented;
2569 case TARGET_NR_swapon:
53a5960a
PB		 2570 p = lock_user_string(arg1);
2571 ret = get_errno(swapon(p, arg2));
2572 unlock_user(p, arg1, 0);
31e31b8a
FB		 2573 break;
2574 case TARGET_NR_reboot:
2575 goto unimplemented;
2576 case TARGET_NR_readdir:
2577 goto unimplemented;
31e31b8a 2578 case TARGET_NR_mmap:
6fb883e8 2579#if defined(TARGET_I386) || defined(TARGET_ARM)
31e31b8a 2580 {
53a5960a
PB		 2581 target_ulong *v;
2582 target_ulong v1, v2, v3, v4, v5, v6;
2583 v = lock_user(arg1, 6 * sizeof(target_ulong), 1);
2584 v1 = tswapl(v[0]);
2585 v2 = tswapl(v[1]);
2586 v3 = tswapl(v[2]);
2587 v4 = tswapl(v[3]);
2588 v5 = tswapl(v[4]);
2589 v6 = tswapl(v[5]);
2590 unlock_user(v, arg1, 0);
5286db75
FB		 2591 ret = get_errno(target_mmap(v1, v2, v3,
2592 target_to_host_bitmask(v4, mmap_flags_tbl),
2593 v5, v6));
31e31b8a 2594 }
31e31b8a 2595#else
6fb883e8
FB		 2596 ret = get_errno(target_mmap(arg1, arg2, arg3,
2597 target_to_host_bitmask(arg4, mmap_flags_tbl),
2598 arg5,
2599 arg6));
31e31b8a 2600#endif
6fb883e8 2601 break;
a315a145 2602#ifdef TARGET_NR_mmap2
6fb883e8 2603 case TARGET_NR_mmap2:
c573ff67
FB		 2604#if defined(TARGET_SPARC)
2605#define MMAP_SHIFT 12
2606#else
2607#define MMAP_SHIFT TARGET_PAGE_BITS
2608#endif
5286db75
FB		 2609 ret = get_errno(target_mmap(arg1, arg2, arg3,
2610 target_to_host_bitmask(arg4, mmap_flags_tbl),
2611 arg5,
c573ff67 2612 arg6 << MMAP_SHIFT));
31e31b8a 2613 break;
a315a145 2614#endif
31e31b8a 2615 case TARGET_NR_munmap:
54936004 2616 ret = get_errno(target_munmap(arg1, arg2));
31e31b8a 2617 break;
9de5e440 2618 case TARGET_NR_mprotect:
54936004 2619 ret = get_errno(target_mprotect(arg1, arg2, arg3));
9de5e440
FB		 2620 break;
2621 case TARGET_NR_mremap:
54936004 2622 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
9de5e440 2623 break;
53a5960a 2624 /* ??? msync/mlock/munlock are broken for softmmu. */
9de5e440 2625 case TARGET_NR_msync:
53a5960a 2626 ret = get_errno(msync(g2h(arg1), arg2, arg3));
9de5e440
FB		 2627 break;
2628 case TARGET_NR_mlock:
53a5960a 2629 ret = get_errno(mlock(g2h(arg1), arg2));
9de5e440
FB		 2630 break;
2631 case TARGET_NR_munlock:
53a5960a 2632 ret = get_errno(munlock(g2h(arg1), arg2));
9de5e440
FB		 2633 break;
2634 case TARGET_NR_mlockall:
2635 ret = get_errno(mlockall(arg1));
2636 break;
2637 case TARGET_NR_munlockall:
2638 ret = get_errno(munlockall());
2639 break;
31e31b8a 2640 case TARGET_NR_truncate:
53a5960a
PB		 2641 p = lock_user_string(arg1);
2642 ret = get_errno(truncate(p, arg2));
2643 unlock_user(p, arg1, 0);
31e31b8a
FB		 2644 break;
2645 case TARGET_NR_ftruncate:
2646 ret = get_errno(ftruncate(arg1, arg2));
2647 break;
2648 case TARGET_NR_fchmod:
2649 ret = get_errno(fchmod(arg1, arg2));
2650 break;
31e31b8a
FB		 2651 case TARGET_NR_getpriority:
2652 ret = get_errno(getpriority(arg1, arg2));
2653 break;
2654 case TARGET_NR_setpriority:
2655 ret = get_errno(setpriority(arg1, arg2, arg3));
2656 break;
ebc05488 2657#ifdef TARGET_NR_profil
31e31b8a
FB		 2658 case TARGET_NR_profil:
2659 goto unimplemented;
ebc05488 2660#endif
31e31b8a 2661 case TARGET_NR_statfs:
53a5960a
PB		 2662 p = lock_user_string(arg1);
2663 ret = get_errno(statfs(path(p), &stfs));
2664 unlock_user(p, arg1, 0);
31e31b8a
FB		 2665 convert_statfs:
2666 if (!is_error(ret)) {
53a5960a 2667 struct target_statfs *target_stfs;
56c8f68f 2668
53a5960a
PB		 2669 lock_user_struct(target_stfs, arg2, 0);
2670 /* ??? put_user is probably wrong. */
56c8f68f
FB		 2671 put_user(stfs.f_type, &target_stfs->f_type);
2672 put_user(stfs.f_bsize, &target_stfs->f_bsize);
2673 put_user(stfs.f_blocks, &target_stfs->f_blocks);
2674 put_user(stfs.f_bfree, &target_stfs->f_bfree);
2675 put_user(stfs.f_bavail, &target_stfs->f_bavail);
2676 put_user(stfs.f_files, &target_stfs->f_files);
2677 put_user(stfs.f_ffree, &target_stfs->f_ffree);
2678 put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid);
2679 put_user(stfs.f_namelen, &target_stfs->f_namelen);
53a5960a 2680 unlock_user_struct(target_stfs, arg2, 1);
31e31b8a
FB		 2681 }
2682 break;
2683 case TARGET_NR_fstatfs:
56c8f68f 2684 ret = get_errno(fstatfs(arg1, &stfs));
31e31b8a 2685 goto convert_statfs;
56c8f68f
FB		 2686#ifdef TARGET_NR_statfs64
2687 case TARGET_NR_statfs64:
53a5960a
PB		 2688 p = lock_user_string(arg1);
2689 ret = get_errno(statfs(path(p), &stfs));
2690 unlock_user(p, arg1, 0);
56c8f68f
FB		 2691 convert_statfs64:
2692 if (!is_error(ret)) {
53a5960a
PB		 2693 struct target_statfs64 *target_stfs;
2694
2695 lock_user_struct(target_stfs, arg3, 0);
2696 /* ??? put_user is probably wrong. */
56c8f68f
FB		 2697 put_user(stfs.f_type, &target_stfs->f_type);
2698 put_user(stfs.f_bsize, &target_stfs->f_bsize);
2699 put_user(stfs.f_blocks, &target_stfs->f_blocks);
2700 put_user(stfs.f_bfree, &target_stfs->f_bfree);
2701 put_user(stfs.f_bavail, &target_stfs->f_bavail);
2702 put_user(stfs.f_files, &target_stfs->f_files);
2703 put_user(stfs.f_ffree, &target_stfs->f_ffree);
2704 put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid);
2705 put_user(stfs.f_namelen, &target_stfs->f_namelen);
53a5960a 2706 unlock_user_struct(target_stfs, arg3, 0);
56c8f68f
FB		 2707 }
2708 break;
2709 case TARGET_NR_fstatfs64:
2710 ret = get_errno(fstatfs(arg1, &stfs));
2711 goto convert_statfs64;
2712#endif
ebc05488 2713#ifdef TARGET_NR_ioperm
31e31b8a
FB		 2714 case TARGET_NR_ioperm:
2715 goto unimplemented;
ebc05488 2716#endif
31e31b8a 2717 case TARGET_NR_socketcall:
53a5960a 2718 ret = do_socketcall(arg1, arg2);
31e31b8a 2719 break;
3532fa74
FB		 2720
2721#ifdef TARGET_NR_accept
2722 case TARGET_NR_accept:
2723 ret = do_socketcallwrapper(SOCKOP_accept, arg1, arg2, arg3, arg4, arg5, arg6);
2724 break;
2725#endif
2726#ifdef TARGET_NR_bind
2727 case TARGET_NR_bind:
2728 ret = do_bind(arg1, arg2, arg3);
2729 break;
2730#endif
2731#ifdef TARGET_NR_connect
2732 case TARGET_NR_connect:
2733 ret = do_connect(arg1, arg2, arg3);
2734 break;
2735#endif
2736#ifdef TARGET_NR_getpeername
2737 case TARGET_NR_getpeername:
2738 ret = do_socketcallwrapper(SOCKOP_getpeername, arg1, arg2, arg3, arg4, arg5, arg6);
2739 break;
2740#endif
2741#ifdef TARGET_NR_getsockname
2742 case TARGET_NR_getsockname:
2743 ret = do_socketcallwrapper(SOCKOP_getsockname, arg1, arg2, arg3, arg4, arg5, arg6);
2744 break;
2745#endif
2746#ifdef TARGET_NR_getsockopt
2747 case TARGET_NR_getsockopt:
2748 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
2749 break;
2750#endif
2751#ifdef TARGET_NR_listen
2752 case TARGET_NR_listen:
2753 ret = do_socketcallwrapper(SOCKOP_listen, arg1, arg2, arg3, arg4, arg5, arg6);
2754 break;
2755#endif
2756#ifdef TARGET_NR_recv
2757 case TARGET_NR_recv:
2758 ret = do_socketcallwrapper(SOCKOP_recv, arg1, arg2, arg3, arg4, arg5, arg6);
2759 break;
2760#endif
2761#ifdef TARGET_NR_recvfrom
2762 case TARGET_NR_recvfrom:
2763 ret = do_socketcallwrapper(SOCKOP_recvfrom, arg1, arg2, arg3, arg4, arg5, arg6);
2764 break;
2765#endif
2766#ifdef TARGET_NR_recvmsg
2767 case TARGET_NR_recvmsg:
2768 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
2769 break;
2770#endif
2771#ifdef TARGET_NR_send
2772 case TARGET_NR_send:
2773 ret = do_socketcallwrapper(SOCKOP_send, arg1, arg2, arg3, arg4, arg5, arg6);
2774 break;
2775#endif
2776#ifdef TARGET_NR_sendmsg
2777 case TARGET_NR_sendmsg:
2778 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
2779 break;
2780#endif
2781#ifdef TARGET_NR_sendto
2782 case TARGET_NR_sendto:
2783 ret = do_socketcallwrapper(SOCKOP_sendto, arg1, arg2, arg3, arg4, arg5, arg6);
2784 break;
2785#endif
2786#ifdef TARGET_NR_shutdown
2787 case TARGET_NR_shutdown:
2788 ret = do_socketcallwrapper(SOCKOP_shutdown, arg1, arg2, arg3, arg4, arg5, arg6);
2789 break;
2790#endif
2791#ifdef TARGET_NR_socket
2792 case TARGET_NR_socket:
2793 ret = do_socket(arg1, arg2, arg3);
2794 break;
2795#endif
2796#ifdef TARGET_NR_socketpair
2797 case TARGET_NR_socketpair:
2798 ret = do_socketcallwrapper(SOCKOP_socketpair, arg1, arg2, arg3, arg4, arg5, arg6);
2799 break;
2800#endif
2801#ifdef TARGET_NR_setsockopt
2802 case TARGET_NR_setsockopt:
2803 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
2804 break;
2805#endif
2806
31e31b8a
FB		 2807 case TARGET_NR_syslog:
2808 goto unimplemented;
2809 case TARGET_NR_setitimer:
66fb9763 2810 {
66fb9763
FB		 2811 struct itimerval value, ovalue, *pvalue;
2812
53a5960a 2813 if (arg2) {
66fb9763
FB		 2814 pvalue = &value;
2815 target_to_host_timeval(&pvalue->it_interval,
53a5960a 2816 arg2);
66fb9763 2817 target_to_host_timeval(&pvalue->it_value,
53a5960a 2818 arg2 + sizeof(struct target_timeval));
66fb9763
FB		 2819 } else {
2820 pvalue = NULL;
2821 }
2822 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
53a5960a
PB		 2823 if (!is_error(ret) && arg3) {
2824 host_to_target_timeval(arg3,
66fb9763 2825 &ovalue.it_interval);
53a5960a 2826 host_to_target_timeval(arg3 + sizeof(struct target_timeval),
66fb9763
FB		 2827 &ovalue.it_value);
2828 }
2829 }
2830 break;
31e31b8a 2831 case TARGET_NR_getitimer:
66fb9763 2832 {
66fb9763
FB		 2833 struct itimerval value;
2834
2835 ret = get_errno(getitimer(arg1, &value));
53a5960a
PB		 2836 if (!is_error(ret) && arg2) {
2837 host_to_target_timeval(arg2,
66fb9763 2838 &value.it_interval);
53a5960a 2839 host_to_target_timeval(arg2 + sizeof(struct target_timeval),
66fb9763
FB		 2840 &value.it_value);
2841 }
2842 }
2843 break;
31e31b8a 2844 case TARGET_NR_stat:
53a5960a
PB		 2845 p = lock_user_string(arg1);
2846 ret = get_errno(stat(path(p), &st));
2847 unlock_user(p, arg1, 0);
31e31b8a
FB		 2848 goto do_stat;
2849 case TARGET_NR_lstat:
53a5960a
PB		 2850 p = lock_user_string(arg1);
2851 ret = get_errno(lstat(path(p), &st));
2852 unlock_user(p, arg1, 0);
31e31b8a
FB		 2853 goto do_stat;
2854 case TARGET_NR_fstat:
2855 {
2856 ret = get_errno(fstat(arg1, &st));
2857 do_stat:
2858 if (!is_error(ret)) {
53a5960a
PB		 2859 struct target_stat *target_st;
2860
2861 lock_user_struct(target_st, arg2, 0);
31e31b8a
FB		 2862 target_st->st_dev = tswap16(st.st_dev);
2863 target_st->st_ino = tswapl(st.st_ino);
67867308
FB		 2864#if defined(TARGET_PPC)
2865 target_st->st_mode = tswapl(st.st_mode); /* XXX: check this */
2866 target_st->st_uid = tswap32(st.st_uid);
2867 target_st->st_gid = tswap32(st.st_gid);
2868#else
ec86b0fb 2869 target_st->st_mode = tswap16(st.st_mode);
31e31b8a
FB		 2870 target_st->st_uid = tswap16(st.st_uid);
2871 target_st->st_gid = tswap16(st.st_gid);
67867308
FB		 2872#endif
2873 target_st->st_nlink = tswap16(st.st_nlink);
31e31b8a
FB		 2874 target_st->st_rdev = tswap16(st.st_rdev);
2875 target_st->st_size = tswapl(st.st_size);
2876 target_st->st_blksize = tswapl(st.st_blksize);
2877 target_st->st_blocks = tswapl(st.st_blocks);
7854b056
FB		 2878 target_st->target_st_atime = tswapl(st.st_atime);
2879 target_st->target_st_mtime = tswapl(st.st_mtime);
2880 target_st->target_st_ctime = tswapl(st.st_ctime);
53a5960a 2881 unlock_user_struct(target_st, arg2, 1);
31e31b8a
FB		 2882 }
2883 }
2884 break;
ebc05488 2885#ifdef TARGET_NR_olduname
31e31b8a
FB		 2886 case TARGET_NR_olduname:
2887 goto unimplemented;
ebc05488
FB		 2888#endif
2889#ifdef TARGET_NR_iopl
31e31b8a
FB		 2890 case TARGET_NR_iopl:
2891 goto unimplemented;
ebc05488 2892#endif
31e31b8a
FB		 2893 case TARGET_NR_vhangup:
2894 ret = get_errno(vhangup());
2895 break;
ebc05488 2896#ifdef TARGET_NR_idle
31e31b8a
FB		 2897 case TARGET_NR_idle:
2898 goto unimplemented;
42ad6ae9
FB		 2899#endif
2900#ifdef TARGET_NR_syscall
2901 case TARGET_NR_syscall:
2902 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
2903 break;
ebc05488 2904#endif
31e31b8a
FB		 2905 case TARGET_NR_wait4:
2906 {
2907 int status;
53a5960a 2908 target_long status_ptr = arg2;
31e31b8a 2909 struct rusage rusage, *rusage_ptr;
53a5960a 2910 target_ulong target_rusage = arg4;
31e31b8a
FB		 2911 if (target_rusage)
2912 rusage_ptr = &rusage;
2913 else
2914 rusage_ptr = NULL;
2915 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
2916 if (!is_error(ret)) {
2917 if (status_ptr)
53a5960a 2918 tputl(status_ptr, status);
31e31b8a 2919 if (target_rusage) {
b409186b 2920 host_to_target_rusage(target_rusage, &rusage);
31e31b8a
FB		 2921 }
2922 }
2923 }
2924 break;
2925 case TARGET_NR_swapoff:
53a5960a
PB		 2926 p = lock_user_string(arg1);
2927 ret = get_errno(swapoff(p));
2928 unlock_user(p, arg1, 0);
31e31b8a
FB		 2929 break;
2930 case TARGET_NR_sysinfo:
a5448a7d 2931 {
53a5960a 2932 struct target_sysinfo *target_value;
a5448a7d
FB		 2933 struct sysinfo value;
2934 ret = get_errno(sysinfo(&value));
53a5960a 2935 if (!is_error(ret) && arg1)
a5448a7d 2936 {
53a5960a
PB		 2937 /* ??? __put_user is probably wrong. */
2938 lock_user_struct(target_value, arg1, 0);
a5448a7d
FB		 2939 __put_user(value.uptime, &target_value->uptime);
2940 __put_user(value.loads[0], &target_value->loads[0]);
2941 __put_user(value.loads[1], &target_value->loads[1]);
2942 __put_user(value.loads[2], &target_value->loads[2]);
2943 __put_user(value.totalram, &target_value->totalram);
2944 __put_user(value.freeram, &target_value->freeram);
2945 __put_user(value.sharedram, &target_value->sharedram);
2946 __put_user(value.bufferram, &target_value->bufferram);
2947 __put_user(value.totalswap, &target_value->totalswap);
2948 __put_user(value.freeswap, &target_value->freeswap);
2949 __put_user(value.procs, &target_value->procs);
2950 __put_user(value.totalhigh, &target_value->totalhigh);
2951 __put_user(value.freehigh, &target_value->freehigh);
2952 __put_user(value.mem_unit, &target_value->mem_unit);
53a5960a 2953 unlock_user_struct(target_value, arg1, 1);
a5448a7d
FB		 2954 }
2955 }
2956 break;
31e31b8a 2957 case TARGET_NR_ipc:
8853f86e
FB		 2958 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
2959 break;
31e31b8a
FB		 2960 case TARGET_NR_fsync:
2961 ret = get_errno(fsync(arg1));
2962 break;
31e31b8a 2963 case TARGET_NR_clone:
1b6b029e
FB		 2964 ret = get_errno(do_fork(cpu_env, arg1, arg2));
2965 break;
ec86b0fb
FB		 2966#ifdef __NR_exit_group
2967 /* new thread calls */
2968 case TARGET_NR_exit_group:
e9009676 2969 gdb_exit(cpu_env, arg1);
ec86b0fb
FB		 2970 ret = get_errno(exit_group(arg1));
2971 break;
2972#endif
31e31b8a 2973 case TARGET_NR_setdomainname:
53a5960a
PB		 2974 p = lock_user_string(arg1);
2975 ret = get_errno(setdomainname(p, arg2));
2976 unlock_user(p, arg1, 0);
31e31b8a
FB		 2977 break;
2978 case TARGET_NR_uname:
2979 /* no need to transcode because we use the linux syscall */
29e619b1
FB		 2980 {
2981 struct new_utsname * buf;
2982
53a5960a 2983 lock_user_struct(buf, arg1, 0);
29e619b1
FB		 2984 ret = get_errno(sys_uname(buf));
2985 if (!is_error(ret)) {
2986 /* Overrite the native machine name with whatever is being
2987 emulated. */
2988 strcpy (buf->machine, UNAME_MACHINE);
c5937220
PB		 2989 /* Allow the user to override the reported release. */
2990 if (qemu_uname_release && *qemu_uname_release)
2991 strcpy (buf->release, qemu_uname_release);
29e619b1 2992 }
53a5960a 2993 unlock_user_struct(buf, arg1, 1);
29e619b1 2994 }
31e31b8a 2995 break;
6dbad63e 2996#ifdef TARGET_I386
31e31b8a 2997 case TARGET_NR_modify_ldt:
53a5960a 2998 ret = get_errno(do_modify_ldt(cpu_env, arg1, arg2, arg3));
5cd4393b
FB		 2999 break;
3000 case TARGET_NR_vm86old:
3001 goto unimplemented;
3002 case TARGET_NR_vm86:
53a5960a 3003 ret = do_vm86(cpu_env, arg1, arg2);
6dbad63e
FB		 3004 break;
3005#endif
31e31b8a
FB		 3006 case TARGET_NR_adjtimex:
3007 goto unimplemented;
31e31b8a
FB		 3008 case TARGET_NR_create_module:
3009 case TARGET_NR_init_module:
3010 case TARGET_NR_delete_module:
3011 case TARGET_NR_get_kernel_syms:
3012 goto unimplemented;
3013 case TARGET_NR_quotactl:
3014 goto unimplemented;
3015 case TARGET_NR_getpgid:
3016 ret = get_errno(getpgid(arg1));
3017 break;
3018 case TARGET_NR_fchdir:
3019 ret = get_errno(fchdir(arg1));
3020 break;
3021 case TARGET_NR_bdflush:
3022 goto unimplemented;
3023 case TARGET_NR_sysfs:
3024 goto unimplemented;
3025 case TARGET_NR_personality:
1b6b029e 3026 ret = get_errno(personality(arg1));
31e31b8a
FB		 3027 break;
3028 case TARGET_NR_afs_syscall:
3029 goto unimplemented;
31e31b8a
FB		 3030 case TARGET_NR__llseek:
3031 {
4f2ac237
FB		 3032#if defined (__x86_64__)
3033 ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
53a5960a 3034 tput64(arg4, ret);
4f2ac237 3035#else
31e31b8a
FB		 3036 int64_t res;
3037 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
53a5960a 3038 tput64(arg4, res);
4f2ac237 3039#endif
31e31b8a
FB		 3040 }
3041 break;
3042 case TARGET_NR_getdents:
3043#if TARGET_LONG_SIZE != 4
53a5960a 3044 goto unimplemented;
a315a145 3045#warning not supported
4add45b4
FB		 3046#elif TARGET_LONG_SIZE == 4 && HOST_LONG_SIZE == 8
3047 {
53a5960a 3048 struct target_dirent *target_dirp;
4add45b4
FB		 3049 struct dirent *dirp;
3050 long count = arg3;
3051
3052 dirp = malloc(count);
3053 if (!dirp)
3054 return -ENOMEM;
3055
3056 ret = get_errno(sys_getdents(arg1, dirp, count));
3057 if (!is_error(ret)) {
3058 struct dirent *de;
3059 struct target_dirent *tde;
3060 int len = ret;
3061 int reclen, treclen;
3062 int count1, tnamelen;
3063
3064 count1 = 0;
3065 de = dirp;
53a5960a 3066 target_dirp = lock_user(arg2, count, 0);
4add45b4
FB		 3067 tde = target_dirp;
3068 while (len > 0) {
3069 reclen = de->d_reclen;
3070 treclen = reclen - (2 * (sizeof(long) - sizeof(target_long)));
3071 tde->d_reclen = tswap16(treclen);
3072 tde->d_ino = tswapl(de->d_ino);
3073 tde->d_off = tswapl(de->d_off);
3074 tnamelen = treclen - (2 * sizeof(target_long) + 2);
3075 if (tnamelen > 256)
3076 tnamelen = 256;
80a9d035 3077 /* XXX: may not be correct */
4add45b4
FB		 3078 strncpy(tde->d_name, de->d_name, tnamelen);
3079 de = (struct dirent *)((char *)de + reclen);
3080 len -= reclen;
3081 tde = (struct dirent *)((char *)tde + treclen);
3082 count1 += treclen;
3083 }
3084 ret = count1;
3085 }
53a5960a 3086 unlock_user(target_dirp, arg2, ret);
4add45b4
FB		 3087 free(dirp);
3088 }
3089#else
31e31b8a 3090 {
53a5960a 3091 struct dirent *dirp;
31e31b8a 3092 long count = arg3;
dab2ed99 3093
53a5960a 3094 dirp = lock_user(arg2, count, 0);
72f03900 3095 ret = get_errno(sys_getdents(arg1, dirp, count));
31e31b8a
FB		 3096 if (!is_error(ret)) {
3097 struct dirent *de;
3098 int len = ret;
3099 int reclen;
3100 de = dirp;
3101 while (len > 0) {
8083a3e5 3102 reclen = de->d_reclen;
31e31b8a
FB		 3103 if (reclen > len)
3104 break;
8083a3e5 3105 de->d_reclen = tswap16(reclen);
31e31b8a
FB		 3106 tswapls(&de->d_ino);
3107 tswapls(&de->d_off);
3108 de = (struct dirent *)((char *)de + reclen);
3109 len -= reclen;
3110 }
3111 }
53a5960a 3112 unlock_user(dirp, arg2, ret);
31e31b8a 3113 }
4add45b4 3114#endif
31e31b8a 3115 break;
a541f297 3116#ifdef TARGET_NR_getdents64
dab2ed99
FB		 3117 case TARGET_NR_getdents64:
3118 {
53a5960a 3119 struct dirent64 *dirp;
dab2ed99 3120 long count = arg3;
53a5960a 3121 dirp = lock_user(arg2, count, 0);
dab2ed99
FB		 3122 ret = get_errno(sys_getdents64(arg1, dirp, count));
3123 if (!is_error(ret)) {
3124 struct dirent64 *de;
3125 int len = ret;
3126 int reclen;
3127 de = dirp;
3128 while (len > 0) {
8083a3e5 3129 reclen = de->d_reclen;
dab2ed99
FB		 3130 if (reclen > len)
3131 break;
8083a3e5 3132 de->d_reclen = tswap16(reclen);
dab2ed99
FB		 3133 tswap64s(&de->d_ino);
3134 tswap64s(&de->d_off);
3135 de = (struct dirent64 *)((char *)de + reclen);
3136 len -= reclen;
3137 }
3138 }
53a5960a 3139 unlock_user(dirp, arg2, ret);
dab2ed99
FB		 3140 }
3141 break;
a541f297 3142#endif /* TARGET_NR_getdents64 */
31e31b8a 3143 case TARGET_NR__newselect:
53a5960a 3144 ret = do_select(arg1, arg2, arg3, arg4, arg5);
31e31b8a 3145 break;
9de5e440
FB		 3146 case TARGET_NR_poll:
3147 {
53a5960a 3148 struct target_pollfd *target_pfd;
9de5e440
FB		 3149 unsigned int nfds = arg2;
3150 int timeout = arg3;
3151 struct pollfd *pfd;
7854b056 3152 unsigned int i;
9de5e440 3153
53a5960a 3154 target_pfd = lock_user(arg1, sizeof(struct target_pollfd) * nfds, 1);
9de5e440
FB		 3155 pfd = alloca(sizeof(struct pollfd) * nfds);
3156 for(i = 0; i < nfds; i++) {
5cd4393b
FB		 3157 pfd[i].fd = tswap32(target_pfd[i].fd);
3158 pfd[i].events = tswap16(target_pfd[i].events);
9de5e440
FB		 3159 }
3160 ret = get_errno(poll(pfd, nfds, timeout));
3161 if (!is_error(ret)) {
3162 for(i = 0; i < nfds; i++) {
5cd4393b 3163 target_pfd[i].revents = tswap16(pfd[i].revents);
9de5e440 3164 }
53a5960a
PB		 3165 ret += nfds * (sizeof(struct target_pollfd)
3166 - sizeof(struct pollfd));
9de5e440 3167 }
53a5960a 3168 unlock_user(target_pfd, arg1, ret);
9de5e440
FB		 3169 }
3170 break;
31e31b8a 3171 case TARGET_NR_flock:
9de5e440
FB		 3172 /* NOTE: the flock constant seems to be the same for every
3173 Linux platform */
3174 ret = get_errno(flock(arg1, arg2));
31e31b8a
FB		 3175 break;
3176 case TARGET_NR_readv:
3177 {
3178 int count = arg3;
31e31b8a 3179 struct iovec *vec;
31e31b8a
FB		 3180
3181 vec = alloca(count * sizeof(struct iovec));
53a5960a 3182 lock_iovec(vec, arg2, count, 0);
31e31b8a 3183 ret = get_errno(readv(arg1, vec, count));
53a5960a 3184 unlock_iovec(vec, arg2, count, 1);
31e31b8a
FB		 3185 }
3186 break;
3187 case TARGET_NR_writev:
3188 {
3189 int count = arg3;
31e31b8a 3190 struct iovec *vec;
31e31b8a
FB		 3191
3192 vec = alloca(count * sizeof(struct iovec));
53a5960a 3193 lock_iovec(vec, arg2, count, 1);
31e31b8a 3194 ret = get_errno(writev(arg1, vec, count));
53a5960a 3195 unlock_iovec(vec, arg2, count, 0);
31e31b8a
FB		 3196 }
3197 break;
3198 case TARGET_NR_getsid:
3199 ret = get_errno(getsid(arg1));
3200 break;
3201 case TARGET_NR_fdatasync:
5cd4393b
FB		 3202 ret = get_errno(fdatasync(arg1));
3203 break;
31e31b8a 3204 case TARGET_NR__sysctl:
29e619b1
FB		 3205 /* We don't implement this, but ENODIR is always a safe
3206 return value. */
3207 return -ENOTDIR;
31e31b8a 3208 case TARGET_NR_sched_setparam:
5cd4393b 3209 {
53a5960a 3210 struct sched_param *target_schp;
5cd4393b 3211 struct sched_param schp;
53a5960a
PB		 3212
3213 lock_user_struct(target_schp, arg2, 1);
5cd4393b 3214 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 3215 unlock_user_struct(target_schp, arg2, 0);
5cd4393b
FB		 3216 ret = get_errno(sched_setparam(arg1, &schp));
3217 }
3218 break;
31e31b8a 3219 case TARGET_NR_sched_getparam:
5cd4393b 3220 {
53a5960a 3221 struct sched_param *target_schp;
5cd4393b
FB		 3222 struct sched_param schp;
3223 ret = get_errno(sched_getparam(arg1, &schp));
3224 if (!is_error(ret)) {
53a5960a 3225 lock_user_struct(target_schp, arg2, 0);
5cd4393b 3226 target_schp->sched_priority = tswap32(schp.sched_priority);
53a5960a 3227 unlock_user_struct(target_schp, arg2, 1);
5cd4393b
FB		 3228 }
3229 }
3230 break;
31e31b8a 3231 case TARGET_NR_sched_setscheduler:
5cd4393b 3232 {
53a5960a 3233 struct sched_param *target_schp;
5cd4393b 3234 struct sched_param schp;
53a5960a 3235 lock_user_struct(target_schp, arg3, 1);
5cd4393b 3236 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 3237 unlock_user_struct(target_schp, arg3, 0);
5cd4393b
FB		 3238 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
3239 }
3240 break;
31e31b8a 3241 case TARGET_NR_sched_getscheduler:
5cd4393b
FB		 3242 ret = get_errno(sched_getscheduler(arg1));
3243 break;
31e31b8a
FB		 3244 case TARGET_NR_sched_yield:
3245 ret = get_errno(sched_yield());
3246 break;
3247 case TARGET_NR_sched_get_priority_max:
5cd4393b
FB		 3248 ret = get_errno(sched_get_priority_max(arg1));
3249 break;
31e31b8a 3250 case TARGET_NR_sched_get_priority_min:
5cd4393b
FB		 3251 ret = get_errno(sched_get_priority_min(arg1));
3252 break;
31e31b8a 3253 case TARGET_NR_sched_rr_get_interval:
5cd4393b 3254 {
5cd4393b
FB		 3255 struct timespec ts;
3256 ret = get_errno(sched_rr_get_interval(arg1, &ts));
3257 if (!is_error(ret)) {
53a5960a 3258 host_to_target_timespec(arg2, &ts);
5cd4393b
FB		 3259 }
3260 }
3261 break;
31e31b8a 3262 case TARGET_NR_nanosleep:
1b6b029e 3263 {
1b6b029e 3264 struct timespec req, rem;
53a5960a 3265 target_to_host_timespec(&req, arg1);
1b6b029e 3266 ret = get_errno(nanosleep(&req, &rem));
53a5960a
PB		 3267 if (is_error(ret) && arg2) {
3268 host_to_target_timespec(arg2, &rem);
1b6b029e
FB		 3269 }
3270 }
3271 break;
31e31b8a 3272 case TARGET_NR_query_module:
5cd4393b 3273 goto unimplemented;
31e31b8a 3274 case TARGET_NR_nfsservctl:
5cd4393b 3275 goto unimplemented;
31e31b8a 3276 case TARGET_NR_prctl:
5cd4393b 3277 goto unimplemented;
67867308 3278#ifdef TARGET_NR_pread
31e31b8a 3279 case TARGET_NR_pread:
53a5960a
PB		 3280 page_unprotect_range(arg2, arg3);
3281 p = lock_user(arg2, arg3, 0);
3282 ret = get_errno(pread(arg1, p, arg3, arg4));
3283 unlock_user(p, arg2, ret);
206f0fa7 3284 break;
31e31b8a 3285 case TARGET_NR_pwrite:
53a5960a
PB		 3286 p = lock_user(arg2, arg3, 1);
3287 ret = get_errno(pwrite(arg1, p, arg3, arg4));
3288 unlock_user(p, arg2, 0);
206f0fa7 3289 break;
67867308 3290#endif
31e31b8a 3291 case TARGET_NR_getcwd:
53a5960a
PB		 3292 p = lock_user(arg1, arg2, 0);
3293 ret = get_errno(sys_getcwd1(p, arg2));
3294 unlock_user(p, arg1, ret);
31e31b8a
FB		 3295 break;
3296 case TARGET_NR_capget:
5cd4393b 3297 goto unimplemented;
31e31b8a 3298 case TARGET_NR_capset:
5cd4393b 3299 goto unimplemented;
31e31b8a 3300 case TARGET_NR_sigaltstack:
5cd4393b 3301 goto unimplemented;
31e31b8a 3302 case TARGET_NR_sendfile:
5cd4393b 3303 goto unimplemented;
ebc05488 3304#ifdef TARGET_NR_getpmsg
31e31b8a 3305 case TARGET_NR_getpmsg:
5cd4393b 3306 goto unimplemented;
ebc05488
FB		 3307#endif
3308#ifdef TARGET_NR_putpmsg
31e31b8a 3309 case TARGET_NR_putpmsg:
5cd4393b 3310 goto unimplemented;
ebc05488 3311#endif
048f6b4d 3312#ifdef TARGET_NR_vfork
31e31b8a 3313 case TARGET_NR_vfork:
1b6b029e 3314 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0));
31e31b8a 3315 break;
048f6b4d 3316#endif
ebc05488 3317#ifdef TARGET_NR_ugetrlimit
31e31b8a 3318 case TARGET_NR_ugetrlimit:
728584be
FB		 3319 {
3320 struct rlimit rlim;
3321 ret = get_errno(getrlimit(arg1, &rlim));
3322 if (!is_error(ret)) {
53a5960a
PB		 3323 struct target_rlimit *target_rlim;
3324 lock_user_struct(target_rlim, arg2, 0);
728584be
FB		 3325 target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
3326 target_rlim->rlim_max = tswapl(rlim.rlim_max);
53a5960a 3327 unlock_user_struct(target_rlim, arg2, 1);
728584be
FB		 3328 }
3329 break;
3330 }
ebc05488 3331#endif
a315a145 3332#ifdef TARGET_NR_truncate64
31e31b8a 3333 case TARGET_NR_truncate64:
53a5960a
PB		 3334 p = lock_user_string(arg1);
3335 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
3336 unlock_user(p, arg1, 0);
667f38b1 3337 break;
a315a145
FB		 3338#endif
3339#ifdef TARGET_NR_ftruncate64
31e31b8a 3340 case TARGET_NR_ftruncate64:
ce4defa0 3341 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
667f38b1 3342 break;
a315a145
FB		 3343#endif
3344#ifdef TARGET_NR_stat64
31e31b8a 3345 case TARGET_NR_stat64:
53a5960a
PB		 3346 p = lock_user_string(arg1);
3347 ret = get_errno(stat(path(p), &st));
3348 unlock_user(p, arg1, 0);
60cd49d5 3349 goto do_stat64;
a315a145
FB		 3350#endif
3351#ifdef TARGET_NR_lstat64
31e31b8a 3352 case TARGET_NR_lstat64:
53a5960a
PB		 3353 p = lock_user_string(arg1);
3354 ret = get_errno(lstat(path(p), &st));
3355 unlock_user(p, arg1, 0);
60cd49d5 3356 goto do_stat64;
a315a145
FB		 3357#endif
3358#ifdef TARGET_NR_fstat64
31e31b8a 3359 case TARGET_NR_fstat64:
60cd49d5
FB		 3360 {
3361 ret = get_errno(fstat(arg1, &st));
3362 do_stat64:
3363 if (!is_error(ret)) {
ce4defa0
PB		 3364#ifdef TARGET_ARM
3365 if (((CPUARMState *)cpu_env)->eabi) {
53a5960a
PB		 3366 struct target_eabi_stat64 *target_st;
3367 lock_user_struct(target_st, arg2, 1);
ce4defa0 3368 memset(target_st, 0, sizeof(struct target_eabi_stat64));
53a5960a 3369 /* put_user is probably wrong. */
ce4defa0
PB		 3370 put_user(st.st_dev, &target_st->st_dev);
3371 put_user(st.st_ino, &target_st->st_ino);
3372#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3373 put_user(st.st_ino, &target_st->__st_ino);
3374#endif
3375 put_user(st.st_mode, &target_st->st_mode);
3376 put_user(st.st_nlink, &target_st->st_nlink);
3377 put_user(st.st_uid, &target_st->st_uid);
3378 put_user(st.st_gid, &target_st->st_gid);
3379 put_user(st.st_rdev, &target_st->st_rdev);
3380 /* XXX: better use of kernel struct */
3381 put_user(st.st_size, &target_st->st_size);
3382 put_user(st.st_blksize, &target_st->st_blksize);
3383 put_user(st.st_blocks, &target_st->st_blocks);
3384 put_user(st.st_atime, &target_st->target_st_atime);
3385 put_user(st.st_mtime, &target_st->target_st_mtime);
3386 put_user(st.st_ctime, &target_st->target_st_ctime);
53a5960a 3387 unlock_user_struct(target_st, arg2, 0);
ce4defa0
PB		 3388 } else
3389#endif
3390 {
53a5960a
PB		 3391 struct target_stat64 *target_st;
3392 lock_user_struct(target_st, arg2, 1);
ce4defa0 3393 memset(target_st, 0, sizeof(struct target_stat64));
53a5960a 3394 /* ??? put_user is probably wrong. */
ce4defa0
PB		 3395 put_user(st.st_dev, &target_st->st_dev);
3396 put_user(st.st_ino, &target_st->st_ino);
ec86b0fb 3397#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
ce4defa0
PB		 3398 put_user(st.st_ino, &target_st->__st_ino);
3399#endif
3400 put_user(st.st_mode, &target_st->st_mode);
3401 put_user(st.st_nlink, &target_st->st_nlink);
3402 put_user(st.st_uid, &target_st->st_uid);
3403 put_user(st.st_gid, &target_st->st_gid);
3404 put_user(st.st_rdev, &target_st->st_rdev);
3405 /* XXX: better use of kernel struct */
3406 put_user(st.st_size, &target_st->st_size);
3407 put_user(st.st_blksize, &target_st->st_blksize);
3408 put_user(st.st_blocks, &target_st->st_blocks);
3409 put_user(st.st_atime, &target_st->target_st_atime);
3410 put_user(st.st_mtime, &target_st->target_st_mtime);
3411 put_user(st.st_ctime, &target_st->target_st_ctime);
53a5960a 3412 unlock_user_struct(target_st, arg2, 0);
ce4defa0 3413 }
60cd49d5
FB		 3414 }
3415 }
3416 break;
a315a145 3417#endif
67867308
FB		 3418#ifdef USE_UID16
3419 case TARGET_NR_lchown:
53a5960a
PB		 3420 p = lock_user_string(arg1);
3421 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
3422 unlock_user(p, arg1, 0);
67867308
FB		 3423 break;
3424 case TARGET_NR_getuid:
3425 ret = get_errno(high2lowuid(getuid()));
3426 break;
3427 case TARGET_NR_getgid:
3428 ret = get_errno(high2lowgid(getgid()));
3429 break;
3430 case TARGET_NR_geteuid:
3431 ret = get_errno(high2lowuid(geteuid()));
3432 break;
3433 case TARGET_NR_getegid:
3434 ret = get_errno(high2lowgid(getegid()));
3435 break;
3436 case TARGET_NR_setreuid:
3437 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
3438 break;
3439 case TARGET_NR_setregid:
3440 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
3441 break;
3442 case TARGET_NR_getgroups:
3443 {
3444 int gidsetsize = arg1;
53a5960a 3445 uint16_t *target_grouplist;
67867308
FB		 3446 gid_t *grouplist;
3447 int i;
3448
3449 grouplist = alloca(gidsetsize * sizeof(gid_t));
3450 ret = get_errno(getgroups(gidsetsize, grouplist));
3451 if (!is_error(ret)) {
53a5960a 3452 target_grouplist = lock_user(arg2, gidsetsize * 2, 0);
67867308
FB		 3453 for(i = 0;i < gidsetsize; i++)
3454 target_grouplist[i] = tswap16(grouplist[i]);
53a5960a 3455 unlock_user(target_grouplist, arg2, gidsetsize * 2);
67867308
FB		 3456 }
3457 }
3458 break;
3459 case TARGET_NR_setgroups:
3460 {
3461 int gidsetsize = arg1;
53a5960a 3462 uint16_t *target_grouplist;
67867308
FB		 3463 gid_t *grouplist;
3464 int i;
3465
3466 grouplist = alloca(gidsetsize * sizeof(gid_t));
53a5960a 3467 target_grouplist = lock_user(arg2, gidsetsize * 2, 1);
67867308
FB		 3468 for(i = 0;i < gidsetsize; i++)
3469 grouplist[i] = tswap16(target_grouplist[i]);
53a5960a 3470 unlock_user(target_grouplist, arg2, 0);
67867308
FB		 3471 ret = get_errno(setgroups(gidsetsize, grouplist));
3472 }
3473 break;
3474 case TARGET_NR_fchown:
3475 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
3476 break;
3477#ifdef TARGET_NR_setresuid
3478 case TARGET_NR_setresuid:
3479 ret = get_errno(setresuid(low2highuid(arg1),
3480 low2highuid(arg2),
3481 low2highuid(arg3)));
3482 break;
3483#endif
3484#ifdef TARGET_NR_getresuid
3485 case TARGET_NR_getresuid:
3486 {
53a5960a 3487 uid_t ruid, euid, suid;
67867308
FB		 3488 ret = get_errno(getresuid(&ruid, &euid, &suid));
3489 if (!is_error(ret)) {
53a5960a
PB		 3490 tput16(arg1, tswap16(high2lowuid(ruid)));
3491 tput16(arg2, tswap16(high2lowuid(euid)));
3492 tput16(arg3, tswap16(high2lowuid(suid)));
67867308
FB		 3493 }
3494 }
3495 break;
3496#endif
3497#ifdef TARGET_NR_getresgid
3498 case TARGET_NR_setresgid:
3499 ret = get_errno(setresgid(low2highgid(arg1),
3500 low2highgid(arg2),
3501 low2highgid(arg3)));
3502 break;
3503#endif
3504#ifdef TARGET_NR_getresgid
3505 case TARGET_NR_getresgid:
3506 {
53a5960a 3507 gid_t rgid, egid, sgid;
67867308
FB		 3508 ret = get_errno(getresgid(&rgid, &egid, &sgid));
3509 if (!is_error(ret)) {
53a5960a
PB		 3510 tput16(arg1, tswap16(high2lowgid(rgid)));
3511 tput16(arg2, tswap16(high2lowgid(egid)));
3512 tput16(arg3, tswap16(high2lowgid(sgid)));
67867308
FB		 3513 }
3514 }
3515 break;
3516#endif
3517 case TARGET_NR_chown:
53a5960a
PB		 3518 p = lock_user_string(arg1);
3519 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
3520 unlock_user(p, arg1, 0);
67867308
FB		 3521 break;
3522 case TARGET_NR_setuid:
3523 ret = get_errno(setuid(low2highuid(arg1)));
3524 break;
3525 case TARGET_NR_setgid:
3526 ret = get_errno(setgid(low2highgid(arg1)));
3527 break;
3528 case TARGET_NR_setfsuid:
3529 ret = get_errno(setfsuid(arg1));
3530 break;
3531 case TARGET_NR_setfsgid:
3532 ret = get_errno(setfsgid(arg1));
3533 break;
3534#endif /* USE_UID16 */
3535
a315a145 3536#ifdef TARGET_NR_lchown32
31e31b8a 3537 case TARGET_NR_lchown32:
53a5960a
PB		 3538 p = lock_user_string(arg1);
3539 ret = get_errno(lchown(p, arg2, arg3));
3540 unlock_user(p, arg1, 0);
b03c60f3 3541 break;
a315a145
FB		 3542#endif
3543#ifdef TARGET_NR_getuid32
31e31b8a 3544 case TARGET_NR_getuid32:
b03c60f3
FB		 3545 ret = get_errno(getuid());
3546 break;
a315a145
FB		 3547#endif
3548#ifdef TARGET_NR_getgid32
31e31b8a 3549 case TARGET_NR_getgid32:
b03c60f3
FB		 3550 ret = get_errno(getgid());
3551 break;
a315a145
FB		 3552#endif
3553#ifdef TARGET_NR_geteuid32
31e31b8a 3554 case TARGET_NR_geteuid32:
b03c60f3
FB		 3555 ret = get_errno(geteuid());
3556 break;
a315a145
FB		 3557#endif
3558#ifdef TARGET_NR_getegid32
31e31b8a 3559 case TARGET_NR_getegid32:
b03c60f3
FB		 3560 ret = get_errno(getegid());
3561 break;
a315a145
FB		 3562#endif
3563#ifdef TARGET_NR_setreuid32
31e31b8a 3564 case TARGET_NR_setreuid32:
b03c60f3
FB		 3565 ret = get_errno(setreuid(arg1, arg2));
3566 break;
a315a145
FB		 3567#endif
3568#ifdef TARGET_NR_setregid32
31e31b8a 3569 case TARGET_NR_setregid32:
b03c60f3
FB		 3570 ret = get_errno(setregid(arg1, arg2));
3571 break;
a315a145
FB		 3572#endif
3573#ifdef TARGET_NR_getgroups32
31e31b8a 3574 case TARGET_NR_getgroups32:
99c475ab
FB		 3575 {
3576 int gidsetsize = arg1;
53a5960a 3577 uint32_t *target_grouplist;
99c475ab
FB		 3578 gid_t *grouplist;
3579 int i;
3580
3581 grouplist = alloca(gidsetsize * sizeof(gid_t));
3582 ret = get_errno(getgroups(gidsetsize, grouplist));
3583 if (!is_error(ret)) {
53a5960a 3584 target_grouplist = lock_user(arg2, gidsetsize * 4, 0);
99c475ab 3585 for(i = 0;i < gidsetsize; i++)
53a5960a
PB		 3586 target_grouplist[i] = tswap32(grouplist[i]);
3587 unlock_user(target_grouplist, arg2, gidsetsize * 4);
99c475ab
FB		 3588 }
3589 }
3590 break;
a315a145
FB		 3591#endif
3592#ifdef TARGET_NR_setgroups32
31e31b8a 3593 case TARGET_NR_setgroups32:
99c475ab
FB		 3594 {
3595 int gidsetsize = arg1;
53a5960a 3596 uint32_t *target_grouplist;
99c475ab
FB		 3597 gid_t *grouplist;
3598 int i;
3599
3600 grouplist = alloca(gidsetsize * sizeof(gid_t));
53a5960a 3601 target_grouplist = lock_user(arg2, gidsetsize * 4, 1);
99c475ab 3602 for(i = 0;i < gidsetsize; i++)
53a5960a
PB		 3603 grouplist[i] = tswap32(target_grouplist[i]);
3604 unlock_user(target_grouplist, arg2, 0);
99c475ab
FB		 3605 ret = get_errno(setgroups(gidsetsize, grouplist));
3606 }
3607 break;
a315a145
FB		 3608#endif
3609#ifdef TARGET_NR_fchown32
31e31b8a 3610 case TARGET_NR_fchown32:
b03c60f3
FB		 3611 ret = get_errno(fchown(arg1, arg2, arg3));
3612 break;
a315a145
FB		 3613#endif
3614#ifdef TARGET_NR_setresuid32
31e31b8a 3615 case TARGET_NR_setresuid32:
b03c60f3
FB		 3616 ret = get_errno(setresuid(arg1, arg2, arg3));
3617 break;
a315a145
FB		 3618#endif
3619#ifdef TARGET_NR_getresuid32
31e31b8a 3620 case TARGET_NR_getresuid32:
b03c60f3 3621 {
53a5960a 3622 uid_t ruid, euid, suid;
b03c60f3
FB		 3623 ret = get_errno(getresuid(&ruid, &euid, &suid));
3624 if (!is_error(ret)) {
53a5960a
PB		 3625 tput32(arg1, tswap32(ruid));
3626 tput32(arg2, tswap32(euid));
3627 tput32(arg3, tswap32(suid));
b03c60f3
FB		 3628 }
3629 }
3630 break;
a315a145
FB		 3631#endif
3632#ifdef TARGET_NR_setresgid32
31e31b8a 3633 case TARGET_NR_setresgid32:
b03c60f3
FB		 3634 ret = get_errno(setresgid(arg1, arg2, arg3));
3635 break;
a315a145
FB		 3636#endif
3637#ifdef TARGET_NR_getresgid32
31e31b8a 3638 case TARGET_NR_getresgid32:
b03c60f3 3639 {
53a5960a 3640 gid_t rgid, egid, sgid;
b03c60f3
FB		 3641 ret = get_errno(getresgid(&rgid, &egid, &sgid));
3642 if (!is_error(ret)) {
53a5960a
PB		 3643 tput32(arg1, tswap32(rgid));
3644 tput32(arg2, tswap32(egid));
3645 tput32(arg3, tswap32(sgid));
b03c60f3
FB		 3646 }
3647 }
3648 break;
a315a145
FB		 3649#endif
3650#ifdef TARGET_NR_chown32
31e31b8a 3651 case TARGET_NR_chown32:
53a5960a
PB		 3652 p = lock_user_string(arg1);
3653 ret = get_errno(chown(p, arg2, arg3));
3654 unlock_user(p, arg1, 0);
b03c60f3 3655 break;
a315a145
FB		 3656#endif
3657#ifdef TARGET_NR_setuid32
31e31b8a 3658 case TARGET_NR_setuid32:
b03c60f3
FB		 3659 ret = get_errno(setuid(arg1));
3660 break;
a315a145
FB		 3661#endif
3662#ifdef TARGET_NR_setgid32
31e31b8a 3663 case TARGET_NR_setgid32:
b03c60f3
FB		 3664 ret = get_errno(setgid(arg1));
3665 break;
a315a145
FB		 3666#endif
3667#ifdef TARGET_NR_setfsuid32
31e31b8a 3668 case TARGET_NR_setfsuid32:
b03c60f3
FB		 3669 ret = get_errno(setfsuid(arg1));
3670 break;
a315a145
FB		 3671#endif
3672#ifdef TARGET_NR_setfsgid32
31e31b8a 3673 case TARGET_NR_setfsgid32:
b03c60f3
FB		 3674 ret = get_errno(setfsgid(arg1));
3675 break;
a315a145 3676#endif
67867308 3677
31e31b8a 3678 case TARGET_NR_pivot_root:
b03c60f3 3679 goto unimplemented;
ffa65c3b 3680#ifdef TARGET_NR_mincore
31e31b8a 3681 case TARGET_NR_mincore:
b03c60f3 3682 goto unimplemented;
ffa65c3b
FB		 3683#endif
3684#ifdef TARGET_NR_madvise
31e31b8a 3685 case TARGET_NR_madvise:
24836689
PB		 3686 /* A straight passthrough may not be safe because qemu sometimes
3687 turns private flie-backed mappings into anonymous mappings.
3688 This will break MADV_DONTNEED.
3689 This is a hint, so ignoring and returning success is ok. */
3690 ret = get_errno(0);
3691 break;
ffa65c3b 3692#endif
60cd49d5 3693#if TARGET_LONG_BITS == 32
31e31b8a 3694 case TARGET_NR_fcntl64:
77e4672d
FB		 3695 {
3696 struct flock64 fl;
53a5960a 3697 struct target_flock64 *target_fl;
ce4defa0 3698#ifdef TARGET_ARM
53a5960a 3699 struct target_eabi_flock64 *target_efl;
ce4defa0 3700#endif
77e4672d 3701
60cd49d5
FB		 3702 switch(arg2) {
3703 case F_GETLK64:
77e4672d
FB		 3704 ret = get_errno(fcntl(arg1, arg2, &fl));
3705 if (ret == 0) {
ce4defa0
PB		 3706#ifdef TARGET_ARM
3707 if (((CPUARMState *)cpu_env)->eabi) {
53a5960a 3708 lock_user_struct(target_efl, arg3, 0);
ce4defa0
PB		 3709 target_efl->l_type = tswap16(fl.l_type);
3710 target_efl->l_whence = tswap16(fl.l_whence);
3711 target_efl->l_start = tswap64(fl.l_start);
3712 target_efl->l_len = tswap64(fl.l_len);
3713 target_efl->l_pid = tswapl(fl.l_pid);
53a5960a 3714 unlock_user_struct(target_efl, arg3, 1);
ce4defa0
PB		 3715 } else
3716#endif
3717 {
53a5960a 3718 lock_user_struct(target_fl, arg3, 0);
ce4defa0
PB		 3719 target_fl->l_type = tswap16(fl.l_type);
3720 target_fl->l_whence = tswap16(fl.l_whence);
3721 target_fl->l_start = tswap64(fl.l_start);
3722 target_fl->l_len = tswap64(fl.l_len);
3723 target_fl->l_pid = tswapl(fl.l_pid);
53a5960a 3724 unlock_user_struct(target_fl, arg3, 1);
ce4defa0 3725 }
77e4672d
FB		 3726 }
3727 break;
3728
60cd49d5
FB		 3729 case F_SETLK64:
3730 case F_SETLKW64:
ce4defa0
PB		 3731#ifdef TARGET_ARM
3732 if (((CPUARMState *)cpu_env)->eabi) {
53a5960a 3733 lock_user_struct(target_efl, arg3, 1);
ce4defa0
PB		 3734 fl.l_type = tswap16(target_efl->l_type);
3735 fl.l_whence = tswap16(target_efl->l_whence);
3736 fl.l_start = tswap64(target_efl->l_start);
3737 fl.l_len = tswap64(target_efl->l_len);
3738 fl.l_pid = tswapl(target_efl->l_pid);
53a5960a 3739 unlock_user_struct(target_efl, arg3, 0);
ce4defa0
PB		 3740 } else
3741#endif
3742 {
53a5960a 3743 lock_user_struct(target_fl, arg3, 1);
ce4defa0
PB		 3744 fl.l_type = tswap16(target_fl->l_type);
3745 fl.l_whence = tswap16(target_fl->l_whence);
3746 fl.l_start = tswap64(target_fl->l_start);
3747 fl.l_len = tswap64(target_fl->l_len);
3748 fl.l_pid = tswapl(target_fl->l_pid);
53a5960a 3749 unlock_user_struct(target_fl, arg3, 0);
ce4defa0 3750 }
77e4672d
FB		 3751 ret = get_errno(fcntl(arg1, arg2, &fl));
3752 break;
60cd49d5 3753 default:
7775e9ec 3754 ret = get_errno(do_fcntl(arg1, arg2, arg3));
60cd49d5
FB		 3755 break;
3756 }
77e4672d
FB		 3757 break;
3758 }
60cd49d5 3759#endif
ebc05488 3760#ifdef TARGET_NR_security
31e31b8a
FB		 3761 case TARGET_NR_security:
3762 goto unimplemented;
c573ff67
FB		 3763#endif
3764#ifdef TARGET_NR_getpagesize
3765 case TARGET_NR_getpagesize:
3766 ret = TARGET_PAGE_SIZE;
3767 break;
ebc05488 3768#endif
31e31b8a
FB		 3769 case TARGET_NR_gettid:
3770 ret = get_errno(gettid());
3771 break;
3772 case TARGET_NR_readahead:
5cd4393b 3773 goto unimplemented;
ebc05488 3774#ifdef TARGET_NR_setxattr
31e31b8a
FB		 3775 case TARGET_NR_setxattr:
3776 case TARGET_NR_lsetxattr:
3777 case TARGET_NR_fsetxattr:
3778 case TARGET_NR_getxattr:
3779 case TARGET_NR_lgetxattr:
3780 case TARGET_NR_fgetxattr:
3781 case TARGET_NR_listxattr:
3782 case TARGET_NR_llistxattr:
3783 case TARGET_NR_flistxattr:
3784 case TARGET_NR_removexattr:
3785 case TARGET_NR_lremovexattr:
3786 case TARGET_NR_fremovexattr:
5cd4393b 3787 goto unimplemented_nowarn;
ebc05488
FB		 3788#endif
3789#ifdef TARGET_NR_set_thread_area
5cd4393b
FB		 3790 case TARGET_NR_set_thread_area:
3791 case TARGET_NR_get_thread_area:
3792 goto unimplemented_nowarn;
48dc41eb
FB		 3793#endif
3794#ifdef TARGET_NR_getdomainname
3795 case TARGET_NR_getdomainname:
3796 goto unimplemented_nowarn;
ebc05488 3797#endif
31e31b8a
FB		 3798 default:
3799 unimplemented:
5cd4393b 3800 gemu_log("qemu: Unsupported syscall: %d\n", num);
48dc41eb 3801#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_set_thread_area) || defined(TARGET_NR_getdomainname)
5cd4393b 3802 unimplemented_nowarn:
80a9d035 3803#endif
31e31b8a
FB		 3804 ret = -ENOSYS;
3805 break;
3806 }
3807 fail:
c573ff67
FB		 3808#ifdef DEBUG
3809 gemu_log(" = %ld\n", ret);
3810#endif
31e31b8a
FB		 3811 return ret;
3812}
3813
QEMU mirror