]> 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
linux-user: Define AT_RANDOM to support target stack protection mechanism.
[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;
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 return -TARGET_EFAULT;
3825 break;
3826 default:
3827 ret = -TARGET_EINVAL;
3828 break;
3829 }
3830 return 0;
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)
4536 {
4537 abi_long ret;
4538 struct stat st;
4539 struct statfs stfs;
4540 void *p;
4541
4542 #ifdef DEBUG
4543 gemu_log("syscall %d", num);
4544 #endif
4545 if(do_strace)
4546 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
4547
4548 switch(num) {
4549 case TARGET_NR_exit:
4550 #ifdef CONFIG_USE_NPTL
4551 /* In old applications this may be used to implement _exit(2).
4552 However in threaded applictions it is used for thread termination,
4553 and _exit_group is used for application termination.
4554 Do thread termination if we have more then one thread. */
4555 /* FIXME: This probably breaks if a signal arrives. We should probably
4556 be disabling signals. */
4557 if (first_cpu->next_cpu) {
4558 TaskState *ts;
4559 CPUState **lastp;
4560 CPUState *p;
4561
4562 cpu_list_lock();
4563 lastp = &first_cpu;
4564 p = first_cpu;
4565 while (p && p != (CPUState *)cpu_env) {
4566 lastp = &p->next_cpu;
4567 p = p->next_cpu;
4568 }
4569 /* If we didn't find the CPU for this thread then something is
4570 horribly wrong. */
4571 if (!p)
4572 abort();
4573 /* Remove the CPU from the list. */
4574 *lastp = p->next_cpu;
4575 cpu_list_unlock();
4576 ts = ((CPUState *)cpu_env)->opaque;
4577 if (ts->child_tidptr) {
4578 put_user_u32(0, ts->child_tidptr);
4579 sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
4580 NULL, NULL, 0);
4581 }
4582 thread_env = NULL;
4583 qemu_free(cpu_env);
4584 qemu_free(ts);
4585 pthread_exit(NULL);
4586 }
4587 #endif
4588 #ifdef TARGET_GPROF
4589 _mcleanup();
4590 #endif
4591 gdb_exit(cpu_env, arg1);
4592 _exit(arg1);
4593 ret = 0; /* avoid warning */
4594 break;
4595 case TARGET_NR_read:
4596 if (arg3 == 0)
4597 ret = 0;
4598 else {
4599 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
4600 goto efault;
4601 ret = get_errno(read(arg1, p, arg3));
4602 unlock_user(p, arg2, ret);
4603 }
4604 break;
4605 case TARGET_NR_write:
4606 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
4607 goto efault;
4608 ret = get_errno(write(arg1, p, arg3));
4609 unlock_user(p, arg2, 0);
4610 break;
4611 case TARGET_NR_open:
4612 if (!(p = lock_user_string(arg1)))
4613 goto efault;
4614 ret = get_errno(open(path(p),
4615 target_to_host_bitmask(arg2, fcntl_flags_tbl),
4616 arg3));
4617 unlock_user(p, arg1, 0);
4618 break;
4619 #if defined(TARGET_NR_openat) && defined(__NR_openat)
4620 case TARGET_NR_openat:
4621 if (!(p = lock_user_string(arg2)))
4622 goto efault;
4623 ret = get_errno(sys_openat(arg1,
4624 path(p),
4625 target_to_host_bitmask(arg3, fcntl_flags_tbl),
4626 arg4));
4627 unlock_user(p, arg2, 0);
4628 break;
4629 #endif
4630 case TARGET_NR_close:
4631 ret = get_errno(close(arg1));
4632 break;
4633 case TARGET_NR_brk:
4634 ret = do_brk(arg1);
4635 break;
4636 case TARGET_NR_fork:
4637 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
4638 break;
4639 #ifdef TARGET_NR_waitpid
4640 case TARGET_NR_waitpid:
4641 {
4642 int status;
4643 ret = get_errno(waitpid(arg1, &status, arg3));
4644 if (!is_error(ret) && arg2
4645 && put_user_s32(host_to_target_waitstatus(status), arg2))
4646 goto efault;
4647 }
4648 break;
4649 #endif
4650 #ifdef TARGET_NR_waitid
4651 case TARGET_NR_waitid:
4652 {
4653 siginfo_t info;
4654 info.si_pid = 0;
4655 ret = get_errno(waitid(arg1, arg2, &info, arg4));
4656 if (!is_error(ret) && arg3 && info.si_pid != 0) {
4657 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
4658 goto efault;
4659 host_to_target_siginfo(p, &info);
4660 unlock_user(p, arg3, sizeof(target_siginfo_t));
4661 }
4662 }
4663 break;
4664 #endif
4665 #ifdef TARGET_NR_creat /* not on alpha */
4666 case TARGET_NR_creat:
4667 if (!(p = lock_user_string(arg1)))
4668 goto efault;
4669 ret = get_errno(creat(p, arg2));
4670 unlock_user(p, arg1, 0);
4671 break;
4672 #endif
4673 case TARGET_NR_link:
4674 {
4675 void * p2;
4676 p = lock_user_string(arg1);
4677 p2 = lock_user_string(arg2);
4678 if (!p || !p2)
4679 ret = -TARGET_EFAULT;
4680 else
4681 ret = get_errno(link(p, p2));
4682 unlock_user(p2, arg2, 0);
4683 unlock_user(p, arg1, 0);
4684 }
4685 break;
4686 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
4687 case TARGET_NR_linkat:
4688 {
4689 void * p2 = NULL;
4690 if (!arg2 || !arg4)
4691 goto efault;
4692 p = lock_user_string(arg2);
4693 p2 = lock_user_string(arg4);
4694 if (!p || !p2)
4695 ret = -TARGET_EFAULT;
4696 else
4697 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
4698 unlock_user(p, arg2, 0);
4699 unlock_user(p2, arg4, 0);
4700 }
4701 break;
4702 #endif
4703 case TARGET_NR_unlink:
4704 if (!(p = lock_user_string(arg1)))
4705 goto efault;
4706 ret = get_errno(unlink(p));
4707 unlock_user(p, arg1, 0);
4708 break;
4709 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
4710 case TARGET_NR_unlinkat:
4711 if (!(p = lock_user_string(arg2)))
4712 goto efault;
4713 ret = get_errno(sys_unlinkat(arg1, p, arg3));
4714 unlock_user(p, arg2, 0);
4715 break;
4716 #endif
4717 case TARGET_NR_execve:
4718 {
4719 char **argp, **envp;
4720 int argc, envc;
4721 abi_ulong gp;
4722 abi_ulong guest_argp;
4723 abi_ulong guest_envp;
4724 abi_ulong addr;
4725 char **q;
4726
4727 argc = 0;
4728 guest_argp = arg2;
4729 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
4730 if (get_user_ual(addr, gp))
4731 goto efault;
4732 if (!addr)
4733 break;
4734 argc++;
4735 }
4736 envc = 0;
4737 guest_envp = arg3;
4738 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
4739 if (get_user_ual(addr, gp))
4740 goto efault;
4741 if (!addr)
4742 break;
4743 envc++;
4744 }
4745
4746 argp = alloca((argc + 1) * sizeof(void *));
4747 envp = alloca((envc + 1) * sizeof(void *));
4748
4749 for (gp = guest_argp, q = argp; gp;
4750 gp += sizeof(abi_ulong), q++) {
4751 if (get_user_ual(addr, gp))
4752 goto execve_efault;
4753 if (!addr)
4754 break;
4755 if (!(*q = lock_user_string(addr)))
4756 goto execve_efault;
4757 }
4758 *q = NULL;
4759
4760 for (gp = guest_envp, q = envp; gp;
4761 gp += sizeof(abi_ulong), q++) {
4762 if (get_user_ual(addr, gp))
4763 goto execve_efault;
4764 if (!addr)
4765 break;
4766 if (!(*q = lock_user_string(addr)))
4767 goto execve_efault;
4768 }
4769 *q = NULL;
4770
4771 if (!(p = lock_user_string(arg1)))
4772 goto execve_efault;
4773 ret = get_errno(execve(p, argp, envp));
4774 unlock_user(p, arg1, 0);
4775
4776 goto execve_end;
4777
4778 execve_efault:
4779 ret = -TARGET_EFAULT;
4780
4781 execve_end:
4782 for (gp = guest_argp, q = argp; *q;
4783 gp += sizeof(abi_ulong), q++) {
4784 if (get_user_ual(addr, gp)
4785 || !addr)
4786 break;
4787 unlock_user(*q, addr, 0);
4788 }
4789 for (gp = guest_envp, q = envp; *q;
4790 gp += sizeof(abi_ulong), q++) {
4791 if (get_user_ual(addr, gp)
4792 || !addr)
4793 break;
4794 unlock_user(*q, addr, 0);
4795 }
4796 }
4797 break;
4798 case TARGET_NR_chdir:
4799 if (!(p = lock_user_string(arg1)))
4800 goto efault;
4801 ret = get_errno(chdir(p));
4802 unlock_user(p, arg1, 0);
4803 break;
4804 #ifdef TARGET_NR_time
4805 case TARGET_NR_time:
4806 {
4807 time_t host_time;
4808 ret = get_errno(time(&host_time));
4809 if (!is_error(ret)
4810 && arg1
4811 && put_user_sal(host_time, arg1))
4812 goto efault;
4813 }
4814 break;
4815 #endif
4816 case TARGET_NR_mknod:
4817 if (!(p = lock_user_string(arg1)))
4818 goto efault;
4819 ret = get_errno(mknod(p, arg2, arg3));
4820 unlock_user(p, arg1, 0);
4821 break;
4822 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
4823 case TARGET_NR_mknodat:
4824 if (!(p = lock_user_string(arg2)))
4825 goto efault;
4826 ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
4827 unlock_user(p, arg2, 0);
4828 break;
4829 #endif
4830 case TARGET_NR_chmod:
4831 if (!(p = lock_user_string(arg1)))
4832 goto efault;
4833 ret = get_errno(chmod(p, arg2));
4834 unlock_user(p, arg1, 0);
4835 break;
4836 #ifdef TARGET_NR_break
4837 case TARGET_NR_break:
4838 goto unimplemented;
4839 #endif
4840 #ifdef TARGET_NR_oldstat
4841 case TARGET_NR_oldstat:
4842 goto unimplemented;
4843 #endif
4844 case TARGET_NR_lseek:
4845 ret = get_errno(lseek(arg1, arg2, arg3));
4846 break;
4847 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
4848 /* Alpha specific */
4849 case TARGET_NR_getxpid:
4850 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
4851 ret = get_errno(getpid());
4852 break;
4853 #endif
4854 #ifdef TARGET_NR_getpid
4855 case TARGET_NR_getpid:
4856 ret = get_errno(getpid());
4857 break;
4858 #endif
4859 case TARGET_NR_mount:
4860 {
4861 /* need to look at the data field */
4862 void *p2, *p3;
4863 p = lock_user_string(arg1);
4864 p2 = lock_user_string(arg2);
4865 p3 = lock_user_string(arg3);
4866 if (!p || !p2 || !p3)
4867 ret = -TARGET_EFAULT;
4868 else {
4869 /* FIXME - arg5 should be locked, but it isn't clear how to
4870 * do that since it's not guaranteed to be a NULL-terminated
4871 * string.
4872 */
4873 if ( ! arg5 )
4874 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, NULL));
4875 else
4876 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
4877 }
4878 unlock_user(p, arg1, 0);
4879 unlock_user(p2, arg2, 0);
4880 unlock_user(p3, arg3, 0);
4881 break;
4882 }
4883 #ifdef TARGET_NR_umount
4884 case TARGET_NR_umount:
4885 if (!(p = lock_user_string(arg1)))
4886 goto efault;
4887 ret = get_errno(umount(p));
4888 unlock_user(p, arg1, 0);
4889 break;
4890 #endif
4891 #ifdef TARGET_NR_stime /* not on alpha */
4892 case TARGET_NR_stime:
4893 {
4894 time_t host_time;
4895 if (get_user_sal(host_time, arg1))
4896 goto efault;
4897 ret = get_errno(stime(&host_time));
4898 }
4899 break;
4900 #endif
4901 case TARGET_NR_ptrace:
4902 goto unimplemented;
4903 #ifdef TARGET_NR_alarm /* not on alpha */
4904 case TARGET_NR_alarm:
4905 ret = alarm(arg1);
4906 break;
4907 #endif
4908 #ifdef TARGET_NR_oldfstat
4909 case TARGET_NR_oldfstat:
4910 goto unimplemented;
4911 #endif
4912 #ifdef TARGET_NR_pause /* not on alpha */
4913 case TARGET_NR_pause:
4914 ret = get_errno(pause());
4915 break;
4916 #endif
4917 #ifdef TARGET_NR_utime
4918 case TARGET_NR_utime:
4919 {
4920 struct utimbuf tbuf, *host_tbuf;
4921 struct target_utimbuf *target_tbuf;
4922 if (arg2) {
4923 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
4924 goto efault;
4925 tbuf.actime = tswapl(target_tbuf->actime);
4926 tbuf.modtime = tswapl(target_tbuf->modtime);
4927 unlock_user_struct(target_tbuf, arg2, 0);
4928 host_tbuf = &tbuf;
4929 } else {
4930 host_tbuf = NULL;
4931 }
4932 if (!(p = lock_user_string(arg1)))
4933 goto efault;
4934 ret = get_errno(utime(p, host_tbuf));
4935 unlock_user(p, arg1, 0);
4936 }
4937 break;
4938 #endif
4939 case TARGET_NR_utimes:
4940 {
4941 struct timeval *tvp, tv[2];
4942 if (arg2) {
4943 if (copy_from_user_timeval(&tv[0], arg2)
4944 || copy_from_user_timeval(&tv[1],
4945 arg2 + sizeof(struct target_timeval)))
4946 goto efault;
4947 tvp = tv;
4948 } else {
4949 tvp = NULL;
4950 }
4951 if (!(p = lock_user_string(arg1)))
4952 goto efault;
4953 ret = get_errno(utimes(p, tvp));
4954 unlock_user(p, arg1, 0);
4955 }
4956 break;
4957 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
4958 case TARGET_NR_futimesat:
4959 {
4960 struct timeval *tvp, tv[2];
4961 if (arg3) {
4962 if (copy_from_user_timeval(&tv[0], arg3)
4963 || copy_from_user_timeval(&tv[1],
4964 arg3 + sizeof(struct target_timeval)))
4965 goto efault;
4966 tvp = tv;
4967 } else {
4968 tvp = NULL;
4969 }
4970 if (!(p = lock_user_string(arg2)))
4971 goto efault;
4972 ret = get_errno(sys_futimesat(arg1, path(p), tvp));
4973 unlock_user(p, arg2, 0);
4974 }
4975 break;
4976 #endif
4977 #ifdef TARGET_NR_stty
4978 case TARGET_NR_stty:
4979 goto unimplemented;
4980 #endif
4981 #ifdef TARGET_NR_gtty
4982 case TARGET_NR_gtty:
4983 goto unimplemented;
4984 #endif
4985 case TARGET_NR_access:
4986 if (!(p = lock_user_string(arg1)))
4987 goto efault;
4988 ret = get_errno(access(path(p), arg2));
4989 unlock_user(p, arg1, 0);
4990 break;
4991 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
4992 case TARGET_NR_faccessat:
4993 if (!(p = lock_user_string(arg2)))
4994 goto efault;
4995 ret = get_errno(sys_faccessat(arg1, p, arg3));
4996 unlock_user(p, arg2, 0);
4997 break;
4998 #endif
4999 #ifdef TARGET_NR_nice /* not on alpha */
5000 case TARGET_NR_nice:
5001 ret = get_errno(nice(arg1));
5002 break;
5003 #endif
5004 #ifdef TARGET_NR_ftime
5005 case TARGET_NR_ftime:
5006 goto unimplemented;
5007 #endif
5008 case TARGET_NR_sync:
5009 sync();
5010 ret = 0;
5011 break;
5012 case TARGET_NR_kill:
5013 ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
5014 break;
5015 case TARGET_NR_rename:
5016 {
5017 void *p2;
5018 p = lock_user_string(arg1);
5019 p2 = lock_user_string(arg2);
5020 if (!p || !p2)
5021 ret = -TARGET_EFAULT;
5022 else
5023 ret = get_errno(rename(p, p2));
5024 unlock_user(p2, arg2, 0);
5025 unlock_user(p, arg1, 0);
5026 }
5027 break;
5028 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
5029 case TARGET_NR_renameat:
5030 {
5031 void *p2;
5032 p = lock_user_string(arg2);
5033 p2 = lock_user_string(arg4);
5034 if (!p || !p2)
5035 ret = -TARGET_EFAULT;
5036 else
5037 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
5038 unlock_user(p2, arg4, 0);
5039 unlock_user(p, arg2, 0);
5040 }
5041 break;
5042 #endif
5043 case TARGET_NR_mkdir:
5044 if (!(p = lock_user_string(arg1)))
5045 goto efault;
5046 ret = get_errno(mkdir(p, arg2));
5047 unlock_user(p, arg1, 0);
5048 break;
5049 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
5050 case TARGET_NR_mkdirat:
5051 if (!(p = lock_user_string(arg2)))
5052 goto efault;
5053 ret = get_errno(sys_mkdirat(arg1, p, arg3));
5054 unlock_user(p, arg2, 0);
5055 break;
5056 #endif
5057 case TARGET_NR_rmdir:
5058 if (!(p = lock_user_string(arg1)))
5059 goto efault;
5060 ret = get_errno(rmdir(p));
5061 unlock_user(p, arg1, 0);
5062 break;
5063 case TARGET_NR_dup:
5064 ret = get_errno(dup(arg1));
5065 break;
5066 case TARGET_NR_pipe:
5067 ret = do_pipe(cpu_env, arg1, 0, 0);
5068 break;
5069 #ifdef TARGET_NR_pipe2
5070 case TARGET_NR_pipe2:
5071 ret = do_pipe(cpu_env, arg1, arg2, 1);
5072 break;
5073 #endif
5074 case TARGET_NR_times:
5075 {
5076 struct target_tms *tmsp;
5077 struct tms tms;
5078 ret = get_errno(times(&tms));
5079 if (arg1) {
5080 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
5081 if (!tmsp)
5082 goto efault;
5083 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
5084 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
5085 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
5086 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
5087 }
5088 if (!is_error(ret))
5089 ret = host_to_target_clock_t(ret);
5090 }
5091 break;
5092 #ifdef TARGET_NR_prof
5093 case TARGET_NR_prof:
5094 goto unimplemented;
5095 #endif
5096 #ifdef TARGET_NR_signal
5097 case TARGET_NR_signal:
5098 goto unimplemented;
5099 #endif
5100 case TARGET_NR_acct:
5101 if (arg1 == 0) {
5102 ret = get_errno(acct(NULL));
5103 } else {
5104 if (!(p = lock_user_string(arg1)))
5105 goto efault;
5106 ret = get_errno(acct(path(p)));
5107 unlock_user(p, arg1, 0);
5108 }
5109 break;
5110 #ifdef TARGET_NR_umount2 /* not on alpha */
5111 case TARGET_NR_umount2:
5112 if (!(p = lock_user_string(arg1)))
5113 goto efault;
5114 ret = get_errno(umount2(p, arg2));
5115 unlock_user(p, arg1, 0);
5116 break;
5117 #endif
5118 #ifdef TARGET_NR_lock
5119 case TARGET_NR_lock:
5120 goto unimplemented;
5121 #endif
5122 case TARGET_NR_ioctl:
5123 ret = do_ioctl(arg1, arg2, arg3);
5124 break;
5125 case TARGET_NR_fcntl:
5126 ret = do_fcntl(arg1, arg2, arg3);
5127 break;
5128 #ifdef TARGET_NR_mpx
5129 case TARGET_NR_mpx:
5130 goto unimplemented;
5131 #endif
5132 case TARGET_NR_setpgid:
5133 ret = get_errno(setpgid(arg1, arg2));
5134 break;
5135 #ifdef TARGET_NR_ulimit
5136 case TARGET_NR_ulimit:
5137 goto unimplemented;
5138 #endif
5139 #ifdef TARGET_NR_oldolduname
5140 case TARGET_NR_oldolduname:
5141 goto unimplemented;
5142 #endif
5143 case TARGET_NR_umask:
5144 ret = get_errno(umask(arg1));
5145 break;
5146 case TARGET_NR_chroot:
5147 if (!(p = lock_user_string(arg1)))
5148 goto efault;
5149 ret = get_errno(chroot(p));
5150 unlock_user(p, arg1, 0);
5151 break;
5152 case TARGET_NR_ustat:
5153 goto unimplemented;
5154 case TARGET_NR_dup2:
5155 ret = get_errno(dup2(arg1, arg2));
5156 break;
5157 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
5158 case TARGET_NR_dup3:
5159 ret = get_errno(dup3(arg1, arg2, arg3));
5160 break;
5161 #endif
5162 #ifdef TARGET_NR_getppid /* not on alpha */
5163 case TARGET_NR_getppid:
5164 ret = get_errno(getppid());
5165 break;
5166 #endif
5167 case TARGET_NR_getpgrp:
5168 ret = get_errno(getpgrp());
5169 break;
5170 case TARGET_NR_setsid:
5171 ret = get_errno(setsid());
5172 break;
5173 #ifdef TARGET_NR_sigaction
5174 case TARGET_NR_sigaction:
5175 {
5176 #if defined(TARGET_ALPHA)
5177 struct target_sigaction act, oact, *pact = 0;
5178 struct target_old_sigaction *old_act;
5179 if (arg2) {
5180 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5181 goto efault;
5182 act._sa_handler = old_act->_sa_handler;
5183 target_siginitset(&act.sa_mask, old_act->sa_mask);
5184 act.sa_flags = old_act->sa_flags;
5185 act.sa_restorer = 0;
5186 unlock_user_struct(old_act, arg2, 0);
5187 pact = &act;
5188 }
5189 ret = get_errno(do_sigaction(arg1, pact, &oact));
5190 if (!is_error(ret) && arg3) {
5191 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5192 goto efault;
5193 old_act->_sa_handler = oact._sa_handler;
5194 old_act->sa_mask = oact.sa_mask.sig[0];
5195 old_act->sa_flags = oact.sa_flags;
5196 unlock_user_struct(old_act, arg3, 1);
5197 }
5198 #elif defined(TARGET_MIPS)
5199 struct target_sigaction act, oact, *pact, *old_act;
5200
5201 if (arg2) {
5202 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5203 goto efault;
5204 act._sa_handler = old_act->_sa_handler;
5205 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
5206 act.sa_flags = old_act->sa_flags;
5207 unlock_user_struct(old_act, arg2, 0);
5208 pact = &act;
5209 } else {
5210 pact = NULL;
5211 }
5212
5213 ret = get_errno(do_sigaction(arg1, pact, &oact));
5214
5215 if (!is_error(ret) && arg3) {
5216 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5217 goto efault;
5218 old_act->_sa_handler = oact._sa_handler;
5219 old_act->sa_flags = oact.sa_flags;
5220 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
5221 old_act->sa_mask.sig[1] = 0;
5222 old_act->sa_mask.sig[2] = 0;
5223 old_act->sa_mask.sig[3] = 0;
5224 unlock_user_struct(old_act, arg3, 1);
5225 }
5226 #else
5227 struct target_old_sigaction *old_act;
5228 struct target_sigaction act, oact, *pact;
5229 if (arg2) {
5230 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
5231 goto efault;
5232 act._sa_handler = old_act->_sa_handler;
5233 target_siginitset(&act.sa_mask, old_act->sa_mask);
5234 act.sa_flags = old_act->sa_flags;
5235 act.sa_restorer = old_act->sa_restorer;
5236 unlock_user_struct(old_act, arg2, 0);
5237 pact = &act;
5238 } else {
5239 pact = NULL;
5240 }
5241 ret = get_errno(do_sigaction(arg1, pact, &oact));
5242 if (!is_error(ret) && arg3) {
5243 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
5244 goto efault;
5245 old_act->_sa_handler = oact._sa_handler;
5246 old_act->sa_mask = oact.sa_mask.sig[0];
5247 old_act->sa_flags = oact.sa_flags;
5248 old_act->sa_restorer = oact.sa_restorer;
5249 unlock_user_struct(old_act, arg3, 1);
5250 }
5251 #endif
5252 }
5253 break;
5254 #endif
5255 case TARGET_NR_rt_sigaction:
5256 {
5257 #if defined(TARGET_ALPHA)
5258 struct target_sigaction act, oact, *pact = 0;
5259 struct target_rt_sigaction *rt_act;
5260 /* ??? arg4 == sizeof(sigset_t). */
5261 if (arg2) {
5262 if (!lock_user_struct(VERIFY_READ, rt_act, arg2, 1))
5263 goto efault;
5264 act._sa_handler = rt_act->_sa_handler;
5265 act.sa_mask = rt_act->sa_mask;
5266 act.sa_flags = rt_act->sa_flags;
5267 act.sa_restorer = arg5;
5268 unlock_user_struct(rt_act, arg2, 0);
5269 pact = &act;
5270 }
5271 ret = get_errno(do_sigaction(arg1, pact, &oact));
5272 if (!is_error(ret) && arg3) {
5273 if (!lock_user_struct(VERIFY_WRITE, rt_act, arg3, 0))
5274 goto efault;
5275 rt_act->_sa_handler = oact._sa_handler;
5276 rt_act->sa_mask = oact.sa_mask;
5277 rt_act->sa_flags = oact.sa_flags;
5278 unlock_user_struct(rt_act, arg3, 1);
5279 }
5280 #else
5281 struct target_sigaction *act;
5282 struct target_sigaction *oact;
5283
5284 if (arg2) {
5285 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
5286 goto efault;
5287 } else
5288 act = NULL;
5289 if (arg3) {
5290 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
5291 ret = -TARGET_EFAULT;
5292 goto rt_sigaction_fail;
5293 }
5294 } else
5295 oact = NULL;
5296 ret = get_errno(do_sigaction(arg1, act, oact));
5297 rt_sigaction_fail:
5298 if (act)
5299 unlock_user_struct(act, arg2, 0);
5300 if (oact)
5301 unlock_user_struct(oact, arg3, 1);
5302 #endif
5303 }
5304 break;
5305 #ifdef TARGET_NR_sgetmask /* not on alpha */
5306 case TARGET_NR_sgetmask:
5307 {
5308 sigset_t cur_set;
5309 abi_ulong target_set;
5310 sigprocmask(0, NULL, &cur_set);
5311 host_to_target_old_sigset(&target_set, &cur_set);
5312 ret = target_set;
5313 }
5314 break;
5315 #endif
5316 #ifdef TARGET_NR_ssetmask /* not on alpha */
5317 case TARGET_NR_ssetmask:
5318 {
5319 sigset_t set, oset, cur_set;
5320 abi_ulong target_set = arg1;
5321 sigprocmask(0, NULL, &cur_set);
5322 target_to_host_old_sigset(&set, &target_set);
5323 sigorset(&set, &set, &cur_set);
5324 sigprocmask(SIG_SETMASK, &set, &oset);
5325 host_to_target_old_sigset(&target_set, &oset);
5326 ret = target_set;
5327 }
5328 break;
5329 #endif
5330 #ifdef TARGET_NR_sigprocmask
5331 case TARGET_NR_sigprocmask:
5332 {
5333 #if defined(TARGET_ALPHA)
5334 sigset_t set, oldset;
5335 abi_ulong mask;
5336 int how;
5337
5338 switch (arg1) {
5339 case TARGET_SIG_BLOCK:
5340 how = SIG_BLOCK;
5341 break;
5342 case TARGET_SIG_UNBLOCK:
5343 how = SIG_UNBLOCK;
5344 break;
5345 case TARGET_SIG_SETMASK:
5346 how = SIG_SETMASK;
5347 break;
5348 default:
5349 ret = -TARGET_EINVAL;
5350 goto fail;
5351 }
5352 mask = arg2;
5353 target_to_host_old_sigset(&set, &mask);
5354
5355 ret = get_errno(sigprocmask(how, &set, &oldset));
5356
5357 if (!is_error(ret)) {
5358 host_to_target_old_sigset(&mask, &oldset);
5359 ret = mask;
5360 ((CPUAlphaState *)cpu_env)->[IR_V0] = 0; /* force no error */
5361 }
5362 #else
5363 sigset_t set, oldset, *set_ptr;
5364 int how;
5365
5366 if (arg2) {
5367 switch (arg1) {
5368 case TARGET_SIG_BLOCK:
5369 how = SIG_BLOCK;
5370 break;
5371 case TARGET_SIG_UNBLOCK:
5372 how = SIG_UNBLOCK;
5373 break;
5374 case TARGET_SIG_SETMASK:
5375 how = SIG_SETMASK;
5376 break;
5377 default:
5378 ret = -TARGET_EINVAL;
5379 goto fail;
5380 }
5381 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
5382 goto efault;
5383 target_to_host_old_sigset(&set, p);
5384 unlock_user(p, arg2, 0);
5385 set_ptr = &set;
5386 } else {
5387 how = 0;
5388 set_ptr = NULL;
5389 }
5390 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
5391 if (!is_error(ret) && arg3) {
5392 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
5393 goto efault;
5394 host_to_target_old_sigset(p, &oldset);
5395 unlock_user(p, arg3, sizeof(target_sigset_t));
5396 }
5397 #endif
5398 }
5399 break;
5400 #endif
5401 case TARGET_NR_rt_sigprocmask:
5402 {
5403 int how = arg1;
5404 sigset_t set, oldset, *set_ptr;
5405
5406 if (arg2) {
5407 switch(how) {
5408 case TARGET_SIG_BLOCK:
5409 how = SIG_BLOCK;
5410 break;
5411 case TARGET_SIG_UNBLOCK:
5412 how = SIG_UNBLOCK;
5413 break;
5414 case TARGET_SIG_SETMASK:
5415 how = SIG_SETMASK;
5416 break;
5417 default:
5418 ret = -TARGET_EINVAL;
5419 goto fail;
5420 }
5421 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
5422 goto efault;
5423 target_to_host_sigset(&set, p);
5424 unlock_user(p, arg2, 0);
5425 set_ptr = &set;
5426 } else {
5427 how = 0;
5428 set_ptr = NULL;
5429 }
5430 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
5431 if (!is_error(ret) && arg3) {
5432 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
5433 goto efault;
5434 host_to_target_sigset(p, &oldset);
5435 unlock_user(p, arg3, sizeof(target_sigset_t));
5436 }
5437 }
5438 break;
5439 #ifdef TARGET_NR_sigpending
5440 case TARGET_NR_sigpending:
5441 {
5442 sigset_t set;
5443 ret = get_errno(sigpending(&set));
5444 if (!is_error(ret)) {
5445 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
5446 goto efault;
5447 host_to_target_old_sigset(p, &set);
5448 unlock_user(p, arg1, sizeof(target_sigset_t));
5449 }
5450 }
5451 break;
5452 #endif
5453 case TARGET_NR_rt_sigpending:
5454 {
5455 sigset_t set;
5456 ret = get_errno(sigpending(&set));
5457 if (!is_error(ret)) {
5458 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
5459 goto efault;
5460 host_to_target_sigset(p, &set);
5461 unlock_user(p, arg1, sizeof(target_sigset_t));
5462 }
5463 }
5464 break;
5465 #ifdef TARGET_NR_sigsuspend
5466 case TARGET_NR_sigsuspend:
5467 {
5468 sigset_t set;
5469 #if defined(TARGET_ALPHA)
5470 abi_ulong mask = arg1;
5471 target_to_host_old_sigset(&set, &mask);
5472 #else
5473 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
5474 goto efault;
5475 target_to_host_old_sigset(&set, p);
5476 unlock_user(p, arg1, 0);
5477 #endif
5478 ret = get_errno(sigsuspend(&set));
5479 }
5480 break;
5481 #endif
5482 case TARGET_NR_rt_sigsuspend:
5483 {
5484 sigset_t set;
5485 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
5486 goto efault;
5487 target_to_host_sigset(&set, p);
5488 unlock_user(p, arg1, 0);
5489 ret = get_errno(sigsuspend(&set));
5490 }
5491 break;
5492 case TARGET_NR_rt_sigtimedwait:
5493 {
5494 sigset_t set;
5495 struct timespec uts, *puts;
5496 siginfo_t uinfo;
5497
5498 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
5499 goto efault;
5500 target_to_host_sigset(&set, p);
5501 unlock_user(p, arg1, 0);
5502 if (arg3) {
5503 puts = &uts;
5504 target_to_host_timespec(puts, arg3);
5505 } else {
5506 puts = NULL;
5507 }
5508 ret = get_errno(sigtimedwait(&set, &uinfo, puts));
5509 if (!is_error(ret) && arg2) {
5510 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
5511 goto efault;
5512 host_to_target_siginfo(p, &uinfo);
5513 unlock_user(p, arg2, sizeof(target_siginfo_t));
5514 }
5515 }
5516 break;
5517 case TARGET_NR_rt_sigqueueinfo:
5518 {
5519 siginfo_t uinfo;
5520 if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
5521 goto efault;
5522 target_to_host_siginfo(&uinfo, p);
5523 unlock_user(p, arg1, 0);
5524 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
5525 }
5526 break;
5527 #ifdef TARGET_NR_sigreturn
5528 case TARGET_NR_sigreturn:
5529 /* NOTE: ret is eax, so not transcoding must be done */
5530 ret = do_sigreturn(cpu_env);
5531 break;
5532 #endif
5533 case TARGET_NR_rt_sigreturn:
5534 /* NOTE: ret is eax, so not transcoding must be done */
5535 ret = do_rt_sigreturn(cpu_env);
5536 break;
5537 case TARGET_NR_sethostname:
5538 if (!(p = lock_user_string(arg1)))
5539 goto efault;
5540 ret = get_errno(sethostname(p, arg2));
5541 unlock_user(p, arg1, 0);
5542 break;
5543 case TARGET_NR_setrlimit:
5544 {
5545 int resource = arg1;
5546 struct target_rlimit *target_rlim;
5547 struct rlimit rlim;
5548 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
5549 goto efault;
5550 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
5551 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
5552 unlock_user_struct(target_rlim, arg2, 0);
5553 ret = get_errno(setrlimit(resource, &rlim));
5554 }
5555 break;
5556 case TARGET_NR_getrlimit:
5557 {
5558 int resource = arg1;
5559 struct target_rlimit *target_rlim;
5560 struct rlimit rlim;
5561
5562 ret = get_errno(getrlimit(resource, &rlim));
5563 if (!is_error(ret)) {
5564 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
5565 goto efault;
5566 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
5567 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
5568 unlock_user_struct(target_rlim, arg2, 1);
5569 }
5570 }
5571 break;
5572 case TARGET_NR_getrusage:
5573 {
5574 struct rusage rusage;
5575 ret = get_errno(getrusage(arg1, &rusage));
5576 if (!is_error(ret)) {
5577 host_to_target_rusage(arg2, &rusage);
5578 }
5579 }
5580 break;
5581 case TARGET_NR_gettimeofday:
5582 {
5583 struct timeval tv;
5584 ret = get_errno(gettimeofday(&tv, NULL));
5585 if (!is_error(ret)) {
5586 if (copy_to_user_timeval(arg1, &tv))
5587 goto efault;
5588 }
5589 }
5590 break;
5591 case TARGET_NR_settimeofday:
5592 {
5593 struct timeval tv;
5594 if (copy_from_user_timeval(&tv, arg1))
5595 goto efault;
5596 ret = get_errno(settimeofday(&tv, NULL));
5597 }
5598 break;
5599 #if defined(TARGET_NR_select) && !defined(TARGET_S390X) && !defined(TARGET_S390)
5600 case TARGET_NR_select:
5601 {
5602 struct target_sel_arg_struct *sel;
5603 abi_ulong inp, outp, exp, tvp;
5604 long nsel;
5605
5606 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
5607 goto efault;
5608 nsel = tswapl(sel->n);
5609 inp = tswapl(sel->inp);
5610 outp = tswapl(sel->outp);
5611 exp = tswapl(sel->exp);
5612 tvp = tswapl(sel->tvp);
5613 unlock_user_struct(sel, arg1, 0);
5614 ret = do_select(nsel, inp, outp, exp, tvp);
5615 }
5616 break;
5617 #endif
5618 #ifdef TARGET_NR_pselect6
5619 case TARGET_NR_pselect6:
5620 {
5621 abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
5622 fd_set rfds, wfds, efds;
5623 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
5624 struct timespec ts, *ts_ptr;
5625
5626 /*
5627 * The 6th arg is actually two args smashed together,
5628 * so we cannot use the C library.
5629 */
5630 sigset_t set;
5631 struct {
5632 sigset_t *set;
5633 size_t size;
5634 } sig, *sig_ptr;
5635
5636 abi_ulong arg_sigset, arg_sigsize, *arg7;
5637 target_sigset_t *target_sigset;
5638
5639 n = arg1;
5640 rfd_addr = arg2;
5641 wfd_addr = arg3;
5642 efd_addr = arg4;
5643 ts_addr = arg5;
5644
5645 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
5646 if (ret) {
5647 goto fail;
5648 }
5649 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
5650 if (ret) {
5651 goto fail;
5652 }
5653 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
5654 if (ret) {
5655 goto fail;
5656 }
5657
5658 /*
5659 * This takes a timespec, and not a timeval, so we cannot
5660 * use the do_select() helper ...
5661 */
5662 if (ts_addr) {
5663 if (target_to_host_timespec(&ts, ts_addr)) {
5664 goto efault;
5665 }
5666 ts_ptr = &ts;
5667 } else {
5668 ts_ptr = NULL;
5669 }
5670
5671 /* Extract the two packed args for the sigset */
5672 if (arg6) {
5673 sig_ptr = &sig;
5674 sig.size = _NSIG / 8;
5675
5676 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
5677 if (!arg7) {
5678 goto efault;
5679 }
5680 arg_sigset = tswapl(arg7[0]);
5681 arg_sigsize = tswapl(arg7[1]);
5682 unlock_user(arg7, arg6, 0);
5683
5684 if (arg_sigset) {
5685 sig.set = &set;
5686 target_sigset = lock_user(VERIFY_READ, arg_sigset,
5687 sizeof(*target_sigset), 1);
5688 if (!target_sigset) {
5689 goto efault;
5690 }
5691 target_to_host_sigset(&set, target_sigset);
5692 unlock_user(target_sigset, arg_sigset, 0);
5693 } else {
5694 sig.set = NULL;
5695 }
5696 } else {
5697 sig_ptr = NULL;
5698 }
5699
5700 ret = get_errno(sys_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
5701 ts_ptr, sig_ptr));
5702
5703 if (!is_error(ret)) {
5704 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
5705 goto efault;
5706 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
5707 goto efault;
5708 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
5709 goto efault;
5710
5711 if (ts_addr && host_to_target_timespec(ts_addr, &ts))
5712 goto efault;
5713 }
5714 }
5715 break;
5716 #endif
5717 case TARGET_NR_symlink:
5718 {
5719 void *p2;
5720 p = lock_user_string(arg1);
5721 p2 = lock_user_string(arg2);
5722 if (!p || !p2)
5723 ret = -TARGET_EFAULT;
5724 else
5725 ret = get_errno(symlink(p, p2));
5726 unlock_user(p2, arg2, 0);
5727 unlock_user(p, arg1, 0);
5728 }
5729 break;
5730 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
5731 case TARGET_NR_symlinkat:
5732 {
5733 void *p2;
5734 p = lock_user_string(arg1);
5735 p2 = lock_user_string(arg3);
5736 if (!p || !p2)
5737 ret = -TARGET_EFAULT;
5738 else
5739 ret = get_errno(sys_symlinkat(p, arg2, p2));
5740 unlock_user(p2, arg3, 0);
5741 unlock_user(p, arg1, 0);
5742 }
5743 break;
5744 #endif
5745 #ifdef TARGET_NR_oldlstat
5746 case TARGET_NR_oldlstat:
5747 goto unimplemented;
5748 #endif
5749 case TARGET_NR_readlink:
5750 {
5751 void *p2, *temp;
5752 p = lock_user_string(arg1);
5753 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
5754 if (!p || !p2)
5755 ret = -TARGET_EFAULT;
5756 else {
5757 if (strncmp((const char *)p, "/proc/self/exe", 14) == 0) {
5758 char real[PATH_MAX];
5759 temp = realpath(exec_path,real);
5760 ret = (temp==NULL) ? get_errno(-1) : strlen(real) ;
5761 snprintf((char *)p2, arg3, "%s", real);
5762 }
5763 else
5764 ret = get_errno(readlink(path(p), p2, arg3));
5765 }
5766 unlock_user(p2, arg2, ret);
5767 unlock_user(p, arg1, 0);
5768 }
5769 break;
5770 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
5771 case TARGET_NR_readlinkat:
5772 {
5773 void *p2;
5774 p = lock_user_string(arg2);
5775 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
5776 if (!p || !p2)
5777 ret = -TARGET_EFAULT;
5778 else
5779 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
5780 unlock_user(p2, arg3, ret);
5781 unlock_user(p, arg2, 0);
5782 }
5783 break;
5784 #endif
5785 #ifdef TARGET_NR_uselib
5786 case TARGET_NR_uselib:
5787 goto unimplemented;
5788 #endif
5789 #ifdef TARGET_NR_swapon
5790 case TARGET_NR_swapon:
5791 if (!(p = lock_user_string(arg1)))
5792 goto efault;
5793 ret = get_errno(swapon(p, arg2));
5794 unlock_user(p, arg1, 0);
5795 break;
5796 #endif
5797 case TARGET_NR_reboot:
5798 goto unimplemented;
5799 #ifdef TARGET_NR_readdir
5800 case TARGET_NR_readdir:
5801 goto unimplemented;
5802 #endif
5803 #ifdef TARGET_NR_mmap
5804 case TARGET_NR_mmap:
5805 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || \
5806 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
5807 || defined(TARGET_S390X)
5808 {
5809 abi_ulong *v;
5810 abi_ulong v1, v2, v3, v4, v5, v6;
5811 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
5812 goto efault;
5813 v1 = tswapl(v[0]);
5814 v2 = tswapl(v[1]);
5815 v3 = tswapl(v[2]);
5816 v4 = tswapl(v[3]);
5817 v5 = tswapl(v[4]);
5818 v6 = tswapl(v[5]);
5819 unlock_user(v, arg1, 0);
5820 ret = get_errno(target_mmap(v1, v2, v3,
5821 target_to_host_bitmask(v4, mmap_flags_tbl),
5822 v5, v6));
5823 }
5824 #else
5825 ret = get_errno(target_mmap(arg1, arg2, arg3,
5826 target_to_host_bitmask(arg4, mmap_flags_tbl),
5827 arg5,
5828 arg6));
5829 #endif
5830 break;
5831 #endif
5832 #ifdef TARGET_NR_mmap2
5833 case TARGET_NR_mmap2:
5834 #ifndef MMAP_SHIFT
5835 #define MMAP_SHIFT 12
5836 #endif
5837 ret = get_errno(target_mmap(arg1, arg2, arg3,
5838 target_to_host_bitmask(arg4, mmap_flags_tbl),
5839 arg5,
5840 arg6 << MMAP_SHIFT));
5841 break;
5842 #endif
5843 case TARGET_NR_munmap:
5844 ret = get_errno(target_munmap(arg1, arg2));
5845 break;
5846 case TARGET_NR_mprotect:
5847 {
5848 TaskState *ts = ((CPUState *)cpu_env)->opaque;
5849 /* Special hack to detect libc making the stack executable. */
5850 if ((arg3 & PROT_GROWSDOWN)
5851 && arg1 >= ts->info->stack_limit
5852 && arg1 <= ts->info->start_stack) {
5853 arg3 &= ~PROT_GROWSDOWN;
5854 arg2 = arg2 + arg1 - ts->info->stack_limit;
5855 arg1 = ts->info->stack_limit;
5856 }
5857 }
5858 ret = get_errno(target_mprotect(arg1, arg2, arg3));
5859 break;
5860 #ifdef TARGET_NR_mremap
5861 case TARGET_NR_mremap:
5862 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
5863 break;
5864 #endif
5865 /* ??? msync/mlock/munlock are broken for softmmu. */
5866 #ifdef TARGET_NR_msync
5867 case TARGET_NR_msync:
5868 ret = get_errno(msync(g2h(arg1), arg2, arg3));
5869 break;
5870 #endif
5871 #ifdef TARGET_NR_mlock
5872 case TARGET_NR_mlock:
5873 ret = get_errno(mlock(g2h(arg1), arg2));
5874 break;
5875 #endif
5876 #ifdef TARGET_NR_munlock
5877 case TARGET_NR_munlock:
5878 ret = get_errno(munlock(g2h(arg1), arg2));
5879 break;
5880 #endif
5881 #ifdef TARGET_NR_mlockall
5882 case TARGET_NR_mlockall:
5883 ret = get_errno(mlockall(arg1));
5884 break;
5885 #endif
5886 #ifdef TARGET_NR_munlockall
5887 case TARGET_NR_munlockall:
5888 ret = get_errno(munlockall());
5889 break;
5890 #endif
5891 case TARGET_NR_truncate:
5892 if (!(p = lock_user_string(arg1)))
5893 goto efault;
5894 ret = get_errno(truncate(p, arg2));
5895 unlock_user(p, arg1, 0);
5896 break;
5897 case TARGET_NR_ftruncate:
5898 ret = get_errno(ftruncate(arg1, arg2));
5899 break;
5900 case TARGET_NR_fchmod:
5901 ret = get_errno(fchmod(arg1, arg2));
5902 break;
5903 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
5904 case TARGET_NR_fchmodat:
5905 if (!(p = lock_user_string(arg2)))
5906 goto efault;
5907 ret = get_errno(sys_fchmodat(arg1, p, arg3));
5908 unlock_user(p, arg2, 0);
5909 break;
5910 #endif
5911 case TARGET_NR_getpriority:
5912 /* libc does special remapping of the return value of
5913 * sys_getpriority() so it's just easiest to call
5914 * sys_getpriority() directly rather than through libc. */
5915 ret = get_errno(sys_getpriority(arg1, arg2));
5916 break;
5917 case TARGET_NR_setpriority:
5918 ret = get_errno(setpriority(arg1, arg2, arg3));
5919 break;
5920 #ifdef TARGET_NR_profil
5921 case TARGET_NR_profil:
5922 goto unimplemented;
5923 #endif
5924 case TARGET_NR_statfs:
5925 if (!(p = lock_user_string(arg1)))
5926 goto efault;
5927 ret = get_errno(statfs(path(p), &stfs));
5928 unlock_user(p, arg1, 0);
5929 convert_statfs:
5930 if (!is_error(ret)) {
5931 struct target_statfs *target_stfs;
5932
5933 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
5934 goto efault;
5935 __put_user(stfs.f_type, &target_stfs->f_type);
5936 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
5937 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
5938 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
5939 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
5940 __put_user(stfs.f_files, &target_stfs->f_files);
5941 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
5942 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
5943 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
5944 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
5945 unlock_user_struct(target_stfs, arg2, 1);
5946 }
5947 break;
5948 case TARGET_NR_fstatfs:
5949 ret = get_errno(fstatfs(arg1, &stfs));
5950 goto convert_statfs;
5951 #ifdef TARGET_NR_statfs64
5952 case TARGET_NR_statfs64:
5953 if (!(p = lock_user_string(arg1)))
5954 goto efault;
5955 ret = get_errno(statfs(path(p), &stfs));
5956 unlock_user(p, arg1, 0);
5957 convert_statfs64:
5958 if (!is_error(ret)) {
5959 struct target_statfs64 *target_stfs;
5960
5961 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
5962 goto efault;
5963 __put_user(stfs.f_type, &target_stfs->f_type);
5964 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
5965 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
5966 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
5967 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
5968 __put_user(stfs.f_files, &target_stfs->f_files);
5969 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
5970 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
5971 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
5972 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
5973 unlock_user_struct(target_stfs, arg3, 1);
5974 }
5975 break;
5976 case TARGET_NR_fstatfs64:
5977 ret = get_errno(fstatfs(arg1, &stfs));
5978 goto convert_statfs64;
5979 #endif
5980 #ifdef TARGET_NR_ioperm
5981 case TARGET_NR_ioperm:
5982 goto unimplemented;
5983 #endif
5984 #ifdef TARGET_NR_socketcall
5985 case TARGET_NR_socketcall:
5986 ret = do_socketcall(arg1, arg2);
5987 break;
5988 #endif
5989 #ifdef TARGET_NR_accept
5990 case TARGET_NR_accept:
5991 ret = do_accept(arg1, arg2, arg3);
5992 break;
5993 #endif
5994 #ifdef TARGET_NR_bind
5995 case TARGET_NR_bind:
5996 ret = do_bind(arg1, arg2, arg3);
5997 break;
5998 #endif
5999 #ifdef TARGET_NR_connect
6000 case TARGET_NR_connect:
6001 ret = do_connect(arg1, arg2, arg3);
6002 break;
6003 #endif
6004 #ifdef TARGET_NR_getpeername
6005 case TARGET_NR_getpeername:
6006 ret = do_getpeername(arg1, arg2, arg3);
6007 break;
6008 #endif
6009 #ifdef TARGET_NR_getsockname
6010 case TARGET_NR_getsockname:
6011 ret = do_getsockname(arg1, arg2, arg3);
6012 break;
6013 #endif
6014 #ifdef TARGET_NR_getsockopt
6015 case TARGET_NR_getsockopt:
6016 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
6017 break;
6018 #endif
6019 #ifdef TARGET_NR_listen
6020 case TARGET_NR_listen:
6021 ret = get_errno(listen(arg1, arg2));
6022 break;
6023 #endif
6024 #ifdef TARGET_NR_recv
6025 case TARGET_NR_recv:
6026 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
6027 break;
6028 #endif
6029 #ifdef TARGET_NR_recvfrom
6030 case TARGET_NR_recvfrom:
6031 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
6032 break;
6033 #endif
6034 #ifdef TARGET_NR_recvmsg
6035 case TARGET_NR_recvmsg:
6036 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
6037 break;
6038 #endif
6039 #ifdef TARGET_NR_send
6040 case TARGET_NR_send:
6041 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
6042 break;
6043 #endif
6044 #ifdef TARGET_NR_sendmsg
6045 case TARGET_NR_sendmsg:
6046 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
6047 break;
6048 #endif
6049 #ifdef TARGET_NR_sendto
6050 case TARGET_NR_sendto:
6051 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
6052 break;
6053 #endif
6054 #ifdef TARGET_NR_shutdown
6055 case TARGET_NR_shutdown:
6056 ret = get_errno(shutdown(arg1, arg2));
6057 break;
6058 #endif
6059 #ifdef TARGET_NR_socket
6060 case TARGET_NR_socket:
6061 ret = do_socket(arg1, arg2, arg3);
6062 break;
6063 #endif
6064 #ifdef TARGET_NR_socketpair
6065 case TARGET_NR_socketpair:
6066 ret = do_socketpair(arg1, arg2, arg3, arg4);
6067 break;
6068 #endif
6069 #ifdef TARGET_NR_setsockopt
6070 case TARGET_NR_setsockopt:
6071 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
6072 break;
6073 #endif
6074
6075 case TARGET_NR_syslog:
6076 if (!(p = lock_user_string(arg2)))
6077 goto efault;
6078 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
6079 unlock_user(p, arg2, 0);
6080 break;
6081
6082 case TARGET_NR_setitimer:
6083 {
6084 struct itimerval value, ovalue, *pvalue;
6085
6086 if (arg2) {
6087 pvalue = &value;
6088 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
6089 || copy_from_user_timeval(&pvalue->it_value,
6090 arg2 + sizeof(struct target_timeval)))
6091 goto efault;
6092 } else {
6093 pvalue = NULL;
6094 }
6095 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
6096 if (!is_error(ret) && arg3) {
6097 if (copy_to_user_timeval(arg3,
6098 &ovalue.it_interval)
6099 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
6100 &ovalue.it_value))
6101 goto efault;
6102 }
6103 }
6104 break;
6105 case TARGET_NR_getitimer:
6106 {
6107 struct itimerval value;
6108
6109 ret = get_errno(getitimer(arg1, &value));
6110 if (!is_error(ret) && arg2) {
6111 if (copy_to_user_timeval(arg2,
6112 &value.it_interval)
6113 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
6114 &value.it_value))
6115 goto efault;
6116 }
6117 }
6118 break;
6119 case TARGET_NR_stat:
6120 if (!(p = lock_user_string(arg1)))
6121 goto efault;
6122 ret = get_errno(stat(path(p), &st));
6123 unlock_user(p, arg1, 0);
6124 goto do_stat;
6125 case TARGET_NR_lstat:
6126 if (!(p = lock_user_string(arg1)))
6127 goto efault;
6128 ret = get_errno(lstat(path(p), &st));
6129 unlock_user(p, arg1, 0);
6130 goto do_stat;
6131 case TARGET_NR_fstat:
6132 {
6133 ret = get_errno(fstat(arg1, &st));
6134 do_stat:
6135 if (!is_error(ret)) {
6136 struct target_stat *target_st;
6137
6138 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
6139 goto efault;
6140 memset(target_st, 0, sizeof(*target_st));
6141 __put_user(st.st_dev, &target_st->st_dev);
6142 __put_user(st.st_ino, &target_st->st_ino);
6143 __put_user(st.st_mode, &target_st->st_mode);
6144 __put_user(st.st_uid, &target_st->st_uid);
6145 __put_user(st.st_gid, &target_st->st_gid);
6146 __put_user(st.st_nlink, &target_st->st_nlink);
6147 __put_user(st.st_rdev, &target_st->st_rdev);
6148 __put_user(st.st_size, &target_st->st_size);
6149 __put_user(st.st_blksize, &target_st->st_blksize);
6150 __put_user(st.st_blocks, &target_st->st_blocks);
6151 __put_user(st.st_atime, &target_st->target_st_atime);
6152 __put_user(st.st_mtime, &target_st->target_st_mtime);
6153 __put_user(st.st_ctime, &target_st->target_st_ctime);
6154 unlock_user_struct(target_st, arg2, 1);
6155 }
6156 }
6157 break;
6158 #ifdef TARGET_NR_olduname
6159 case TARGET_NR_olduname:
6160 goto unimplemented;
6161 #endif
6162 #ifdef TARGET_NR_iopl
6163 case TARGET_NR_iopl:
6164 goto unimplemented;
6165 #endif
6166 case TARGET_NR_vhangup:
6167 ret = get_errno(vhangup());
6168 break;
6169 #ifdef TARGET_NR_idle
6170 case TARGET_NR_idle:
6171 goto unimplemented;
6172 #endif
6173 #ifdef TARGET_NR_syscall
6174 case TARGET_NR_syscall:
6175 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
6176 break;
6177 #endif
6178 case TARGET_NR_wait4:
6179 {
6180 int status;
6181 abi_long status_ptr = arg2;
6182 struct rusage rusage, *rusage_ptr;
6183 abi_ulong target_rusage = arg4;
6184 if (target_rusage)
6185 rusage_ptr = &rusage;
6186 else
6187 rusage_ptr = NULL;
6188 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
6189 if (!is_error(ret)) {
6190 if (status_ptr) {
6191 status = host_to_target_waitstatus(status);
6192 if (put_user_s32(status, status_ptr))
6193 goto efault;
6194 }
6195 if (target_rusage)
6196 host_to_target_rusage(target_rusage, &rusage);
6197 }
6198 }
6199 break;
6200 #ifdef TARGET_NR_swapoff
6201 case TARGET_NR_swapoff:
6202 if (!(p = lock_user_string(arg1)))
6203 goto efault;
6204 ret = get_errno(swapoff(p));
6205 unlock_user(p, arg1, 0);
6206 break;
6207 #endif
6208 case TARGET_NR_sysinfo:
6209 {
6210 struct target_sysinfo *target_value;
6211 struct sysinfo value;
6212 ret = get_errno(sysinfo(&value));
6213 if (!is_error(ret) && arg1)
6214 {
6215 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
6216 goto efault;
6217 __put_user(value.uptime, &target_value->uptime);
6218 __put_user(value.loads[0], &target_value->loads[0]);
6219 __put_user(value.loads[1], &target_value->loads[1]);
6220 __put_user(value.loads[2], &target_value->loads[2]);
6221 __put_user(value.totalram, &target_value->totalram);
6222 __put_user(value.freeram, &target_value->freeram);
6223 __put_user(value.sharedram, &target_value->sharedram);
6224 __put_user(value.bufferram, &target_value->bufferram);
6225 __put_user(value.totalswap, &target_value->totalswap);
6226 __put_user(value.freeswap, &target_value->freeswap);
6227 __put_user(value.procs, &target_value->procs);
6228 __put_user(value.totalhigh, &target_value->totalhigh);
6229 __put_user(value.freehigh, &target_value->freehigh);
6230 __put_user(value.mem_unit, &target_value->mem_unit);
6231 unlock_user_struct(target_value, arg1, 1);
6232 }
6233 }
6234 break;
6235 #ifdef TARGET_NR_ipc
6236 case TARGET_NR_ipc:
6237 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
6238 break;
6239 #endif
6240 #ifdef TARGET_NR_semget
6241 case TARGET_NR_semget:
6242 ret = get_errno(semget(arg1, arg2, arg3));
6243 break;
6244 #endif
6245 #ifdef TARGET_NR_semop
6246 case TARGET_NR_semop:
6247 ret = get_errno(do_semop(arg1, arg2, arg3));
6248 break;
6249 #endif
6250 #ifdef TARGET_NR_semctl
6251 case TARGET_NR_semctl:
6252 ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);
6253 break;
6254 #endif
6255 #ifdef TARGET_NR_msgctl
6256 case TARGET_NR_msgctl:
6257 ret = do_msgctl(arg1, arg2, arg3);
6258 break;
6259 #endif
6260 #ifdef TARGET_NR_msgget
6261 case TARGET_NR_msgget:
6262 ret = get_errno(msgget(arg1, arg2));
6263 break;
6264 #endif
6265 #ifdef TARGET_NR_msgrcv
6266 case TARGET_NR_msgrcv:
6267 ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
6268 break;
6269 #endif
6270 #ifdef TARGET_NR_msgsnd
6271 case TARGET_NR_msgsnd:
6272 ret = do_msgsnd(arg1, arg2, arg3, arg4);
6273 break;
6274 #endif
6275 #ifdef TARGET_NR_shmget
6276 case TARGET_NR_shmget:
6277 ret = get_errno(shmget(arg1, arg2, arg3));
6278 break;
6279 #endif
6280 #ifdef TARGET_NR_shmctl
6281 case TARGET_NR_shmctl:
6282 ret = do_shmctl(arg1, arg2, arg3);
6283 break;
6284 #endif
6285 #ifdef TARGET_NR_shmat
6286 case TARGET_NR_shmat:
6287 ret = do_shmat(arg1, arg2, arg3);
6288 break;
6289 #endif
6290 #ifdef TARGET_NR_shmdt
6291 case TARGET_NR_shmdt:
6292 ret = do_shmdt(arg1);
6293 break;
6294 #endif
6295 case TARGET_NR_fsync:
6296 ret = get_errno(fsync(arg1));
6297 break;
6298 case TARGET_NR_clone:
6299 #if defined(TARGET_SH4) || defined(TARGET_ALPHA)
6300 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
6301 #elif defined(TARGET_CRIS)
6302 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5));
6303 #elif defined(TARGET_S390X)
6304 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
6305 #else
6306 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
6307 #endif
6308 break;
6309 #ifdef __NR_exit_group
6310 /* new thread calls */
6311 case TARGET_NR_exit_group:
6312 #ifdef TARGET_GPROF
6313 _mcleanup();
6314 #endif
6315 gdb_exit(cpu_env, arg1);
6316 ret = get_errno(exit_group(arg1));
6317 break;
6318 #endif
6319 case TARGET_NR_setdomainname:
6320 if (!(p = lock_user_string(arg1)))
6321 goto efault;
6322 ret = get_errno(setdomainname(p, arg2));
6323 unlock_user(p, arg1, 0);
6324 break;
6325 case TARGET_NR_uname:
6326 /* no need to transcode because we use the linux syscall */
6327 {
6328 struct new_utsname * buf;
6329
6330 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
6331 goto efault;
6332 ret = get_errno(sys_uname(buf));
6333 if (!is_error(ret)) {
6334 /* Overrite the native machine name with whatever is being
6335 emulated. */
6336 strcpy (buf->machine, cpu_to_uname_machine(cpu_env));
6337 /* Allow the user to override the reported release. */
6338 if (qemu_uname_release && *qemu_uname_release)
6339 strcpy (buf->release, qemu_uname_release);
6340 }
6341 unlock_user_struct(buf, arg1, 1);
6342 }
6343 break;
6344 #ifdef TARGET_I386
6345 case TARGET_NR_modify_ldt:
6346 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
6347 break;
6348 #if !defined(TARGET_X86_64)
6349 case TARGET_NR_vm86old:
6350 goto unimplemented;
6351 case TARGET_NR_vm86:
6352 ret = do_vm86(cpu_env, arg1, arg2);
6353 break;
6354 #endif
6355 #endif
6356 case TARGET_NR_adjtimex:
6357 goto unimplemented;
6358 #ifdef TARGET_NR_create_module
6359 case TARGET_NR_create_module:
6360 #endif
6361 case TARGET_NR_init_module:
6362 case TARGET_NR_delete_module:
6363 #ifdef TARGET_NR_get_kernel_syms
6364 case TARGET_NR_get_kernel_syms:
6365 #endif
6366 goto unimplemented;
6367 case TARGET_NR_quotactl:
6368 goto unimplemented;
6369 case TARGET_NR_getpgid:
6370 ret = get_errno(getpgid(arg1));
6371 break;
6372 case TARGET_NR_fchdir:
6373 ret = get_errno(fchdir(arg1));
6374 break;
6375 #ifdef TARGET_NR_bdflush /* not on x86_64 */
6376 case TARGET_NR_bdflush:
6377 goto unimplemented;
6378 #endif
6379 #ifdef TARGET_NR_sysfs
6380 case TARGET_NR_sysfs:
6381 goto unimplemented;
6382 #endif
6383 case TARGET_NR_personality:
6384 ret = get_errno(personality(arg1));
6385 break;
6386 #ifdef TARGET_NR_afs_syscall
6387 case TARGET_NR_afs_syscall:
6388 goto unimplemented;
6389 #endif
6390 #ifdef TARGET_NR__llseek /* Not on alpha */
6391 case TARGET_NR__llseek:
6392 {
6393 int64_t res;
6394 #if !defined(__NR_llseek)
6395 res = lseek(arg1, ((uint64_t)arg2 << 32) | arg3, arg5);
6396 if (res == -1) {
6397 ret = get_errno(res);
6398 } else {
6399 ret = 0;
6400 }
6401 #else
6402 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
6403 #endif
6404 if ((ret == 0) && put_user_s64(res, arg4)) {
6405 goto efault;
6406 }
6407 }
6408 break;
6409 #endif
6410 case TARGET_NR_getdents:
6411 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
6412 {
6413 struct target_dirent *target_dirp;
6414 struct linux_dirent *dirp;
6415 abi_long count = arg3;
6416
6417 dirp = malloc(count);
6418 if (!dirp) {
6419 ret = -TARGET_ENOMEM;
6420 goto fail;
6421 }
6422
6423 ret = get_errno(sys_getdents(arg1, dirp, count));
6424 if (!is_error(ret)) {
6425 struct linux_dirent *de;
6426 struct target_dirent *tde;
6427 int len = ret;
6428 int reclen, treclen;
6429 int count1, tnamelen;
6430
6431 count1 = 0;
6432 de = dirp;
6433 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
6434 goto efault;
6435 tde = target_dirp;
6436 while (len > 0) {
6437 reclen = de->d_reclen;
6438 treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
6439 tde->d_reclen = tswap16(treclen);
6440 tde->d_ino = tswapl(de->d_ino);
6441 tde->d_off = tswapl(de->d_off);
6442 tnamelen = treclen - (2 * sizeof(abi_long) + 2);
6443 if (tnamelen > 256)
6444 tnamelen = 256;
6445 /* XXX: may not be correct */
6446 pstrcpy(tde->d_name, tnamelen, de->d_name);
6447 de = (struct linux_dirent *)((char *)de + reclen);
6448 len -= reclen;
6449 tde = (struct target_dirent *)((char *)tde + treclen);
6450 count1 += treclen;
6451 }
6452 ret = count1;
6453 unlock_user(target_dirp, arg2, ret);
6454 }
6455 free(dirp);
6456 }
6457 #else
6458 {
6459 struct linux_dirent *dirp;
6460 abi_long count = arg3;
6461
6462 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
6463 goto efault;
6464 ret = get_errno(sys_getdents(arg1, dirp, count));
6465 if (!is_error(ret)) {
6466 struct linux_dirent *de;
6467 int len = ret;
6468 int reclen;
6469 de = dirp;
6470 while (len > 0) {
6471 reclen = de->d_reclen;
6472 if (reclen > len)
6473 break;
6474 de->d_reclen = tswap16(reclen);
6475 tswapls(&de->d_ino);
6476 tswapls(&de->d_off);
6477 de = (struct linux_dirent *)((char *)de + reclen);
6478 len -= reclen;
6479 }
6480 }
6481 unlock_user(dirp, arg2, ret);
6482 }
6483 #endif
6484 break;
6485 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
6486 case TARGET_NR_getdents64:
6487 {
6488 struct linux_dirent64 *dirp;
6489 abi_long count = arg3;
6490 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
6491 goto efault;
6492 ret = get_errno(sys_getdents64(arg1, dirp, count));
6493 if (!is_error(ret)) {
6494 struct linux_dirent64 *de;
6495 int len = ret;
6496 int reclen;
6497 de = dirp;
6498 while (len > 0) {
6499 reclen = de->d_reclen;
6500 if (reclen > len)
6501 break;
6502 de->d_reclen = tswap16(reclen);
6503 tswap64s((uint64_t *)&de->d_ino);
6504 tswap64s((uint64_t *)&de->d_off);
6505 de = (struct linux_dirent64 *)((char *)de + reclen);
6506 len -= reclen;
6507 }
6508 }
6509 unlock_user(dirp, arg2, ret);
6510 }
6511 break;
6512 #endif /* TARGET_NR_getdents64 */
6513 #if defined(TARGET_NR__newselect) || defined(TARGET_S390X)
6514 #ifdef TARGET_S390X
6515 case TARGET_NR_select:
6516 #else
6517 case TARGET_NR__newselect:
6518 #endif
6519 ret = do_select(arg1, arg2, arg3, arg4, arg5);
6520 break;
6521 #endif
6522 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
6523 # ifdef TARGET_NR_poll
6524 case TARGET_NR_poll:
6525 # endif
6526 # ifdef TARGET_NR_ppoll
6527 case TARGET_NR_ppoll:
6528 # endif
6529 {
6530 struct target_pollfd *target_pfd;
6531 unsigned int nfds = arg2;
6532 int timeout = arg3;
6533 struct pollfd *pfd;
6534 unsigned int i;
6535
6536 target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
6537 if (!target_pfd)
6538 goto efault;
6539
6540 pfd = alloca(sizeof(struct pollfd) * nfds);
6541 for(i = 0; i < nfds; i++) {
6542 pfd[i].fd = tswap32(target_pfd[i].fd);
6543 pfd[i].events = tswap16(target_pfd[i].events);
6544 }
6545
6546 # ifdef TARGET_NR_ppoll
6547 if (num == TARGET_NR_ppoll) {
6548 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
6549 target_sigset_t *target_set;
6550 sigset_t _set, *set = &_set;
6551
6552 if (arg3) {
6553 if (target_to_host_timespec(timeout_ts, arg3)) {
6554 unlock_user(target_pfd, arg1, 0);
6555 goto efault;
6556 }
6557 } else {
6558 timeout_ts = NULL;
6559 }
6560
6561 if (arg4) {
6562 target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
6563 if (!target_set) {
6564 unlock_user(target_pfd, arg1, 0);
6565 goto efault;
6566 }
6567 target_to_host_sigset(set, target_set);
6568 } else {
6569 set = NULL;
6570 }
6571
6572 ret = get_errno(sys_ppoll(pfd, nfds, timeout_ts, set, _NSIG/8));
6573
6574 if (!is_error(ret) && arg3) {
6575 host_to_target_timespec(arg3, timeout_ts);
6576 }
6577 if (arg4) {
6578 unlock_user(target_set, arg4, 0);
6579 }
6580 } else
6581 # endif
6582 ret = get_errno(poll(pfd, nfds, timeout));
6583
6584 if (!is_error(ret)) {
6585 for(i = 0; i < nfds; i++) {
6586 target_pfd[i].revents = tswap16(pfd[i].revents);
6587 }
6588 }
6589 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
6590 }
6591 break;
6592 #endif
6593 case TARGET_NR_flock:
6594 /* NOTE: the flock constant seems to be the same for every
6595 Linux platform */
6596 ret = get_errno(flock(arg1, arg2));
6597 break;
6598 case TARGET_NR_readv:
6599 {
6600 int count = arg3;
6601 struct iovec *vec;
6602
6603 vec = alloca(count * sizeof(struct iovec));
6604 if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
6605 goto efault;
6606 ret = get_errno(readv(arg1, vec, count));
6607 unlock_iovec(vec, arg2, count, 1);
6608 }
6609 break;
6610 case TARGET_NR_writev:
6611 {
6612 int count = arg3;
6613 struct iovec *vec;
6614
6615 vec = alloca(count * sizeof(struct iovec));
6616 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
6617 goto efault;
6618 ret = get_errno(writev(arg1, vec, count));
6619 unlock_iovec(vec, arg2, count, 0);
6620 }
6621 break;
6622 case TARGET_NR_getsid:
6623 ret = get_errno(getsid(arg1));
6624 break;
6625 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
6626 case TARGET_NR_fdatasync:
6627 ret = get_errno(fdatasync(arg1));
6628 break;
6629 #endif
6630 case TARGET_NR__sysctl:
6631 /* We don't implement this, but ENOTDIR is always a safe
6632 return value. */
6633 ret = -TARGET_ENOTDIR;
6634 break;
6635 case TARGET_NR_sched_getaffinity:
6636 {
6637 unsigned int mask_size;
6638 unsigned long *mask;
6639
6640 /*
6641 * sched_getaffinity needs multiples of ulong, so need to take
6642 * care of mismatches between target ulong and host ulong sizes.
6643 */
6644 if (arg2 & (sizeof(abi_ulong) - 1)) {
6645 ret = -TARGET_EINVAL;
6646 break;
6647 }
6648 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
6649
6650 mask = alloca(mask_size);
6651 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
6652
6653 if (!is_error(ret)) {
6654 if (copy_to_user(arg3, mask, ret)) {
6655 goto efault;
6656 }
6657 }
6658 }
6659 break;
6660 case TARGET_NR_sched_setaffinity:
6661 {
6662 unsigned int mask_size;
6663 unsigned long *mask;
6664
6665 /*
6666 * sched_setaffinity needs multiples of ulong, so need to take
6667 * care of mismatches between target ulong and host ulong sizes.
6668 */
6669 if (arg2 & (sizeof(abi_ulong) - 1)) {
6670 ret = -TARGET_EINVAL;
6671 break;
6672 }
6673 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
6674
6675 mask = alloca(mask_size);
6676 if (!lock_user_struct(VERIFY_READ, p, arg3, 1)) {
6677 goto efault;
6678 }
6679 memcpy(mask, p, arg2);
6680 unlock_user_struct(p, arg2, 0);
6681
6682 ret = get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
6683 }
6684 break;
6685 case TARGET_NR_sched_setparam:
6686 {
6687 struct sched_param *target_schp;
6688 struct sched_param schp;
6689
6690 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
6691 goto efault;
6692 schp.sched_priority = tswap32(target_schp->sched_priority);
6693 unlock_user_struct(target_schp, arg2, 0);
6694 ret = get_errno(sched_setparam(arg1, &schp));
6695 }
6696 break;
6697 case TARGET_NR_sched_getparam:
6698 {
6699 struct sched_param *target_schp;
6700 struct sched_param schp;
6701 ret = get_errno(sched_getparam(arg1, &schp));
6702 if (!is_error(ret)) {
6703 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
6704 goto efault;
6705 target_schp->sched_priority = tswap32(schp.sched_priority);
6706 unlock_user_struct(target_schp, arg2, 1);
6707 }
6708 }
6709 break;
6710 case TARGET_NR_sched_setscheduler:
6711 {
6712 struct sched_param *target_schp;
6713 struct sched_param schp;
6714 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
6715 goto efault;
6716 schp.sched_priority = tswap32(target_schp->sched_priority);
6717 unlock_user_struct(target_schp, arg3, 0);
6718 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
6719 }
6720 break;
6721 case TARGET_NR_sched_getscheduler:
6722 ret = get_errno(sched_getscheduler(arg1));
6723 break;
6724 case TARGET_NR_sched_yield:
6725 ret = get_errno(sched_yield());
6726 break;
6727 case TARGET_NR_sched_get_priority_max:
6728 ret = get_errno(sched_get_priority_max(arg1));
6729 break;
6730 case TARGET_NR_sched_get_priority_min:
6731 ret = get_errno(sched_get_priority_min(arg1));
6732 break;
6733 case TARGET_NR_sched_rr_get_interval:
6734 {
6735 struct timespec ts;
6736 ret = get_errno(sched_rr_get_interval(arg1, &ts));
6737 if (!is_error(ret)) {
6738 host_to_target_timespec(arg2, &ts);
6739 }
6740 }
6741 break;
6742 case TARGET_NR_nanosleep:
6743 {
6744 struct timespec req, rem;
6745 target_to_host_timespec(&req, arg1);
6746 ret = get_errno(nanosleep(&req, &rem));
6747 if (is_error(ret) && arg2) {
6748 host_to_target_timespec(arg2, &rem);
6749 }
6750 }
6751 break;
6752 #ifdef TARGET_NR_query_module
6753 case TARGET_NR_query_module:
6754 goto unimplemented;
6755 #endif
6756 #ifdef TARGET_NR_nfsservctl
6757 case TARGET_NR_nfsservctl:
6758 goto unimplemented;
6759 #endif
6760 case TARGET_NR_prctl:
6761 switch (arg1)
6762 {
6763 case PR_GET_PDEATHSIG:
6764 {
6765 int deathsig;
6766 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
6767 if (!is_error(ret) && arg2
6768 && put_user_ual(deathsig, arg2))
6769 goto efault;
6770 }
6771 break;
6772 default:
6773 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
6774 break;
6775 }
6776 break;
6777 #ifdef TARGET_NR_arch_prctl
6778 case TARGET_NR_arch_prctl:
6779 #if defined(TARGET_I386) && !defined(TARGET_ABI32)
6780 ret = do_arch_prctl(cpu_env, arg1, arg2);
6781 break;
6782 #else
6783 goto unimplemented;
6784 #endif
6785 #endif
6786 #ifdef TARGET_NR_pread
6787 case TARGET_NR_pread:
6788 #ifdef TARGET_ARM
6789 if (((CPUARMState *)cpu_env)->eabi)
6790 arg4 = arg5;
6791 #endif
6792 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
6793 goto efault;
6794 ret = get_errno(pread(arg1, p, arg3, arg4));
6795 unlock_user(p, arg2, ret);
6796 break;
6797 case TARGET_NR_pwrite:
6798 #ifdef TARGET_ARM
6799 if (((CPUARMState *)cpu_env)->eabi)
6800 arg4 = arg5;
6801 #endif
6802 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
6803 goto efault;
6804 ret = get_errno(pwrite(arg1, p, arg3, arg4));
6805 unlock_user(p, arg2, 0);
6806 break;
6807 #endif
6808 #ifdef TARGET_NR_pread64
6809 case TARGET_NR_pread64:
6810 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
6811 goto efault;
6812 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
6813 unlock_user(p, arg2, ret);
6814 break;
6815 case TARGET_NR_pwrite64:
6816 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
6817 goto efault;
6818 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
6819 unlock_user(p, arg2, 0);
6820 break;
6821 #endif
6822 case TARGET_NR_getcwd:
6823 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
6824 goto efault;
6825 ret = get_errno(sys_getcwd1(p, arg2));
6826 unlock_user(p, arg1, ret);
6827 break;
6828 case TARGET_NR_capget:
6829 goto unimplemented;
6830 case TARGET_NR_capset:
6831 goto unimplemented;
6832 case TARGET_NR_sigaltstack:
6833 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
6834 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \
6835 defined(TARGET_M68K) || defined(TARGET_S390X)
6836 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
6837 break;
6838 #else
6839 goto unimplemented;
6840 #endif
6841 case TARGET_NR_sendfile:
6842 goto unimplemented;
6843 #ifdef TARGET_NR_getpmsg
6844 case TARGET_NR_getpmsg:
6845 goto unimplemented;
6846 #endif
6847 #ifdef TARGET_NR_putpmsg
6848 case TARGET_NR_putpmsg:
6849 goto unimplemented;
6850 #endif
6851 #ifdef TARGET_NR_vfork
6852 case TARGET_NR_vfork:
6853 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
6854 0, 0, 0, 0));
6855 break;
6856 #endif
6857 #ifdef TARGET_NR_ugetrlimit
6858 case TARGET_NR_ugetrlimit:
6859 {
6860 struct rlimit rlim;
6861 ret = get_errno(getrlimit(arg1, &rlim));
6862 if (!is_error(ret)) {
6863 struct target_rlimit *target_rlim;
6864 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
6865 goto efault;
6866 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
6867 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
6868 unlock_user_struct(target_rlim, arg2, 1);
6869 }
6870 break;
6871 }
6872 #endif
6873 #ifdef TARGET_NR_truncate64
6874 case TARGET_NR_truncate64:
6875 if (!(p = lock_user_string(arg1)))
6876 goto efault;
6877 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
6878 unlock_user(p, arg1, 0);
6879 break;
6880 #endif
6881 #ifdef TARGET_NR_ftruncate64
6882 case TARGET_NR_ftruncate64:
6883 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
6884 break;
6885 #endif
6886 #ifdef TARGET_NR_stat64
6887 case TARGET_NR_stat64:
6888 if (!(p = lock_user_string(arg1)))
6889 goto efault;
6890 ret = get_errno(stat(path(p), &st));
6891 unlock_user(p, arg1, 0);
6892 if (!is_error(ret))
6893 ret = host_to_target_stat64(cpu_env, arg2, &st);
6894 break;
6895 #endif
6896 #ifdef TARGET_NR_lstat64
6897 case TARGET_NR_lstat64:
6898 if (!(p = lock_user_string(arg1)))
6899 goto efault;
6900 ret = get_errno(lstat(path(p), &st));
6901 unlock_user(p, arg1, 0);
6902 if (!is_error(ret))
6903 ret = host_to_target_stat64(cpu_env, arg2, &st);
6904 break;
6905 #endif
6906 #ifdef TARGET_NR_fstat64
6907 case TARGET_NR_fstat64:
6908 ret = get_errno(fstat(arg1, &st));
6909 if (!is_error(ret))
6910 ret = host_to_target_stat64(cpu_env, arg2, &st);
6911 break;
6912 #endif
6913 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \
6914 (defined(__NR_fstatat64) || defined(__NR_newfstatat))
6915 #ifdef TARGET_NR_fstatat64
6916 case TARGET_NR_fstatat64:
6917 #endif
6918 #ifdef TARGET_NR_newfstatat
6919 case TARGET_NR_newfstatat:
6920 #endif
6921 if (!(p = lock_user_string(arg2)))
6922 goto efault;
6923 #ifdef __NR_fstatat64
6924 ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));
6925 #else
6926 ret = get_errno(sys_newfstatat(arg1, path(p), &st, arg4));
6927 #endif
6928 if (!is_error(ret))
6929 ret = host_to_target_stat64(cpu_env, arg3, &st);
6930 break;
6931 #endif
6932 case TARGET_NR_lchown:
6933 if (!(p = lock_user_string(arg1)))
6934 goto efault;
6935 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
6936 unlock_user(p, arg1, 0);
6937 break;
6938 #ifdef TARGET_NR_getuid
6939 case TARGET_NR_getuid:
6940 ret = get_errno(high2lowuid(getuid()));
6941 break;
6942 #endif
6943 #ifdef TARGET_NR_getgid
6944 case TARGET_NR_getgid:
6945 ret = get_errno(high2lowgid(getgid()));
6946 break;
6947 #endif
6948 #ifdef TARGET_NR_geteuid
6949 case TARGET_NR_geteuid:
6950 ret = get_errno(high2lowuid(geteuid()));
6951 break;
6952 #endif
6953 #ifdef TARGET_NR_getegid
6954 case TARGET_NR_getegid:
6955 ret = get_errno(high2lowgid(getegid()));
6956 break;
6957 #endif
6958 case TARGET_NR_setreuid:
6959 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
6960 break;
6961 case TARGET_NR_setregid:
6962 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
6963 break;
6964 case TARGET_NR_getgroups:
6965 {
6966 int gidsetsize = arg1;
6967 target_id *target_grouplist;
6968 gid_t *grouplist;
6969 int i;
6970
6971 grouplist = alloca(gidsetsize * sizeof(gid_t));
6972 ret = get_errno(getgroups(gidsetsize, grouplist));
6973 if (gidsetsize == 0)
6974 break;
6975 if (!is_error(ret)) {
6976 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
6977 if (!target_grouplist)
6978 goto efault;
6979 for(i = 0;i < ret; i++)
6980 target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
6981 unlock_user(target_grouplist, arg2, gidsetsize * 2);
6982 }
6983 }
6984 break;
6985 case TARGET_NR_setgroups:
6986 {
6987 int gidsetsize = arg1;
6988 target_id *target_grouplist;
6989 gid_t *grouplist;
6990 int i;
6991
6992 grouplist = alloca(gidsetsize * sizeof(gid_t));
6993 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
6994 if (!target_grouplist) {
6995 ret = -TARGET_EFAULT;
6996 goto fail;
6997 }
6998 for(i = 0;i < gidsetsize; i++)
6999 grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
7000 unlock_user(target_grouplist, arg2, 0);
7001 ret = get_errno(setgroups(gidsetsize, grouplist));
7002 }
7003 break;
7004 case TARGET_NR_fchown:
7005 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
7006 break;
7007 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
7008 case TARGET_NR_fchownat:
7009 if (!(p = lock_user_string(arg2)))
7010 goto efault;
7011 ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
7012 unlock_user(p, arg2, 0);
7013 break;
7014 #endif
7015 #ifdef TARGET_NR_setresuid
7016 case TARGET_NR_setresuid:
7017 ret = get_errno(setresuid(low2highuid(arg1),
7018 low2highuid(arg2),
7019 low2highuid(arg3)));
7020 break;
7021 #endif
7022 #ifdef TARGET_NR_getresuid
7023 case TARGET_NR_getresuid:
7024 {
7025 uid_t ruid, euid, suid;
7026 ret = get_errno(getresuid(&ruid, &euid, &suid));
7027 if (!is_error(ret)) {
7028 if (put_user_u16(high2lowuid(ruid), arg1)
7029 || put_user_u16(high2lowuid(euid), arg2)
7030 || put_user_u16(high2lowuid(suid), arg3))
7031 goto efault;
7032 }
7033 }
7034 break;
7035 #endif
7036 #ifdef TARGET_NR_getresgid
7037 case TARGET_NR_setresgid:
7038 ret = get_errno(setresgid(low2highgid(arg1),
7039 low2highgid(arg2),
7040 low2highgid(arg3)));
7041 break;
7042 #endif
7043 #ifdef TARGET_NR_getresgid
7044 case TARGET_NR_getresgid:
7045 {
7046 gid_t rgid, egid, sgid;
7047 ret = get_errno(getresgid(&rgid, &egid, &sgid));
7048 if (!is_error(ret)) {
7049 if (put_user_u16(high2lowgid(rgid), arg1)
7050 || put_user_u16(high2lowgid(egid), arg2)
7051 || put_user_u16(high2lowgid(sgid), arg3))
7052 goto efault;
7053 }
7054 }
7055 break;
7056 #endif
7057 case TARGET_NR_chown:
7058 if (!(p = lock_user_string(arg1)))
7059 goto efault;
7060 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
7061 unlock_user(p, arg1, 0);
7062 break;
7063 case TARGET_NR_setuid:
7064 ret = get_errno(setuid(low2highuid(arg1)));
7065 break;
7066 case TARGET_NR_setgid:
7067 ret = get_errno(setgid(low2highgid(arg1)));
7068 break;
7069 case TARGET_NR_setfsuid:
7070 ret = get_errno(setfsuid(arg1));
7071 break;
7072 case TARGET_NR_setfsgid:
7073 ret = get_errno(setfsgid(arg1));
7074 break;
7075
7076 #ifdef TARGET_NR_lchown32
7077 case TARGET_NR_lchown32:
7078 if (!(p = lock_user_string(arg1)))
7079 goto efault;
7080 ret = get_errno(lchown(p, arg2, arg3));
7081 unlock_user(p, arg1, 0);
7082 break;
7083 #endif
7084 #ifdef TARGET_NR_getuid32
7085 case TARGET_NR_getuid32:
7086 ret = get_errno(getuid());
7087 break;
7088 #endif
7089
7090 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
7091 /* Alpha specific */
7092 case TARGET_NR_getxuid:
7093 {
7094 uid_t euid;
7095 euid=geteuid();
7096 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
7097 }
7098 ret = get_errno(getuid());
7099 break;
7100 #endif
7101 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
7102 /* Alpha specific */
7103 case TARGET_NR_getxgid:
7104 {
7105 uid_t egid;
7106 egid=getegid();
7107 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
7108 }
7109 ret = get_errno(getgid());
7110 break;
7111 #endif
7112 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
7113 /* Alpha specific */
7114 case TARGET_NR_osf_getsysinfo:
7115 ret = -TARGET_EOPNOTSUPP;
7116 switch (arg1) {
7117 case TARGET_GSI_IEEE_FP_CONTROL:
7118 {
7119 uint64_t swcr, fpcr = cpu_alpha_load_fpcr (cpu_env);
7120
7121 /* Copied from linux ieee_fpcr_to_swcr. */
7122 swcr = (fpcr >> 35) & SWCR_STATUS_MASK;
7123 swcr |= (fpcr >> 36) & SWCR_MAP_DMZ;
7124 swcr |= (~fpcr >> 48) & (SWCR_TRAP_ENABLE_INV
7125 | SWCR_TRAP_ENABLE_DZE
7126 | SWCR_TRAP_ENABLE_OVF);
7127 swcr |= (~fpcr >> 57) & (SWCR_TRAP_ENABLE_UNF
7128 | SWCR_TRAP_ENABLE_INE);
7129 swcr |= (fpcr >> 47) & SWCR_MAP_UMZ;
7130 swcr |= (~fpcr >> 41) & SWCR_TRAP_ENABLE_DNO;
7131
7132 if (put_user_u64 (swcr, arg2))
7133 goto efault;
7134 ret = 0;
7135 }
7136 break;
7137
7138 /* case GSI_IEEE_STATE_AT_SIGNAL:
7139 -- Not implemented in linux kernel.
7140 case GSI_UACPROC:
7141 -- Retrieves current unaligned access state; not much used.
7142 case GSI_PROC_TYPE:
7143 -- Retrieves implver information; surely not used.
7144 case GSI_GET_HWRPB:
7145 -- Grabs a copy of the HWRPB; surely not used.
7146 */
7147 }
7148 break;
7149 #endif
7150 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
7151 /* Alpha specific */
7152 case TARGET_NR_osf_setsysinfo:
7153 ret = -TARGET_EOPNOTSUPP;
7154 switch (arg1) {
7155 case TARGET_SSI_IEEE_FP_CONTROL:
7156 case TARGET_SSI_IEEE_RAISE_EXCEPTION:
7157 {
7158 uint64_t swcr, fpcr, orig_fpcr;
7159
7160 if (get_user_u64 (swcr, arg2))
7161 goto efault;
7162 orig_fpcr = cpu_alpha_load_fpcr (cpu_env);
7163 fpcr = orig_fpcr & FPCR_DYN_MASK;
7164
7165 /* Copied from linux ieee_swcr_to_fpcr. */
7166 fpcr |= (swcr & SWCR_STATUS_MASK) << 35;
7167 fpcr |= (swcr & SWCR_MAP_DMZ) << 36;
7168 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_INV
7169 | SWCR_TRAP_ENABLE_DZE
7170 | SWCR_TRAP_ENABLE_OVF)) << 48;
7171 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_UNF
7172 | SWCR_TRAP_ENABLE_INE)) << 57;
7173 fpcr |= (swcr & SWCR_MAP_UMZ ? FPCR_UNDZ | FPCR_UNFD : 0);
7174 fpcr |= (~swcr & SWCR_TRAP_ENABLE_DNO) << 41;
7175
7176 cpu_alpha_store_fpcr (cpu_env, fpcr);
7177 ret = 0;
7178
7179 if (arg1 == TARGET_SSI_IEEE_RAISE_EXCEPTION) {
7180 /* Old exceptions are not signaled. */
7181 fpcr &= ~(orig_fpcr & FPCR_STATUS_MASK);
7182
7183 /* If any exceptions set by this call, and are unmasked,
7184 send a signal. */
7185 /* ??? FIXME */
7186 }
7187 }
7188 break;
7189
7190 /* case SSI_NVPAIRS:
7191 -- Used with SSIN_UACPROC to enable unaligned accesses.
7192 case SSI_IEEE_STATE_AT_SIGNAL:
7193 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
7194 -- Not implemented in linux kernel
7195 */
7196 }
7197 break;
7198 #endif
7199 #ifdef TARGET_NR_osf_sigprocmask
7200 /* Alpha specific. */
7201 case TARGET_NR_osf_sigprocmask:
7202 {
7203 abi_ulong mask;
7204 int how = arg1;
7205 sigset_t set, oldset;
7206
7207 switch(arg1) {
7208 case TARGET_SIG_BLOCK:
7209 how = SIG_BLOCK;
7210 break;
7211 case TARGET_SIG_UNBLOCK:
7212 how = SIG_UNBLOCK;
7213 break;
7214 case TARGET_SIG_SETMASK:
7215 how = SIG_SETMASK;
7216 break;
7217 default:
7218 ret = -TARGET_EINVAL;
7219 goto fail;
7220 }
7221 mask = arg2;
7222 target_to_host_old_sigset(&set, &mask);
7223 sigprocmask(arg1, &set, &oldset);
7224 host_to_target_old_sigset(&mask, &oldset);
7225 ret = mask;
7226 }
7227 break;
7228 #endif
7229
7230 #ifdef TARGET_NR_getgid32
7231 case TARGET_NR_getgid32:
7232 ret = get_errno(getgid());
7233 break;
7234 #endif
7235 #ifdef TARGET_NR_geteuid32
7236 case TARGET_NR_geteuid32:
7237 ret = get_errno(geteuid());
7238 break;
7239 #endif
7240 #ifdef TARGET_NR_getegid32
7241 case TARGET_NR_getegid32:
7242 ret = get_errno(getegid());
7243 break;
7244 #endif
7245 #ifdef TARGET_NR_setreuid32
7246 case TARGET_NR_setreuid32:
7247 ret = get_errno(setreuid(arg1, arg2));
7248 break;
7249 #endif
7250 #ifdef TARGET_NR_setregid32
7251 case TARGET_NR_setregid32:
7252 ret = get_errno(setregid(arg1, arg2));
7253 break;
7254 #endif
7255 #ifdef TARGET_NR_getgroups32
7256 case TARGET_NR_getgroups32:
7257 {
7258 int gidsetsize = arg1;
7259 uint32_t *target_grouplist;
7260 gid_t *grouplist;
7261 int i;
7262
7263 grouplist = alloca(gidsetsize * sizeof(gid_t));
7264 ret = get_errno(getgroups(gidsetsize, grouplist));
7265 if (gidsetsize == 0)
7266 break;
7267 if (!is_error(ret)) {
7268 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
7269 if (!target_grouplist) {
7270 ret = -TARGET_EFAULT;
7271 goto fail;
7272 }
7273 for(i = 0;i < ret; i++)
7274 target_grouplist[i] = tswap32(grouplist[i]);
7275 unlock_user(target_grouplist, arg2, gidsetsize * 4);
7276 }
7277 }
7278 break;
7279 #endif
7280 #ifdef TARGET_NR_setgroups32
7281 case TARGET_NR_setgroups32:
7282 {
7283 int gidsetsize = arg1;
7284 uint32_t *target_grouplist;
7285 gid_t *grouplist;
7286 int i;
7287
7288 grouplist = alloca(gidsetsize * sizeof(gid_t));
7289 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
7290 if (!target_grouplist) {
7291 ret = -TARGET_EFAULT;
7292 goto fail;
7293 }
7294 for(i = 0;i < gidsetsize; i++)
7295 grouplist[i] = tswap32(target_grouplist[i]);
7296 unlock_user(target_grouplist, arg2, 0);
7297 ret = get_errno(setgroups(gidsetsize, grouplist));
7298 }
7299 break;
7300 #endif
7301 #ifdef TARGET_NR_fchown32
7302 case TARGET_NR_fchown32:
7303 ret = get_errno(fchown(arg1, arg2, arg3));
7304 break;
7305 #endif
7306 #ifdef TARGET_NR_setresuid32
7307 case TARGET_NR_setresuid32:
7308 ret = get_errno(setresuid(arg1, arg2, arg3));
7309 break;
7310 #endif
7311 #ifdef TARGET_NR_getresuid32
7312 case TARGET_NR_getresuid32:
7313 {
7314 uid_t ruid, euid, suid;
7315 ret = get_errno(getresuid(&ruid, &euid, &suid));
7316 if (!is_error(ret)) {
7317 if (put_user_u32(ruid, arg1)
7318 || put_user_u32(euid, arg2)
7319 || put_user_u32(suid, arg3))
7320 goto efault;
7321 }
7322 }
7323 break;
7324 #endif
7325 #ifdef TARGET_NR_setresgid32
7326 case TARGET_NR_setresgid32:
7327 ret = get_errno(setresgid(arg1, arg2, arg3));
7328 break;
7329 #endif
7330 #ifdef TARGET_NR_getresgid32
7331 case TARGET_NR_getresgid32:
7332 {
7333 gid_t rgid, egid, sgid;
7334 ret = get_errno(getresgid(&rgid, &egid, &sgid));
7335 if (!is_error(ret)) {
7336 if (put_user_u32(rgid, arg1)
7337 || put_user_u32(egid, arg2)
7338 || put_user_u32(sgid, arg3))
7339 goto efault;
7340 }
7341 }
7342 break;
7343 #endif
7344 #ifdef TARGET_NR_chown32
7345 case TARGET_NR_chown32:
7346 if (!(p = lock_user_string(arg1)))
7347 goto efault;
7348 ret = get_errno(chown(p, arg2, arg3));
7349 unlock_user(p, arg1, 0);
7350 break;
7351 #endif
7352 #ifdef TARGET_NR_setuid32
7353 case TARGET_NR_setuid32:
7354 ret = get_errno(setuid(arg1));
7355 break;
7356 #endif
7357 #ifdef TARGET_NR_setgid32
7358 case TARGET_NR_setgid32:
7359 ret = get_errno(setgid(arg1));
7360 break;
7361 #endif
7362 #ifdef TARGET_NR_setfsuid32
7363 case TARGET_NR_setfsuid32:
7364 ret = get_errno(setfsuid(arg1));
7365 break;
7366 #endif
7367 #ifdef TARGET_NR_setfsgid32
7368 case TARGET_NR_setfsgid32:
7369 ret = get_errno(setfsgid(arg1));
7370 break;
7371 #endif
7372
7373 case TARGET_NR_pivot_root:
7374 goto unimplemented;
7375 #ifdef TARGET_NR_mincore
7376 case TARGET_NR_mincore:
7377 {
7378 void *a;
7379 ret = -TARGET_EFAULT;
7380 if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
7381 goto efault;
7382 if (!(p = lock_user_string(arg3)))
7383 goto mincore_fail;
7384 ret = get_errno(mincore(a, arg2, p));
7385 unlock_user(p, arg3, ret);
7386 mincore_fail:
7387 unlock_user(a, arg1, 0);
7388 }
7389 break;
7390 #endif
7391 #ifdef TARGET_NR_arm_fadvise64_64
7392 case TARGET_NR_arm_fadvise64_64:
7393 {
7394 /*
7395 * arm_fadvise64_64 looks like fadvise64_64 but
7396 * with different argument order
7397 */
7398 abi_long temp;
7399 temp = arg3;
7400 arg3 = arg4;
7401 arg4 = temp;
7402 }
7403 #endif
7404 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)
7405 #ifdef TARGET_NR_fadvise64_64
7406 case TARGET_NR_fadvise64_64:
7407 #endif
7408 #ifdef TARGET_NR_fadvise64
7409 case TARGET_NR_fadvise64:
7410 #endif
7411 #ifdef TARGET_S390X
7412 switch (arg4) {
7413 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
7414 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
7415 case 6: arg4 = POSIX_FADV_DONTNEED; break;
7416 case 7: arg4 = POSIX_FADV_NOREUSE; break;
7417 default: break;
7418 }
7419 #endif
7420 ret = -posix_fadvise(arg1, arg2, arg3, arg4);
7421 break;
7422 #endif
7423 #ifdef TARGET_NR_madvise
7424 case TARGET_NR_madvise:
7425 /* A straight passthrough may not be safe because qemu sometimes
7426 turns private flie-backed mappings into anonymous mappings.
7427 This will break MADV_DONTNEED.
7428 This is a hint, so ignoring and returning success is ok. */
7429 ret = get_errno(0);
7430 break;
7431 #endif
7432 #if TARGET_ABI_BITS == 32
7433 case TARGET_NR_fcntl64:
7434 {
7435 int cmd;
7436 struct flock64 fl;
7437 struct target_flock64 *target_fl;
7438 #ifdef TARGET_ARM
7439 struct target_eabi_flock64 *target_efl;
7440 #endif
7441
7442 cmd = target_to_host_fcntl_cmd(arg2);
7443 if (cmd == -TARGET_EINVAL)
7444 return cmd;
7445
7446 switch(arg2) {
7447 case TARGET_F_GETLK64:
7448 #ifdef TARGET_ARM
7449 if (((CPUARMState *)cpu_env)->eabi) {
7450 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
7451 goto efault;
7452 fl.l_type = tswap16(target_efl->l_type);
7453 fl.l_whence = tswap16(target_efl->l_whence);
7454 fl.l_start = tswap64(target_efl->l_start);
7455 fl.l_len = tswap64(target_efl->l_len);
7456 fl.l_pid = tswap32(target_efl->l_pid);
7457 unlock_user_struct(target_efl, arg3, 0);
7458 } else
7459 #endif
7460 {
7461 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
7462 goto efault;
7463 fl.l_type = tswap16(target_fl->l_type);
7464 fl.l_whence = tswap16(target_fl->l_whence);
7465 fl.l_start = tswap64(target_fl->l_start);
7466 fl.l_len = tswap64(target_fl->l_len);
7467 fl.l_pid = tswap32(target_fl->l_pid);
7468 unlock_user_struct(target_fl, arg3, 0);
7469 }
7470 ret = get_errno(fcntl(arg1, cmd, &fl));
7471 if (ret == 0) {
7472 #ifdef TARGET_ARM
7473 if (((CPUARMState *)cpu_env)->eabi) {
7474 if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
7475 goto efault;
7476 target_efl->l_type = tswap16(fl.l_type);
7477 target_efl->l_whence = tswap16(fl.l_whence);
7478 target_efl->l_start = tswap64(fl.l_start);
7479 target_efl->l_len = tswap64(fl.l_len);
7480 target_efl->l_pid = tswap32(fl.l_pid);
7481 unlock_user_struct(target_efl, arg3, 1);
7482 } else
7483 #endif
7484 {
7485 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
7486 goto efault;
7487 target_fl->l_type = tswap16(fl.l_type);
7488 target_fl->l_whence = tswap16(fl.l_whence);
7489 target_fl->l_start = tswap64(fl.l_start);
7490 target_fl->l_len = tswap64(fl.l_len);
7491 target_fl->l_pid = tswap32(fl.l_pid);
7492 unlock_user_struct(target_fl, arg3, 1);
7493 }
7494 }
7495 break;
7496
7497 case TARGET_F_SETLK64:
7498 case TARGET_F_SETLKW64:
7499 #ifdef TARGET_ARM
7500 if (((CPUARMState *)cpu_env)->eabi) {
7501 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
7502 goto efault;
7503 fl.l_type = tswap16(target_efl->l_type);
7504 fl.l_whence = tswap16(target_efl->l_whence);
7505 fl.l_start = tswap64(target_efl->l_start);
7506 fl.l_len = tswap64(target_efl->l_len);
7507 fl.l_pid = tswap32(target_efl->l_pid);
7508 unlock_user_struct(target_efl, arg3, 0);
7509 } else
7510 #endif
7511 {
7512 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
7513 goto efault;
7514 fl.l_type = tswap16(target_fl->l_type);
7515 fl.l_whence = tswap16(target_fl->l_whence);
7516 fl.l_start = tswap64(target_fl->l_start);
7517 fl.l_len = tswap64(target_fl->l_len);
7518 fl.l_pid = tswap32(target_fl->l_pid);
7519 unlock_user_struct(target_fl, arg3, 0);
7520 }
7521 ret = get_errno(fcntl(arg1, cmd, &fl));
7522 break;
7523 default:
7524 ret = do_fcntl(arg1, arg2, arg3);
7525 break;
7526 }
7527 break;
7528 }
7529 #endif
7530 #ifdef TARGET_NR_cacheflush
7531 case TARGET_NR_cacheflush:
7532 /* self-modifying code is handled automatically, so nothing needed */
7533 ret = 0;
7534 break;
7535 #endif
7536 #ifdef TARGET_NR_security
7537 case TARGET_NR_security:
7538 goto unimplemented;
7539 #endif
7540 #ifdef TARGET_NR_getpagesize
7541 case TARGET_NR_getpagesize:
7542 ret = TARGET_PAGE_SIZE;
7543 break;
7544 #endif
7545 case TARGET_NR_gettid:
7546 ret = get_errno(gettid());
7547 break;
7548 #ifdef TARGET_NR_readahead
7549 case TARGET_NR_readahead:
7550 #if TARGET_ABI_BITS == 32
7551 #ifdef TARGET_ARM
7552 if (((CPUARMState *)cpu_env)->eabi)
7553 {
7554 arg2 = arg3;
7555 arg3 = arg4;
7556 arg4 = arg5;
7557 }
7558 #endif
7559 ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
7560 #else
7561 ret = get_errno(readahead(arg1, arg2, arg3));
7562 #endif
7563 break;
7564 #endif
7565 #ifdef TARGET_NR_setxattr
7566 case TARGET_NR_setxattr:
7567 case TARGET_NR_lsetxattr:
7568 case TARGET_NR_fsetxattr:
7569 case TARGET_NR_getxattr:
7570 case TARGET_NR_lgetxattr:
7571 case TARGET_NR_fgetxattr:
7572 case TARGET_NR_listxattr:
7573 case TARGET_NR_llistxattr:
7574 case TARGET_NR_flistxattr:
7575 case TARGET_NR_removexattr:
7576 case TARGET_NR_lremovexattr:
7577 case TARGET_NR_fremovexattr:
7578 ret = -TARGET_EOPNOTSUPP;
7579 break;
7580 #endif
7581 #ifdef TARGET_NR_set_thread_area
7582 case TARGET_NR_set_thread_area:
7583 #if defined(TARGET_MIPS)
7584 ((CPUMIPSState *) cpu_env)->tls_value = arg1;
7585 ret = 0;
7586 break;
7587 #elif defined(TARGET_CRIS)
7588 if (arg1 & 0xff)
7589 ret = -TARGET_EINVAL;
7590 else {
7591 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
7592 ret = 0;
7593 }
7594 break;
7595 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
7596 ret = do_set_thread_area(cpu_env, arg1);
7597 break;
7598 #else
7599 goto unimplemented_nowarn;
7600 #endif
7601 #endif
7602 #ifdef TARGET_NR_get_thread_area
7603 case TARGET_NR_get_thread_area:
7604 #if defined(TARGET_I386) && defined(TARGET_ABI32)
7605 ret = do_get_thread_area(cpu_env, arg1);
7606 #else
7607 goto unimplemented_nowarn;
7608 #endif
7609 #endif
7610 #ifdef TARGET_NR_getdomainname
7611 case TARGET_NR_getdomainname:
7612 goto unimplemented_nowarn;
7613 #endif
7614
7615 #ifdef TARGET_NR_clock_gettime
7616 case TARGET_NR_clock_gettime:
7617 {
7618 struct timespec ts;
7619 ret = get_errno(clock_gettime(arg1, &ts));
7620 if (!is_error(ret)) {
7621 host_to_target_timespec(arg2, &ts);
7622 }
7623 break;
7624 }
7625 #endif
7626 #ifdef TARGET_NR_clock_getres
7627 case TARGET_NR_clock_getres:
7628 {
7629 struct timespec ts;
7630 ret = get_errno(clock_getres(arg1, &ts));
7631 if (!is_error(ret)) {
7632 host_to_target_timespec(arg2, &ts);
7633 }
7634 break;
7635 }
7636 #endif
7637 #ifdef TARGET_NR_clock_nanosleep
7638 case TARGET_NR_clock_nanosleep:
7639 {
7640 struct timespec ts;
7641 target_to_host_timespec(&ts, arg3);
7642 ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
7643 if (arg4)
7644 host_to_target_timespec(arg4, &ts);
7645 break;
7646 }
7647 #endif
7648
7649 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
7650 case TARGET_NR_set_tid_address:
7651 ret = get_errno(set_tid_address((int *)g2h(arg1)));
7652 break;
7653 #endif
7654
7655 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
7656 case TARGET_NR_tkill:
7657 ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
7658 break;
7659 #endif
7660
7661 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
7662 case TARGET_NR_tgkill:
7663 ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
7664 target_to_host_signal(arg3)));
7665 break;
7666 #endif
7667
7668 #ifdef TARGET_NR_set_robust_list
7669 case TARGET_NR_set_robust_list:
7670 goto unimplemented_nowarn;
7671 #endif
7672
7673 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
7674 case TARGET_NR_utimensat:
7675 {
7676 struct timespec *tsp, ts[2];
7677 if (!arg3) {
7678 tsp = NULL;
7679 } else {
7680 target_to_host_timespec(ts, arg3);
7681 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
7682 tsp = ts;
7683 }
7684 if (!arg2)
7685 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
7686 else {
7687 if (!(p = lock_user_string(arg2))) {
7688 ret = -TARGET_EFAULT;
7689 goto fail;
7690 }
7691 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
7692 unlock_user(p, arg2, 0);
7693 }
7694 }
7695 break;
7696 #endif
7697 #if defined(CONFIG_USE_NPTL)
7698 case TARGET_NR_futex:
7699 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
7700 break;
7701 #endif
7702 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
7703 case TARGET_NR_inotify_init:
7704 ret = get_errno(sys_inotify_init());
7705 break;
7706 #endif
7707 #ifdef CONFIG_INOTIFY1
7708 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
7709 case TARGET_NR_inotify_init1:
7710 ret = get_errno(sys_inotify_init1(arg1));
7711 break;
7712 #endif
7713 #endif
7714 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
7715 case TARGET_NR_inotify_add_watch:
7716 p = lock_user_string(arg2);
7717 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
7718 unlock_user(p, arg2, 0);
7719 break;
7720 #endif
7721 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
7722 case TARGET_NR_inotify_rm_watch:
7723 ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
7724 break;
7725 #endif
7726
7727 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
7728 case TARGET_NR_mq_open:
7729 {
7730 struct mq_attr posix_mq_attr;
7731
7732 p = lock_user_string(arg1 - 1);
7733 if (arg4 != 0)
7734 copy_from_user_mq_attr (&posix_mq_attr, arg4);
7735 ret = get_errno(mq_open(p, arg2, arg3, &posix_mq_attr));
7736 unlock_user (p, arg1, 0);
7737 }
7738 break;
7739
7740 case TARGET_NR_mq_unlink:
7741 p = lock_user_string(arg1 - 1);
7742 ret = get_errno(mq_unlink(p));
7743 unlock_user (p, arg1, 0);
7744 break;
7745
7746 case TARGET_NR_mq_timedsend:
7747 {
7748 struct timespec ts;
7749
7750 p = lock_user (VERIFY_READ, arg2, arg3, 1);
7751 if (arg5 != 0) {
7752 target_to_host_timespec(&ts, arg5);
7753 ret = get_errno(mq_timedsend(arg1, p, arg3, arg4, &ts));
7754 host_to_target_timespec(arg5, &ts);
7755 }
7756 else
7757 ret = get_errno(mq_send(arg1, p, arg3, arg4));
7758 unlock_user (p, arg2, arg3);
7759 }
7760 break;
7761
7762 case TARGET_NR_mq_timedreceive:
7763 {
7764 struct timespec ts;
7765 unsigned int prio;
7766
7767 p = lock_user (VERIFY_READ, arg2, arg3, 1);
7768 if (arg5 != 0) {
7769 target_to_host_timespec(&ts, arg5);
7770 ret = get_errno(mq_timedreceive(arg1, p, arg3, &prio, &ts));
7771 host_to_target_timespec(arg5, &ts);
7772 }
7773 else
7774 ret = get_errno(mq_receive(arg1, p, arg3, &prio));
7775 unlock_user (p, arg2, arg3);
7776 if (arg4 != 0)
7777 put_user_u32(prio, arg4);
7778 }
7779 break;
7780
7781 /* Not implemented for now... */
7782 /* case TARGET_NR_mq_notify: */
7783 /* break; */
7784
7785 case TARGET_NR_mq_getsetattr:
7786 {
7787 struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
7788 ret = 0;
7789 if (arg3 != 0) {
7790 ret = mq_getattr(arg1, &posix_mq_attr_out);
7791 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
7792 }
7793 if (arg2 != 0) {
7794 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
7795 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
7796 }
7797
7798 }
7799 break;
7800 #endif
7801
7802 #ifdef CONFIG_SPLICE
7803 #ifdef TARGET_NR_tee
7804 case TARGET_NR_tee:
7805 {
7806 ret = get_errno(tee(arg1,arg2,arg3,arg4));
7807 }
7808 break;
7809 #endif
7810 #ifdef TARGET_NR_splice
7811 case TARGET_NR_splice:
7812 {
7813 loff_t loff_in, loff_out;
7814 loff_t *ploff_in = NULL, *ploff_out = NULL;
7815 if(arg2) {
7816 get_user_u64(loff_in, arg2);
7817 ploff_in = &loff_in;
7818 }
7819 if(arg4) {
7820 get_user_u64(loff_out, arg2);
7821 ploff_out = &loff_out;
7822 }
7823 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
7824 }
7825 break;
7826 #endif
7827 #ifdef TARGET_NR_vmsplice
7828 case TARGET_NR_vmsplice:
7829 {
7830 int count = arg3;
7831 struct iovec *vec;
7832
7833 vec = alloca(count * sizeof(struct iovec));
7834 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
7835 goto efault;
7836 ret = get_errno(vmsplice(arg1, vec, count, arg4));
7837 unlock_iovec(vec, arg2, count, 0);
7838 }
7839 break;
7840 #endif
7841 #endif /* CONFIG_SPLICE */
7842 #ifdef CONFIG_EVENTFD
7843 #if defined(TARGET_NR_eventfd)
7844 case TARGET_NR_eventfd:
7845 ret = get_errno(eventfd(arg1, 0));
7846 break;
7847 #endif
7848 #if defined(TARGET_NR_eventfd2)
7849 case TARGET_NR_eventfd2:
7850 ret = get_errno(eventfd(arg1, arg2));
7851 break;
7852 #endif
7853 #endif /* CONFIG_EVENTFD */
7854 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
7855 case TARGET_NR_fallocate:
7856 ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
7857 break;
7858 #endif
7859 #if defined(CONFIG_SYNC_FILE_RANGE)
7860 #if defined(TARGET_NR_sync_file_range)
7861 case TARGET_NR_sync_file_range:
7862 #if TARGET_ABI_BITS == 32
7863 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
7864 target_offset64(arg4, arg5), arg6));
7865 #else
7866 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
7867 #endif
7868 break;
7869 #endif
7870 #if defined(TARGET_NR_sync_file_range2)
7871 case TARGET_NR_sync_file_range2:
7872 /* This is like sync_file_range but the arguments are reordered */
7873 #if TARGET_ABI_BITS == 32
7874 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
7875 target_offset64(arg5, arg6), arg2));
7876 #else
7877 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
7878 #endif
7879 break;
7880 #endif
7881 #endif
7882 #if defined(CONFIG_EPOLL)
7883 #if defined(TARGET_NR_epoll_create)
7884 case TARGET_NR_epoll_create:
7885 ret = get_errno(epoll_create(arg1));
7886 break;
7887 #endif
7888 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
7889 case TARGET_NR_epoll_create1:
7890 ret = get_errno(epoll_create1(arg1));
7891 break;
7892 #endif
7893 #if defined(TARGET_NR_epoll_ctl)
7894 case TARGET_NR_epoll_ctl:
7895 {
7896 struct epoll_event ep;
7897 struct epoll_event *epp = 0;
7898 if (arg4) {
7899 struct target_epoll_event *target_ep;
7900 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
7901 goto efault;
7902 }
7903 ep.events = tswap32(target_ep->events);
7904 /* The epoll_data_t union is just opaque data to the kernel,
7905 * so we transfer all 64 bits across and need not worry what
7906 * actual data type it is.
7907 */
7908 ep.data.u64 = tswap64(target_ep->data.u64);
7909 unlock_user_struct(target_ep, arg4, 0);
7910 epp = &ep;
7911 }
7912 ret = get_errno(epoll_ctl(arg1, arg2, arg3, epp));
7913 break;
7914 }
7915 #endif
7916
7917 #if defined(TARGET_NR_epoll_pwait) && defined(CONFIG_EPOLL_PWAIT)
7918 #define IMPLEMENT_EPOLL_PWAIT
7919 #endif
7920 #if defined(TARGET_NR_epoll_wait) || defined(IMPLEMENT_EPOLL_PWAIT)
7921 #if defined(TARGET_NR_epoll_wait)
7922 case TARGET_NR_epoll_wait:
7923 #endif
7924 #if defined(IMPLEMENT_EPOLL_PWAIT)
7925 case TARGET_NR_epoll_pwait:
7926 #endif
7927 {
7928 struct target_epoll_event *target_ep;
7929 struct epoll_event *ep;
7930 int epfd = arg1;
7931 int maxevents = arg3;
7932 int timeout = arg4;
7933
7934 target_ep = lock_user(VERIFY_WRITE, arg2,
7935 maxevents * sizeof(struct target_epoll_event), 1);
7936 if (!target_ep) {
7937 goto efault;
7938 }
7939
7940 ep = alloca(maxevents * sizeof(struct epoll_event));
7941
7942 switch (num) {
7943 #if defined(IMPLEMENT_EPOLL_PWAIT)
7944 case TARGET_NR_epoll_pwait:
7945 {
7946 target_sigset_t *target_set;
7947 sigset_t _set, *set = &_set;
7948
7949 if (arg5) {
7950 target_set = lock_user(VERIFY_READ, arg5,
7951 sizeof(target_sigset_t), 1);
7952 if (!target_set) {
7953 unlock_user(target_ep, arg2, 0);
7954 goto efault;
7955 }
7956 target_to_host_sigset(set, target_set);
7957 unlock_user(target_set, arg5, 0);
7958 } else {
7959 set = NULL;
7960 }
7961
7962 ret = get_errno(epoll_pwait(epfd, ep, maxevents, timeout, set));
7963 break;
7964 }
7965 #endif
7966 #if defined(TARGET_NR_epoll_wait)
7967 case TARGET_NR_epoll_wait:
7968 ret = get_errno(epoll_wait(epfd, ep, maxevents, timeout));
7969 break;
7970 #endif
7971 default:
7972 ret = -TARGET_ENOSYS;
7973 }
7974 if (!is_error(ret)) {
7975 int i;
7976 for (i = 0; i < ret; i++) {
7977 target_ep[i].events = tswap32(ep[i].events);
7978 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
7979 }
7980 }
7981 unlock_user(target_ep, arg2, ret * sizeof(struct target_epoll_event));
7982 break;
7983 }
7984 #endif
7985 #endif
7986 default:
7987 unimplemented:
7988 gemu_log("qemu: Unsupported syscall: %d\n", num);
7989 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
7990 unimplemented_nowarn:
7991 #endif
7992 ret = -TARGET_ENOSYS;
7993 break;
7994 }
7995 fail:
7996 #ifdef DEBUG
7997 gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
7998 #endif
7999 if(do_strace)
8000 print_syscall_ret(num, ret);
8001 return ret;
8002 efault:
8003 ret = -TARGET_EFAULT;
8004 goto fail;
8005 }
Qemu copy for testing