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