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