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