?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
To make syscall.c for 64 bit truly warning-free, we need some more #ifs.
[qemu/mini2440.git] / linux-user / syscall.c
blob741ebd6443ee50de29d937147ed1eaf8acd58342
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>
23 #include <string.h>
24 #include <elf.h>
25 #include <endian.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <time.h>
30 #include <limits.h>
31 #include <sys/types.h>
32 #include <sys/ipc.h>
33 #include <sys/msg.h>
34 #include <sys/wait.h>
35 #include <sys/time.h>
36 #include <sys/stat.h>
37 #include <sys/mount.h>
38 #include <sys/prctl.h>
39 #include <sys/resource.h>
40 #include <sys/mman.h>
41 #include <sys/swap.h>
42 #include <signal.h>
43 #include <sched.h>
44 #include <sys/socket.h>
45 #include <sys/uio.h>
46 #include <sys/poll.h>
47 #include <sys/times.h>
48 #include <sys/shm.h>
49 #include <sys/sem.h>
50 #include <sys/statfs.h>
51 #include <utime.h>
52 #include <sys/sysinfo.h>
53 //#include <sys/user.h>
54 #include <netinet/ip.h>
55 #include <netinet/tcp.h>
56
57 #define termios host_termios
58 #define winsize host_winsize
59 #define termio host_termio
60 #define sgttyb host_sgttyb /* same as target */
61 #define tchars host_tchars /* same as target */
62 #define ltchars host_ltchars /* same as target */
63
64 #include <linux/termios.h>
65 #include <linux/unistd.h>
66 #include <linux/utsname.h>
67 #include <linux/cdrom.h>
68 #include <linux/hdreg.h>
69 #include <linux/soundcard.h>
70 #include <linux/dirent.h>
71 #include <linux/kd.h>
72 #include "linux_loop.h"
73
74 #include "qemu.h"
75 #include "qemu-common.h"
76
77 #if defined(USE_NPTL)
78 #include <linux/futex.h>
79 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
80 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
81 #else
82 /* XXX: Hardcode the above values. */
83 #define CLONE_NPTL_FLAGS2 0
84 #endif
85
86 //#define DEBUG
87
88 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
89 || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
90 /* 16 bit uid wrappers emulation */
91 #define USE_UID16
92 #endif
93
94 //#include <linux/msdos_fs.h>
95 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2])
96 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2])
97
98
99 #undef _syscall0
100 #undef _syscall1
101 #undef _syscall2
102 #undef _syscall3
103 #undef _syscall4
104 #undef _syscall5
105 #undef _syscall6
106
107 #define _syscall0(type,name) \
108 static type name (void) \
109 { \
110 return syscall(__NR_##name); \
111 }
112
113 #define _syscall1(type,name,type1,arg1) \
114 static type name (type1 arg1) \
115 { \
116 return syscall(__NR_##name, arg1); \
117 }
118
119 #define _syscall2(type,name,type1,arg1,type2,arg2) \
120 static type name (type1 arg1,type2 arg2) \
121 { \
122 return syscall(__NR_##name, arg1, arg2); \
123 }
124
125 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
126 static type name (type1 arg1,type2 arg2,type3 arg3) \
127 { \
128 return syscall(__NR_##name, arg1, arg2, arg3); \
129 }
130
131 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
132 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
133 { \
134 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
135 }
136
137 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
138 type5,arg5) \
139 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
140 { \
141 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
142 }
143
144
145 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
146 type5,arg5,type6,arg6) \
147 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
148 type6 arg6) \
149 { \
150 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
151 }
152
153
154 #define __NR_sys_uname __NR_uname
155 #define __NR_sys_faccessat __NR_faccessat
156 #define __NR_sys_fchmodat __NR_fchmodat
157 #define __NR_sys_fchownat __NR_fchownat
158 #define __NR_sys_getcwd1 __NR_getcwd
159 #define __NR_sys_getdents __NR_getdents
160 #define __NR_sys_getdents64 __NR_getdents64
161 #define __NR_sys_getpriority __NR_getpriority
162 #define __NR_sys_linkat __NR_linkat
163 #define __NR_sys_mkdirat __NR_mkdirat
164 #define __NR_sys_mknodat __NR_mknodat
165 #define __NR_sys_openat __NR_openat
166 #define __NR_sys_readlinkat __NR_readlinkat
167 #define __NR_sys_renameat __NR_renameat
168 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
169 #define __NR_sys_symlinkat __NR_symlinkat
170 #define __NR_sys_syslog __NR_syslog
171 #define __NR_sys_tgkill __NR_tgkill
172 #define __NR_sys_tkill __NR_tkill
173 #define __NR_sys_unlinkat __NR_unlinkat
174 #define __NR_sys_utimensat __NR_utimensat
175 #define __NR_sys_futex __NR_futex
176
177 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
178 #define __NR__llseek __NR_lseek
179 #endif
180
181 #ifdef __NR_gettid
182 _syscall0(int, gettid)
183 #else
184 /* This is a replacement for the host gettid() and must return a host
185 errno. */
186 static int gettid(void) {
187 return -ENOSYS;
188 }
189 #endif
190 _syscall1(int,sys_uname,struct new_utsname *,buf)
191 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
192 _syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags)
193 #endif
194 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
195 _syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname,
196 mode_t,mode,int,flags)
197 #endif
198 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16)
199 _syscall5(int,sys_fchownat,int,dirfd,const char *,pathname,
200 uid_t,owner,gid_t,group,int,flags)
201 #endif
202 _syscall2(int,sys_getcwd1,char *,buf,size_t,size)
203 #if TARGET_ABI_BITS == 32
204 _syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count);
205 #endif
206 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
207 _syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count);
208 #endif
209 _syscall2(int, sys_getpriority, int, which, int, who);
210 #if !defined (__x86_64__)
211 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
212 loff_t *, res, uint, wh);
213 #endif
214 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
215 _syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath,
216 int,newdirfd,const char *,newpath,int,flags)
217 #endif
218 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
219 _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode)
220 #endif
221 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
222 _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname,
223 mode_t,mode,dev_t,dev)
224 #endif
225 #if defined(TARGET_NR_openat) && defined(__NR_openat)
226 _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)
227 #endif
228 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
229 _syscall4(int,sys_readlinkat,int,dirfd,const char *,pathname,
230 char *,buf,size_t,bufsize)
231 #endif
232 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
233 _syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath,
234 int,newdirfd,const char *,newpath)
235 #endif
236 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
237 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
238 _syscall3(int,sys_symlinkat,const char *,oldpath,
239 int,newdirfd,const char *,newpath)
240 #endif
241 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
242 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
243 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
244 #endif
245 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
246 _syscall2(int,sys_tkill,int,tid,int,sig)
247 #endif
248 #ifdef __NR_exit_group
249 _syscall1(int,exit_group,int,error_code)
250 #endif
251 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
252 _syscall1(int,set_tid_address,int *,tidptr)
253 #endif
254 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
255 _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)
256 #endif
257 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
258 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
259 const struct timespec *,tsp,int,flags)
260 #endif
261 #if defined(USE_NPTL)
262 #if defined(TARGET_NR_futex) && defined(__NR_futex)
263 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
264 const struct timespec *,timeout,int *,uaddr2,int,val3)
265 #endif
266 #endif
267
268 extern int personality(int);
269 extern int flock(int, int);
270 extern int setfsuid(int);
271 extern int setfsgid(int);
272 extern int setresuid(uid_t, uid_t, uid_t);
273 extern int getresuid(uid_t *, uid_t *, uid_t *);
274 extern int setresgid(gid_t, gid_t, gid_t);
275 extern int getresgid(gid_t *, gid_t *, gid_t *);
276 extern int setgroups(int, gid_t *);
277
278 #define ERRNO_TABLE_SIZE 1200
279
280 /* target_to_host_errno_table[] is initialized from
281 * host_to_target_errno_table[] in syscall_init(). */
282 static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
283 };
284
285 /*
286 * This list is the union of errno values overridden in asm-<arch>/errno.h
287 * minus the errnos that are not actually generic to all archs.
288 */
289 static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
290 [EIDRM] = TARGET_EIDRM,
291 [ECHRNG] = TARGET_ECHRNG,
292 [EL2NSYNC] = TARGET_EL2NSYNC,
293 [EL3HLT] = TARGET_EL3HLT,
294 [EL3RST] = TARGET_EL3RST,
295 [ELNRNG] = TARGET_ELNRNG,
296 [EUNATCH] = TARGET_EUNATCH,
297 [ENOCSI] = TARGET_ENOCSI,
298 [EL2HLT] = TARGET_EL2HLT,
299 [EDEADLK] = TARGET_EDEADLK,
300 [ENOLCK] = TARGET_ENOLCK,
301 [EBADE] = TARGET_EBADE,
302 [EBADR] = TARGET_EBADR,
303 [EXFULL] = TARGET_EXFULL,
304 [ENOANO] = TARGET_ENOANO,
305 [EBADRQC] = TARGET_EBADRQC,
306 [EBADSLT] = TARGET_EBADSLT,
307 [EBFONT] = TARGET_EBFONT,
308 [ENOSTR] = TARGET_ENOSTR,
309 [ENODATA] = TARGET_ENODATA,
310 [ETIME] = TARGET_ETIME,
311 [ENOSR] = TARGET_ENOSR,
312 [ENONET] = TARGET_ENONET,
313 [ENOPKG] = TARGET_ENOPKG,
314 [EREMOTE] = TARGET_EREMOTE,
315 [ENOLINK] = TARGET_ENOLINK,
316 [EADV] = TARGET_EADV,
317 [ESRMNT] = TARGET_ESRMNT,
318 [ECOMM] = TARGET_ECOMM,
319 [EPROTO] = TARGET_EPROTO,
320 [EDOTDOT] = TARGET_EDOTDOT,
321 [EMULTIHOP] = TARGET_EMULTIHOP,
322 [EBADMSG] = TARGET_EBADMSG,
323 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
324 [EOVERFLOW] = TARGET_EOVERFLOW,
325 [ENOTUNIQ] = TARGET_ENOTUNIQ,
326 [EBADFD] = TARGET_EBADFD,
327 [EREMCHG] = TARGET_EREMCHG,
328 [ELIBACC] = TARGET_ELIBACC,
329 [ELIBBAD] = TARGET_ELIBBAD,
330 [ELIBSCN] = TARGET_ELIBSCN,
331 [ELIBMAX] = TARGET_ELIBMAX,
332 [ELIBEXEC] = TARGET_ELIBEXEC,
333 [EILSEQ] = TARGET_EILSEQ,
334 [ENOSYS] = TARGET_ENOSYS,
335 [ELOOP] = TARGET_ELOOP,
336 [ERESTART] = TARGET_ERESTART,
337 [ESTRPIPE] = TARGET_ESTRPIPE,
338 [ENOTEMPTY] = TARGET_ENOTEMPTY,
339 [EUSERS] = TARGET_EUSERS,
340 [ENOTSOCK] = TARGET_ENOTSOCK,
341 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
342 [EMSGSIZE] = TARGET_EMSGSIZE,
343 [EPROTOTYPE] = TARGET_EPROTOTYPE,
344 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
345 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
346 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
347 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
348 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
349 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
350 [EADDRINUSE] = TARGET_EADDRINUSE,
351 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
352 [ENETDOWN] = TARGET_ENETDOWN,
353 [ENETUNREACH] = TARGET_ENETUNREACH,
354 [ENETRESET] = TARGET_ENETRESET,
355 [ECONNABORTED] = TARGET_ECONNABORTED,
356 [ECONNRESET] = TARGET_ECONNRESET,
357 [ENOBUFS] = TARGET_ENOBUFS,
358 [EISCONN] = TARGET_EISCONN,
359 [ENOTCONN] = TARGET_ENOTCONN,
360 [EUCLEAN] = TARGET_EUCLEAN,
361 [ENOTNAM] = TARGET_ENOTNAM,
362 [ENAVAIL] = TARGET_ENAVAIL,
363 [EISNAM] = TARGET_EISNAM,
364 [EREMOTEIO] = TARGET_EREMOTEIO,
365 [ESHUTDOWN] = TARGET_ESHUTDOWN,
366 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
367 [ETIMEDOUT] = TARGET_ETIMEDOUT,
368 [ECONNREFUSED] = TARGET_ECONNREFUSED,
369 [EHOSTDOWN] = TARGET_EHOSTDOWN,
370 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
371 [EALREADY] = TARGET_EALREADY,
372 [EINPROGRESS] = TARGET_EINPROGRESS,
373 [ESTALE] = TARGET_ESTALE,
374 [ECANCELED] = TARGET_ECANCELED,
375 [ENOMEDIUM] = TARGET_ENOMEDIUM,
376 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
377 #ifdef ENOKEY
378 [ENOKEY] = TARGET_ENOKEY,
379 #endif
380 #ifdef EKEYEXPIRED
381 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
382 #endif
383 #ifdef EKEYREVOKED
384 [EKEYREVOKED] = TARGET_EKEYREVOKED,
385 #endif
386 #ifdef EKEYREJECTED
387 [EKEYREJECTED] = TARGET_EKEYREJECTED,
388 #endif
389 #ifdef EOWNERDEAD
390 [EOWNERDEAD] = TARGET_EOWNERDEAD,
391 #endif
392 #ifdef ENOTRECOVERABLE
393 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
394 #endif
395 };
396
397 static inline int host_to_target_errno(int err)
398 {
399 if(host_to_target_errno_table[err])
400 return host_to_target_errno_table[err];
401 return err;
402 }
403
404 static inline int target_to_host_errno(int err)
405 {
406 if (target_to_host_errno_table[err])
407 return target_to_host_errno_table[err];
408 return err;
409 }
410
411 static inline abi_long get_errno(abi_long ret)
412 {
413 if (ret == -1)
414 return -host_to_target_errno(errno);
415 else
416 return ret;
417 }
418
419 static inline int is_error(abi_long ret)
420 {
421 return (abi_ulong)ret >= (abi_ulong)(-4096);
422 }
423
424 char *target_strerror(int err)
425 {
426 return strerror(target_to_host_errno(err));
427 }
428
429 static abi_ulong target_brk;
430 static abi_ulong target_original_brk;
431
432 void target_set_brk(abi_ulong new_brk)
433 {
434 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
435 }
436
437 /* do_brk() must return target values and target errnos. */
438 abi_long do_brk(abi_ulong new_brk)
439 {
440 abi_ulong brk_page;
441 abi_long mapped_addr;
442 int new_alloc_size;
443
444 if (!new_brk)
445 return target_brk;
446 if (new_brk < target_original_brk)
447 return target_brk;
448
449 brk_page = HOST_PAGE_ALIGN(target_brk);
450
451 /* If the new brk is less than this, set it and we're done... */
452 if (new_brk < brk_page) {
453 target_brk = new_brk;
454 return target_brk;
455 }
456
457 /* We need to allocate more memory after the brk... */
458 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
459 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
460 PROT_READ|PROT_WRITE,
461 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));
462
463 if (!is_error(mapped_addr))
464 target_brk = new_brk;
465
466 return target_brk;
467 }
468
469 static inline abi_long copy_from_user_fdset(fd_set *fds,
470 abi_ulong target_fds_addr,
471 int n)
472 {
473 int i, nw, j, k;
474 abi_ulong b, *target_fds;
475
476 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
477 if (!(target_fds = lock_user(VERIFY_READ,
478 target_fds_addr,
479 sizeof(abi_ulong) * nw,
480 1)))
481 return -TARGET_EFAULT;
482
483 FD_ZERO(fds);
484 k = 0;
485 for (i = 0; i < nw; i++) {
486 /* grab the abi_ulong */
487 __get_user(b, &target_fds[i]);
488 for (j = 0; j < TARGET_ABI_BITS; j++) {
489 /* check the bit inside the abi_ulong */
490 if ((b >> j) & 1)
491 FD_SET(k, fds);
492 k++;
493 }
494 }
495
496 unlock_user(target_fds, target_fds_addr, 0);
497
498 return 0;
499 }
500
501 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
502 const fd_set *fds,
503 int n)
504 {
505 int i, nw, j, k;
506 abi_long v;
507 abi_ulong *target_fds;
508
509 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
510 if (!(target_fds = lock_user(VERIFY_WRITE,
511 target_fds_addr,
512 sizeof(abi_ulong) * nw,
513 0)))
514 return -TARGET_EFAULT;
515
516 k = 0;
517 for (i = 0; i < nw; i++) {
518 v = 0;
519 for (j = 0; j < TARGET_ABI_BITS; j++) {
520 v |= ((FD_ISSET(k, fds) != 0) << j);
521 k++;
522 }
523 __put_user(v, &target_fds[i]);
524 }
525
526 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
527
528 return 0;
529 }
530
531 #if defined(__alpha__)
532 #define HOST_HZ 1024
533 #else
534 #define HOST_HZ 100
535 #endif
536
537 static inline abi_long host_to_target_clock_t(long ticks)
538 {
539 #if HOST_HZ == TARGET_HZ
540 return ticks;
541 #else
542 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
543 #endif
544 }
545
546 static inline abi_long host_to_target_rusage(abi_ulong target_addr,
547 const struct rusage *rusage)
548 {
549 struct target_rusage *target_rusage;
550
551 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
552 return -TARGET_EFAULT;
553 target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec);
554 target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec);
555 target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec);
556 target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec);
557 target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss);
558 target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss);
559 target_rusage->ru_idrss = tswapl(rusage->ru_idrss);
560 target_rusage->ru_isrss = tswapl(rusage->ru_isrss);
561 target_rusage->ru_minflt = tswapl(rusage->ru_minflt);
562 target_rusage->ru_majflt = tswapl(rusage->ru_majflt);
563 target_rusage->ru_nswap = tswapl(rusage->ru_nswap);
564 target_rusage->ru_inblock = tswapl(rusage->ru_inblock);
565 target_rusage->ru_oublock = tswapl(rusage->ru_oublock);
566 target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd);
567 target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv);
568 target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals);
569 target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw);
570 target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw);
571 unlock_user_struct(target_rusage, target_addr, 1);
572
573 return 0;
574 }
575
576 static inline abi_long copy_from_user_timeval(struct timeval *tv,
577 abi_ulong target_tv_addr)
578 {
579 struct target_timeval *target_tv;
580
581 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
582 return -TARGET_EFAULT;
583
584 __get_user(tv->tv_sec, &target_tv->tv_sec);
585 __get_user(tv->tv_usec, &target_tv->tv_usec);
586
587 unlock_user_struct(target_tv, target_tv_addr, 0);
588
589 return 0;
590 }
591
592 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
593 const struct timeval *tv)
594 {
595 struct target_timeval *target_tv;
596
597 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
598 return -TARGET_EFAULT;
599
600 __put_user(tv->tv_sec, &target_tv->tv_sec);
601 __put_user(tv->tv_usec, &target_tv->tv_usec);
602
603 unlock_user_struct(target_tv, target_tv_addr, 1);
604
605 return 0;
606 }
607
608
609 /* do_select() must return target values and target errnos. */
610 static abi_long do_select(int n,
611 abi_ulong rfd_addr, abi_ulong wfd_addr,
612 abi_ulong efd_addr, abi_ulong target_tv_addr)
613 {
614 fd_set rfds, wfds, efds;
615 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
616 struct timeval tv, *tv_ptr;
617 abi_long ret;
618
619 if (rfd_addr) {
620 if (copy_from_user_fdset(&rfds, rfd_addr, n))
621 return -TARGET_EFAULT;
622 rfds_ptr = &rfds;
623 } else {
624 rfds_ptr = NULL;
625 }
626 if (wfd_addr) {
627 if (copy_from_user_fdset(&wfds, wfd_addr, n))
628 return -TARGET_EFAULT;
629 wfds_ptr = &wfds;
630 } else {
631 wfds_ptr = NULL;
632 }
633 if (efd_addr) {
634 if (copy_from_user_fdset(&efds, efd_addr, n))
635 return -TARGET_EFAULT;
636 efds_ptr = &efds;
637 } else {
638 efds_ptr = NULL;
639 }
640
641 if (target_tv_addr) {
642 if (copy_from_user_timeval(&tv, target_tv_addr))
643 return -TARGET_EFAULT;
644 tv_ptr = &tv;
645 } else {
646 tv_ptr = NULL;
647 }
648
649 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
650
651 if (!is_error(ret)) {
652 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
653 return -TARGET_EFAULT;
654 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
655 return -TARGET_EFAULT;
656 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
657 return -TARGET_EFAULT;
658
659 if (target_tv_addr && copy_to_user_timeval(target_tv_addr, &tv))
660 return -TARGET_EFAULT;
661 }
662
663 return ret;
664 }
665
666 static inline abi_long target_to_host_sockaddr(struct sockaddr *addr,
667 abi_ulong target_addr,
668 socklen_t len)
669 {
670 struct target_sockaddr *target_saddr;
671
672 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
673 if (!target_saddr)
674 return -TARGET_EFAULT;
675 memcpy(addr, target_saddr, len);
676 addr->sa_family = tswap16(target_saddr->sa_family);
677 unlock_user(target_saddr, target_addr, 0);
678
679 return 0;
680 }
681
682 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
683 struct sockaddr *addr,
684 socklen_t len)
685 {
686 struct target_sockaddr *target_saddr;
687
688 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
689 if (!target_saddr)
690 return -TARGET_EFAULT;
691 memcpy(target_saddr, addr, len);
692 target_saddr->sa_family = tswap16(addr->sa_family);
693 unlock_user(target_saddr, target_addr, len);
694
695 return 0;
696 }
697
698 /* ??? Should this also swap msgh->name? */
699 static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
700 struct target_msghdr *target_msgh)
701 {
702 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
703 abi_long msg_controllen;
704 abi_ulong target_cmsg_addr;
705 struct target_cmsghdr *target_cmsg;
706 socklen_t space = 0;
707
708 msg_controllen = tswapl(target_msgh->msg_controllen);
709 if (msg_controllen < sizeof (struct target_cmsghdr))
710 goto the_end;
711 target_cmsg_addr = tswapl(target_msgh->msg_control);
712 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
713 if (!target_cmsg)
714 return -TARGET_EFAULT;
715
716 while (cmsg && target_cmsg) {
717 void *data = CMSG_DATA(cmsg);
718 void *target_data = TARGET_CMSG_DATA(target_cmsg);
719
720 int len = tswapl(target_cmsg->cmsg_len)
721 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
722
723 space += CMSG_SPACE(len);
724 if (space > msgh->msg_controllen) {
725 space -= CMSG_SPACE(len);
726 gemu_log("Host cmsg overflow\n");
727 break;
728 }
729
730 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
731 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
732 cmsg->cmsg_len = CMSG_LEN(len);
733
734 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
735 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
736 memcpy(data, target_data, len);
737 } else {
738 int *fd = (int *)data;
739 int *target_fd = (int *)target_data;
740 int i, numfds = len / sizeof(int);
741
742 for (i = 0; i < numfds; i++)
743 fd[i] = tswap32(target_fd[i]);
744 }
745
746 cmsg = CMSG_NXTHDR(msgh, cmsg);
747 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
748 }
749 unlock_user(target_cmsg, target_cmsg_addr, 0);
750 the_end:
751 msgh->msg_controllen = space;
752 return 0;
753 }
754
755 /* ??? Should this also swap msgh->name? */
756 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
757 struct msghdr *msgh)
758 {
759 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
760 abi_long msg_controllen;
761 abi_ulong target_cmsg_addr;
762 struct target_cmsghdr *target_cmsg;
763 socklen_t space = 0;
764
765 msg_controllen = tswapl(target_msgh->msg_controllen);
766 if (msg_controllen < sizeof (struct target_cmsghdr))
767 goto the_end;
768 target_cmsg_addr = tswapl(target_msgh->msg_control);
769 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
770 if (!target_cmsg)
771 return -TARGET_EFAULT;
772
773 while (cmsg && target_cmsg) {
774 void *data = CMSG_DATA(cmsg);
775 void *target_data = TARGET_CMSG_DATA(target_cmsg);
776
777 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
778
779 space += TARGET_CMSG_SPACE(len);
780 if (space > msg_controllen) {
781 space -= TARGET_CMSG_SPACE(len);
782 gemu_log("Target cmsg overflow\n");
783 break;
784 }
785
786 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
787 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
788 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
789
790 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
791 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
792 memcpy(target_data, data, len);
793 } else {
794 int *fd = (int *)data;
795 int *target_fd = (int *)target_data;
796 int i, numfds = len / sizeof(int);
797
798 for (i = 0; i < numfds; i++)
799 target_fd[i] = tswap32(fd[i]);
800 }
801
802 cmsg = CMSG_NXTHDR(msgh, cmsg);
803 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
804 }
805 unlock_user(target_cmsg, target_cmsg_addr, space);
806 the_end:
807 target_msgh->msg_controllen = tswapl(space);
808 return 0;
809 }
810
811 /* do_setsockopt() Must return target values and target errnos. */
812 static abi_long do_setsockopt(int sockfd, int level, int optname,
813 abi_ulong optval_addr, socklen_t optlen)
814 {
815 abi_long ret;
816 int val;
817
818 switch(level) {
819 case SOL_TCP:
820 /* TCP options all take an 'int' value. */
821 if (optlen < sizeof(uint32_t))
822 return -TARGET_EINVAL;
823
824 if (get_user_u32(val, optval_addr))
825 return -TARGET_EFAULT;
826 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
827 break;
828 case SOL_IP:
829 switch(optname) {
830 case IP_TOS:
831 case IP_TTL:
832 case IP_HDRINCL:
833 case IP_ROUTER_ALERT:
834 case IP_RECVOPTS:
835 case IP_RETOPTS:
836 case IP_PKTINFO:
837 case IP_MTU_DISCOVER:
838 case IP_RECVERR:
839 case IP_RECVTOS:
840 #ifdef IP_FREEBIND
841 case IP_FREEBIND:
842 #endif
843 case IP_MULTICAST_TTL:
844 case IP_MULTICAST_LOOP:
845 val = 0;
846 if (optlen >= sizeof(uint32_t)) {
847 if (get_user_u32(val, optval_addr))
848 return -TARGET_EFAULT;
849 } else if (optlen >= 1) {
850 if (get_user_u8(val, optval_addr))
851 return -TARGET_EFAULT;
852 }
853 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
854 break;
855 default:
856 goto unimplemented;
857 }
858 break;
859 case TARGET_SOL_SOCKET:
860 switch (optname) {
861 /* Options with 'int' argument. */
862 case TARGET_SO_DEBUG:
863 optname = SO_DEBUG;
864 break;
865 case TARGET_SO_REUSEADDR:
866 optname = SO_REUSEADDR;
867 break;
868 case TARGET_SO_TYPE:
869 optname = SO_TYPE;
870 break;
871 case TARGET_SO_ERROR:
872 optname = SO_ERROR;
873 break;
874 case TARGET_SO_DONTROUTE:
875 optname = SO_DONTROUTE;
876 break;
877 case TARGET_SO_BROADCAST:
878 optname = SO_BROADCAST;
879 break;
880 case TARGET_SO_SNDBUF:
881 optname = SO_SNDBUF;
882 break;
883 case TARGET_SO_RCVBUF:
884 optname = SO_RCVBUF;
885 break;
886 case TARGET_SO_KEEPALIVE:
887 optname = SO_KEEPALIVE;
888 break;
889 case TARGET_SO_OOBINLINE:
890 optname = SO_OOBINLINE;
891 break;
892 case TARGET_SO_NO_CHECK:
893 optname = SO_NO_CHECK;
894 break;
895 case TARGET_SO_PRIORITY:
896 optname = SO_PRIORITY;
897 break;
898 #ifdef SO_BSDCOMPAT
899 case TARGET_SO_BSDCOMPAT:
900 optname = SO_BSDCOMPAT;
901 break;
902 #endif
903 case TARGET_SO_PASSCRED:
904 optname = SO_PASSCRED;
905 break;
906 case TARGET_SO_TIMESTAMP:
907 optname = SO_TIMESTAMP;
908 break;
909 case TARGET_SO_RCVLOWAT:
910 optname = SO_RCVLOWAT;
911 break;
912 case TARGET_SO_RCVTIMEO:
913 optname = SO_RCVTIMEO;
914 break;
915 case TARGET_SO_SNDTIMEO:
916 optname = SO_SNDTIMEO;
917 break;
918 break;
919 default:
920 goto unimplemented;
921 }
922 if (optlen < sizeof(uint32_t))
923 return -TARGET_EINVAL;
924
925 if (get_user_u32(val, optval_addr))
926 return -TARGET_EFAULT;
927 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
928 break;
929 default:
930 unimplemented:
931 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
932 ret = -TARGET_ENOPROTOOPT;
933 }
934 return ret;
935 }
936
937 /* do_getsockopt() Must return target values and target errnos. */
938 static abi_long do_getsockopt(int sockfd, int level, int optname,
939 abi_ulong optval_addr, abi_ulong optlen)
940 {
941 abi_long ret;
942 int len, lv, val;
943
944 switch(level) {
945 case TARGET_SOL_SOCKET:
946 level = SOL_SOCKET;
947 switch (optname) {
948 case TARGET_SO_LINGER:
949 case TARGET_SO_RCVTIMEO:
950 case TARGET_SO_SNDTIMEO:
951 case TARGET_SO_PEERCRED:
952 case TARGET_SO_PEERNAME:
953 /* These don't just return a single integer */
954 goto unimplemented;
955 default:
956 goto int_case;
957 }
958 break;
959 case SOL_TCP:
960 /* TCP options all take an 'int' value. */
961 int_case:
962 if (get_user_u32(len, optlen))
963 return -TARGET_EFAULT;
964 if (len < 0)
965 return -TARGET_EINVAL;
966 lv = sizeof(int);
967 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
968 if (ret < 0)
969 return ret;
970 val = tswap32(val);
971 if (len > lv)
972 len = lv;
973 if (len == 4) {
974 if (put_user_u32(val, optval_addr))
975 return -TARGET_EFAULT;
976 } else {
977 if (put_user_u8(val, optval_addr))
978 return -TARGET_EFAULT;
979 }
980 if (put_user_u32(len, optlen))
981 return -TARGET_EFAULT;
982 break;
983 case SOL_IP:
984 switch(optname) {
985 case IP_TOS:
986 case IP_TTL:
987 case IP_HDRINCL:
988 case IP_ROUTER_ALERT:
989 case IP_RECVOPTS:
990 case IP_RETOPTS:
991 case IP_PKTINFO:
992 case IP_MTU_DISCOVER:
993 case IP_RECVERR:
994 case IP_RECVTOS:
995 #ifdef IP_FREEBIND
996 case IP_FREEBIND:
997 #endif
998 case IP_MULTICAST_TTL:
999 case IP_MULTICAST_LOOP:
1000 if (get_user_u32(len, optlen))
1001 return -TARGET_EFAULT;
1002 if (len < 0)
1003 return -TARGET_EINVAL;
1004 lv = sizeof(int);
1005 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
1006 if (ret < 0)
1007 return ret;
1008 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
1009 len = 1;
1010 if (put_user_u32(len, optlen)
1011 || put_user_u8(val, optval_addr))
1012 return -TARGET_EFAULT;
1013 } else {
1014 if (len > sizeof(int))
1015 len = sizeof(int);
1016 if (put_user_u32(len, optlen)
1017 || put_user_u32(val, optval_addr))
1018 return -TARGET_EFAULT;
1019 }
1020 break;
1021 default:
1022 ret = -TARGET_ENOPROTOOPT;
1023 break;
1024 }
1025 break;
1026 default:
1027 unimplemented:
1028 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1029 level, optname);
1030 ret = -TARGET_EOPNOTSUPP;
1031 break;
1032 }
1033 return ret;
1034 }
1035
1036 /* FIXME
1037 * lock_iovec()/unlock_iovec() have a return code of 0 for success where
1038 * other lock functions have a return code of 0 for failure.
1039 */
1040 static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
1041 int count, int copy)
1042 {
1043 struct target_iovec *target_vec;
1044 abi_ulong base;
1045 int i, j;
1046
1047 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1048 if (!target_vec)
1049 return -TARGET_EFAULT;
1050 for(i = 0;i < count; i++) {
1051 base = tswapl(target_vec[i].iov_base);
1052 vec[i].iov_len = tswapl(target_vec[i].iov_len);
1053 if (vec[i].iov_len != 0) {
1054 vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
1055 if (!vec[i].iov_base && vec[i].iov_len)
1056 goto fail;
1057 } else {
1058 /* zero length pointer is ignored */
1059 vec[i].iov_base = NULL;
1060 }
1061 }
1062 unlock_user (target_vec, target_addr, 0);
1063 return 0;
1064 fail:
1065 /* failure - unwind locks */
1066 for (j = 0; j < i; j++) {
1067 base = tswapl(target_vec[j].iov_base);
1068 unlock_user(vec[j].iov_base, base, 0);
1069 }
1070 unlock_user (target_vec, target_addr, 0);
1071 return -TARGET_EFAULT;
1072 }
1073
1074 static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
1075 int count, int copy)
1076 {
1077 struct target_iovec *target_vec;
1078 abi_ulong base;
1079 int i;
1080
1081 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1082 if (!target_vec)
1083 return -TARGET_EFAULT;
1084 for(i = 0;i < count; i++) {
1085 base = tswapl(target_vec[i].iov_base);
1086 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
1087 }
1088 unlock_user (target_vec, target_addr, 0);
1089
1090 return 0;
1091 }
1092
1093 /* do_socket() Must return target values and target errnos. */
1094 static abi_long do_socket(int domain, int type, int protocol)
1095 {
1096 #if defined(TARGET_MIPS)
1097 switch(type) {
1098 case TARGET_SOCK_DGRAM:
1099 type = SOCK_DGRAM;
1100 break;
1101 case TARGET_SOCK_STREAM:
1102 type = SOCK_STREAM;
1103 break;
1104 case TARGET_SOCK_RAW:
1105 type = SOCK_RAW;
1106 break;
1107 case TARGET_SOCK_RDM:
1108 type = SOCK_RDM;
1109 break;
1110 case TARGET_SOCK_SEQPACKET:
1111 type = SOCK_SEQPACKET;
1112 break;
1113 case TARGET_SOCK_PACKET:
1114 type = SOCK_PACKET;
1115 break;
1116 }
1117 #endif
1118 if (domain == PF_NETLINK)
1119 return -EAFNOSUPPORT; /* do not NETLINK socket connections possible */
1120 return get_errno(socket(domain, type, protocol));
1121 }
1122
1123 /* do_bind() Must return target values and target errnos. */
1124 static abi_long do_bind(int sockfd, abi_ulong target_addr,
1125 socklen_t addrlen)
1126 {
1127 void *addr = alloca(addrlen);
1128
1129 target_to_host_sockaddr(addr, target_addr, addrlen);
1130 return get_errno(bind(sockfd, addr, addrlen));
1131 }
1132
1133 /* do_connect() Must return target values and target errnos. */
1134 static abi_long do_connect(int sockfd, abi_ulong target_addr,
1135 socklen_t addrlen)
1136 {
1137 void *addr = alloca(addrlen);
1138
1139 target_to_host_sockaddr(addr, target_addr, addrlen);
1140 return get_errno(connect(sockfd, addr, addrlen));
1141 }
1142
1143 /* do_sendrecvmsg() Must return target values and target errnos. */
1144 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
1145 int flags, int send)
1146 {
1147 abi_long ret;
1148 struct target_msghdr *msgp;
1149 struct msghdr msg;
1150 int count;
1151 struct iovec *vec;
1152 abi_ulong target_vec;
1153
1154 /* FIXME */
1155 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
1156 msgp,
1157 target_msg,
1158 send ? 1 : 0))
1159 return -TARGET_EFAULT;
1160 if (msgp->msg_name) {
1161 msg.msg_namelen = tswap32(msgp->msg_namelen);
1162 msg.msg_name = alloca(msg.msg_namelen);
1163 target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name),
1164 msg.msg_namelen);
1165 } else {
1166 msg.msg_name = NULL;
1167 msg.msg_namelen = 0;
1168 }
1169 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
1170 msg.msg_control = alloca(msg.msg_controllen);
1171 msg.msg_flags = tswap32(msgp->msg_flags);
1172
1173 count = tswapl(msgp->msg_iovlen);
1174 vec = alloca(count * sizeof(struct iovec));
1175 target_vec = tswapl(msgp->msg_iov);
1176 lock_iovec(send ? VERIFY_READ : VERIFY_WRITE, vec, target_vec, count, send);
1177 msg.msg_iovlen = count;
1178 msg.msg_iov = vec;
1179
1180 if (send) {
1181 ret = target_to_host_cmsg(&msg, msgp);
1182 if (ret == 0)
1183 ret = get_errno(sendmsg(fd, &msg, flags));
1184 } else {
1185 ret = get_errno(recvmsg(fd, &msg, flags));
1186 if (!is_error(ret))
1187 ret = host_to_target_cmsg(msgp, &msg);
1188 }
1189 unlock_iovec(vec, target_vec, count, !send);
1190 unlock_user_struct(msgp, target_msg, send ? 0 : 1);
1191 return ret;
1192 }
1193
1194 /* do_accept() Must return target values and target errnos. */
1195 static abi_long do_accept(int fd, abi_ulong target_addr,
1196 abi_ulong target_addrlen_addr)
1197 {
1198 socklen_t addrlen;
1199 void *addr;
1200 abi_long ret;
1201
1202 if (get_user_u32(addrlen, target_addrlen_addr))
1203 return -TARGET_EFAULT;
1204
1205 addr = alloca(addrlen);
1206
1207 ret = get_errno(accept(fd, addr, &addrlen));
1208 if (!is_error(ret)) {
1209 host_to_target_sockaddr(target_addr, addr, addrlen);
1210 if (put_user_u32(addrlen, target_addrlen_addr))
1211 ret = -TARGET_EFAULT;
1212 }
1213 return ret;
1214 }
1215
1216 /* do_getpeername() Must return target values and target errnos. */
1217 static abi_long do_getpeername(int fd, abi_ulong target_addr,
1218 abi_ulong target_addrlen_addr)
1219 {
1220 socklen_t addrlen;
1221 void *addr;
1222 abi_long ret;
1223
1224 if (get_user_u32(addrlen, target_addrlen_addr))
1225 return -TARGET_EFAULT;
1226
1227 addr = alloca(addrlen);
1228
1229 ret = get_errno(getpeername(fd, addr, &addrlen));
1230 if (!is_error(ret)) {
1231 host_to_target_sockaddr(target_addr, addr, addrlen);
1232 if (put_user_u32(addrlen, target_addrlen_addr))
1233 ret = -TARGET_EFAULT;
1234 }
1235 return ret;
1236 }
1237
1238 /* do_getsockname() Must return target values and target errnos. */
1239 static abi_long do_getsockname(int fd, abi_ulong target_addr,
1240 abi_ulong target_addrlen_addr)
1241 {
1242 socklen_t addrlen;
1243 void *addr;
1244 abi_long ret;
1245
1246 if (get_user_u32(addrlen, target_addrlen_addr))
1247 return -TARGET_EFAULT;
1248
1249 addr = alloca(addrlen);
1250
1251 ret = get_errno(getsockname(fd, addr, &addrlen));
1252 if (!is_error(ret)) {
1253 host_to_target_sockaddr(target_addr, addr, addrlen);
1254 if (put_user_u32(addrlen, target_addrlen_addr))
1255 ret = -TARGET_EFAULT;
1256 }
1257 return ret;
1258 }
1259
1260 /* do_socketpair() Must return target values and target errnos. */
1261 static abi_long do_socketpair(int domain, int type, int protocol,
1262 abi_ulong target_tab_addr)
1263 {
1264 int tab[2];
1265 abi_long ret;
1266
1267 ret = get_errno(socketpair(domain, type, protocol, tab));
1268 if (!is_error(ret)) {
1269 if (put_user_s32(tab[0], target_tab_addr)
1270 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
1271 ret = -TARGET_EFAULT;
1272 }
1273 return ret;
1274 }
1275
1276 /* do_sendto() Must return target values and target errnos. */
1277 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
1278 abi_ulong target_addr, socklen_t addrlen)
1279 {
1280 void *addr;
1281 void *host_msg;
1282 abi_long ret;
1283
1284 host_msg = lock_user(VERIFY_READ, msg, len, 1);
1285 if (!host_msg)
1286 return -TARGET_EFAULT;
1287 if (target_addr) {
1288 addr = alloca(addrlen);
1289 target_to_host_sockaddr(addr, target_addr, addrlen);
1290 ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen));
1291 } else {
1292 ret = get_errno(send(fd, host_msg, len, flags));
1293 }
1294 unlock_user(host_msg, msg, 0);
1295 return ret;
1296 }
1297
1298 /* do_recvfrom() Must return target values and target errnos. */
1299 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
1300 abi_ulong target_addr,
1301 abi_ulong target_addrlen)
1302 {
1303 socklen_t addrlen;
1304 void *addr;
1305 void *host_msg;
1306 abi_long ret;
1307
1308 host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
1309 if (!host_msg)
1310 return -TARGET_EFAULT;
1311 if (target_addr) {
1312 if (get_user_u32(addrlen, target_addrlen)) {
1313 ret = -TARGET_EFAULT;
1314 goto fail;
1315 }
1316 addr = alloca(addrlen);
1317 ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen));
1318 } else {
1319 addr = NULL; /* To keep compiler quiet. */
1320 ret = get_errno(recv(fd, host_msg, len, flags));
1321 }
1322 if (!is_error(ret)) {
1323 if (target_addr) {
1324 host_to_target_sockaddr(target_addr, addr, addrlen);
1325 if (put_user_u32(addrlen, target_addrlen)) {
1326 ret = -TARGET_EFAULT;
1327 goto fail;
1328 }
1329 }
1330 unlock_user(host_msg, msg, len);
1331 } else {
1332 fail:
1333 unlock_user(host_msg, msg, 0);
1334 }
1335 return ret;
1336 }
1337
1338 #ifdef TARGET_NR_socketcall
1339 /* do_socketcall() Must return target values and target errnos. */
1340 static abi_long do_socketcall(int num, abi_ulong vptr)
1341 {
1342 abi_long ret;
1343 const int n = sizeof(abi_ulong);
1344
1345 switch(num) {
1346 case SOCKOP_socket:
1347 {
1348 int domain, type, protocol;
1349
1350 if (get_user_s32(domain, vptr)
1351 || get_user_s32(type, vptr + n)
1352 || get_user_s32(protocol, vptr + 2 * n))
1353 return -TARGET_EFAULT;
1354
1355 ret = do_socket(domain, type, protocol);
1356 }
1357 break;
1358 case SOCKOP_bind:
1359 {
1360 int sockfd;
1361 abi_ulong target_addr;
1362 socklen_t addrlen;
1363
1364 if (get_user_s32(sockfd, vptr)
1365 || get_user_ual(target_addr, vptr + n)
1366 || get_user_u32(addrlen, vptr + 2 * n))
1367 return -TARGET_EFAULT;
1368
1369 ret = do_bind(sockfd, target_addr, addrlen);
1370 }
1371 break;
1372 case SOCKOP_connect:
1373 {
1374 int sockfd;
1375 abi_ulong target_addr;
1376 socklen_t addrlen;
1377
1378 if (get_user_s32(sockfd, vptr)
1379 || get_user_ual(target_addr, vptr + n)
1380 || get_user_u32(addrlen, vptr + 2 * n))
1381 return -TARGET_EFAULT;
1382
1383 ret = do_connect(sockfd, target_addr, addrlen);
1384 }
1385 break;
1386 case SOCKOP_listen:
1387 {
1388 int sockfd, backlog;
1389
1390 if (get_user_s32(sockfd, vptr)
1391 || get_user_s32(backlog, vptr + n))
1392 return -TARGET_EFAULT;
1393
1394 ret = get_errno(listen(sockfd, backlog));
1395 }
1396 break;
1397 case SOCKOP_accept:
1398 {
1399 int sockfd;
1400 abi_ulong target_addr, target_addrlen;
1401
1402 if (get_user_s32(sockfd, vptr)
1403 || get_user_ual(target_addr, vptr + n)
1404 || get_user_u32(target_addrlen, vptr + 2 * n))
1405 return -TARGET_EFAULT;
1406
1407 ret = do_accept(sockfd, target_addr, target_addrlen);
1408 }
1409 break;
1410 case SOCKOP_getsockname:
1411 {
1412 int sockfd;
1413 abi_ulong target_addr, target_addrlen;
1414
1415 if (get_user_s32(sockfd, vptr)
1416 || get_user_ual(target_addr, vptr + n)
1417 || get_user_u32(target_addrlen, vptr + 2 * n))
1418 return -TARGET_EFAULT;
1419
1420 ret = do_getsockname(sockfd, target_addr, target_addrlen);
1421 }
1422 break;
1423 case SOCKOP_getpeername:
1424 {
1425 int sockfd;
1426 abi_ulong target_addr, target_addrlen;
1427
1428 if (get_user_s32(sockfd, vptr)
1429 || get_user_ual(target_addr, vptr + n)
1430 || get_user_u32(target_addrlen, vptr + 2 * n))
1431 return -TARGET_EFAULT;
1432
1433 ret = do_getpeername(sockfd, target_addr, target_addrlen);
1434 }
1435 break;
1436 case SOCKOP_socketpair:
1437 {
1438 int domain, type, protocol;
1439 abi_ulong tab;
1440
1441 if (get_user_s32(domain, vptr)
1442 || get_user_s32(type, vptr + n)
1443 || get_user_s32(protocol, vptr + 2 * n)
1444 || get_user_ual(tab, vptr + 3 * n))
1445 return -TARGET_EFAULT;
1446
1447 ret = do_socketpair(domain, type, protocol, tab);
1448 }
1449 break;
1450 case SOCKOP_send:
1451 {
1452 int sockfd;
1453 abi_ulong msg;
1454 size_t len;
1455 int flags;
1456
1457 if (get_user_s32(sockfd, vptr)
1458 || get_user_ual(msg, vptr + n)
1459 || get_user_ual(len, vptr + 2 * n)
1460 || get_user_s32(flags, vptr + 3 * n))
1461 return -TARGET_EFAULT;
1462
1463 ret = do_sendto(sockfd, msg, len, flags, 0, 0);
1464 }
1465 break;
1466 case SOCKOP_recv:
1467 {
1468 int sockfd;
1469 abi_ulong msg;
1470 size_t len;
1471 int flags;
1472
1473 if (get_user_s32(sockfd, vptr)
1474 || get_user_ual(msg, vptr + n)
1475 || get_user_ual(len, vptr + 2 * n)
1476 || get_user_s32(flags, vptr + 3 * n))
1477 return -TARGET_EFAULT;
1478
1479 ret = do_recvfrom(sockfd, msg, len, flags, 0, 0);
1480 }
1481 break;
1482 case SOCKOP_sendto:
1483 {
1484 int sockfd;
1485 abi_ulong msg;
1486 size_t len;
1487 int flags;
1488 abi_ulong addr;
1489 socklen_t addrlen;
1490
1491 if (get_user_s32(sockfd, vptr)
1492 || get_user_ual(msg, vptr + n)
1493 || get_user_ual(len, vptr + 2 * n)
1494 || get_user_s32(flags, vptr + 3 * n)
1495 || get_user_ual(addr, vptr + 4 * n)
1496 || get_user_u32(addrlen, vptr + 5 * n))
1497 return -TARGET_EFAULT;
1498
1499 ret = do_sendto(sockfd, msg, len, flags, addr, addrlen);
1500 }
1501 break;
1502 case SOCKOP_recvfrom:
1503 {
1504 int sockfd;
1505 abi_ulong msg;
1506 size_t len;
1507 int flags;
1508 abi_ulong addr;
1509 socklen_t addrlen;
1510
1511 if (get_user_s32(sockfd, vptr)
1512 || get_user_ual(msg, vptr + n)
1513 || get_user_ual(len, vptr + 2 * n)
1514 || get_user_s32(flags, vptr + 3 * n)
1515 || get_user_ual(addr, vptr + 4 * n)
1516 || get_user_u32(addrlen, vptr + 5 * n))
1517 return -TARGET_EFAULT;
1518
1519 ret = do_recvfrom(sockfd, msg, len, flags, addr, addrlen);
1520 }
1521 break;
1522 case SOCKOP_shutdown:
1523 {
1524 int sockfd, how;
1525
1526 if (get_user_s32(sockfd, vptr)
1527 || get_user_s32(how, vptr + n))
1528 return -TARGET_EFAULT;
1529
1530 ret = get_errno(shutdown(sockfd, how));
1531 }
1532 break;
1533 case SOCKOP_sendmsg:
1534 case SOCKOP_recvmsg:
1535 {
1536 int fd;
1537 abi_ulong target_msg;
1538 int flags;
1539
1540 if (get_user_s32(fd, vptr)
1541 || get_user_ual(target_msg, vptr + n)
1542 || get_user_s32(flags, vptr + 2 * n))
1543 return -TARGET_EFAULT;
1544
1545 ret = do_sendrecvmsg(fd, target_msg, flags,
1546 (num == SOCKOP_sendmsg));
1547 }
1548 break;
1549 case SOCKOP_setsockopt:
1550 {
1551 int sockfd;
1552 int level;
1553 int optname;
1554 abi_ulong optval;
1555 socklen_t optlen;
1556
1557 if (get_user_s32(sockfd, vptr)
1558 || get_user_s32(level, vptr + n)
1559 || get_user_s32(optname, vptr + 2 * n)
1560 || get_user_ual(optval, vptr + 3 * n)
1561 || get_user_u32(optlen, vptr + 4 * n))
1562 return -TARGET_EFAULT;
1563
1564 ret = do_setsockopt(sockfd, level, optname, optval, optlen);
1565 }
1566 break;
1567 case SOCKOP_getsockopt:
1568 {
1569 int sockfd;
1570 int level;
1571 int optname;
1572 abi_ulong optval;
1573 socklen_t optlen;
1574
1575 if (get_user_s32(sockfd, vptr)
1576 || get_user_s32(level, vptr + n)
1577 || get_user_s32(optname, vptr + 2 * n)
1578 || get_user_ual(optval, vptr + 3 * n)
1579 || get_user_u32(optlen, vptr + 4 * n))
1580 return -TARGET_EFAULT;
1581
1582 ret = do_getsockopt(sockfd, level, optname, optval, optlen);
1583 }
1584 break;
1585 default:
1586 gemu_log("Unsupported socketcall: %d\n", num);
1587 ret = -TARGET_ENOSYS;
1588 break;
1589 }
1590 return ret;
1591 }
1592 #endif
1593
1594 #ifdef TARGET_NR_ipc
1595 #define N_SHM_REGIONS 32
1596
1597 static struct shm_region {
1598 abi_ulong start;
1599 abi_ulong size;
1600 } shm_regions[N_SHM_REGIONS];
1601
1602 struct target_ipc_perm
1603 {
1604 abi_long __key;
1605 abi_ulong uid;
1606 abi_ulong gid;
1607 abi_ulong cuid;
1608 abi_ulong cgid;
1609 unsigned short int mode;
1610 unsigned short int __pad1;
1611 unsigned short int __seq;
1612 unsigned short int __pad2;
1613 abi_ulong __unused1;
1614 abi_ulong __unused2;
1615 };
1616
1617 struct target_semid_ds
1618 {
1619 struct target_ipc_perm sem_perm;
1620 abi_ulong sem_otime;
1621 abi_ulong __unused1;
1622 abi_ulong sem_ctime;
1623 abi_ulong __unused2;
1624 abi_ulong sem_nsems;
1625 abi_ulong __unused3;
1626 abi_ulong __unused4;
1627 };
1628
1629 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
1630 abi_ulong target_addr)
1631 {
1632 struct target_ipc_perm *target_ip;
1633 struct target_semid_ds *target_sd;
1634
1635 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1636 return -TARGET_EFAULT;
1637 target_ip=&(target_sd->sem_perm);
1638 host_ip->__key = tswapl(target_ip->__key);
1639 host_ip->uid = tswapl(target_ip->uid);
1640 host_ip->gid = tswapl(target_ip->gid);
1641 host_ip->cuid = tswapl(target_ip->cuid);
1642 host_ip->cgid = tswapl(target_ip->cgid);
1643 host_ip->mode = tswapl(target_ip->mode);
1644 unlock_user_struct(target_sd, target_addr, 0);
1645 return 0;
1646 }
1647
1648 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
1649 struct ipc_perm *host_ip)
1650 {
1651 struct target_ipc_perm *target_ip;
1652 struct target_semid_ds *target_sd;
1653
1654 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1655 return -TARGET_EFAULT;
1656 target_ip = &(target_sd->sem_perm);
1657 target_ip->__key = tswapl(host_ip->__key);
1658 target_ip->uid = tswapl(host_ip->uid);
1659 target_ip->gid = tswapl(host_ip->gid);
1660 target_ip->cuid = tswapl(host_ip->cuid);
1661 target_ip->cgid = tswapl(host_ip->cgid);
1662 target_ip->mode = tswapl(host_ip->mode);
1663 unlock_user_struct(target_sd, target_addr, 1);
1664 return 0;
1665 }
1666
1667 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
1668 abi_ulong target_addr)
1669 {
1670 struct target_semid_ds *target_sd;
1671
1672 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1673 return -TARGET_EFAULT;
1674 target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1675 host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1676 host_sd->sem_otime = tswapl(target_sd->sem_otime);
1677 host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1678 unlock_user_struct(target_sd, target_addr, 0);
1679 return 0;
1680 }
1681
1682 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
1683 struct semid_ds *host_sd)
1684 {
1685 struct target_semid_ds *target_sd;
1686
1687 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1688 return -TARGET_EFAULT;
1689 host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1690 target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1691 target_sd->sem_otime = tswapl(host_sd->sem_otime);
1692 target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1693 unlock_user_struct(target_sd, target_addr, 1);
1694 return 0;
1695 }
1696
1697 union semun {
1698 int val;
1699 struct semid_ds *buf;
1700 unsigned short *array;
1701 };
1702
1703 union target_semun {
1704 int val;
1705 abi_long buf;
1706 unsigned short int *array;
1707 };
1708
1709 static inline abi_long target_to_host_semun(int cmd,
1710 union semun *host_su,
1711 abi_ulong target_addr,
1712 struct semid_ds *ds)
1713 {
1714 union target_semun *target_su;
1715
1716 switch( cmd ) {
1717 case IPC_STAT:
1718 case IPC_SET:
1719 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1720 return -TARGET_EFAULT;
1721 target_to_host_semid_ds(ds,target_su->buf);
1722 host_su->buf = ds;
1723 unlock_user_struct(target_su, target_addr, 0);
1724 break;
1725 case GETVAL:
1726 case SETVAL:
1727 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1728 return -TARGET_EFAULT;
1729 host_su->val = tswapl(target_su->val);
1730 unlock_user_struct(target_su, target_addr, 0);
1731 break;
1732 case GETALL:
1733 case SETALL:
1734 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1735 return -TARGET_EFAULT;
1736 *host_su->array = tswap16(*target_su->array);
1737 unlock_user_struct(target_su, target_addr, 0);
1738 break;
1739 default:
1740 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1741 }
1742 return 0;
1743 }
1744
1745 static inline abi_long host_to_target_semun(int cmd,
1746 abi_ulong target_addr,
1747 union semun *host_su,
1748 struct semid_ds *ds)
1749 {
1750 union target_semun *target_su;
1751
1752 switch( cmd ) {
1753 case IPC_STAT:
1754 case IPC_SET:
1755 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1756 return -TARGET_EFAULT;
1757 host_to_target_semid_ds(target_su->buf,ds);
1758 unlock_user_struct(target_su, target_addr, 1);
1759 break;
1760 case GETVAL:
1761 case SETVAL:
1762 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1763 return -TARGET_EFAULT;
1764 target_su->val = tswapl(host_su->val);
1765 unlock_user_struct(target_su, target_addr, 1);
1766 break;
1767 case GETALL:
1768 case SETALL:
1769 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1770 return -TARGET_EFAULT;
1771 *target_su->array = tswap16(*host_su->array);
1772 unlock_user_struct(target_su, target_addr, 1);
1773 break;
1774 default:
1775 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1776 }
1777 return 0;
1778 }
1779
1780 static inline abi_long do_semctl(int first, int second, int third,
1781 abi_long ptr)
1782 {
1783 union semun arg;
1784 struct semid_ds dsarg;
1785 int cmd = third&0xff;
1786 abi_long ret = 0;
1787
1788 switch( cmd ) {
1789 case GETVAL:
1790 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1791 ret = get_errno(semctl(first, second, cmd, arg));
1792 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1793 break;
1794 case SETVAL:
1795 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1796 ret = get_errno(semctl(first, second, cmd, arg));
1797 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1798 break;
1799 case GETALL:
1800 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1801 ret = get_errno(semctl(first, second, cmd, arg));
1802 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1803 break;
1804 case SETALL:
1805 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1806 ret = get_errno(semctl(first, second, cmd, arg));
1807 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1808 break;
1809 case IPC_STAT:
1810 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1811 ret = get_errno(semctl(first, second, cmd, arg));
1812 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1813 break;
1814 case IPC_SET:
1815 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1816 ret = get_errno(semctl(first, second, cmd, arg));
1817 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1818 break;
1819 default:
1820 ret = get_errno(semctl(first, second, cmd, arg));
1821 }
1822
1823 return ret;
1824 }
1825
1826 struct target_msqid_ds
1827 {
1828 struct target_ipc_perm msg_perm;
1829 abi_ulong msg_stime;
1830 abi_ulong __unused1;
1831 abi_ulong msg_rtime;
1832 abi_ulong __unused2;
1833 abi_ulong msg_ctime;
1834 abi_ulong __unused3;
1835 abi_ulong __msg_cbytes;
1836 abi_ulong msg_qnum;
1837 abi_ulong msg_qbytes;
1838 abi_ulong msg_lspid;
1839 abi_ulong msg_lrpid;
1840 abi_ulong __unused4;
1841 abi_ulong __unused5;
1842 };
1843
1844 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
1845 abi_ulong target_addr)
1846 {
1847 struct target_msqid_ds *target_md;
1848
1849 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
1850 return -TARGET_EFAULT;
1851 target_to_host_ipc_perm(&(host_md->msg_perm),target_addr);
1852 host_md->msg_stime = tswapl(target_md->msg_stime);
1853 host_md->msg_rtime = tswapl(target_md->msg_rtime);
1854 host_md->msg_ctime = tswapl(target_md->msg_ctime);
1855 host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1856 host_md->msg_qnum = tswapl(target_md->msg_qnum);
1857 host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1858 host_md->msg_lspid = tswapl(target_md->msg_lspid);
1859 host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1860 unlock_user_struct(target_md, target_addr, 0);
1861 return 0;
1862 }
1863
1864 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
1865 struct msqid_ds *host_md)
1866 {
1867 struct target_msqid_ds *target_md;
1868
1869 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
1870 return -TARGET_EFAULT;
1871 host_to_target_ipc_perm(target_addr,&(host_md->msg_perm));
1872 target_md->msg_stime = tswapl(host_md->msg_stime);
1873 target_md->msg_rtime = tswapl(host_md->msg_rtime);
1874 target_md->msg_ctime = tswapl(host_md->msg_ctime);
1875 target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1876 target_md->msg_qnum = tswapl(host_md->msg_qnum);
1877 target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1878 target_md->msg_lspid = tswapl(host_md->msg_lspid);
1879 target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1880 unlock_user_struct(target_md, target_addr, 1);
1881 return 0;
1882 }
1883
1884 static inline abi_long do_msgctl(int first, int second, abi_long ptr)
1885 {
1886 struct msqid_ds dsarg;
1887 int cmd = second&0xff;
1888 abi_long ret = 0;
1889 switch( cmd ) {
1890 case IPC_STAT:
1891 case IPC_SET:
1892 target_to_host_msqid_ds(&dsarg,ptr);
1893 ret = get_errno(msgctl(first, cmd, &dsarg));
1894 host_to_target_msqid_ds(ptr,&dsarg);
1895 default:
1896 ret = get_errno(msgctl(first, cmd, &dsarg));
1897 }
1898 return ret;
1899 }
1900
1901 struct target_msgbuf {
1902 abi_ulong mtype;
1903 char mtext[1];
1904 };
1905
1906 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
1907 unsigned int msgsz, int msgflg)
1908 {
1909 struct target_msgbuf *target_mb;
1910 struct msgbuf *host_mb;
1911 abi_long ret = 0;
1912
1913 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
1914 return -TARGET_EFAULT;
1915 host_mb = malloc(msgsz+sizeof(long));
1916 host_mb->mtype = tswapl(target_mb->mtype);
1917 memcpy(host_mb->mtext,target_mb->mtext,msgsz);
1918 ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1919 free(host_mb);
1920 unlock_user_struct(target_mb, msgp, 0);
1921
1922 return ret;
1923 }
1924
1925 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
1926 unsigned int msgsz, int msgtype,
1927 int msgflg)
1928 {
1929 struct target_msgbuf *target_mb;
1930 char *target_mtext;
1931 struct msgbuf *host_mb;
1932 abi_long ret = 0;
1933
1934 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
1935 return -TARGET_EFAULT;
1936 host_mb = malloc(msgsz+sizeof(long));
1937 ret = get_errno(msgrcv(msqid, host_mb, msgsz, 1, msgflg));
1938 if (ret > 0) {
1939 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
1940 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
1941 if (!target_mtext) {
1942 ret = -TARGET_EFAULT;
1943 goto end;
1944 }
1945 memcpy(target_mb->mtext, host_mb->mtext, ret);
1946 unlock_user(target_mtext, target_mtext_addr, ret);
1947 }
1948 target_mb->mtype = tswapl(host_mb->mtype);
1949 free(host_mb);
1950
1951 end:
1952 if (target_mb)
1953 unlock_user_struct(target_mb, msgp, 1);
1954 return ret;
1955 }
1956
1957 /* ??? This only works with linear mappings. */
1958 /* do_ipc() must return target values and target errnos. */
1959 static abi_long do_ipc(unsigned int call, int first,
1960 int second, int third,
1961 abi_long ptr, abi_long fifth)
1962 {
1963 int version;
1964 abi_long ret = 0;
1965 struct shmid_ds shm_info;
1966 int i;
1967
1968 version = call >> 16;
1969 call &= 0xffff;
1970
1971 switch (call) {
1972 case IPCOP_semop:
1973 ret = get_errno(semop(first,(struct sembuf *)g2h(ptr), second));
1974 break;
1975
1976 case IPCOP_semget:
1977 ret = get_errno(semget(first, second, third));
1978 break;
1979
1980 case IPCOP_semctl:
1981 ret = do_semctl(first, second, third, ptr);
1982 break;
1983
1984 case IPCOP_semtimedop:
1985 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
1986 ret = -TARGET_ENOSYS;
1987 break;
1988
1989 case IPCOP_msgget:
1990 ret = get_errno(msgget(first, second));
1991 break;
1992
1993 case IPCOP_msgsnd:
1994 ret = do_msgsnd(first, ptr, second, third);
1995 break;
1996
1997 case IPCOP_msgctl:
1998 ret = do_msgctl(first, second, ptr);
1999 break;
2000
2001 case IPCOP_msgrcv:
2002 {
2003 /* XXX: this code is not correct */
2004 struct ipc_kludge
2005 {
2006 void *__unbounded msgp;
2007 long int msgtyp;
2008 };
2009
2010 struct ipc_kludge *foo = (struct ipc_kludge *)g2h(ptr);
2011 struct msgbuf *msgp = (struct msgbuf *) foo->msgp;
2012
2013 ret = do_msgrcv(first, (long)msgp, second, 0, third);
2014
2015 }
2016 break;
2017
2018 case IPCOP_shmat:
2019 {
2020 abi_ulong raddr;
2021 void *host_addr;
2022 /* SHM_* flags are the same on all linux platforms */
2023 host_addr = shmat(first, (void *)g2h(ptr), second);
2024 if (host_addr == (void *)-1) {
2025 ret = get_errno((long)host_addr);
2026 break;
2027 }
2028 raddr = h2g((unsigned long)host_addr);
2029 /* find out the length of the shared memory segment */
2030
2031 ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
2032 if (is_error(ret)) {
2033 /* can't get length, bail out */
2034 shmdt(host_addr);
2035 break;
2036 }
2037 page_set_flags(raddr, raddr + shm_info.shm_segsz,
2038 PAGE_VALID | PAGE_READ |
2039 ((second & SHM_RDONLY)? 0: PAGE_WRITE));
2040 for (i = 0; i < N_SHM_REGIONS; ++i) {
2041 if (shm_regions[i].start == 0) {
2042 shm_regions[i].start = raddr;
2043 shm_regions[i].size = shm_info.shm_segsz;
2044 break;
2045 }
2046 }
2047 if (put_user_ual(raddr, third))
2048 return -TARGET_EFAULT;
2049 ret = 0;
2050 }
2051 break;
2052 case IPCOP_shmdt:
2053 for (i = 0; i < N_SHM_REGIONS; ++i) {
2054 if (shm_regions[i].start == ptr) {
2055 shm_regions[i].start = 0;
2056 page_set_flags(ptr, shm_regions[i].size, 0);
2057 break;
2058 }
2059 }
2060 ret = get_errno(shmdt((void *)g2h(ptr)));
2061 break;
2062
2063 case IPCOP_shmget:
2064 /* IPC_* flag values are the same on all linux platforms */
2065 ret = get_errno(shmget(first, second, third));
2066 break;
2067
2068 /* IPC_* and SHM_* command values are the same on all linux platforms */
2069 case IPCOP_shmctl:
2070 switch(second) {
2071 case IPC_RMID:
2072 case SHM_LOCK:
2073 case SHM_UNLOCK:
2074 ret = get_errno(shmctl(first, second, NULL));
2075 break;
2076 default:
2077 goto unimplemented;
2078 }
2079 break;
2080 default:
2081 unimplemented:
2082 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
2083 ret = -TARGET_ENOSYS;
2084 break;
2085 }
2086 return ret;
2087 }
2088 #endif
2089
2090 /* kernel structure types definitions */
2091 #define IFNAMSIZ 16
2092
2093 #define STRUCT(name, list...) STRUCT_ ## name,
2094 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
2095 enum {
2096 #include "syscall_types.h"
2097 };
2098 #undef STRUCT
2099 #undef STRUCT_SPECIAL
2100
2101 #define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2102 #define STRUCT_SPECIAL(name)
2103 #include "syscall_types.h"
2104 #undef STRUCT
2105 #undef STRUCT_SPECIAL
2106
2107 typedef struct IOCTLEntry {
2108 unsigned int target_cmd;
2109 unsigned int host_cmd;
2110 const char *name;
2111 int access;
2112 const argtype arg_type[5];
2113 } IOCTLEntry;
2114
2115 #define IOC_R 0x0001
2116 #define IOC_W 0x0002
2117 #define IOC_RW (IOC_R | IOC_W)
2118
2119 #define MAX_STRUCT_SIZE 4096
2120
2121 IOCTLEntry ioctl_entries[] = {
2122 #define IOCTL(cmd, access, types...) \
2123 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2124 #include "ioctls.h"
2125 { 0, 0, },
2126 };
2127
2128 /* ??? Implement proper locking for ioctls. */
2129 /* do_ioctl() Must return target values and target errnos. */
2130 static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
2131 {
2132 const IOCTLEntry *ie;
2133 const argtype *arg_type;
2134 abi_long ret;
2135 uint8_t buf_temp[MAX_STRUCT_SIZE];
2136 int target_size;
2137 void *argptr;
2138
2139 ie = ioctl_entries;
2140 for(;;) {
2141 if (ie->target_cmd == 0) {
2142 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
2143 return -TARGET_ENOSYS;
2144 }
2145 if (ie->target_cmd == cmd)
2146 break;
2147 ie++;
2148 }
2149 arg_type = ie->arg_type;
2150 #if defined(DEBUG)
2151 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
2152 #endif
2153 switch(arg_type[0]) {
2154 case TYPE_NULL:
2155 /* no argument */
2156 ret = get_errno(ioctl(fd, ie->host_cmd));
2157 break;
2158 case TYPE_PTRVOID:
2159 case TYPE_INT:
2160 /* int argment */
2161 ret = get_errno(ioctl(fd, ie->host_cmd, arg));
2162 break;
2163 case TYPE_PTR:
2164 arg_type++;
2165 target_size = thunk_type_size(arg_type, 0);
2166 switch(ie->access) {
2167 case IOC_R:
2168 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2169 if (!is_error(ret)) {
2170 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2171 if (!argptr)
2172 return -TARGET_EFAULT;
2173 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2174 unlock_user(argptr, arg, target_size);
2175 }
2176 break;
2177 case IOC_W:
2178 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2179 if (!argptr)
2180 return -TARGET_EFAULT;
2181 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2182 unlock_user(argptr, arg, 0);
2183 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2184 break;
2185 default:
2186 case IOC_RW:
2187 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2188 if (!argptr)
2189 return -TARGET_EFAULT;
2190 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2191 unlock_user(argptr, arg, 0);
2192 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2193 if (!is_error(ret)) {
2194 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2195 if (!argptr)
2196 return -TARGET_EFAULT;
2197 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2198 unlock_user(argptr, arg, target_size);
2199 }
2200 break;
2201 }
2202 break;
2203 default:
2204 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2205 (long)cmd, arg_type[0]);
2206 ret = -TARGET_ENOSYS;
2207 break;
2208 }
2209 return ret;
2210 }
2211
2212 bitmask_transtbl iflag_tbl[] = {
2213 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
2214 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
2215 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
2216 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
2217 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
2218 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
2219 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
2220 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
2221 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
2222 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
2223 { TARGET_IXON, TARGET_IXON, IXON, IXON },
2224 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
2225 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
2226 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
2227 { 0, 0, 0, 0 }
2228 };
2229
2230 bitmask_transtbl oflag_tbl[] = {
2231 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
2232 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
2233 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
2234 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
2235 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
2236 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
2237 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
2238 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
2239 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
2240 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
2241 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
2242 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
2243 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
2244 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
2245 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
2246 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
2247 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
2248 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
2249 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
2250 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
2251 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
2252 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
2253 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
2254 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
2255 { 0, 0, 0, 0 }
2256 };
2257
2258 bitmask_transtbl cflag_tbl[] = {
2259 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
2260 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
2261 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
2262 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
2263 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
2264 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
2265 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
2266 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
2267 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
2268 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
2269 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
2270 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
2271 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
2272 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
2273 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
2274 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
2275 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
2276 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
2277 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
2278 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
2279 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
2280 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
2281 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
2282 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
2283 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
2284 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
2285 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
2286 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
2287 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
2288 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
2289 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
2290 { 0, 0, 0, 0 }
2291 };
2292
2293 bitmask_transtbl lflag_tbl[] = {
2294 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
2295 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
2296 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
2297 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
2298 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
2299 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
2300 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
2301 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
2302 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
2303 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
2304 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
2305 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
2306 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
2307 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
2308 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
2309 { 0, 0, 0, 0 }
2310 };
2311
2312 static void target_to_host_termios (void *dst, const void *src)
2313 {
2314 struct host_termios *host = dst;
2315 const struct target_termios *target = src;
2316
2317 host->c_iflag =
2318 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
2319 host->c_oflag =
2320 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
2321 host->c_cflag =
2322 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
2323 host->c_lflag =
2324 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
2325 host->c_line = target->c_line;
2326
2327 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
2328 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
2329 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
2330 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
2331 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
2332 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
2333 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
2334 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
2335 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
2336 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
2337 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
2338 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
2339 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
2340 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
2341 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
2342 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
2343 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
2344 }
2345
2346 static void host_to_target_termios (void *dst, const void *src)
2347 {
2348 struct target_termios *target = dst;
2349 const struct host_termios *host = src;
2350
2351 target->c_iflag =
2352 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
2353 target->c_oflag =
2354 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
2355 target->c_cflag =
2356 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
2357 target->c_lflag =
2358 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
2359 target->c_line = host->c_line;
2360
2361 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
2362 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
2363 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
2364 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
2365 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
2366 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
2367 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
2368 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
2369 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
2370 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
2371 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
2372 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
2373 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
2374 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
2375 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
2376 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
2377 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
2378 }
2379
2380 StructEntry struct_termios_def = {
2381 .convert = { host_to_target_termios, target_to_host_termios },
2382 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
2383 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
2384 };
2385
2386 static bitmask_transtbl mmap_flags_tbl[] = {
2387 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
2388 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
2389 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
2390 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
2391 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
2392 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
2393 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
2394 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
2395 { 0, 0, 0, 0 }
2396 };
2397
2398 static bitmask_transtbl fcntl_flags_tbl[] = {
2399 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
2400 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
2401 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
2402 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
2403 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
2404 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
2405 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
2406 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
2407 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
2408 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
2409 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
2410 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
2411 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
2412 #if defined(O_DIRECT)
2413 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
2414 #endif
2415 { 0, 0, 0, 0 }
2416 };
2417
2418 #if defined(TARGET_I386)
2419
2420 /* NOTE: there is really one LDT for all the threads */
2421 uint8_t *ldt_table;
2422
2423 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
2424 {
2425 int size;
2426 void *p;
2427
2428 if (!ldt_table)
2429 return 0;
2430 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
2431 if (size > bytecount)
2432 size = bytecount;
2433 p = lock_user(VERIFY_WRITE, ptr, size, 0);
2434 if (!p)
2435 return -TARGET_EFAULT;
2436 /* ??? Should this by byteswapped? */
2437 memcpy(p, ldt_table, size);
2438 unlock_user(p, ptr, size);
2439 return size;
2440 }
2441
2442 /* XXX: add locking support */
2443 static abi_long write_ldt(CPUX86State *env,
2444 abi_ulong ptr, unsigned long bytecount, int oldmode)
2445 {
2446 struct target_modify_ldt_ldt_s ldt_info;
2447 struct target_modify_ldt_ldt_s *target_ldt_info;
2448 int seg_32bit, contents, read_exec_only, limit_in_pages;
2449 int seg_not_present, useable, lm;
2450 uint32_t *lp, entry_1, entry_2;
2451
2452 if (bytecount != sizeof(ldt_info))
2453 return -TARGET_EINVAL;
2454 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
2455 return -TARGET_EFAULT;
2456 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2457 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2458 ldt_info.limit = tswap32(target_ldt_info->limit);
2459 ldt_info.flags = tswap32(target_ldt_info->flags);
2460 unlock_user_struct(target_ldt_info, ptr, 0);
2461
2462 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
2463 return -TARGET_EINVAL;
2464 seg_32bit = ldt_info.flags & 1;
2465 contents = (ldt_info.flags >> 1) & 3;
2466 read_exec_only = (ldt_info.flags >> 3) & 1;
2467 limit_in_pages = (ldt_info.flags >> 4) & 1;
2468 seg_not_present = (ldt_info.flags >> 5) & 1;
2469 useable = (ldt_info.flags >> 6) & 1;
2470 #ifdef TARGET_ABI32
2471 lm = 0;
2472 #else
2473 lm = (ldt_info.flags >> 7) & 1;
2474 #endif
2475 if (contents == 3) {
2476 if (oldmode)
2477 return -TARGET_EINVAL;
2478 if (seg_not_present == 0)
2479 return -TARGET_EINVAL;
2480 }
2481 /* allocate the LDT */
2482 if (!ldt_table) {
2483 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2484 if (!ldt_table)
2485 return -TARGET_ENOMEM;
2486 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2487 env->ldt.base = h2g((unsigned long)ldt_table);
2488 env->ldt.limit = 0xffff;
2489 }
2490
2491 /* NOTE: same code as Linux kernel */
2492 /* Allow LDTs to be cleared by the user. */
2493 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2494 if (oldmode ||
2495 (contents == 0 &&
2496 read_exec_only == 1 &&
2497 seg_32bit == 0 &&
2498 limit_in_pages == 0 &&
2499 seg_not_present == 1 &&
2500 useable == 0 )) {
2501 entry_1 = 0;
2502 entry_2 = 0;
2503 goto install;
2504 }
2505 }
2506
2507 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2508 (ldt_info.limit & 0x0ffff);
2509 entry_2 = (ldt_info.base_addr & 0xff000000) |
2510 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2511 (ldt_info.limit & 0xf0000) |
2512 ((read_exec_only ^ 1) << 9) |
2513 (contents << 10) |
2514 ((seg_not_present ^ 1) << 15) |
2515 (seg_32bit << 22) |
2516 (limit_in_pages << 23) |
2517 (lm << 21) |
2518 0x7000;
2519 if (!oldmode)
2520 entry_2 |= (useable << 20);
2521
2522 /* Install the new entry ... */
2523 install:
2524 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
2525 lp[0] = tswap32(entry_1);
2526 lp[1] = tswap32(entry_2);
2527 return 0;
2528 }
2529
2530 /* specific and weird i386 syscalls */
2531 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
2532 unsigned long bytecount)
2533 {
2534 abi_long ret;
2535
2536 switch (func) {
2537 case 0:
2538 ret = read_ldt(ptr, bytecount);
2539 break;
2540 case 1:
2541 ret = write_ldt(env, ptr, bytecount, 1);
2542 break;
2543 case 0x11:
2544 ret = write_ldt(env, ptr, bytecount, 0);
2545 break;
2546 default:
2547 ret = -TARGET_ENOSYS;
2548 break;
2549 }
2550 return ret;
2551 }
2552
2553 #if defined(TARGET_I386) && defined(TARGET_ABI32)
2554 static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
2555 {
2556 uint64_t *gdt_table = g2h(env->gdt.base);
2557 struct target_modify_ldt_ldt_s ldt_info;
2558 struct target_modify_ldt_ldt_s *target_ldt_info;
2559 int seg_32bit, contents, read_exec_only, limit_in_pages;
2560 int seg_not_present, useable, lm;
2561 uint32_t *lp, entry_1, entry_2;
2562 int i;
2563
2564 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2565 if (!target_ldt_info)
2566 return -TARGET_EFAULT;
2567 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2568 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2569 ldt_info.limit = tswap32(target_ldt_info->limit);
2570 ldt_info.flags = tswap32(target_ldt_info->flags);
2571 if (ldt_info.entry_number == -1) {
2572 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
2573 if (gdt_table[i] == 0) {
2574 ldt_info.entry_number = i;
2575 target_ldt_info->entry_number = tswap32(i);
2576 break;
2577 }
2578 }
2579 }
2580 unlock_user_struct(target_ldt_info, ptr, 1);
2581
2582 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
2583 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
2584 return -TARGET_EINVAL;
2585 seg_32bit = ldt_info.flags & 1;
2586 contents = (ldt_info.flags >> 1) & 3;
2587 read_exec_only = (ldt_info.flags >> 3) & 1;
2588 limit_in_pages = (ldt_info.flags >> 4) & 1;
2589 seg_not_present = (ldt_info.flags >> 5) & 1;
2590 useable = (ldt_info.flags >> 6) & 1;
2591 #ifdef TARGET_ABI32
2592 lm = 0;
2593 #else
2594 lm = (ldt_info.flags >> 7) & 1;
2595 #endif
2596
2597 if (contents == 3) {
2598 if (seg_not_present == 0)
2599 return -TARGET_EINVAL;
2600 }
2601
2602 /* NOTE: same code as Linux kernel */
2603 /* Allow LDTs to be cleared by the user. */
2604 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2605 if ((contents == 0 &&
2606 read_exec_only == 1 &&
2607 seg_32bit == 0 &&
2608 limit_in_pages == 0 &&
2609 seg_not_present == 1 &&
2610 useable == 0 )) {
2611 entry_1 = 0;
2612 entry_2 = 0;
2613 goto install;
2614 }
2615 }
2616
2617 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2618 (ldt_info.limit & 0x0ffff);
2619 entry_2 = (ldt_info.base_addr & 0xff000000) |
2620 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2621 (ldt_info.limit & 0xf0000) |
2622 ((read_exec_only ^ 1) << 9) |
2623 (contents << 10) |
2624 ((seg_not_present ^ 1) << 15) |
2625 (seg_32bit << 22) |
2626 (limit_in_pages << 23) |
2627 (useable << 20) |
2628 (lm << 21) |
2629 0x7000;
2630
2631 /* Install the new entry ... */
2632 install:
2633 lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
2634 lp[0] = tswap32(entry_1);
2635 lp[1] = tswap32(entry_2);
2636 return 0;
2637 }
2638
2639 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
2640 {
2641 struct target_modify_ldt_ldt_s *target_ldt_info;
2642 uint64_t *gdt_table = g2h(env->gdt.base);
2643 uint32_t base_addr, limit, flags;
2644 int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
2645 int seg_not_present, useable, lm;
2646 uint32_t *lp, entry_1, entry_2;
2647
2648 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2649 if (!target_ldt_info)
2650 return -TARGET_EFAULT;
2651 idx = tswap32(target_ldt_info->entry_number);
2652 if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
2653 idx > TARGET_GDT_ENTRY_TLS_MAX) {
2654 unlock_user_struct(target_ldt_info, ptr, 1);
2655 return -TARGET_EINVAL;
2656 }
2657 lp = (uint32_t *)(gdt_table + idx);
2658 entry_1 = tswap32(lp[0]);
2659 entry_2 = tswap32(lp[1]);
2660
2661 read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
2662 contents = (entry_2 >> 10) & 3;
2663 seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
2664 seg_32bit = (entry_2 >> 22) & 1;
2665 limit_in_pages = (entry_2 >> 23) & 1;
2666 useable = (entry_2 >> 20) & 1;
2667 #ifdef TARGET_ABI32
2668 lm = 0;
2669 #else
2670 lm = (entry_2 >> 21) & 1;
2671 #endif
2672 flags = (seg_32bit << 0) | (contents << 1) |
2673 (read_exec_only << 3) | (limit_in_pages << 4) |
2674 (seg_not_present << 5) | (useable << 6) | (lm << 7);
2675 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000);
2676 base_addr = (entry_1 >> 16) |
2677 (entry_2 & 0xff000000) |
2678 ((entry_2 & 0xff) << 16);
2679 target_ldt_info->base_addr = tswapl(base_addr);
2680 target_ldt_info->limit = tswap32(limit);
2681 target_ldt_info->flags = tswap32(flags);
2682 unlock_user_struct(target_ldt_info, ptr, 1);
2683 return 0;
2684 }
2685 #endif /* TARGET_I386 && TARGET_ABI32 */
2686
2687 #ifndef TARGET_ABI32
2688 static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
2689 {
2690 abi_long ret;
2691 abi_ulong val;
2692 int idx;
2693
2694 switch(code) {
2695 case TARGET_ARCH_SET_GS:
2696 case TARGET_ARCH_SET_FS:
2697 if (code == TARGET_ARCH_SET_GS)
2698 idx = R_GS;
2699 else
2700 idx = R_FS;
2701 cpu_x86_load_seg(env, idx, 0);
2702 env->segs[idx].base = addr;
2703 break;
2704 case TARGET_ARCH_GET_GS:
2705 case TARGET_ARCH_GET_FS:
2706 if (code == TARGET_ARCH_GET_GS)
2707 idx = R_GS;
2708 else
2709 idx = R_FS;
2710 val = env->segs[idx].base;
2711 if (put_user(val, addr, abi_ulong))
2712 return -TARGET_EFAULT;
2713 break;
2714 default:
2715 ret = -TARGET_EINVAL;
2716 break;
2717 }
2718 return 0;
2719 }
2720 #endif
2721
2722 #endif /* defined(TARGET_I386) */
2723
2724 #if defined(USE_NPTL)
2725
2726 #define NEW_STACK_SIZE PTHREAD_STACK_MIN
2727
2728 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
2729 typedef struct {
2730 CPUState *env;
2731 pthread_mutex_t mutex;
2732 pthread_cond_t cond;
2733 pthread_t thread;
2734 uint32_t tid;
2735 abi_ulong child_tidptr;
2736 abi_ulong parent_tidptr;
2737 sigset_t sigmask;
2738 } new_thread_info;
2739
2740 static void *clone_func(void *arg)
2741 {
2742 new_thread_info *info = arg;
2743 CPUState *env;
2744
2745 env = info->env;
2746 thread_env = env;
2747 info->tid = gettid();
2748 if (info->child_tidptr)
2749 put_user_u32(info->tid, info->child_tidptr);
2750 if (info->parent_tidptr)
2751 put_user_u32(info->tid, info->parent_tidptr);
2752 /* Enable signals. */
2753 sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
2754 /* Signal to the parent that we're ready. */
2755 pthread_mutex_lock(&info->mutex);
2756 pthread_cond_broadcast(&info->cond);
2757 pthread_mutex_unlock(&info->mutex);
2758 /* Wait until the parent has finshed initializing the tls state. */
2759 pthread_mutex_lock(&clone_lock);
2760 pthread_mutex_unlock(&clone_lock);
2761 cpu_loop(env);
2762 /* never exits */
2763 return NULL;
2764 }
2765 #else
2766 /* this stack is the equivalent of the kernel stack associated with a
2767 thread/process */
2768 #define NEW_STACK_SIZE 8192
2769
2770 static int clone_func(void *arg)
2771 {
2772 CPUState *env = arg;
2773 cpu_loop(env);
2774 /* never exits */
2775 return 0;
2776 }
2777 #endif
2778
2779 /* do_fork() Must return host values and target errnos (unlike most
2780 do_*() functions). */
2781 static int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp,
2782 abi_ulong parent_tidptr, target_ulong newtls,
2783 abi_ulong child_tidptr)
2784 {
2785 int ret;
2786 TaskState *ts;
2787 uint8_t *new_stack;
2788 CPUState *new_env;
2789 #if defined(USE_NPTL)
2790 unsigned int nptl_flags;
2791 sigset_t sigmask;
2792 #endif
2793
2794 if (flags & CLONE_VM) {
2795 #if defined(USE_NPTL)
2796 new_thread_info info;
2797 pthread_attr_t attr;
2798 #endif
2799 ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
2800 init_task_state(ts);
2801 new_stack = ts->stack;
2802 /* we create a new CPU instance. */
2803 new_env = cpu_copy(env);
2804 /* Init regs that differ from the parent. */
2805 cpu_clone_regs(new_env, newsp);
2806 new_env->opaque = ts;
2807 #if defined(USE_NPTL)
2808 nptl_flags = flags;
2809 flags &= ~CLONE_NPTL_FLAGS2;
2810
2811 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2812 if (nptl_flags & CLONE_SETTLS)
2813 cpu_set_tls (new_env, newtls);
2814
2815 /* Grab a mutex so that thread setup appears atomic. */
2816 pthread_mutex_lock(&clone_lock);
2817
2818 memset(&info, 0, sizeof(info));
2819 pthread_mutex_init(&info.mutex, NULL);
2820 pthread_mutex_lock(&info.mutex);
2821 pthread_cond_init(&info.cond, NULL);
2822 info.env = new_env;
2823 if (nptl_flags & CLONE_CHILD_SETTID)
2824 info.child_tidptr = child_tidptr;
2825 if (nptl_flags & CLONE_PARENT_SETTID)
2826 info.parent_tidptr = parent_tidptr;
2827
2828 ret = pthread_attr_init(&attr);
2829 ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
2830 /* It is not safe to deliver signals until the child has finished
2831 initializing, so temporarily block all signals. */
2832 sigfillset(&sigmask);
2833 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
2834
2835 ret = pthread_create(&info.thread, &attr, clone_func, &info);
2836
2837 sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
2838 pthread_attr_destroy(&attr);
2839 if (ret == 0) {
2840 /* Wait for the child to initialize. */
2841 pthread_cond_wait(&info.cond, &info.mutex);
2842 ret = info.tid;
2843 if (flags & CLONE_PARENT_SETTID)
2844 put_user_u32(ret, parent_tidptr);
2845 } else {
2846 ret = -1;
2847 }
2848 pthread_mutex_unlock(&info.mutex);
2849 pthread_cond_destroy(&info.cond);
2850 pthread_mutex_destroy(&info.mutex);
2851 pthread_mutex_unlock(&clone_lock);
2852 #else
2853 if (flags & CLONE_NPTL_FLAGS2)
2854 return -EINVAL;
2855 /* This is probably going to die very quickly, but do it anyway. */
2856 #ifdef __ia64__
2857 ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2858 #else
2859 ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2860 #endif
2861 #endif
2862 } else {
2863 /* if no CLONE_VM, we consider it is a fork */
2864 if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
2865 return -EINVAL;
2866 fork_start();
2867 ret = fork();
2868 #if defined(USE_NPTL)
2869 /* There is a race condition here. The parent process could
2870 theoretically read the TID in the child process before the child
2871 tid is set. This would require using either ptrace
2872 (not implemented) or having *_tidptr to point at a shared memory
2873 mapping. We can't repeat the spinlock hack used above because
2874 the child process gets its own copy of the lock. */
2875 if (ret == 0) {
2876 cpu_clone_regs(env, newsp);
2877 fork_end(1);
2878 /* Child Process. */
2879 if (flags & CLONE_CHILD_SETTID)
2880 put_user_u32(gettid(), child_tidptr);
2881 if (flags & CLONE_PARENT_SETTID)
2882 put_user_u32(gettid(), parent_tidptr);
2883 ts = (TaskState *)env->opaque;
2884 if (flags & CLONE_SETTLS)
2885 cpu_set_tls (env, newtls);
2886 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2887 } else {
2888 fork_end(0);
2889 }
2890 #else
2891 if (ret == 0) {
2892 cpu_clone_regs(env, newsp);
2893 }
2894 #endif
2895 }
2896 return ret;
2897 }
2898
2899 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
2900 {
2901 struct flock fl;
2902 struct target_flock *target_fl;
2903 struct flock64 fl64;
2904 struct target_flock64 *target_fl64;
2905 abi_long ret;
2906
2907 switch(cmd) {
2908 case TARGET_F_GETLK:
2909 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
2910 return -TARGET_EFAULT;
2911 fl.l_type = tswap16(target_fl->l_type);
2912 fl.l_whence = tswap16(target_fl->l_whence);
2913 fl.l_start = tswapl(target_fl->l_start);
2914 fl.l_len = tswapl(target_fl->l_len);
2915 fl.l_pid = tswapl(target_fl->l_pid);
2916 unlock_user_struct(target_fl, arg, 0);
2917 ret = get_errno(fcntl(fd, cmd, &fl));
2918 if (ret == 0) {
2919 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0))
2920 return -TARGET_EFAULT;
2921 target_fl->l_type = tswap16(fl.l_type);
2922 target_fl->l_whence = tswap16(fl.l_whence);
2923 target_fl->l_start = tswapl(fl.l_start);
2924 target_fl->l_len = tswapl(fl.l_len);
2925 target_fl->l_pid = tswapl(fl.l_pid);
2926 unlock_user_struct(target_fl, arg, 1);
2927 }
2928 break;
2929
2930 case TARGET_F_SETLK:
2931 case TARGET_F_SETLKW:
2932 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
2933 return -TARGET_EFAULT;
2934 fl.l_type = tswap16(target_fl->l_type);
2935 fl.l_whence = tswap16(target_fl->l_whence);
2936 fl.l_start = tswapl(target_fl->l_start);
2937 fl.l_len = tswapl(target_fl->l_len);
2938 fl.l_pid = tswapl(target_fl->l_pid);
2939 unlock_user_struct(target_fl, arg, 0);
2940 ret = get_errno(fcntl(fd, cmd, &fl));
2941 break;
2942
2943 case TARGET_F_GETLK64:
2944 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
2945 return -TARGET_EFAULT;
2946 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2947 fl64.l_whence = tswap16(target_fl64->l_whence);
2948 fl64.l_start = tswapl(target_fl64->l_start);
2949 fl64.l_len = tswapl(target_fl64->l_len);
2950 fl64.l_pid = tswap16(target_fl64->l_pid);
2951 unlock_user_struct(target_fl64, arg, 0);
2952 ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
2953 if (ret == 0) {
2954 if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0))
2955 return -TARGET_EFAULT;
2956 target_fl64->l_type = tswap16(fl64.l_type) >> 1;
2957 target_fl64->l_whence = tswap16(fl64.l_whence);
2958 target_fl64->l_start = tswapl(fl64.l_start);
2959 target_fl64->l_len = tswapl(fl64.l_len);
2960 target_fl64->l_pid = tswapl(fl64.l_pid);
2961 unlock_user_struct(target_fl64, arg, 1);
2962 }
2963 break;
2964 case TARGET_F_SETLK64:
2965 case TARGET_F_SETLKW64:
2966 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
2967 return -TARGET_EFAULT;
2968 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2969 fl64.l_whence = tswap16(target_fl64->l_whence);
2970 fl64.l_start = tswapl(target_fl64->l_start);
2971 fl64.l_len = tswapl(target_fl64->l_len);
2972 fl64.l_pid = tswap16(target_fl64->l_pid);
2973 unlock_user_struct(target_fl64, arg, 0);
2974 ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
2975 break;
2976
2977 case F_GETFL:
2978 ret = get_errno(fcntl(fd, cmd, arg));
2979 if (ret >= 0) {
2980 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
2981 }
2982 break;
2983
2984 case F_SETFL:
2985 ret = get_errno(fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl)));
2986 break;
2987
2988 default:
2989 ret = get_errno(fcntl(fd, cmd, arg));
2990 break;
2991 }
2992 return ret;
2993 }
2994
2995 #ifdef USE_UID16
2996
2997 static inline int high2lowuid(int uid)
2998 {
2999 if (uid > 65535)
3000 return 65534;
3001 else
3002 return uid;
3003 }
3004
3005 static inline int high2lowgid(int gid)
3006 {
3007 if (gid > 65535)
3008 return 65534;
3009 else
3010 return gid;
3011 }
3012
3013 static inline int low2highuid(int uid)
3014 {
3015 if ((int16_t)uid == -1)
3016 return -1;
3017 else
3018 return uid;
3019 }
3020
3021 static inline int low2highgid(int gid)
3022 {
3023 if ((int16_t)gid == -1)
3024 return -1;
3025 else
3026 return gid;
3027 }
3028
3029 #endif /* USE_UID16 */
3030
3031 void syscall_init(void)
3032 {
3033 IOCTLEntry *ie;
3034 const argtype *arg_type;
3035 int size;
3036 int i;
3037
3038 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3039 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
3040 #include "syscall_types.h"
3041 #undef STRUCT
3042 #undef STRUCT_SPECIAL
3043
3044 /* we patch the ioctl size if necessary. We rely on the fact that
3045 no ioctl has all the bits at '1' in the size field */
3046 ie = ioctl_entries;
3047 while (ie->target_cmd != 0) {
3048 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
3049 TARGET_IOC_SIZEMASK) {
3050 arg_type = ie->arg_type;
3051 if (arg_type[0] != TYPE_PTR) {
3052 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
3053 ie->target_cmd);
3054 exit(1);
3055 }
3056 arg_type++;
3057 size = thunk_type_size(arg_type, 0);
3058 ie->target_cmd = (ie->target_cmd &
3059 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
3060 (size << TARGET_IOC_SIZESHIFT);
3061 }
3062
3063 /* Build target_to_host_errno_table[] table from
3064 * host_to_target_errno_table[]. */
3065 for (i=0; i < ERRNO_TABLE_SIZE; i++)
3066 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
3067
3068 /* automatic consistency check if same arch */
3069 #if defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)
3070 if (ie->target_cmd != ie->host_cmd) {
3071 fprintf(stderr, "ERROR: ioctl: target=0x%x host=0x%x\n",
3072 ie->target_cmd, ie->host_cmd);
3073 }
3074 #endif
3075 ie++;
3076 }
3077 }
3078
3079 #if TARGET_ABI_BITS == 32
3080 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
3081 {
3082 #ifdef TARGET_WORDS_BIGENDIAN
3083 return ((uint64_t)word0 << 32) | word1;
3084 #else
3085 return ((uint64_t)word1 << 32) | word0;
3086 #endif
3087 }
3088 #else /* TARGET_ABI_BITS == 32 */
3089 static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
3090 {
3091 return word0;
3092 }
3093 #endif /* TARGET_ABI_BITS != 32 */
3094
3095 #ifdef TARGET_NR_truncate64
3096 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
3097 abi_long arg2,
3098 abi_long arg3,
3099 abi_long arg4)
3100 {
3101 #ifdef TARGET_ARM
3102 if (((CPUARMState *)cpu_env)->eabi)
3103 {
3104 arg2 = arg3;
3105 arg3 = arg4;
3106 }
3107 #endif
3108 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
3109 }
3110 #endif
3111
3112 #ifdef TARGET_NR_ftruncate64
3113 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
3114 abi_long arg2,
3115 abi_long arg3,
3116 abi_long arg4)
3117 {
3118 #ifdef TARGET_ARM
3119 if (((CPUARMState *)cpu_env)->eabi)
3120 {
3121 arg2 = arg3;
3122 arg3 = arg4;
3123 }
3124 #endif
3125 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
3126 }
3127 #endif
3128
3129 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
3130 abi_ulong target_addr)
3131 {
3132 struct target_timespec *target_ts;
3133
3134 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
3135 return -TARGET_EFAULT;
3136 host_ts->tv_sec = tswapl(target_ts->tv_sec);
3137 host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
3138 unlock_user_struct(target_ts, target_addr, 0);
3139 return 0;
3140 }
3141
3142 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
3143 struct timespec *host_ts)
3144 {
3145 struct target_timespec *target_ts;
3146
3147 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
3148 return -TARGET_EFAULT;
3149 target_ts->tv_sec = tswapl(host_ts->tv_sec);
3150 target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
3151 unlock_user_struct(target_ts, target_addr, 1);
3152 return 0;
3153 }
3154
3155 #if defined(USE_NPTL)
3156 /* ??? Using host futex calls even when target atomic operations
3157 are not really atomic probably breaks things. However implementing
3158 futexes locally would make futexes shared between multiple processes
3159 tricky. However they're probably useless because guest atomic
3160 operations won't work either. */
3161 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
3162 target_ulong uaddr2, int val3)
3163 {
3164 struct timespec ts, *pts;
3165
3166 /* ??? We assume FUTEX_* constants are the same on both host
3167 and target. */
3168 switch (op) {
3169 case FUTEX_WAIT:
3170 if (timeout) {
3171 pts = &ts;
3172 target_to_host_timespec(pts, timeout);
3173 } else {
3174 pts = NULL;
3175 }
3176 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAIT, tswap32(val),
3177 pts, NULL, 0));
3178 case FUTEX_WAKE:
3179 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAKE, val, NULL, NULL, 0));
3180 case FUTEX_FD:
3181 return get_errno(sys_futex(g2h(uaddr), FUTEX_FD, val, NULL, NULL, 0));
3182 case FUTEX_REQUEUE:
3183 return get_errno(sys_futex(g2h(uaddr), FUTEX_REQUEUE, val,
3184 NULL, g2h(uaddr2), 0));
3185 case FUTEX_CMP_REQUEUE:
3186 return get_errno(sys_futex(g2h(uaddr), FUTEX_CMP_REQUEUE, val,
3187 NULL, g2h(uaddr2), tswap32(val3)));
3188 default:
3189 return -TARGET_ENOSYS;
3190 }
3191 }
3192 #endif
3193
3194 int get_osversion(void)
3195 {
3196 static int osversion;
3197 struct new_utsname buf;
3198 const char *s;
3199 int i, n, tmp;
3200 if (osversion)
3201 return osversion;
3202 if (qemu_uname_release && *qemu_uname_release) {
3203 s = qemu_uname_release;
3204 } else {
3205 if (sys_uname(&buf))
3206 return 0;
3207 s = buf.release;
3208 }
3209 tmp = 0;
3210 for (i = 0; i < 3; i++) {
3211 n = 0;
3212 while (*s >= '0' && *s <= '9') {
3213 n *= 10;
3214 n += *s - '0';
3215 s++;
3216 }
3217 tmp = (tmp << 8) + n;
3218 if (*s == '.')
3219 s++;
3220 }
3221 osversion = tmp;
3222 return osversion;
3223 }
3224
3225 /* do_syscall() should always have a single exit point at the end so
3226 that actions, such as logging of syscall results, can be performed.
3227 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
3228 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
3229 abi_long arg2, abi_long arg3, abi_long arg4,
3230 abi_long arg5, abi_long arg6)
3231 {
3232 abi_long ret;
3233 struct stat st;
3234 struct statfs stfs;
3235 void *p;
3236
3237 #ifdef DEBUG
3238 gemu_log("syscall %d", num);
3239 #endif
3240 if(do_strace)
3241 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
3242
3243 switch(num) {
3244 case TARGET_NR_exit:
3245 #ifdef HAVE_GPROF
3246 _mcleanup();
3247 #endif
3248 gdb_exit(cpu_env, arg1);
3249 /* XXX: should free thread stack and CPU env */
3250 _exit(arg1);
3251 ret = 0; /* avoid warning */
3252 break;
3253 case TARGET_NR_read:
3254 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
3255 goto efault;
3256 ret = get_errno(read(arg1, p, arg3));
3257 unlock_user(p, arg2, ret);
3258 break;
3259 case TARGET_NR_write:
3260 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
3261 goto efault;
3262 ret = get_errno(write(arg1, p, arg3));
3263 unlock_user(p, arg2, 0);
3264 break;
3265 case TARGET_NR_open:
3266 if (!(p = lock_user_string(arg1)))
3267 goto efault;
3268 ret = get_errno(open(path(p),
3269 target_to_host_bitmask(arg2, fcntl_flags_tbl),
3270 arg3));
3271 unlock_user(p, arg1, 0);
3272 break;
3273 #if defined(TARGET_NR_openat) && defined(__NR_openat)
3274 case TARGET_NR_openat:
3275 if (!(p = lock_user_string(arg2)))
3276 goto efault;
3277 ret = get_errno(sys_openat(arg1,
3278 path(p),
3279 target_to_host_bitmask(arg3, fcntl_flags_tbl),
3280 arg4));
3281 unlock_user(p, arg2, 0);
3282 break;
3283 #endif
3284 case TARGET_NR_close:
3285 ret = get_errno(close(arg1));
3286 break;
3287 case TARGET_NR_brk:
3288 ret = do_brk(arg1);
3289 break;
3290 case TARGET_NR_fork:
3291 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
3292 break;
3293 #ifdef TARGET_NR_waitpid
3294 case TARGET_NR_waitpid:
3295 {
3296 int status;
3297 ret = get_errno(waitpid(arg1, &status, arg3));
3298 if (!is_error(ret) && arg2
3299 && put_user_s32(status, arg2))
3300 goto efault;
3301 }
3302 break;
3303 #endif
3304 #ifdef TARGET_NR_waitid
3305 case TARGET_NR_waitid:
3306 {
3307 siginfo_t info;
3308 info.si_pid = 0;
3309 ret = get_errno(waitid(arg1, arg2, &info, arg4));
3310 if (!is_error(ret) && arg3 && info.si_pid != 0) {
3311 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
3312 goto efault;
3313 host_to_target_siginfo(p, &info);
3314 unlock_user(p, arg3, sizeof(target_siginfo_t));
3315 }
3316 }
3317 break;
3318 #endif
3319 #ifdef TARGET_NR_creat /* not on alpha */
3320 case TARGET_NR_creat:
3321 if (!(p = lock_user_string(arg1)))
3322 goto efault;
3323 ret = get_errno(creat(p, arg2));
3324 unlock_user(p, arg1, 0);
3325 break;
3326 #endif
3327 case TARGET_NR_link:
3328 {
3329 void * p2;
3330 p = lock_user_string(arg1);
3331 p2 = lock_user_string(arg2);
3332 if (!p || !p2)
3333 ret = -TARGET_EFAULT;
3334 else
3335 ret = get_errno(link(p, p2));
3336 unlock_user(p2, arg2, 0);
3337 unlock_user(p, arg1, 0);
3338 }
3339 break;
3340 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3341 case TARGET_NR_linkat:
3342 {
3343 void * p2 = NULL;
3344 if (!arg2 || !arg4)
3345 goto efault;
3346 p = lock_user_string(arg2);
3347 p2 = lock_user_string(arg4);
3348 if (!p || !p2)
3349 ret = -TARGET_EFAULT;
3350 else
3351 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
3352 unlock_user(p, arg2, 0);
3353 unlock_user(p2, arg4, 0);
3354 }
3355 break;
3356 #endif
3357 case TARGET_NR_unlink:
3358 if (!(p = lock_user_string(arg1)))
3359 goto efault;
3360 ret = get_errno(unlink(p));
3361 unlock_user(p, arg1, 0);
3362 break;
3363 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3364 case TARGET_NR_unlinkat:
3365 if (!(p = lock_user_string(arg2)))
3366 goto efault;
3367 ret = get_errno(sys_unlinkat(arg1, p, arg3));
3368 unlock_user(p, arg2, 0);
3369 break;
3370 #endif
3371 case TARGET_NR_execve:
3372 {
3373 char **argp, **envp;
3374 int argc, envc;
3375 abi_ulong gp;
3376 abi_ulong guest_argp;
3377 abi_ulong guest_envp;
3378 abi_ulong addr;
3379 char **q;
3380
3381 argc = 0;
3382 guest_argp = arg2;
3383 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
3384 if (get_user_ual(addr, gp))
3385 goto efault;
3386 if (!addr)
3387 break;
3388 argc++;
3389 }
3390 envc = 0;
3391 guest_envp = arg3;
3392 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
3393 if (get_user_ual(addr, gp))
3394 goto efault;
3395 if (!addr)
3396 break;
3397 envc++;
3398 }
3399
3400 argp = alloca((argc + 1) * sizeof(void *));
3401 envp = alloca((envc + 1) * sizeof(void *));
3402
3403 for (gp = guest_argp, q = argp; gp;
3404 gp += sizeof(abi_ulong), q++) {
3405 if (get_user_ual(addr, gp))
3406 goto execve_efault;
3407 if (!addr)
3408 break;
3409 if (!(*q = lock_user_string(addr)))
3410 goto execve_efault;
3411 }
3412 *q = NULL;
3413
3414 for (gp = guest_envp, q = envp; gp;
3415 gp += sizeof(abi_ulong), q++) {
3416 if (get_user_ual(addr, gp))
3417 goto execve_efault;
3418 if (!addr)
3419 break;
3420 if (!(*q = lock_user_string(addr)))
3421 goto execve_efault;
3422 }
3423 *q = NULL;
3424
3425 if (!(p = lock_user_string(arg1)))
3426 goto execve_efault;
3427 ret = get_errno(execve(p, argp, envp));
3428 unlock_user(p, arg1, 0);
3429
3430 goto execve_end;
3431
3432 execve_efault:
3433 ret = -TARGET_EFAULT;
3434
3435 execve_end:
3436 for (gp = guest_argp, q = argp; *q;
3437 gp += sizeof(abi_ulong), q++) {
3438 if (get_user_ual(addr, gp)
3439 || !addr)
3440 break;
3441 unlock_user(*q, addr, 0);
3442 }
3443 for (gp = guest_envp, q = envp; *q;
3444 gp += sizeof(abi_ulong), q++) {
3445 if (get_user_ual(addr, gp)
3446 || !addr)
3447 break;
3448 unlock_user(*q, addr, 0);
3449 }
3450 }
3451 break;
3452 case TARGET_NR_chdir:
3453 if (!(p = lock_user_string(arg1)))
3454 goto efault;
3455 ret = get_errno(chdir(p));
3456 unlock_user(p, arg1, 0);
3457 break;
3458 #ifdef TARGET_NR_time
3459 case TARGET_NR_time:
3460 {
3461 time_t host_time;
3462 ret = get_errno(time(&host_time));
3463 if (!is_error(ret)
3464 && arg1
3465 && put_user_sal(host_time, arg1))
3466 goto efault;
3467 }
3468 break;
3469 #endif
3470 case TARGET_NR_mknod:
3471 if (!(p = lock_user_string(arg1)))
3472 goto efault;
3473 ret = get_errno(mknod(p, arg2, arg3));
3474 unlock_user(p, arg1, 0);
3475 break;
3476 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3477 case TARGET_NR_mknodat:
3478 if (!(p = lock_user_string(arg2)))
3479 goto efault;
3480 ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
3481 unlock_user(p, arg2, 0);
3482 break;
3483 #endif
3484 case TARGET_NR_chmod:
3485 if (!(p = lock_user_string(arg1)))
3486 goto efault;
3487 ret = get_errno(chmod(p, arg2));
3488 unlock_user(p, arg1, 0);
3489 break;
3490 #ifdef TARGET_NR_break
3491 case TARGET_NR_break:
3492 goto unimplemented;
3493 #endif
3494 #ifdef TARGET_NR_oldstat
3495 case TARGET_NR_oldstat:
3496 goto unimplemented;
3497 #endif
3498 case TARGET_NR_lseek:
3499 ret = get_errno(lseek(arg1, arg2, arg3));
3500 break;
3501 #ifdef TARGET_NR_getxpid
3502 case TARGET_NR_getxpid:
3503 #else
3504 case TARGET_NR_getpid:
3505 #endif
3506 ret = get_errno(getpid());
3507 break;
3508 case TARGET_NR_mount:
3509 {
3510 /* need to look at the data field */
3511 void *p2, *p3;
3512 p = lock_user_string(arg1);
3513 p2 = lock_user_string(arg2);
3514 p3 = lock_user_string(arg3);
3515 if (!p || !p2 || !p3)
3516 ret = -TARGET_EFAULT;
3517 else
3518 /* FIXME - arg5 should be locked, but it isn't clear how to
3519 * do that since it's not guaranteed to be a NULL-terminated
3520 * string.
3521 */
3522 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
3523 unlock_user(p, arg1, 0);
3524 unlock_user(p2, arg2, 0);
3525 unlock_user(p3, arg3, 0);
3526 break;
3527 }
3528 #ifdef TARGET_NR_umount
3529 case TARGET_NR_umount:
3530 if (!(p = lock_user_string(arg1)))
3531 goto efault;
3532 ret = get_errno(umount(p));
3533 unlock_user(p, arg1, 0);
3534 break;
3535 #endif
3536 #ifdef TARGET_NR_stime /* not on alpha */
3537 case TARGET_NR_stime:
3538 {
3539 time_t host_time;
3540 if (get_user_sal(host_time, arg1))
3541 goto efault;
3542 ret = get_errno(stime(&host_time));
3543 }
3544 break;
3545 #endif
3546 case TARGET_NR_ptrace:
3547 goto unimplemented;
3548 #ifdef TARGET_NR_alarm /* not on alpha */
3549 case TARGET_NR_alarm:
3550 ret = alarm(arg1);
3551 break;
3552 #endif
3553 #ifdef TARGET_NR_oldfstat
3554 case TARGET_NR_oldfstat:
3555 goto unimplemented;
3556 #endif
3557 #ifdef TARGET_NR_pause /* not on alpha */
3558 case TARGET_NR_pause:
3559 ret = get_errno(pause());
3560 break;
3561 #endif
3562 #ifdef TARGET_NR_utime
3563 case TARGET_NR_utime:
3564 {
3565 struct utimbuf tbuf, *host_tbuf;
3566 struct target_utimbuf *target_tbuf;
3567 if (arg2) {
3568 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
3569 goto efault;
3570 tbuf.actime = tswapl(target_tbuf->actime);
3571 tbuf.modtime = tswapl(target_tbuf->modtime);
3572 unlock_user_struct(target_tbuf, arg2, 0);
3573 host_tbuf = &tbuf;
3574 } else {
3575 host_tbuf = NULL;
3576 }
3577 if (!(p = lock_user_string(arg1)))
3578 goto efault;
3579 ret = get_errno(utime(p, host_tbuf));
3580 unlock_user(p, arg1, 0);
3581 }
3582 break;
3583 #endif
3584 case TARGET_NR_utimes:
3585 {
3586 struct timeval *tvp, tv[2];
3587 if (arg2) {
3588 if (copy_from_user_timeval(&tv[0], arg2)
3589 || copy_from_user_timeval(&tv[1],
3590 arg2 + sizeof(struct target_timeval)))
3591 goto efault;
3592 tvp = tv;
3593 } else {
3594 tvp = NULL;
3595 }
3596 if (!(p = lock_user_string(arg1)))
3597 goto efault;
3598 ret = get_errno(utimes(p, tvp));
3599 unlock_user(p, arg1, 0);
3600 }
3601 break;
3602 #ifdef TARGET_NR_stty
3603 case TARGET_NR_stty:
3604 goto unimplemented;
3605 #endif
3606 #ifdef TARGET_NR_gtty
3607 case TARGET_NR_gtty:
3608 goto unimplemented;
3609 #endif
3610 case TARGET_NR_access:
3611 if (!(p = lock_user_string(arg1)))
3612 goto efault;
3613 ret = get_errno(access(p, arg2));
3614 unlock_user(p, arg1, 0);
3615 break;
3616 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3617 case TARGET_NR_faccessat:
3618 if (!(p = lock_user_string(arg2)))
3619 goto efault;
3620 ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
3621 unlock_user(p, arg2, 0);
3622 break;
3623 #endif
3624 #ifdef TARGET_NR_nice /* not on alpha */
3625 case TARGET_NR_nice:
3626 ret = get_errno(nice(arg1));
3627 break;
3628 #endif
3629 #ifdef TARGET_NR_ftime
3630 case TARGET_NR_ftime:
3631 goto unimplemented;
3632 #endif
3633 case TARGET_NR_sync:
3634 sync();
3635 ret = 0;
3636 break;
3637 case TARGET_NR_kill:
3638 ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
3639 break;
3640 case TARGET_NR_rename:
3641 {
3642 void *p2;
3643 p = lock_user_string(arg1);
3644 p2 = lock_user_string(arg2);
3645 if (!p || !p2)
3646 ret = -TARGET_EFAULT;
3647 else
3648 ret = get_errno(rename(p, p2));
3649 unlock_user(p2, arg2, 0);
3650 unlock_user(p, arg1, 0);
3651 }
3652 break;
3653 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3654 case TARGET_NR_renameat:
3655 {
3656 void *p2;
3657 p = lock_user_string(arg2);
3658 p2 = lock_user_string(arg4);
3659 if (!p || !p2)
3660 ret = -TARGET_EFAULT;
3661 else
3662 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
3663 unlock_user(p2, arg4, 0);
3664 unlock_user(p, arg2, 0);
3665 }
3666 break;
3667 #endif
3668 case TARGET_NR_mkdir:
3669 if (!(p = lock_user_string(arg1)))
3670 goto efault;
3671 ret = get_errno(mkdir(p, arg2));
3672 unlock_user(p, arg1, 0);
3673 break;
3674 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3675 case TARGET_NR_mkdirat:
3676 if (!(p = lock_user_string(arg2)))
3677 goto efault;
3678 ret = get_errno(sys_mkdirat(arg1, p, arg3));
3679 unlock_user(p, arg2, 0);
3680 break;
3681 #endif
3682 case TARGET_NR_rmdir:
3683 if (!(p = lock_user_string(arg1)))
3684 goto efault;
3685 ret = get_errno(rmdir(p));
3686 unlock_user(p, arg1, 0);
3687 break;
3688 case TARGET_NR_dup:
3689 ret = get_errno(dup(arg1));
3690 break;
3691 case TARGET_NR_pipe:
3692 {
3693 int host_pipe[2];
3694 ret = get_errno(pipe(host_pipe));
3695 if (!is_error(ret)) {
3696 #if defined(TARGET_MIPS)
3697 CPUMIPSState *env = (CPUMIPSState*)cpu_env;
3698 env->active_tc.gpr[3] = host_pipe[1];
3699 ret = host_pipe[0];
3700 #elif defined(TARGET_SH4)
3701 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
3702 ret = host_pipe[0];
3703 #else
3704 if (put_user_s32(host_pipe[0], arg1)
3705 || put_user_s32(host_pipe[1], arg1 + sizeof(host_pipe[0])))
3706 goto efault;
3707 #endif
3708 }
3709 }
3710 break;
3711 case TARGET_NR_times:
3712 {
3713 struct target_tms *tmsp;
3714 struct tms tms;
3715 ret = get_errno(times(&tms));
3716 if (arg1) {
3717 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
3718 if (!tmsp)
3719 goto efault;
3720 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
3721 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
3722 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
3723 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
3724 }
3725 if (!is_error(ret))
3726 ret = host_to_target_clock_t(ret);
3727 }
3728 break;
3729 #ifdef TARGET_NR_prof
3730 case TARGET_NR_prof:
3731 goto unimplemented;
3732 #endif
3733 #ifdef TARGET_NR_signal
3734 case TARGET_NR_signal:
3735 goto unimplemented;
3736 #endif
3737 case TARGET_NR_acct:
3738 if (!(p = lock_user_string(arg1)))
3739 goto efault;
3740 ret = get_errno(acct(path(p)));
3741 unlock_user(p, arg1, 0);
3742 break;
3743 #ifdef TARGET_NR_umount2 /* not on alpha */
3744 case TARGET_NR_umount2:
3745 if (!(p = lock_user_string(arg1)))
3746 goto efault;
3747 ret = get_errno(umount2(p, arg2));
3748 unlock_user(p, arg1, 0);
3749 break;
3750 #endif
3751 #ifdef TARGET_NR_lock
3752 case TARGET_NR_lock:
3753 goto unimplemented;
3754 #endif
3755 case TARGET_NR_ioctl:
3756 ret = do_ioctl(arg1, arg2, arg3);
3757 break;
3758 case TARGET_NR_fcntl:
3759 ret = do_fcntl(arg1, arg2, arg3);
3760 break;
3761 #ifdef TARGET_NR_mpx
3762 case TARGET_NR_mpx:
3763 goto unimplemented;
3764 #endif
3765 case TARGET_NR_setpgid:
3766 ret = get_errno(setpgid(arg1, arg2));
3767 break;
3768 #ifdef TARGET_NR_ulimit
3769 case TARGET_NR_ulimit:
3770 goto unimplemented;
3771 #endif
3772 #ifdef TARGET_NR_oldolduname
3773 case TARGET_NR_oldolduname:
3774 goto unimplemented;
3775 #endif
3776 case TARGET_NR_umask:
3777 ret = get_errno(umask(arg1));
3778 break;
3779 case TARGET_NR_chroot:
3780 if (!(p = lock_user_string(arg1)))
3781 goto efault;
3782 ret = get_errno(chroot(p));
3783 unlock_user(p, arg1, 0);
3784 break;
3785 case TARGET_NR_ustat:
3786 goto unimplemented;
3787 case TARGET_NR_dup2:
3788 ret = get_errno(dup2(arg1, arg2));
3789 break;
3790 #ifdef TARGET_NR_getppid /* not on alpha */
3791 case TARGET_NR_getppid:
3792 ret = get_errno(getppid());
3793 break;
3794 #endif
3795 case TARGET_NR_getpgrp:
3796 ret = get_errno(getpgrp());
3797 break;
3798 case TARGET_NR_setsid:
3799 ret = get_errno(setsid());
3800 break;
3801 #ifdef TARGET_NR_sigaction
3802 case TARGET_NR_sigaction:
3803 {
3804 #if !defined(TARGET_MIPS)
3805 struct target_old_sigaction *old_act;
3806 struct target_sigaction act, oact, *pact;
3807 if (arg2) {
3808 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3809 goto efault;
3810 act._sa_handler = old_act->_sa_handler;
3811 target_siginitset(&act.sa_mask, old_act->sa_mask);
3812 act.sa_flags = old_act->sa_flags;
3813 act.sa_restorer = old_act->sa_restorer;
3814 unlock_user_struct(old_act, arg2, 0);
3815 pact = &act;
3816 } else {
3817 pact = NULL;
3818 }
3819 ret = get_errno(do_sigaction(arg1, pact, &oact));
3820 if (!is_error(ret) && arg3) {
3821 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3822 goto efault;
3823 old_act->_sa_handler = oact._sa_handler;
3824 old_act->sa_mask = oact.sa_mask.sig[0];
3825 old_act->sa_flags = oact.sa_flags;
3826 old_act->sa_restorer = oact.sa_restorer;
3827 unlock_user_struct(old_act, arg3, 1);
3828 }
3829 #else
3830 struct target_sigaction act, oact, *pact, *old_act;
3831
3832 if (arg2) {
3833 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3834 goto efault;
3835 act._sa_handler = old_act->_sa_handler;
3836 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
3837 act.sa_flags = old_act->sa_flags;
3838 unlock_user_struct(old_act, arg2, 0);
3839 pact = &act;
3840 } else {
3841 pact = NULL;
3842 }
3843
3844 ret = get_errno(do_sigaction(arg1, pact, &oact));
3845
3846 if (!is_error(ret) && arg3) {
3847 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3848 goto efault;
3849 old_act->_sa_handler = oact._sa_handler;
3850 old_act->sa_flags = oact.sa_flags;
3851 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
3852 old_act->sa_mask.sig[1] = 0;
3853 old_act->sa_mask.sig[2] = 0;
3854 old_act->sa_mask.sig[3] = 0;
3855 unlock_user_struct(old_act, arg3, 1);
3856 }
3857 #endif
3858 }
3859 break;
3860 #endif
3861 case TARGET_NR_rt_sigaction:
3862 {
3863 struct target_sigaction *act;
3864 struct target_sigaction *oact;
3865
3866 if (arg2) {
3867 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
3868 goto efault;
3869 } else
3870 act = NULL;
3871 if (arg3) {
3872 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
3873 ret = -TARGET_EFAULT;
3874 goto rt_sigaction_fail;
3875 }
3876 } else
3877 oact = NULL;
3878 ret = get_errno(do_sigaction(arg1, act, oact));
3879 rt_sigaction_fail:
3880 if (act)
3881 unlock_user_struct(act, arg2, 0);
3882 if (oact)
3883 unlock_user_struct(oact, arg3, 1);
3884 }
3885 break;
3886 #ifdef TARGET_NR_sgetmask /* not on alpha */
3887 case TARGET_NR_sgetmask:
3888 {
3889 sigset_t cur_set;
3890 abi_ulong target_set;
3891 sigprocmask(0, NULL, &cur_set);
3892 host_to_target_old_sigset(&target_set, &cur_set);
3893 ret = target_set;
3894 }
3895 break;
3896 #endif
3897 #ifdef TARGET_NR_ssetmask /* not on alpha */
3898 case TARGET_NR_ssetmask:
3899 {
3900 sigset_t set, oset, cur_set;
3901 abi_ulong target_set = arg1;
3902 sigprocmask(0, NULL, &cur_set);
3903 target_to_host_old_sigset(&set, &target_set);
3904 sigorset(&set, &set, &cur_set);
3905 sigprocmask(SIG_SETMASK, &set, &oset);
3906 host_to_target_old_sigset(&target_set, &oset);
3907 ret = target_set;
3908 }
3909 break;
3910 #endif
3911 #ifdef TARGET_NR_sigprocmask
3912 case TARGET_NR_sigprocmask:
3913 {
3914 int how = arg1;
3915 sigset_t set, oldset, *set_ptr;
3916
3917 if (arg2) {
3918 switch(how) {
3919 case TARGET_SIG_BLOCK:
3920 how = SIG_BLOCK;
3921 break;
3922 case TARGET_SIG_UNBLOCK:
3923 how = SIG_UNBLOCK;
3924 break;
3925 case TARGET_SIG_SETMASK:
3926 how = SIG_SETMASK;
3927 break;
3928 default:
3929 ret = -TARGET_EINVAL;
3930 goto fail;
3931 }
3932 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
3933 goto efault;
3934 target_to_host_old_sigset(&set, p);
3935 unlock_user(p, arg2, 0);
3936 set_ptr = &set;
3937 } else {
3938 how = 0;
3939 set_ptr = NULL;
3940 }
3941 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
3942 if (!is_error(ret) && arg3) {
3943 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
3944 goto efault;
3945 host_to_target_old_sigset(p, &oldset);
3946 unlock_user(p, arg3, sizeof(target_sigset_t));
3947 }
3948 }
3949 break;
3950 #endif
3951 case TARGET_NR_rt_sigprocmask:
3952 {
3953 int how = arg1;
3954 sigset_t set, oldset, *set_ptr;
3955
3956 if (arg2) {
3957 switch(how) {
3958 case TARGET_SIG_BLOCK:
3959 how = SIG_BLOCK;
3960 break;
3961 case TARGET_SIG_UNBLOCK:
3962 how = SIG_UNBLOCK;
3963 break;
3964 case TARGET_SIG_SETMASK:
3965 how = SIG_SETMASK;
3966 break;
3967 default:
3968 ret = -TARGET_EINVAL;
3969 goto fail;
3970 }
3971 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
3972 goto efault;
3973 target_to_host_sigset(&set, p);
3974 unlock_user(p, arg2, 0);
3975 set_ptr = &set;
3976 } else {
3977 how = 0;
3978 set_ptr = NULL;
3979 }
3980 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
3981 if (!is_error(ret) && arg3) {
3982 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
3983 goto efault;
3984 host_to_target_sigset(p, &oldset);
3985 unlock_user(p, arg3, sizeof(target_sigset_t));
3986 }
3987 }
3988 break;
3989 #ifdef TARGET_NR_sigpending
3990 case TARGET_NR_sigpending:
3991 {
3992 sigset_t set;
3993 ret = get_errno(sigpending(&set));
3994 if (!is_error(ret)) {
3995 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
3996 goto efault;
3997 host_to_target_old_sigset(p, &set);
3998 unlock_user(p, arg1, sizeof(target_sigset_t));
3999 }
4000 }
4001 break;
4002 #endif
4003 case TARGET_NR_rt_sigpending:
4004 {
4005 sigset_t set;
4006 ret = get_errno(sigpending(&set));
4007 if (!is_error(ret)) {
4008 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4009 goto efault;
4010 host_to_target_sigset(p, &set);
4011 unlock_user(p, arg1, sizeof(target_sigset_t));
4012 }
4013 }
4014 break;
4015 #ifdef TARGET_NR_sigsuspend
4016 case TARGET_NR_sigsuspend:
4017 {
4018 sigset_t set;
4019 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4020 goto efault;
4021 target_to_host_old_sigset(&set, p);
4022 unlock_user(p, arg1, 0);
4023 ret = get_errno(sigsuspend(&set));
4024 }
4025 break;
4026 #endif
4027 case TARGET_NR_rt_sigsuspend:
4028 {
4029 sigset_t set;
4030 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4031 goto efault;
4032 target_to_host_sigset(&set, p);
4033 unlock_user(p, arg1, 0);
4034 ret = get_errno(sigsuspend(&set));
4035 }
4036 break;
4037 case TARGET_NR_rt_sigtimedwait:
4038 {
4039 sigset_t set;
4040 struct timespec uts, *puts;
4041 siginfo_t uinfo;
4042
4043 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4044 goto efault;
4045 target_to_host_sigset(&set, p);
4046 unlock_user(p, arg1, 0);
4047 if (arg3) {
4048 puts = &uts;
4049 target_to_host_timespec(puts, arg3);
4050 } else {
4051 puts = NULL;
4052 }
4053 ret = get_errno(sigtimedwait(&set, &uinfo, puts));
4054 if (!is_error(ret) && arg2) {
4055 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
4056 goto efault;
4057 host_to_target_siginfo(p, &uinfo);
4058 unlock_user(p, arg2, sizeof(target_siginfo_t));
4059 }
4060 }
4061 break;
4062 case TARGET_NR_rt_sigqueueinfo:
4063 {
4064 siginfo_t uinfo;
4065 if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
4066 goto efault;
4067 target_to_host_siginfo(&uinfo, p);
4068 unlock_user(p, arg1, 0);
4069 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
4070 }
4071 break;
4072 #ifdef TARGET_NR_sigreturn
4073 case TARGET_NR_sigreturn:
4074 /* NOTE: ret is eax, so not transcoding must be done */
4075 ret = do_sigreturn(cpu_env);
4076 break;
4077 #endif
4078 case TARGET_NR_rt_sigreturn:
4079 /* NOTE: ret is eax, so not transcoding must be done */
4080 ret = do_rt_sigreturn(cpu_env);
4081 break;
4082 case TARGET_NR_sethostname:
4083 if (!(p = lock_user_string(arg1)))
4084 goto efault;
4085 ret = get_errno(sethostname(p, arg2));
4086 unlock_user(p, arg1, 0);
4087 break;
4088 case TARGET_NR_setrlimit:
4089 {
4090 /* XXX: convert resource ? */
4091 int resource = arg1;
4092 struct target_rlimit *target_rlim;
4093 struct rlimit rlim;
4094 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
4095 goto efault;
4096 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4097 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4098 unlock_user_struct(target_rlim, arg2, 0);
4099 ret = get_errno(setrlimit(resource, &rlim));
4100 }
4101 break;
4102 case TARGET_NR_getrlimit:
4103 {
4104 /* XXX: convert resource ? */
4105 int resource = arg1;
4106 struct target_rlimit *target_rlim;
4107 struct rlimit rlim;
4108
4109 ret = get_errno(getrlimit(resource, &rlim));
4110 if (!is_error(ret)) {
4111 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
4112 goto efault;
4113 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4114 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4115 unlock_user_struct(target_rlim, arg2, 1);
4116 }
4117 }
4118 break;
4119 case TARGET_NR_getrusage:
4120 {
4121 struct rusage rusage;
4122 ret = get_errno(getrusage(arg1, &rusage));
4123 if (!is_error(ret)) {
4124 host_to_target_rusage(arg2, &rusage);
4125 }
4126 }
4127 break;
4128 case TARGET_NR_gettimeofday:
4129 {
4130 struct timeval tv;
4131 ret = get_errno(gettimeofday(&tv, NULL));
4132 if (!is_error(ret)) {
4133 if (copy_to_user_timeval(arg1, &tv))
4134 goto efault;
4135 }
4136 }
4137 break;
4138 case TARGET_NR_settimeofday:
4139 {
4140 struct timeval tv;
4141 if (copy_from_user_timeval(&tv, arg1))
4142 goto efault;
4143 ret = get_errno(settimeofday(&tv, NULL));
4144 }
4145 break;
4146 #ifdef TARGET_NR_select
4147 case TARGET_NR_select:
4148 {
4149 struct target_sel_arg_struct *sel;
4150 abi_ulong inp, outp, exp, tvp;
4151 long nsel;
4152
4153 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
4154 goto efault;
4155 nsel = tswapl(sel->n);
4156 inp = tswapl(sel->inp);
4157 outp = tswapl(sel->outp);
4158 exp = tswapl(sel->exp);
4159 tvp = tswapl(sel->tvp);
4160 unlock_user_struct(sel, arg1, 0);
4161 ret = do_select(nsel, inp, outp, exp, tvp);
4162 }
4163 break;
4164 #endif
4165 case TARGET_NR_symlink:
4166 {
4167 void *p2;
4168 p = lock_user_string(arg1);
4169 p2 = lock_user_string(arg2);
4170 if (!p || !p2)
4171 ret = -TARGET_EFAULT;
4172 else
4173 ret = get_errno(symlink(p, p2));
4174 unlock_user(p2, arg2, 0);
4175 unlock_user(p, arg1, 0);
4176 }
4177 break;
4178 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4179 case TARGET_NR_symlinkat:
4180 {
4181 void *p2;
4182 p = lock_user_string(arg1);
4183 p2 = lock_user_string(arg3);
4184 if (!p || !p2)
4185 ret = -TARGET_EFAULT;
4186 else
4187 ret = get_errno(sys_symlinkat(p, arg2, p2));
4188 unlock_user(p2, arg3, 0);
4189 unlock_user(p, arg1, 0);
4190 }
4191 break;
4192 #endif
4193 #ifdef TARGET_NR_oldlstat
4194 case TARGET_NR_oldlstat:
4195 goto unimplemented;
4196 #endif
4197 case TARGET_NR_readlink:
4198 {
4199 void *p2;
4200 p = lock_user_string(arg1);
4201 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
4202 if (!p || !p2)
4203 ret = -TARGET_EFAULT;
4204 else
4205 ret = get_errno(readlink(path(p), p2, arg3));
4206 unlock_user(p2, arg2, ret);
4207 unlock_user(p, arg1, 0);
4208 }
4209 break;
4210 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4211 case TARGET_NR_readlinkat:
4212 {
4213 void *p2;
4214 p = lock_user_string(arg2);
4215 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
4216 if (!p || !p2)
4217 ret = -TARGET_EFAULT;
4218 else
4219 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
4220 unlock_user(p2, arg3, ret);
4221 unlock_user(p, arg2, 0);
4222 }
4223 break;
4224 #endif
4225 #ifdef TARGET_NR_uselib
4226 case TARGET_NR_uselib:
4227 goto unimplemented;
4228 #endif
4229 #ifdef TARGET_NR_swapon
4230 case TARGET_NR_swapon:
4231 if (!(p = lock_user_string(arg1)))
4232 goto efault;
4233 ret = get_errno(swapon(p, arg2));
4234 unlock_user(p, arg1, 0);
4235 break;
4236 #endif
4237 case TARGET_NR_reboot:
4238 goto unimplemented;
4239 #ifdef TARGET_NR_readdir
4240 case TARGET_NR_readdir:
4241 goto unimplemented;
4242 #endif
4243 #ifdef TARGET_NR_mmap
4244 case TARGET_NR_mmap:
4245 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
4246 {
4247 abi_ulong *v;
4248 abi_ulong v1, v2, v3, v4, v5, v6;
4249 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
4250 goto efault;
4251 v1 = tswapl(v[0]);
4252 v2 = tswapl(v[1]);
4253 v3 = tswapl(v[2]);
4254 v4 = tswapl(v[3]);
4255 v5 = tswapl(v[4]);
4256 v6 = tswapl(v[5]);
4257 unlock_user(v, arg1, 0);
4258 ret = get_errno(target_mmap(v1, v2, v3,
4259 target_to_host_bitmask(v4, mmap_flags_tbl),
4260 v5, v6));
4261 }
4262 #else
4263 ret = get_errno(target_mmap(arg1, arg2, arg3,
4264 target_to_host_bitmask(arg4, mmap_flags_tbl),
4265 arg5,
4266 arg6));
4267 #endif
4268 break;
4269 #endif
4270 #ifdef TARGET_NR_mmap2
4271 case TARGET_NR_mmap2:
4272 #ifndef MMAP_SHIFT
4273 #define MMAP_SHIFT 12
4274 #endif
4275 ret = get_errno(target_mmap(arg1, arg2, arg3,
4276 target_to_host_bitmask(arg4, mmap_flags_tbl),
4277 arg5,
4278 arg6 << MMAP_SHIFT));
4279 break;
4280 #endif
4281 case TARGET_NR_munmap:
4282 ret = get_errno(target_munmap(arg1, arg2));
4283 break;
4284 case TARGET_NR_mprotect:
4285 ret = get_errno(target_mprotect(arg1, arg2, arg3));
4286 break;
4287 #ifdef TARGET_NR_mremap
4288 case TARGET_NR_mremap:
4289 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
4290 break;
4291 #endif
4292 /* ??? msync/mlock/munlock are broken for softmmu. */
4293 #ifdef TARGET_NR_msync
4294 case TARGET_NR_msync:
4295 ret = get_errno(msync(g2h(arg1), arg2, arg3));
4296 break;
4297 #endif
4298 #ifdef TARGET_NR_mlock
4299 case TARGET_NR_mlock:
4300 ret = get_errno(mlock(g2h(arg1), arg2));
4301 break;
4302 #endif
4303 #ifdef TARGET_NR_munlock
4304 case TARGET_NR_munlock:
4305 ret = get_errno(munlock(g2h(arg1), arg2));
4306 break;
4307 #endif
4308 #ifdef TARGET_NR_mlockall
4309 case TARGET_NR_mlockall:
4310 ret = get_errno(mlockall(arg1));
4311 break;
4312 #endif
4313 #ifdef TARGET_NR_munlockall
4314 case TARGET_NR_munlockall:
4315 ret = get_errno(munlockall());
4316 break;
4317 #endif
4318 case TARGET_NR_truncate:
4319 if (!(p = lock_user_string(arg1)))
4320 goto efault;
4321 ret = get_errno(truncate(p, arg2));
4322 unlock_user(p, arg1, 0);
4323 break;
4324 case TARGET_NR_ftruncate:
4325 ret = get_errno(ftruncate(arg1, arg2));
4326 break;
4327 case TARGET_NR_fchmod:
4328 ret = get_errno(fchmod(arg1, arg2));
4329 break;
4330 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4331 case TARGET_NR_fchmodat:
4332 if (!(p = lock_user_string(arg2)))
4333 goto efault;
4334 ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4));
4335 unlock_user(p, arg2, 0);
4336 break;
4337 #endif
4338 case TARGET_NR_getpriority:
4339 /* libc does special remapping of the return value of
4340 * sys_getpriority() so it's just easiest to call
4341 * sys_getpriority() directly rather than through libc. */
4342 ret = sys_getpriority(arg1, arg2);
4343 break;
4344 case TARGET_NR_setpriority:
4345 ret = get_errno(setpriority(arg1, arg2, arg3));
4346 break;
4347 #ifdef TARGET_NR_profil
4348 case TARGET_NR_profil:
4349 goto unimplemented;
4350 #endif
4351 case TARGET_NR_statfs:
4352 if (!(p = lock_user_string(arg1)))
4353 goto efault;
4354 ret = get_errno(statfs(path(p), &stfs));
4355 unlock_user(p, arg1, 0);
4356 convert_statfs:
4357 if (!is_error(ret)) {
4358 struct target_statfs *target_stfs;
4359
4360 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
4361 goto efault;
4362 __put_user(stfs.f_type, &target_stfs->f_type);
4363 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4364 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4365 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4366 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4367 __put_user(stfs.f_files, &target_stfs->f_files);
4368 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4369 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4370 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4371 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4372 unlock_user_struct(target_stfs, arg2, 1);
4373 }
4374 break;
4375 case TARGET_NR_fstatfs:
4376 ret = get_errno(fstatfs(arg1, &stfs));
4377 goto convert_statfs;
4378 #ifdef TARGET_NR_statfs64
4379 case TARGET_NR_statfs64:
4380 if (!(p = lock_user_string(arg1)))
4381 goto efault;
4382 ret = get_errno(statfs(path(p), &stfs));
4383 unlock_user(p, arg1, 0);
4384 convert_statfs64:
4385 if (!is_error(ret)) {
4386 struct target_statfs64 *target_stfs;
4387
4388 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
4389 goto efault;
4390 __put_user(stfs.f_type, &target_stfs->f_type);
4391 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4392 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4393 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4394 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4395 __put_user(stfs.f_files, &target_stfs->f_files);
4396 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4397 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4398 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4399 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4400 unlock_user_struct(target_stfs, arg3, 1);
4401 }
4402 break;
4403 case TARGET_NR_fstatfs64:
4404 ret = get_errno(fstatfs(arg1, &stfs));
4405 goto convert_statfs64;
4406 #endif
4407 #ifdef TARGET_NR_ioperm
4408 case TARGET_NR_ioperm:
4409 goto unimplemented;
4410 #endif
4411 #ifdef TARGET_NR_socketcall
4412 case TARGET_NR_socketcall:
4413 ret = do_socketcall(arg1, arg2);
4414 break;
4415 #endif
4416 #ifdef TARGET_NR_accept
4417 case TARGET_NR_accept:
4418 ret = do_accept(arg1, arg2, arg3);
4419 break;
4420 #endif
4421 #ifdef TARGET_NR_bind
4422 case TARGET_NR_bind:
4423 ret = do_bind(arg1, arg2, arg3);
4424 break;
4425 #endif
4426 #ifdef TARGET_NR_connect
4427 case TARGET_NR_connect:
4428 ret = do_connect(arg1, arg2, arg3);
4429 break;
4430 #endif
4431 #ifdef TARGET_NR_getpeername
4432 case TARGET_NR_getpeername:
4433 ret = do_getpeername(arg1, arg2, arg3);
4434 break;
4435 #endif
4436 #ifdef TARGET_NR_getsockname
4437 case TARGET_NR_getsockname:
4438 ret = do_getsockname(arg1, arg2, arg3);
4439 break;
4440 #endif
4441 #ifdef TARGET_NR_getsockopt
4442 case TARGET_NR_getsockopt:
4443 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
4444 break;
4445 #endif
4446 #ifdef TARGET_NR_listen
4447 case TARGET_NR_listen:
4448 ret = get_errno(listen(arg1, arg2));
4449 break;
4450 #endif
4451 #ifdef TARGET_NR_recv
4452 case TARGET_NR_recv:
4453 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
4454 break;
4455 #endif
4456 #ifdef TARGET_NR_recvfrom
4457 case TARGET_NR_recvfrom:
4458 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
4459 break;
4460 #endif
4461 #ifdef TARGET_NR_recvmsg
4462 case TARGET_NR_recvmsg:
4463 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
4464 break;
4465 #endif
4466 #ifdef TARGET_NR_send
4467 case TARGET_NR_send:
4468 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
4469 break;
4470 #endif
4471 #ifdef TARGET_NR_sendmsg
4472 case TARGET_NR_sendmsg:
4473 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
4474 break;
4475 #endif
4476 #ifdef TARGET_NR_sendto
4477 case TARGET_NR_sendto:
4478 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
4479 break;
4480 #endif
4481 #ifdef TARGET_NR_shutdown
4482 case TARGET_NR_shutdown:
4483 ret = get_errno(shutdown(arg1, arg2));
4484 break;
4485 #endif
4486 #ifdef TARGET_NR_socket
4487 case TARGET_NR_socket:
4488 ret = do_socket(arg1, arg2, arg3);
4489 break;
4490 #endif
4491 #ifdef TARGET_NR_socketpair
4492 case TARGET_NR_socketpair:
4493 ret = do_socketpair(arg1, arg2, arg3, arg4);
4494 break;
4495 #endif
4496 #ifdef TARGET_NR_setsockopt
4497 case TARGET_NR_setsockopt:
4498 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
4499 break;
4500 #endif
4501
4502 case TARGET_NR_syslog:
4503 if (!(p = lock_user_string(arg2)))
4504 goto efault;
4505 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
4506 unlock_user(p, arg2, 0);
4507 break;
4508
4509 case TARGET_NR_setitimer:
4510 {
4511 struct itimerval value, ovalue, *pvalue;
4512
4513 if (arg2) {
4514 pvalue = &value;
4515 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
4516 || copy_from_user_timeval(&pvalue->it_value,
4517 arg2 + sizeof(struct target_timeval)))
4518 goto efault;
4519 } else {
4520 pvalue = NULL;
4521 }
4522 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
4523 if (!is_error(ret) && arg3) {
4524 if (copy_to_user_timeval(arg3,
4525 &ovalue.it_interval)
4526 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
4527 &ovalue.it_value))
4528 goto efault;
4529 }
4530 }
4531 break;
4532 case TARGET_NR_getitimer:
4533 {
4534 struct itimerval value;
4535
4536 ret = get_errno(getitimer(arg1, &value));
4537 if (!is_error(ret) && arg2) {
4538 if (copy_to_user_timeval(arg2,
4539 &value.it_interval)
4540 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
4541 &value.it_value))
4542 goto efault;
4543 }
4544 }
4545 break;
4546 case TARGET_NR_stat:
4547 if (!(p = lock_user_string(arg1)))
4548 goto efault;
4549 ret = get_errno(stat(path(p), &st));
4550 unlock_user(p, arg1, 0);
4551 goto do_stat;
4552 case TARGET_NR_lstat:
4553 if (!(p = lock_user_string(arg1)))
4554 goto efault;
4555 ret = get_errno(lstat(path(p), &st));
4556 unlock_user(p, arg1, 0);
4557 goto do_stat;
4558 case TARGET_NR_fstat:
4559 {
4560 ret = get_errno(fstat(arg1, &st));
4561 do_stat:
4562 if (!is_error(ret)) {
4563 struct target_stat *target_st;
4564
4565 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
4566 goto efault;
4567 __put_user(st.st_dev, &target_st->st_dev);
4568 __put_user(st.st_ino, &target_st->st_ino);
4569 __put_user(st.st_mode, &target_st->st_mode);
4570 __put_user(st.st_uid, &target_st->st_uid);
4571 __put_user(st.st_gid, &target_st->st_gid);
4572 __put_user(st.st_nlink, &target_st->st_nlink);
4573 __put_user(st.st_rdev, &target_st->st_rdev);
4574 __put_user(st.st_size, &target_st->st_size);
4575 __put_user(st.st_blksize, &target_st->st_blksize);
4576 __put_user(st.st_blocks, &target_st->st_blocks);
4577 __put_user(st.st_atime, &target_st->target_st_atime);
4578 __put_user(st.st_mtime, &target_st->target_st_mtime);
4579 __put_user(st.st_ctime, &target_st->target_st_ctime);
4580 unlock_user_struct(target_st, arg2, 1);
4581 }
4582 }
4583 break;
4584 #ifdef TARGET_NR_olduname
4585 case TARGET_NR_olduname:
4586 goto unimplemented;
4587 #endif
4588 #ifdef TARGET_NR_iopl
4589 case TARGET_NR_iopl:
4590 goto unimplemented;
4591 #endif
4592 case TARGET_NR_vhangup:
4593 ret = get_errno(vhangup());
4594 break;
4595 #ifdef TARGET_NR_idle
4596 case TARGET_NR_idle:
4597 goto unimplemented;
4598 #endif
4599 #ifdef TARGET_NR_syscall
4600 case TARGET_NR_syscall:
4601 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
4602 break;
4603 #endif
4604 case TARGET_NR_wait4:
4605 {
4606 int status;
4607 abi_long status_ptr = arg2;
4608 struct rusage rusage, *rusage_ptr;
4609 abi_ulong target_rusage = arg4;
4610 if (target_rusage)
4611 rusage_ptr = &rusage;
4612 else
4613 rusage_ptr = NULL;
4614 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
4615 if (!is_error(ret)) {
4616 if (status_ptr) {
4617 if (put_user_s32(status, status_ptr))
4618 goto efault;
4619 }
4620 if (target_rusage)
4621 host_to_target_rusage(target_rusage, &rusage);
4622 }
4623 }
4624 break;
4625 #ifdef TARGET_NR_swapoff
4626 case TARGET_NR_swapoff:
4627 if (!(p = lock_user_string(arg1)))
4628 goto efault;
4629 ret = get_errno(swapoff(p));
4630 unlock_user(p, arg1, 0);
4631 break;
4632 #endif
4633 case TARGET_NR_sysinfo:
4634 {
4635 struct target_sysinfo *target_value;
4636 struct sysinfo value;
4637 ret = get_errno(sysinfo(&value));
4638 if (!is_error(ret) && arg1)
4639 {
4640 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
4641 goto efault;
4642 __put_user(value.uptime, &target_value->uptime);
4643 __put_user(value.loads[0], &target_value->loads[0]);
4644 __put_user(value.loads[1], &target_value->loads[1]);
4645 __put_user(value.loads[2], &target_value->loads[2]);
4646 __put_user(value.totalram, &target_value->totalram);
4647 __put_user(value.freeram, &target_value->freeram);
4648 __put_user(value.sharedram, &target_value->sharedram);
4649 __put_user(value.bufferram, &target_value->bufferram);
4650 __put_user(value.totalswap, &target_value->totalswap);
4651 __put_user(value.freeswap, &target_value->freeswap);
4652 __put_user(value.procs, &target_value->procs);
4653 __put_user(value.totalhigh, &target_value->totalhigh);
4654 __put_user(value.freehigh, &target_value->freehigh);
4655 __put_user(value.mem_unit, &target_value->mem_unit);
4656 unlock_user_struct(target_value, arg1, 1);
4657 }
4658 }
4659 break;
4660 #ifdef TARGET_NR_ipc
4661 case TARGET_NR_ipc:
4662 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
4663 break;
4664 #endif
4665 case TARGET_NR_fsync:
4666 ret = get_errno(fsync(arg1));
4667 break;
4668 case TARGET_NR_clone:
4669 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
4670 break;
4671 #ifdef __NR_exit_group
4672 /* new thread calls */
4673 case TARGET_NR_exit_group:
4674 gdb_exit(cpu_env, arg1);
4675 ret = get_errno(exit_group(arg1));
4676 break;
4677 #endif
4678 case TARGET_NR_setdomainname:
4679 if (!(p = lock_user_string(arg1)))
4680 goto efault;
4681 ret = get_errno(setdomainname(p, arg2));
4682 unlock_user(p, arg1, 0);
4683 break;
4684 case TARGET_NR_uname:
4685 /* no need to transcode because we use the linux syscall */
4686 {
4687 struct new_utsname * buf;
4688
4689 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
4690 goto efault;
4691 ret = get_errno(sys_uname(buf));
4692 if (!is_error(ret)) {
4693 /* Overrite the native machine name with whatever is being
4694 emulated. */
4695 strcpy (buf->machine, UNAME_MACHINE);
4696 /* Allow the user to override the reported release. */
4697 if (qemu_uname_release && *qemu_uname_release)
4698 strcpy (buf->release, qemu_uname_release);
4699 }
4700 unlock_user_struct(buf, arg1, 1);
4701 }
4702 break;
4703 #ifdef TARGET_I386
4704 case TARGET_NR_modify_ldt:
4705 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
4706 break;
4707 #if !defined(TARGET_X86_64)
4708 case TARGET_NR_vm86old:
4709 goto unimplemented;
4710 case TARGET_NR_vm86:
4711 ret = do_vm86(cpu_env, arg1, arg2);
4712 break;
4713 #endif
4714 #endif
4715 case TARGET_NR_adjtimex:
4716 goto unimplemented;
4717 #ifdef TARGET_NR_create_module
4718 case TARGET_NR_create_module:
4719 #endif
4720 case TARGET_NR_init_module:
4721 case TARGET_NR_delete_module:
4722 #ifdef TARGET_NR_get_kernel_syms
4723 case TARGET_NR_get_kernel_syms:
4724 #endif
4725 goto unimplemented;
4726 case TARGET_NR_quotactl:
4727 goto unimplemented;
4728 case TARGET_NR_getpgid:
4729 ret = get_errno(getpgid(arg1));
4730 break;
4731 case TARGET_NR_fchdir:
4732 ret = get_errno(fchdir(arg1));
4733 break;
4734 #ifdef TARGET_NR_bdflush /* not on x86_64 */
4735 case TARGET_NR_bdflush:
4736 goto unimplemented;
4737 #endif
4738 #ifdef TARGET_NR_sysfs
4739 case TARGET_NR_sysfs:
4740 goto unimplemented;
4741 #endif
4742 case TARGET_NR_personality:
4743 ret = get_errno(personality(arg1));
4744 break;
4745 #ifdef TARGET_NR_afs_syscall
4746 case TARGET_NR_afs_syscall:
4747 goto unimplemented;
4748 #endif
4749 #ifdef TARGET_NR__llseek /* Not on alpha */
4750 case TARGET_NR__llseek:
4751 {
4752 #if defined (__x86_64__)
4753 ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
4754 if (put_user_s64(ret, arg4))
4755 goto efault;
4756 #else
4757 int64_t res;
4758 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
4759 if (put_user_s64(res, arg4))
4760 goto efault;
4761 #endif
4762 }
4763 break;
4764 #endif
4765 case TARGET_NR_getdents:
4766 #if TARGET_ABI_BITS != 32
4767 goto unimplemented;
4768 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4769 {
4770 struct target_dirent *target_dirp;
4771 struct dirent *dirp;
4772 abi_long count = arg3;
4773
4774 dirp = malloc(count);
4775 if (!dirp) {
4776 ret = -TARGET_ENOMEM;
4777 goto fail;
4778 }
4779
4780 ret = get_errno(sys_getdents(arg1, dirp, count));
4781 if (!is_error(ret)) {
4782 struct dirent *de;
4783 struct target_dirent *tde;
4784 int len = ret;
4785 int reclen, treclen;
4786 int count1, tnamelen;
4787
4788 count1 = 0;
4789 de = dirp;
4790 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4791 goto efault;
4792 tde = target_dirp;
4793 while (len > 0) {
4794 reclen = de->d_reclen;
4795 treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
4796 tde->d_reclen = tswap16(treclen);
4797 tde->d_ino = tswapl(de->d_ino);
4798 tde->d_off = tswapl(de->d_off);
4799 tnamelen = treclen - (2 * sizeof(abi_long) + 2);
4800 if (tnamelen > 256)
4801 tnamelen = 256;
4802 /* XXX: may not be correct */
4803 strncpy(tde->d_name, de->d_name, tnamelen);
4804 de = (struct dirent *)((char *)de + reclen);
4805 len -= reclen;
4806 tde = (struct target_dirent *)((char *)tde + treclen);
4807 count1 += treclen;
4808 }
4809 ret = count1;
4810 unlock_user(target_dirp, arg2, ret);
4811 }
4812 free(dirp);
4813 }
4814 #else
4815 {
4816 struct dirent *dirp;
4817 abi_long count = arg3;
4818
4819 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4820 goto efault;
4821 ret = get_errno(sys_getdents(arg1, dirp, count));
4822 if (!is_error(ret)) {
4823 struct dirent *de;
4824 int len = ret;
4825 int reclen;
4826 de = dirp;
4827 while (len > 0) {
4828 reclen = de->d_reclen;
4829 if (reclen > len)
4830 break;
4831 de->d_reclen = tswap16(reclen);
4832 tswapls(&de->d_ino);
4833 tswapls(&de->d_off);
4834 de = (struct dirent *)((char *)de + reclen);
4835 len -= reclen;
4836 }
4837 }
4838 unlock_user(dirp, arg2, ret);
4839 }
4840 #endif
4841 break;
4842 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
4843 case TARGET_NR_getdents64:
4844 {
4845 struct dirent64 *dirp;
4846 abi_long count = arg3;
4847 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4848 goto efault;
4849 ret = get_errno(sys_getdents64(arg1, dirp, count));
4850 if (!is_error(ret)) {
4851 struct dirent64 *de;
4852 int len = ret;
4853 int reclen;
4854 de = dirp;
4855 while (len > 0) {
4856 reclen = de->d_reclen;
4857 if (reclen > len)
4858 break;
4859 de->d_reclen = tswap16(reclen);
4860 tswap64s((uint64_t *)&de->d_ino);
4861 tswap64s((uint64_t *)&de->d_off);
4862 de = (struct dirent64 *)((char *)de + reclen);
4863 len -= reclen;
4864 }
4865 }
4866 unlock_user(dirp, arg2, ret);
4867 }
4868 break;
4869 #endif /* TARGET_NR_getdents64 */
4870 #ifdef TARGET_NR__newselect
4871 case TARGET_NR__newselect:
4872 ret = do_select(arg1, arg2, arg3, arg4, arg5);
4873 break;
4874 #endif
4875 #ifdef TARGET_NR_poll
4876 case TARGET_NR_poll:
4877 {
4878 struct target_pollfd *target_pfd;
4879 unsigned int nfds = arg2;
4880 int timeout = arg3;
4881 struct pollfd *pfd;
4882 unsigned int i;
4883
4884 target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
4885 if (!target_pfd)
4886 goto efault;
4887 pfd = alloca(sizeof(struct pollfd) * nfds);
4888 for(i = 0; i < nfds; i++) {
4889 pfd[i].fd = tswap32(target_pfd[i].fd);
4890 pfd[i].events = tswap16(target_pfd[i].events);
4891 }
4892 ret = get_errno(poll(pfd, nfds, timeout));
4893 if (!is_error(ret)) {
4894 for(i = 0; i < nfds; i++) {
4895 target_pfd[i].revents = tswap16(pfd[i].revents);
4896 }
4897 ret += nfds * (sizeof(struct target_pollfd)
4898 - sizeof(struct pollfd));
4899 }
4900 unlock_user(target_pfd, arg1, ret);
4901 }
4902 break;
4903 #endif
4904 case TARGET_NR_flock:
4905 /* NOTE: the flock constant seems to be the same for every
4906 Linux platform */
4907 ret = get_errno(flock(arg1, arg2));
4908 break;
4909 case TARGET_NR_readv:
4910 {
4911 int count = arg3;
4912 struct iovec *vec;
4913
4914 vec = alloca(count * sizeof(struct iovec));
4915 if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
4916 goto efault;
4917 ret = get_errno(readv(arg1, vec, count));
4918 unlock_iovec(vec, arg2, count, 1);
4919 }
4920 break;
4921 case TARGET_NR_writev:
4922 {
4923 int count = arg3;
4924 struct iovec *vec;
4925
4926 vec = alloca(count * sizeof(struct iovec));
4927 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
4928 goto efault;
4929 ret = get_errno(writev(arg1, vec, count));
4930 unlock_iovec(vec, arg2, count, 0);
4931 }
4932 break;
4933 case TARGET_NR_getsid:
4934 ret = get_errno(getsid(arg1));
4935 break;
4936 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
4937 case TARGET_NR_fdatasync:
4938 ret = get_errno(fdatasync(arg1));
4939 break;
4940 #endif
4941 case TARGET_NR__sysctl:
4942 /* We don't implement this, but ENOTDIR is always a safe
4943 return value. */
4944 ret = -TARGET_ENOTDIR;
4945 break;
4946 case TARGET_NR_sched_setparam:
4947 {
4948 struct sched_param *target_schp;
4949 struct sched_param schp;
4950
4951 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
4952 goto efault;
4953 schp.sched_priority = tswap32(target_schp->sched_priority);
4954 unlock_user_struct(target_schp, arg2, 0);
4955 ret = get_errno(sched_setparam(arg1, &schp));
4956 }
4957 break;
4958 case TARGET_NR_sched_getparam:
4959 {
4960 struct sched_param *target_schp;
4961 struct sched_param schp;
4962 ret = get_errno(sched_getparam(arg1, &schp));
4963 if (!is_error(ret)) {
4964 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
4965 goto efault;
4966 target_schp->sched_priority = tswap32(schp.sched_priority);
4967 unlock_user_struct(target_schp, arg2, 1);
4968 }
4969 }
4970 break;
4971 case TARGET_NR_sched_setscheduler:
4972 {
4973 struct sched_param *target_schp;
4974 struct sched_param schp;
4975 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
4976 goto efault;
4977 schp.sched_priority = tswap32(target_schp->sched_priority);
4978 unlock_user_struct(target_schp, arg3, 0);
4979 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
4980 }
4981 break;
4982 case TARGET_NR_sched_getscheduler:
4983 ret = get_errno(sched_getscheduler(arg1));
4984 break;
4985 case TARGET_NR_sched_yield:
4986 ret = get_errno(sched_yield());
4987 break;
4988 case TARGET_NR_sched_get_priority_max:
4989 ret = get_errno(sched_get_priority_max(arg1));
4990 break;
4991 case TARGET_NR_sched_get_priority_min:
4992 ret = get_errno(sched_get_priority_min(arg1));
4993 break;
4994 case TARGET_NR_sched_rr_get_interval:
4995 {
4996 struct timespec ts;
4997 ret = get_errno(sched_rr_get_interval(arg1, &ts));
4998 if (!is_error(ret)) {
4999 host_to_target_timespec(arg2, &ts);
5000 }
5001 }
5002 break;
5003 case TARGET_NR_nanosleep:
5004 {
5005 struct timespec req, rem;
5006 target_to_host_timespec(&req, arg1);
5007 ret = get_errno(nanosleep(&req, &rem));
5008 if (is_error(ret) && arg2) {
5009 host_to_target_timespec(arg2, &rem);
5010 }
5011 }
5012 break;
5013 #ifdef TARGET_NR_query_module
5014 case TARGET_NR_query_module:
5015 goto unimplemented;
5016 #endif
5017 #ifdef TARGET_NR_nfsservctl
5018 case TARGET_NR_nfsservctl:
5019 goto unimplemented;
5020 #endif
5021 case TARGET_NR_prctl:
5022 switch (arg1)
5023 {
5024 case PR_GET_PDEATHSIG:
5025 {
5026 int deathsig;
5027 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
5028 if (!is_error(ret) && arg2
5029 && put_user_ual(deathsig, arg2))
5030 goto efault;
5031 }
5032 break;
5033 default:
5034 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
5035 break;
5036 }
5037 break;
5038 #ifdef TARGET_NR_arch_prctl
5039 case TARGET_NR_arch_prctl:
5040 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
5041 ret = do_arch_prctl(cpu_env, arg1, arg2);
5042 break;
5043 #else
5044 goto unimplemented;
5045 #endif
5046 #endif
5047 #ifdef TARGET_NR_pread
5048 case TARGET_NR_pread:
5049 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5050 goto efault;
5051 ret = get_errno(pread(arg1, p, arg3, arg4));
5052 unlock_user(p, arg2, ret);
5053 break;
5054 case TARGET_NR_pwrite:
5055 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5056 goto efault;
5057 ret = get_errno(pwrite(arg1, p, arg3, arg4));
5058 unlock_user(p, arg2, 0);
5059 break;
5060 #endif
5061 #ifdef TARGET_NR_pread64
5062 case TARGET_NR_pread64:
5063 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5064 goto efault;
5065 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
5066 unlock_user(p, arg2, ret);
5067 break;
5068 case TARGET_NR_pwrite64:
5069 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5070 goto efault;
5071 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
5072 unlock_user(p, arg2, 0);
5073 break;
5074 #endif
5075 case TARGET_NR_getcwd:
5076 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
5077 goto efault;
5078 ret = get_errno(sys_getcwd1(p, arg2));
5079 unlock_user(p, arg1, ret);
5080 break;
5081 case TARGET_NR_capget:
5082 goto unimplemented;
5083 case TARGET_NR_capset:
5084 goto unimplemented;
5085 case TARGET_NR_sigaltstack:
5086 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5087 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
5088 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
5089 break;
5090 #else
5091 goto unimplemented;
5092 #endif
5093 case TARGET_NR_sendfile:
5094 goto unimplemented;
5095 #ifdef TARGET_NR_getpmsg
5096 case TARGET_NR_getpmsg:
5097 goto unimplemented;
5098 #endif
5099 #ifdef TARGET_NR_putpmsg
5100 case TARGET_NR_putpmsg:
5101 goto unimplemented;
5102 #endif
5103 #ifdef TARGET_NR_vfork
5104 case TARGET_NR_vfork:
5105 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
5106 0, 0, 0, 0));
5107 break;
5108 #endif
5109 #ifdef TARGET_NR_ugetrlimit
5110 case TARGET_NR_ugetrlimit:
5111 {
5112 struct rlimit rlim;
5113 ret = get_errno(getrlimit(arg1, &rlim));
5114 if (!is_error(ret)) {
5115 struct target_rlimit *target_rlim;
5116 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
5117 goto efault;
5118 target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
5119 target_rlim->rlim_max = tswapl(rlim.rlim_max);
5120 unlock_user_struct(target_rlim, arg2, 1);
5121 }
5122 break;
5123 }
5124 #endif
5125 #ifdef TARGET_NR_truncate64
5126 case TARGET_NR_truncate64:
5127 if (!(p = lock_user_string(arg1)))
5128 goto efault;
5129 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
5130 unlock_user(p, arg1, 0);
5131 break;
5132 #endif
5133 #ifdef TARGET_NR_ftruncate64
5134 case TARGET_NR_ftruncate64:
5135 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
5136 break;
5137 #endif
5138 #ifdef TARGET_NR_stat64
5139 case TARGET_NR_stat64:
5140 if (!(p = lock_user_string(arg1)))
5141 goto efault;
5142 ret = get_errno(stat(path(p), &st));
5143 unlock_user(p, arg1, 0);
5144 goto do_stat64;
5145 #endif
5146 #ifdef TARGET_NR_lstat64
5147 case TARGET_NR_lstat64:
5148 if (!(p = lock_user_string(arg1)))
5149 goto efault;
5150 ret = get_errno(lstat(path(p), &st));
5151 unlock_user(p, arg1, 0);
5152 goto do_stat64;
5153 #endif
5154 #ifdef TARGET_NR_fstat64
5155 case TARGET_NR_fstat64:
5156 {
5157 ret = get_errno(fstat(arg1, &st));
5158 do_stat64:
5159 if (!is_error(ret)) {
5160 #ifdef TARGET_ARM
5161 if (((CPUARMState *)cpu_env)->eabi) {
5162 struct target_eabi_stat64 *target_st;
5163
5164 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
5165 goto efault;
5166 memset(target_st, 0, sizeof(struct target_eabi_stat64));
5167 __put_user(st.st_dev, &target_st->st_dev);
5168 __put_user(st.st_ino, &target_st->st_ino);
5169 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
5170 __put_user(st.st_ino, &target_st->__st_ino);
5171 #endif
5172 __put_user(st.st_mode, &target_st->st_mode);
5173 __put_user(st.st_nlink, &target_st->st_nlink);
5174 __put_user(st.st_uid, &target_st->st_uid);
5175 __put_user(st.st_gid, &target_st->st_gid);
5176 __put_user(st.st_rdev, &target_st->st_rdev);
5177 __put_user(st.st_size, &target_st->st_size);
5178 __put_user(st.st_blksize, &target_st->st_blksize);
5179 __put_user(st.st_blocks, &target_st->st_blocks);
5180 __put_user(st.st_atime, &target_st->target_st_atime);
5181 __put_user(st.st_mtime, &target_st->target_st_mtime);
5182 __put_user(st.st_ctime, &target_st->target_st_ctime);
5183 unlock_user_struct(target_st, arg2, 1);
5184 } else
5185 #endif
5186 {
5187 struct target_stat64 *target_st;
5188
5189 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
5190 goto efault;
5191 memset(target_st, 0, sizeof(struct target_stat64));
5192 __put_user(st.st_dev, &target_st->st_dev);
5193 __put_user(st.st_ino, &target_st->st_ino);
5194 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
5195 __put_user(st.st_ino, &target_st->__st_ino);
5196 #endif
5197 __put_user(st.st_mode, &target_st->st_mode);
5198 __put_user(st.st_nlink, &target_st->st_nlink);
5199 __put_user(st.st_uid, &target_st->st_uid);
5200 __put_user(st.st_gid, &target_st->st_gid);
5201 __put_user(st.st_rdev, &target_st->st_rdev);
5202 /* XXX: better use of kernel struct */
5203 __put_user(st.st_size, &target_st->st_size);
5204 __put_user(st.st_blksize, &target_st->st_blksize);
5205 __put_user(st.st_blocks, &target_st->st_blocks);
5206 __put_user(st.st_atime, &target_st->target_st_atime);
5207 __put_user(st.st_mtime, &target_st->target_st_mtime);
5208 __put_user(st.st_ctime, &target_st->target_st_ctime);
5209 unlock_user_struct(target_st, arg2, 1);
5210 }
5211 }
5212 }
5213 break;
5214 #endif
5215 #ifdef USE_UID16
5216 case TARGET_NR_lchown:
5217 if (!(p = lock_user_string(arg1)))
5218 goto efault;
5219 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
5220 unlock_user(p, arg1, 0);
5221 break;
5222 case TARGET_NR_getuid:
5223 ret = get_errno(high2lowuid(getuid()));
5224 break;
5225 case TARGET_NR_getgid:
5226 ret = get_errno(high2lowgid(getgid()));
5227 break;
5228 case TARGET_NR_geteuid:
5229 ret = get_errno(high2lowuid(geteuid()));
5230 break;
5231 case TARGET_NR_getegid:
5232 ret = get_errno(high2lowgid(getegid()));
5233 break;
5234 case TARGET_NR_setreuid:
5235 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
5236 break;
5237 case TARGET_NR_setregid:
5238 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
5239 break;
5240 case TARGET_NR_getgroups:
5241 {
5242 int gidsetsize = arg1;
5243 uint16_t *target_grouplist;
5244 gid_t *grouplist;
5245 int i;
5246
5247 grouplist = alloca(gidsetsize * sizeof(gid_t));
5248 ret = get_errno(getgroups(gidsetsize, grouplist));
5249 if (!is_error(ret)) {
5250 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
5251 if (!target_grouplist)
5252 goto efault;
5253 for(i = 0;i < gidsetsize; i++)
5254 target_grouplist[i] = tswap16(grouplist[i]);
5255 unlock_user(target_grouplist, arg2, gidsetsize * 2);
5256 }
5257 }
5258 break;
5259 case TARGET_NR_setgroups:
5260 {
5261 int gidsetsize = arg1;
5262 uint16_t *target_grouplist;
5263 gid_t *grouplist;
5264 int i;
5265
5266 grouplist = alloca(gidsetsize * sizeof(gid_t));
5267 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
5268 if (!target_grouplist) {
5269 ret = -TARGET_EFAULT;
5270 goto fail;
5271 }
5272 for(i = 0;i < gidsetsize; i++)
5273 grouplist[i] = tswap16(target_grouplist[i]);
5274 unlock_user(target_grouplist, arg2, 0);
5275 ret = get_errno(setgroups(gidsetsize, grouplist));
5276 }
5277 break;
5278 case TARGET_NR_fchown:
5279 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
5280 break;
5281 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5282 case TARGET_NR_fchownat:
5283 if (!(p = lock_user_string(arg2)))
5284 goto efault;
5285 ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
5286 unlock_user(p, arg2, 0);
5287 break;
5288 #endif
5289 #ifdef TARGET_NR_setresuid
5290 case TARGET_NR_setresuid:
5291 ret = get_errno(setresuid(low2highuid(arg1),
5292 low2highuid(arg2),
5293 low2highuid(arg3)));
5294 break;
5295 #endif
5296 #ifdef TARGET_NR_getresuid
5297 case TARGET_NR_getresuid:
5298 {
5299 uid_t ruid, euid, suid;
5300 ret = get_errno(getresuid(&ruid, &euid, &suid));
5301 if (!is_error(ret)) {
5302 if (put_user_u16(high2lowuid(ruid), arg1)
5303 || put_user_u16(high2lowuid(euid), arg2)
5304 || put_user_u16(high2lowuid(suid), arg3))
5305 goto efault;
5306 }
5307 }
5308 break;
5309 #endif
5310 #ifdef TARGET_NR_getresgid
5311 case TARGET_NR_setresgid:
5312 ret = get_errno(setresgid(low2highgid(arg1),
5313 low2highgid(arg2),
5314 low2highgid(arg3)));
5315 break;
5316 #endif
5317 #ifdef TARGET_NR_getresgid
5318 case TARGET_NR_getresgid:
5319 {
5320 gid_t rgid, egid, sgid;
5321 ret = get_errno(getresgid(&rgid, &egid, &sgid));
5322 if (!is_error(ret)) {
5323 if (put_user_u16(high2lowgid(rgid), arg1)
5324 || put_user_u16(high2lowgid(egid), arg2)
5325 || put_user_u16(high2lowgid(sgid), arg3))
5326 goto efault;
5327 }
5328 }
5329 break;
5330 #endif
5331 case TARGET_NR_chown:
5332 if (!(p = lock_user_string(arg1)))
5333 goto efault;
5334 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
5335 unlock_user(p, arg1, 0);
5336 break;
5337 case TARGET_NR_setuid:
5338 ret = get_errno(setuid(low2highuid(arg1)));
5339 break;
5340 case TARGET_NR_setgid:
5341 ret = get_errno(setgid(low2highgid(arg1)));
5342 break;
5343 case TARGET_NR_setfsuid:
5344 ret = get_errno(setfsuid(arg1));
5345 break;
5346 case TARGET_NR_setfsgid:
5347 ret = get_errno(setfsgid(arg1));
5348 break;
5349 #endif /* USE_UID16 */
5350
5351 #ifdef TARGET_NR_lchown32
5352 case TARGET_NR_lchown32:
5353 if (!(p = lock_user_string(arg1)))
5354 goto efault;
5355 ret = get_errno(lchown(p, arg2, arg3));
5356 unlock_user(p, arg1, 0);
5357 break;
5358 #endif
5359 #ifdef TARGET_NR_getuid32
5360 case TARGET_NR_getuid32:
5361 ret = get_errno(getuid());
5362 break;
5363 #endif
5364 #ifdef TARGET_NR_getgid32
5365 case TARGET_NR_getgid32:
5366 ret = get_errno(getgid());
5367 break;
5368 #endif
5369 #ifdef TARGET_NR_geteuid32
5370 case TARGET_NR_geteuid32:
5371 ret = get_errno(geteuid());
5372 break;
5373 #endif
5374 #ifdef TARGET_NR_getegid32
5375 case TARGET_NR_getegid32:
5376 ret = get_errno(getegid());
5377 break;
5378 #endif
5379 #ifdef TARGET_NR_setreuid32
5380 case TARGET_NR_setreuid32:
5381 ret = get_errno(setreuid(arg1, arg2));
5382 break;
5383 #endif
5384 #ifdef TARGET_NR_setregid32
5385 case TARGET_NR_setregid32:
5386 ret = get_errno(setregid(arg1, arg2));
5387 break;
5388 #endif
5389 #ifdef TARGET_NR_getgroups32
5390 case TARGET_NR_getgroups32:
5391 {
5392 int gidsetsize = arg1;
5393 uint32_t *target_grouplist;
5394 gid_t *grouplist;
5395 int i;
5396
5397 grouplist = alloca(gidsetsize * sizeof(gid_t));
5398 ret = get_errno(getgroups(gidsetsize, grouplist));
5399 if (!is_error(ret)) {
5400 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
5401 if (!target_grouplist) {
5402 ret = -TARGET_EFAULT;
5403 goto fail;
5404 }
5405 for(i = 0;i < gidsetsize; i++)
5406 target_grouplist[i] = tswap32(grouplist[i]);
5407 unlock_user(target_grouplist, arg2, gidsetsize * 4);
5408 }
5409 }
5410 break;
5411 #endif
5412 #ifdef TARGET_NR_setgroups32
5413 case TARGET_NR_setgroups32:
5414 {
5415 int gidsetsize = arg1;
5416 uint32_t *target_grouplist;
5417 gid_t *grouplist;
5418 int i;
5419
5420 grouplist = alloca(gidsetsize * sizeof(gid_t));
5421 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
5422 if (!target_grouplist) {
5423 ret = -TARGET_EFAULT;
5424 goto fail;
5425 }
5426 for(i = 0;i < gidsetsize; i++)
5427 grouplist[i] = tswap32(target_grouplist[i]);
5428 unlock_user(target_grouplist, arg2, 0);
5429 ret = get_errno(setgroups(gidsetsize, grouplist));
5430 }
5431 break;
5432 #endif
5433 #ifdef TARGET_NR_fchown32
5434 case TARGET_NR_fchown32:
5435 ret = get_errno(fchown(arg1, arg2, arg3));
5436 break;
5437 #endif
5438 #ifdef TARGET_NR_setresuid32
5439 case TARGET_NR_setresuid32:
5440 ret = get_errno(setresuid(arg1, arg2, arg3));
5441 break;
5442 #endif
5443 #ifdef TARGET_NR_getresuid32
5444 case TARGET_NR_getresuid32:
5445 {
5446 uid_t ruid, euid, suid;
5447 ret = get_errno(getresuid(&ruid, &euid, &suid));
5448 if (!is_error(ret)) {
5449 if (put_user_u32(ruid, arg1)
5450 || put_user_u32(euid, arg2)
5451 || put_user_u32(suid, arg3))
5452 goto efault;
5453 }
5454 }
5455 break;
5456 #endif
5457 #ifdef TARGET_NR_setresgid32
5458 case TARGET_NR_setresgid32:
5459 ret = get_errno(setresgid(arg1, arg2, arg3));
5460 break;
5461 #endif
5462 #ifdef TARGET_NR_getresgid32
5463 case TARGET_NR_getresgid32:
5464 {
5465 gid_t rgid, egid, sgid;
5466 ret = get_errno(getresgid(&rgid, &egid, &sgid));
5467 if (!is_error(ret)) {
5468 if (put_user_u32(rgid, arg1)
5469 || put_user_u32(egid, arg2)
5470 || put_user_u32(sgid, arg3))
5471 goto efault;
5472 }
5473 }
5474 break;
5475 #endif
5476 #ifdef TARGET_NR_chown32
5477 case TARGET_NR_chown32:
5478 if (!(p = lock_user_string(arg1)))
5479 goto efault;
5480 ret = get_errno(chown(p, arg2, arg3));
5481 unlock_user(p, arg1, 0);
5482 break;
5483 #endif
5484 #ifdef TARGET_NR_setuid32
5485 case TARGET_NR_setuid32:
5486 ret = get_errno(setuid(arg1));
5487 break;
5488 #endif
5489 #ifdef TARGET_NR_setgid32
5490 case TARGET_NR_setgid32:
5491 ret = get_errno(setgid(arg1));
5492 break;
5493 #endif
5494 #ifdef TARGET_NR_setfsuid32
5495 case TARGET_NR_setfsuid32:
5496 ret = get_errno(setfsuid(arg1));
5497 break;
5498 #endif
5499 #ifdef TARGET_NR_setfsgid32
5500 case TARGET_NR_setfsgid32:
5501 ret = get_errno(setfsgid(arg1));
5502 break;
5503 #endif
5504
5505 case TARGET_NR_pivot_root:
5506 goto unimplemented;
5507 #ifdef TARGET_NR_mincore
5508 case TARGET_NR_mincore:
5509 goto unimplemented;
5510 #endif
5511 #ifdef TARGET_NR_madvise
5512 case TARGET_NR_madvise:
5513 /* A straight passthrough may not be safe because qemu sometimes
5514 turns private flie-backed mappings into anonymous mappings.
5515 This will break MADV_DONTNEED.
5516 This is a hint, so ignoring and returning success is ok. */
5517 ret = get_errno(0);
5518 break;
5519 #endif
5520 #if TARGET_ABI_BITS == 32
5521 case TARGET_NR_fcntl64:
5522 {
5523 int cmd;
5524 struct flock64 fl;
5525 struct target_flock64 *target_fl;
5526 #ifdef TARGET_ARM
5527 struct target_eabi_flock64 *target_efl;
5528 #endif
5529
5530 switch(arg2){
5531 case TARGET_F_GETLK64:
5532 cmd = F_GETLK64;
5533 break;
5534 case TARGET_F_SETLK64:
5535 cmd = F_SETLK64;
5536 break;
5537 case TARGET_F_SETLKW64:
5538 cmd = F_SETLK64;
5539 break;
5540 default:
5541 cmd = arg2;
5542 break;
5543 }
5544
5545 switch(arg2) {
5546 case TARGET_F_GETLK64:
5547 #ifdef TARGET_ARM
5548 if (((CPUARMState *)cpu_env)->eabi) {
5549 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5550 goto efault;
5551 fl.l_type = tswap16(target_efl->l_type);
5552 fl.l_whence = tswap16(target_efl->l_whence);
5553 fl.l_start = tswap64(target_efl->l_start);
5554 fl.l_len = tswap64(target_efl->l_len);
5555 fl.l_pid = tswapl(target_efl->l_pid);
5556 unlock_user_struct(target_efl, arg3, 0);
5557 } else
5558 #endif
5559 {
5560 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5561 goto efault;
5562 fl.l_type = tswap16(target_fl->l_type);
5563 fl.l_whence = tswap16(target_fl->l_whence);
5564 fl.l_start = tswap64(target_fl->l_start);
5565 fl.l_len = tswap64(target_fl->l_len);
5566 fl.l_pid = tswapl(target_fl->l_pid);
5567 unlock_user_struct(target_fl, arg3, 0);
5568 }
5569 ret = get_errno(fcntl(arg1, cmd, &fl));
5570 if (ret == 0) {
5571 #ifdef TARGET_ARM
5572 if (((CPUARMState *)cpu_env)->eabi) {
5573 if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
5574 goto efault;
5575 target_efl->l_type = tswap16(fl.l_type);
5576 target_efl->l_whence = tswap16(fl.l_whence);
5577 target_efl->l_start = tswap64(fl.l_start);
5578 target_efl->l_len = tswap64(fl.l_len);
5579 target_efl->l_pid = tswapl(fl.l_pid);
5580 unlock_user_struct(target_efl, arg3, 1);
5581 } else
5582 #endif
5583 {
5584 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
5585 goto efault;
5586 target_fl->l_type = tswap16(fl.l_type);
5587 target_fl->l_whence = tswap16(fl.l_whence);
5588 target_fl->l_start = tswap64(fl.l_start);
5589 target_fl->l_len = tswap64(fl.l_len);
5590 target_fl->l_pid = tswapl(fl.l_pid);
5591 unlock_user_struct(target_fl, arg3, 1);
5592 }
5593 }
5594 break;
5595
5596 case TARGET_F_SETLK64:
5597 case TARGET_F_SETLKW64:
5598 #ifdef TARGET_ARM
5599 if (((CPUARMState *)cpu_env)->eabi) {
5600 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5601 goto efault;
5602 fl.l_type = tswap16(target_efl->l_type);
5603 fl.l_whence = tswap16(target_efl->l_whence);
5604 fl.l_start = tswap64(target_efl->l_start);
5605 fl.l_len = tswap64(target_efl->l_len);
5606 fl.l_pid = tswapl(target_efl->l_pid);
5607 unlock_user_struct(target_efl, arg3, 0);
5608 } else
5609 #endif
5610 {
5611 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5612 goto efault;
5613 fl.l_type = tswap16(target_fl->l_type);
5614 fl.l_whence = tswap16(target_fl->l_whence);
5615 fl.l_start = tswap64(target_fl->l_start);
5616 fl.l_len = tswap64(target_fl->l_len);
5617 fl.l_pid = tswapl(target_fl->l_pid);
5618 unlock_user_struct(target_fl, arg3, 0);
5619 }
5620 ret = get_errno(fcntl(arg1, cmd, &fl));
5621 break;
5622 default:
5623 ret = do_fcntl(arg1, cmd, arg3);
5624 break;
5625 }
5626 break;
5627 }
5628 #endif
5629 #ifdef TARGET_NR_cacheflush
5630 case TARGET_NR_cacheflush:
5631 /* self-modifying code is handled automatically, so nothing needed */
5632 ret = 0;
5633 break;
5634 #endif
5635 #ifdef TARGET_NR_security
5636 case TARGET_NR_security:
5637 goto unimplemented;
5638 #endif
5639 #ifdef TARGET_NR_getpagesize
5640 case TARGET_NR_getpagesize:
5641 ret = TARGET_PAGE_SIZE;
5642 break;
5643 #endif
5644 case TARGET_NR_gettid:
5645 ret = get_errno(gettid());
5646 break;
5647 #ifdef TARGET_NR_readahead
5648 case TARGET_NR_readahead:
5649 goto unimplemented;
5650 #endif
5651 #ifdef TARGET_NR_setxattr
5652 case TARGET_NR_setxattr:
5653 case TARGET_NR_lsetxattr:
5654 case TARGET_NR_fsetxattr:
5655 case TARGET_NR_getxattr:
5656 case TARGET_NR_lgetxattr:
5657 case TARGET_NR_fgetxattr:
5658 case TARGET_NR_listxattr:
5659 case TARGET_NR_llistxattr:
5660 case TARGET_NR_flistxattr:
5661 case TARGET_NR_removexattr:
5662 case TARGET_NR_lremovexattr:
5663 case TARGET_NR_fremovexattr:
5664 goto unimplemented_nowarn;
5665 #endif
5666 #ifdef TARGET_NR_set_thread_area
5667 case TARGET_NR_set_thread_area:
5668 #if defined(TARGET_MIPS)
5669 ((CPUMIPSState *) cpu_env)->tls_value = arg1;
5670 ret = 0;
5671 break;
5672 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
5673 ret = do_set_thread_area(cpu_env, arg1);
5674 break;
5675 #else
5676 goto unimplemented_nowarn;
5677 #endif
5678 #endif
5679 #ifdef TARGET_NR_get_thread_area
5680 case TARGET_NR_get_thread_area:
5681 #if defined(TARGET_I386) && defined(TARGET_ABI32)
5682 ret = do_get_thread_area(cpu_env, arg1);
5683 #else
5684 goto unimplemented_nowarn;
5685 #endif
5686 #endif
5687 #ifdef TARGET_NR_getdomainname
5688 case TARGET_NR_getdomainname:
5689 goto unimplemented_nowarn;
5690 #endif
5691
5692 #ifdef TARGET_NR_clock_gettime
5693 case TARGET_NR_clock_gettime:
5694 {
5695 struct timespec ts;
5696 ret = get_errno(clock_gettime(arg1, &ts));
5697 if (!is_error(ret)) {
5698 host_to_target_timespec(arg2, &ts);
5699 }
5700 break;
5701 }
5702 #endif
5703 #ifdef TARGET_NR_clock_getres
5704 case TARGET_NR_clock_getres:
5705 {
5706 struct timespec ts;
5707 ret = get_errno(clock_getres(arg1, &ts));
5708 if (!is_error(ret)) {
5709 host_to_target_timespec(arg2, &ts);
5710 }
5711 break;
5712 }
5713 #endif
5714 #ifdef TARGET_NR_clock_nanosleep
5715 case TARGET_NR_clock_nanosleep:
5716 {
5717 struct timespec ts;
5718 target_to_host_timespec(&ts, arg3);
5719 ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
5720 if (arg4)
5721 host_to_target_timespec(arg4, &ts);
5722 break;
5723 }
5724 #endif
5725
5726 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5727 case TARGET_NR_set_tid_address:
5728 ret = get_errno(set_tid_address((int *)g2h(arg1)));
5729 break;
5730 #endif
5731
5732 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
5733 case TARGET_NR_tkill:
5734 ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
5735 break;
5736 #endif
5737
5738 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
5739 case TARGET_NR_tgkill:
5740 ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
5741 target_to_host_signal(arg3)));
5742 break;
5743 #endif
5744
5745 #ifdef TARGET_NR_set_robust_list
5746 case TARGET_NR_set_robust_list:
5747 goto unimplemented_nowarn;
5748 #endif
5749
5750 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5751 case TARGET_NR_utimensat:
5752 {
5753 struct timespec ts[2];
5754 target_to_host_timespec(ts, arg3);
5755 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
5756 if (!arg2)
5757 ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4));
5758 else {
5759 if (!(p = lock_user_string(arg2))) {
5760 ret = -TARGET_EFAULT;
5761 goto fail;
5762 }
5763 ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
5764 unlock_user(p, arg2, 0);
5765 }
5766 }
5767 break;
5768 #endif
5769 #if defined(USE_NPTL)
5770 case TARGET_NR_futex:
5771 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
5772 break;
5773 #endif
5774
5775 default:
5776 unimplemented:
5777 gemu_log("qemu: Unsupported syscall: %d\n", num);
5778 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
5779 unimplemented_nowarn:
5780 #endif
5781 ret = -TARGET_ENOSYS;
5782 break;
5783 }
5784 fail:
5785 #ifdef DEBUG
5786 gemu_log(" = %ld\n", ret);
5787 #endif
5788 if(do_strace)
5789 print_syscall_ret(num, ret);
5790 return ret;
5791 efault:
5792 ret = -TARGET_EFAULT;
5793 goto fail;
5794 }
Samsung s3c2440 and arm920t support for the mini2440 dev board