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