?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tests/qtest: do not list ahci-test twice
[qemu/ar7.git] / linux-user / syscall.c
blob93da3b97285234c3cec09673d7129ad776eaeaca
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 "qemu/osdep.h"
21 #include "qemu/cutils.h"
22 #include "qemu/path.h"
23 #include "qemu/memfd.h"
24 #include "qemu/queue.h"
25 #include <elf.h>
26 #include <endian.h>
27 #include <grp.h>
28 #include <sys/ipc.h>
29 #include <sys/msg.h>
30 #include <sys/wait.h>
31 #include <sys/mount.h>
32 #include <sys/file.h>
33 #include <sys/fsuid.h>
34 #include <sys/personality.h>
35 #include <sys/prctl.h>
36 #include <sys/resource.h>
37 #include <sys/swap.h>
38 #include <linux/capability.h>
39 #include <sched.h>
40 #include <sys/timex.h>
41 #include <sys/socket.h>
42 #include <linux/sockios.h>
43 #include <sys/un.h>
44 #include <sys/uio.h>
45 #include <poll.h>
46 #include <sys/times.h>
47 #include <sys/shm.h>
48 #include <sys/sem.h>
49 #include <sys/statfs.h>
50 #include <utime.h>
51 #include <sys/sysinfo.h>
52 #include <sys/signalfd.h>
53 //#include <sys/user.h>
54 #include <netinet/ip.h>
55 #include <netinet/tcp.h>
56 #include <linux/wireless.h>
57 #include <linux/icmp.h>
58 #include <linux/icmpv6.h>
59 #include <linux/errqueue.h>
60 #include <linux/random.h>
61 #ifdef CONFIG_TIMERFD
62 #include <sys/timerfd.h>
63 #endif
64 #ifdef CONFIG_EVENTFD
65 #include <sys/eventfd.h>
66 #endif
67 #ifdef CONFIG_EPOLL
68 #include <sys/epoll.h>
69 #endif
70 #ifdef CONFIG_ATTR
71 #include "qemu/xattr.h"
72 #endif
73 #ifdef CONFIG_SENDFILE
74 #include <sys/sendfile.h>
75 #endif
76 #ifdef CONFIG_KCOV
77 #include <sys/kcov.h>
78 #endif
79
80 #define termios host_termios
81 #define winsize host_winsize
82 #define termio host_termio
83 #define sgttyb host_sgttyb /* same as target */
84 #define tchars host_tchars /* same as target */
85 #define ltchars host_ltchars /* same as target */
86
87 #include <linux/termios.h>
88 #include <linux/unistd.h>
89 #include <linux/cdrom.h>
90 #include <linux/hdreg.h>
91 #include <linux/soundcard.h>
92 #include <linux/kd.h>
93 #include <linux/mtio.h>
94 #include <linux/fs.h>
95 #include <linux/fd.h>
96 #if defined(CONFIG_FIEMAP)
97 #include <linux/fiemap.h>
98 #endif
99 #include <linux/fb.h>
100 #if defined(CONFIG_USBFS)
101 #include <linux/usbdevice_fs.h>
102 #include <linux/usb/ch9.h>
103 #endif
104 #include <linux/vt.h>
105 #include <linux/dm-ioctl.h>
106 #include <linux/reboot.h>
107 #include <linux/route.h>
108 #include <linux/filter.h>
109 #include <linux/blkpg.h>
110 #include <netpacket/packet.h>
111 #include <linux/netlink.h>
112 #include <linux/if_alg.h>
113 #include <linux/rtc.h>
114 #include <sound/asound.h>
115 #ifdef CONFIG_BTRFS
116 #include <linux/btrfs.h>
117 #endif
118 #ifdef HAVE_DRM_H
119 #include <libdrm/drm.h>
120 #include <libdrm/i915_drm.h>
121 #endif
122 #include "linux_loop.h"
123 #include "uname.h"
124
125 #include "qemu.h"
126 #include "qemu/guest-random.h"
127 #include "qemu/selfmap.h"
128 #include "user/syscall-trace.h"
129 #include "qapi/error.h"
130 #include "fd-trans.h"
131 #include "tcg/tcg.h"
132
133 #ifndef CLONE_IO
134 #define CLONE_IO 0x80000000 /* Clone io context */
135 #endif
136
137 /* We can't directly call the host clone syscall, because this will
138 * badly confuse libc (breaking mutexes, for example). So we must
139 * divide clone flags into:
140 * * flag combinations that look like pthread_create()
141 * * flag combinations that look like fork()
142 * * flags we can implement within QEMU itself
143 * * flags we can't support and will return an error for
144 */
145 /* For thread creation, all these flags must be present; for
146 * fork, none must be present.
147 */
148 #define CLONE_THREAD_FLAGS \
149 (CLONE_VM | CLONE_FS | CLONE_FILES | \
150 CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM)
151
152 /* These flags are ignored:
153 * CLONE_DETACHED is now ignored by the kernel;
154 * CLONE_IO is just an optimisation hint to the I/O scheduler
155 */
156 #define CLONE_IGNORED_FLAGS \
157 (CLONE_DETACHED | CLONE_IO)
158
159 /* Flags for fork which we can implement within QEMU itself */
160 #define CLONE_OPTIONAL_FORK_FLAGS \
161 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
162 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID)
163
164 /* Flags for thread creation which we can implement within QEMU itself */
165 #define CLONE_OPTIONAL_THREAD_FLAGS \
166 (CLONE_SETTLS | CLONE_PARENT_SETTID | \
167 CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT)
168
169 #define CLONE_INVALID_FORK_FLAGS \
170 (~(CSIGNAL | CLONE_OPTIONAL_FORK_FLAGS | CLONE_IGNORED_FLAGS))
171
172 #define CLONE_INVALID_THREAD_FLAGS \
173 (~(CSIGNAL | CLONE_THREAD_FLAGS | CLONE_OPTIONAL_THREAD_FLAGS | \
174 CLONE_IGNORED_FLAGS))
175
176 /* CLONE_VFORK is special cased early in do_fork(). The other flag bits
177 * have almost all been allocated. We cannot support any of
178 * CLONE_NEWNS, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC,
179 * CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_PTRACE, CLONE_UNTRACED.
180 * The checks against the invalid thread masks above will catch these.
181 * (The one remaining unallocated bit is 0x1000 which used to be CLONE_PID.)
182 */
183
184 /* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
185 * once. This exercises the codepaths for restart.
186 */
187 //#define DEBUG_ERESTARTSYS
188
189 //#include <linux/msdos_fs.h>
190 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
191 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
192
193 #undef _syscall0
194 #undef _syscall1
195 #undef _syscall2
196 #undef _syscall3
197 #undef _syscall4
198 #undef _syscall5
199 #undef _syscall6
200
201 #define _syscall0(type,name) \
202 static type name (void) \
203 { \
204 return syscall(__NR_##name); \
205 }
206
207 #define _syscall1(type,name,type1,arg1) \
208 static type name (type1 arg1) \
209 { \
210 return syscall(__NR_##name, arg1); \
211 }
212
213 #define _syscall2(type,name,type1,arg1,type2,arg2) \
214 static type name (type1 arg1,type2 arg2) \
215 { \
216 return syscall(__NR_##name, arg1, arg2); \
217 }
218
219 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
220 static type name (type1 arg1,type2 arg2,type3 arg3) \
221 { \
222 return syscall(__NR_##name, arg1, arg2, arg3); \
223 }
224
225 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
226 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
227 { \
228 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
229 }
230
231 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
232 type5,arg5) \
233 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
234 { \
235 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
236 }
237
238
239 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
240 type5,arg5,type6,arg6) \
241 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
242 type6 arg6) \
243 { \
244 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
245 }
246
247
248 #define __NR_sys_uname __NR_uname
249 #define __NR_sys_getcwd1 __NR_getcwd
250 #define __NR_sys_getdents __NR_getdents
251 #define __NR_sys_getdents64 __NR_getdents64
252 #define __NR_sys_getpriority __NR_getpriority
253 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
254 #define __NR_sys_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
255 #define __NR_sys_syslog __NR_syslog
256 #if defined(__NR_futex)
257 # define __NR_sys_futex __NR_futex
258 #endif
259 #if defined(__NR_futex_time64)
260 # define __NR_sys_futex_time64 __NR_futex_time64
261 #endif
262 #define __NR_sys_inotify_init __NR_inotify_init
263 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch
264 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
265 #define __NR_sys_statx __NR_statx
266
267 #if defined(__alpha__) || defined(__x86_64__) || defined(__s390x__)
268 #define __NR__llseek __NR_lseek
269 #endif
270
271 /* Newer kernel ports have llseek() instead of _llseek() */
272 #if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
273 #define TARGET_NR__llseek TARGET_NR_llseek
274 #endif
275
276 #define __NR_sys_gettid __NR_gettid
277 _syscall0(int, sys_gettid)
278
279 /* For the 64-bit guest on 32-bit host case we must emulate
280 * getdents using getdents64, because otherwise the host
281 * might hand us back more dirent records than we can fit
282 * into the guest buffer after structure format conversion.
283 * Otherwise we emulate getdents with getdents if the host has it.
284 */
285 #if defined(__NR_getdents) && HOST_LONG_BITS >= TARGET_ABI_BITS
286 #define EMULATE_GETDENTS_WITH_GETDENTS
287 #endif
288
289 #if defined(TARGET_NR_getdents) && defined(EMULATE_GETDENTS_WITH_GETDENTS)
290 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
291 #endif
292 #if (defined(TARGET_NR_getdents) && \
293 !defined(EMULATE_GETDENTS_WITH_GETDENTS)) || \
294 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
295 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
296 #endif
297 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
298 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
299 loff_t *, res, uint, wh);
300 #endif
301 _syscall3(int, sys_rt_sigqueueinfo, pid_t, pid, int, sig, siginfo_t *, uinfo)
302 _syscall4(int, sys_rt_tgsigqueueinfo, pid_t, pid, pid_t, tid, int, sig,
303 siginfo_t *, uinfo)
304 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
305 #ifdef __NR_exit_group
306 _syscall1(int,exit_group,int,error_code)
307 #endif
308 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
309 _syscall1(int,set_tid_address,int *,tidptr)
310 #endif
311 #if defined(__NR_futex)
312 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
313 const struct timespec *,timeout,int *,uaddr2,int,val3)
314 #endif
315 #if defined(__NR_futex_time64)
316 _syscall6(int,sys_futex_time64,int *,uaddr,int,op,int,val,
317 const struct timespec *,timeout,int *,uaddr2,int,val3)
318 #endif
319 #define __NR_sys_sched_getaffinity __NR_sched_getaffinity
320 _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len,
321 unsigned long *, user_mask_ptr);
322 #define __NR_sys_sched_setaffinity __NR_sched_setaffinity
323 _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len,
324 unsigned long *, user_mask_ptr);
325 #define __NR_sys_getcpu __NR_getcpu
326 _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache);
327 _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd,
328 void *, arg);
329 _syscall2(int, capget, struct __user_cap_header_struct *, header,
330 struct __user_cap_data_struct *, data);
331 _syscall2(int, capset, struct __user_cap_header_struct *, header,
332 struct __user_cap_data_struct *, data);
333 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
334 _syscall2(int, ioprio_get, int, which, int, who)
335 #endif
336 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
337 _syscall3(int, ioprio_set, int, which, int, who, int, ioprio)
338 #endif
339 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
340 _syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags)
341 #endif
342
343 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
344 _syscall5(int, kcmp, pid_t, pid1, pid_t, pid2, int, type,
345 unsigned long, idx1, unsigned long, idx2)
346 #endif
347
348 /*
349 * It is assumed that struct statx is architecture independent.
350 */
351 #if defined(TARGET_NR_statx) && defined(__NR_statx)
352 _syscall5(int, sys_statx, int, dirfd, const char *, pathname, int, flags,
353 unsigned int, mask, struct target_statx *, statxbuf)
354 #endif
355 #if defined(TARGET_NR_membarrier) && defined(__NR_membarrier)
356 _syscall2(int, membarrier, int, cmd, int, flags)
357 #endif
358
359 static bitmask_transtbl fcntl_flags_tbl[] = {
360 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
361 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
362 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
363 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
364 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
365 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
366 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
367 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
368 { TARGET_O_SYNC, TARGET_O_DSYNC, O_SYNC, O_DSYNC, },
369 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
370 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
371 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
372 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
373 #if defined(O_DIRECT)
374 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
375 #endif
376 #if defined(O_NOATIME)
377 { TARGET_O_NOATIME, TARGET_O_NOATIME, O_NOATIME, O_NOATIME },
378 #endif
379 #if defined(O_CLOEXEC)
380 { TARGET_O_CLOEXEC, TARGET_O_CLOEXEC, O_CLOEXEC, O_CLOEXEC },
381 #endif
382 #if defined(O_PATH)
383 { TARGET_O_PATH, TARGET_O_PATH, O_PATH, O_PATH },
384 #endif
385 #if defined(O_TMPFILE)
386 { TARGET_O_TMPFILE, TARGET_O_TMPFILE, O_TMPFILE, O_TMPFILE },
387 #endif
388 /* Don't terminate the list prematurely on 64-bit host+guest. */
389 #if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
390 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
391 #endif
392 { 0, 0, 0, 0 }
393 };
394
395 _syscall2(int, sys_getcwd1, char *, buf, size_t, size)
396
397 #if defined(TARGET_NR_utimensat) || defined(TARGET_NR_utimensat_time64)
398 #if defined(__NR_utimensat)
399 #define __NR_sys_utimensat __NR_utimensat
400 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
401 const struct timespec *,tsp,int,flags)
402 #else
403 static int sys_utimensat(int dirfd, const char *pathname,
404 const struct timespec times[2], int flags)
405 {
406 errno = ENOSYS;
407 return -1;
408 }
409 #endif
410 #endif /* TARGET_NR_utimensat */
411
412 #ifdef TARGET_NR_renameat2
413 #if defined(__NR_renameat2)
414 #define __NR_sys_renameat2 __NR_renameat2
415 _syscall5(int, sys_renameat2, int, oldfd, const char *, old, int, newfd,
416 const char *, new, unsigned int, flags)
417 #else
418 static int sys_renameat2(int oldfd, const char *old,
419 int newfd, const char *new, int flags)
420 {
421 if (flags == 0) {
422 return renameat(oldfd, old, newfd, new);
423 }
424 errno = ENOSYS;
425 return -1;
426 }
427 #endif
428 #endif /* TARGET_NR_renameat2 */
429
430 #ifdef CONFIG_INOTIFY
431 #include <sys/inotify.h>
432
433 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
434 static int sys_inotify_init(void)
435 {
436 return (inotify_init());
437 }
438 #endif
439 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
440 static int sys_inotify_add_watch(int fd,const char *pathname, int32_t mask)
441 {
442 return (inotify_add_watch(fd, pathname, mask));
443 }
444 #endif
445 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
446 static int sys_inotify_rm_watch(int fd, int32_t wd)
447 {
448 return (inotify_rm_watch(fd, wd));
449 }
450 #endif
451 #ifdef CONFIG_INOTIFY1
452 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
453 static int sys_inotify_init1(int flags)
454 {
455 return (inotify_init1(flags));
456 }
457 #endif
458 #endif
459 #else
460 /* Userspace can usually survive runtime without inotify */
461 #undef TARGET_NR_inotify_init
462 #undef TARGET_NR_inotify_init1
463 #undef TARGET_NR_inotify_add_watch
464 #undef TARGET_NR_inotify_rm_watch
465 #endif /* CONFIG_INOTIFY */
466
467 #if defined(TARGET_NR_prlimit64)
468 #ifndef __NR_prlimit64
469 # define __NR_prlimit64 -1
470 #endif
471 #define __NR_sys_prlimit64 __NR_prlimit64
472 /* The glibc rlimit structure may not be that used by the underlying syscall */
473 struct host_rlimit64 {
474 uint64_t rlim_cur;
475 uint64_t rlim_max;
476 };
477 _syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
478 const struct host_rlimit64 *, new_limit,
479 struct host_rlimit64 *, old_limit)
480 #endif
481
482
483 #if defined(TARGET_NR_timer_create)
484 /* Maxiumum of 32 active POSIX timers allowed at any one time. */
485 static timer_t g_posix_timers[32] = { 0, } ;
486
487 static inline int next_free_host_timer(void)
488 {
489 int k ;
490 /* FIXME: Does finding the next free slot require a lock? */
491 for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) {
492 if (g_posix_timers[k] == 0) {
493 g_posix_timers[k] = (timer_t) 1;
494 return k;
495 }
496 }
497 return -1;
498 }
499 #endif
500
501 #define ERRNO_TABLE_SIZE 1200
502
503 /* target_to_host_errno_table[] is initialized from
504 * host_to_target_errno_table[] in syscall_init(). */
505 static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
506 };
507
508 /*
509 * This list is the union of errno values overridden in asm-<arch>/errno.h
510 * minus the errnos that are not actually generic to all archs.
511 */
512 static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
513 [EAGAIN] = TARGET_EAGAIN,
514 [EIDRM] = TARGET_EIDRM,
515 [ECHRNG] = TARGET_ECHRNG,
516 [EL2NSYNC] = TARGET_EL2NSYNC,
517 [EL3HLT] = TARGET_EL3HLT,
518 [EL3RST] = TARGET_EL3RST,
519 [ELNRNG] = TARGET_ELNRNG,
520 [EUNATCH] = TARGET_EUNATCH,
521 [ENOCSI] = TARGET_ENOCSI,
522 [EL2HLT] = TARGET_EL2HLT,
523 [EDEADLK] = TARGET_EDEADLK,
524 [ENOLCK] = TARGET_ENOLCK,
525 [EBADE] = TARGET_EBADE,
526 [EBADR] = TARGET_EBADR,
527 [EXFULL] = TARGET_EXFULL,
528 [ENOANO] = TARGET_ENOANO,
529 [EBADRQC] = TARGET_EBADRQC,
530 [EBADSLT] = TARGET_EBADSLT,
531 [EBFONT] = TARGET_EBFONT,
532 [ENOSTR] = TARGET_ENOSTR,
533 [ENODATA] = TARGET_ENODATA,
534 [ETIME] = TARGET_ETIME,
535 [ENOSR] = TARGET_ENOSR,
536 [ENONET] = TARGET_ENONET,
537 [ENOPKG] = TARGET_ENOPKG,
538 [EREMOTE] = TARGET_EREMOTE,
539 [ENOLINK] = TARGET_ENOLINK,
540 [EADV] = TARGET_EADV,
541 [ESRMNT] = TARGET_ESRMNT,
542 [ECOMM] = TARGET_ECOMM,
543 [EPROTO] = TARGET_EPROTO,
544 [EDOTDOT] = TARGET_EDOTDOT,
545 [EMULTIHOP] = TARGET_EMULTIHOP,
546 [EBADMSG] = TARGET_EBADMSG,
547 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
548 [EOVERFLOW] = TARGET_EOVERFLOW,
549 [ENOTUNIQ] = TARGET_ENOTUNIQ,
550 [EBADFD] = TARGET_EBADFD,
551 [EREMCHG] = TARGET_EREMCHG,
552 [ELIBACC] = TARGET_ELIBACC,
553 [ELIBBAD] = TARGET_ELIBBAD,
554 [ELIBSCN] = TARGET_ELIBSCN,
555 [ELIBMAX] = TARGET_ELIBMAX,
556 [ELIBEXEC] = TARGET_ELIBEXEC,
557 [EILSEQ] = TARGET_EILSEQ,
558 [ENOSYS] = TARGET_ENOSYS,
559 [ELOOP] = TARGET_ELOOP,
560 [ERESTART] = TARGET_ERESTART,
561 [ESTRPIPE] = TARGET_ESTRPIPE,
562 [ENOTEMPTY] = TARGET_ENOTEMPTY,
563 [EUSERS] = TARGET_EUSERS,
564 [ENOTSOCK] = TARGET_ENOTSOCK,
565 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
566 [EMSGSIZE] = TARGET_EMSGSIZE,
567 [EPROTOTYPE] = TARGET_EPROTOTYPE,
568 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
569 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
570 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
571 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
572 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
573 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
574 [EADDRINUSE] = TARGET_EADDRINUSE,
575 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
576 [ENETDOWN] = TARGET_ENETDOWN,
577 [ENETUNREACH] = TARGET_ENETUNREACH,
578 [ENETRESET] = TARGET_ENETRESET,
579 [ECONNABORTED] = TARGET_ECONNABORTED,
580 [ECONNRESET] = TARGET_ECONNRESET,
581 [ENOBUFS] = TARGET_ENOBUFS,
582 [EISCONN] = TARGET_EISCONN,
583 [ENOTCONN] = TARGET_ENOTCONN,
584 [EUCLEAN] = TARGET_EUCLEAN,
585 [ENOTNAM] = TARGET_ENOTNAM,
586 [ENAVAIL] = TARGET_ENAVAIL,
587 [EISNAM] = TARGET_EISNAM,
588 [EREMOTEIO] = TARGET_EREMOTEIO,
589 [EDQUOT] = TARGET_EDQUOT,
590 [ESHUTDOWN] = TARGET_ESHUTDOWN,
591 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
592 [ETIMEDOUT] = TARGET_ETIMEDOUT,
593 [ECONNREFUSED] = TARGET_ECONNREFUSED,
594 [EHOSTDOWN] = TARGET_EHOSTDOWN,
595 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
596 [EALREADY] = TARGET_EALREADY,
597 [EINPROGRESS] = TARGET_EINPROGRESS,
598 [ESTALE] = TARGET_ESTALE,
599 [ECANCELED] = TARGET_ECANCELED,
600 [ENOMEDIUM] = TARGET_ENOMEDIUM,
601 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
602 #ifdef ENOKEY
603 [ENOKEY] = TARGET_ENOKEY,
604 #endif
605 #ifdef EKEYEXPIRED
606 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
607 #endif
608 #ifdef EKEYREVOKED
609 [EKEYREVOKED] = TARGET_EKEYREVOKED,
610 #endif
611 #ifdef EKEYREJECTED
612 [EKEYREJECTED] = TARGET_EKEYREJECTED,
613 #endif
614 #ifdef EOWNERDEAD
615 [EOWNERDEAD] = TARGET_EOWNERDEAD,
616 #endif
617 #ifdef ENOTRECOVERABLE
618 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
619 #endif
620 #ifdef ENOMSG
621 [ENOMSG] = TARGET_ENOMSG,
622 #endif
623 #ifdef ERKFILL
624 [ERFKILL] = TARGET_ERFKILL,
625 #endif
626 #ifdef EHWPOISON
627 [EHWPOISON] = TARGET_EHWPOISON,
628 #endif
629 };
630
631 static inline int host_to_target_errno(int err)
632 {
633 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
634 host_to_target_errno_table[err]) {
635 return host_to_target_errno_table[err];
636 }
637 return err;
638 }
639
640 static inline int target_to_host_errno(int err)
641 {
642 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
643 target_to_host_errno_table[err]) {
644 return target_to_host_errno_table[err];
645 }
646 return err;
647 }
648
649 static inline abi_long get_errno(abi_long ret)
650 {
651 if (ret == -1)
652 return -host_to_target_errno(errno);
653 else
654 return ret;
655 }
656
657 const char *target_strerror(int err)
658 {
659 if (err == TARGET_ERESTARTSYS) {
660 return "To be restarted";
661 }
662 if (err == TARGET_QEMU_ESIGRETURN) {
663 return "Successful exit from sigreturn";
664 }
665
666 if ((err >= ERRNO_TABLE_SIZE) || (err < 0)) {
667 return NULL;
668 }
669 return strerror(target_to_host_errno(err));
670 }
671
672 #define safe_syscall0(type, name) \
673 static type safe_##name(void) \
674 { \
675 return safe_syscall(__NR_##name); \
676 }
677
678 #define safe_syscall1(type, name, type1, arg1) \
679 static type safe_##name(type1 arg1) \
680 { \
681 return safe_syscall(__NR_##name, arg1); \
682 }
683
684 #define safe_syscall2(type, name, type1, arg1, type2, arg2) \
685 static type safe_##name(type1 arg1, type2 arg2) \
686 { \
687 return safe_syscall(__NR_##name, arg1, arg2); \
688 }
689
690 #define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
691 static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
692 { \
693 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
694 }
695
696 #define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
697 type4, arg4) \
698 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
699 { \
700 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
701 }
702
703 #define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
704 type4, arg4, type5, arg5) \
705 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
706 type5 arg5) \
707 { \
708 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
709 }
710
711 #define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
712 type4, arg4, type5, arg5, type6, arg6) \
713 static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
714 type5 arg5, type6 arg6) \
715 { \
716 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
717 }
718
719 safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count)
720 safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)
721 safe_syscall4(int, openat, int, dirfd, const char *, pathname, \
722 int, flags, mode_t, mode)
723 #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid)
724 safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \
725 struct rusage *, rusage)
726 #endif
727 safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
728 int, options, struct rusage *, rusage)
729 safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
730 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
731 defined(TARGET_NR_pselect6)
732 safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
733 fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
734 #endif
735 #if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
736 safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
737 struct timespec *, tsp, const sigset_t *, sigmask,
738 size_t, sigsetsize)
739 #endif
740 safe_syscall6(int, epoll_pwait, int, epfd, struct epoll_event *, events,
741 int, maxevents, int, timeout, const sigset_t *, sigmask,
742 size_t, sigsetsize)
743 #if defined(__NR_futex)
744 safe_syscall6(int,futex,int *,uaddr,int,op,int,val, \
745 const struct timespec *,timeout,int *,uaddr2,int,val3)
746 #endif
747 #if defined(__NR_futex_time64)
748 safe_syscall6(int,futex_time64,int *,uaddr,int,op,int,val, \
749 const struct timespec *,timeout,int *,uaddr2,int,val3)
750 #endif
751 safe_syscall2(int, rt_sigsuspend, sigset_t *, newset, size_t, sigsetsize)
752 safe_syscall2(int, kill, pid_t, pid, int, sig)
753 safe_syscall2(int, tkill, int, tid, int, sig)
754 safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig)
755 safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt)
756 safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt)
757 safe_syscall5(ssize_t, preadv, int, fd, const struct iovec *, iov, int, iovcnt,
758 unsigned long, pos_l, unsigned long, pos_h)
759 safe_syscall5(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt,
760 unsigned long, pos_l, unsigned long, pos_h)
761 safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr,
762 socklen_t, addrlen)
763 safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len,
764 int, flags, const struct sockaddr *, addr, socklen_t, addrlen)
765 safe_syscall6(ssize_t, recvfrom, int, fd, void *, buf, size_t, len,
766 int, flags, struct sockaddr *, addr, socklen_t *, addrlen)
767 safe_syscall3(ssize_t, sendmsg, int, fd, const struct msghdr *, msg, int, flags)
768 safe_syscall3(ssize_t, recvmsg, int, fd, struct msghdr *, msg, int, flags)
769 safe_syscall2(int, flock, int, fd, int, operation)
770 #if defined(TARGET_NR_rt_sigtimedwait) || defined(TARGET_NR_rt_sigtimedwait_time64)
771 safe_syscall4(int, rt_sigtimedwait, const sigset_t *, these, siginfo_t *, uinfo,
772 const struct timespec *, uts, size_t, sigsetsize)
773 #endif
774 safe_syscall4(int, accept4, int, fd, struct sockaddr *, addr, socklen_t *, len,
775 int, flags)
776 #if defined(TARGET_NR_nanosleep)
777 safe_syscall2(int, nanosleep, const struct timespec *, req,
778 struct timespec *, rem)
779 #endif
780 #if defined(TARGET_NR_clock_nanosleep) || \
781 defined(TARGET_NR_clock_nanosleep_time64)
782 safe_syscall4(int, clock_nanosleep, const clockid_t, clock, int, flags,
783 const struct timespec *, req, struct timespec *, rem)
784 #endif
785 #ifdef __NR_ipc
786 #ifdef __s390x__
787 safe_syscall5(int, ipc, int, call, long, first, long, second, long, third,
788 void *, ptr)
789 #else
790 safe_syscall6(int, ipc, int, call, long, first, long, second, long, third,
791 void *, ptr, long, fifth)
792 #endif
793 #endif
794 #ifdef __NR_msgsnd
795 safe_syscall4(int, msgsnd, int, msgid, const void *, msgp, size_t, sz,
796 int, flags)
797 #endif
798 #ifdef __NR_msgrcv
799 safe_syscall5(int, msgrcv, int, msgid, void *, msgp, size_t, sz,
800 long, msgtype, int, flags)
801 #endif
802 #ifdef __NR_semtimedop
803 safe_syscall4(int, semtimedop, int, semid, struct sembuf *, tsops,
804 unsigned, nsops, const struct timespec *, timeout)
805 #endif
806 #if defined(TARGET_NR_mq_timedsend) || \
807 defined(TARGET_NR_mq_timedsend_time64)
808 safe_syscall5(int, mq_timedsend, int, mqdes, const char *, msg_ptr,
809 size_t, len, unsigned, prio, const struct timespec *, timeout)
810 #endif
811 #if defined(TARGET_NR_mq_timedreceive) || \
812 defined(TARGET_NR_mq_timedreceive_time64)
813 safe_syscall5(int, mq_timedreceive, int, mqdes, char *, msg_ptr,
814 size_t, len, unsigned *, prio, const struct timespec *, timeout)
815 #endif
816 /* We do ioctl like this rather than via safe_syscall3 to preserve the
817 * "third argument might be integer or pointer or not present" behaviour of
818 * the libc function.
819 */
820 #define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
821 /* Similarly for fcntl. Note that callers must always:
822 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
823 * use the flock64 struct rather than unsuffixed flock
824 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
825 */
826 #ifdef __NR_fcntl64
827 #define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
828 #else
829 #define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
830 #endif
831
832 static inline int host_to_target_sock_type(int host_type)
833 {
834 int target_type;
835
836 switch (host_type & 0xf /* SOCK_TYPE_MASK */) {
837 case SOCK_DGRAM:
838 target_type = TARGET_SOCK_DGRAM;
839 break;
840 case SOCK_STREAM:
841 target_type = TARGET_SOCK_STREAM;
842 break;
843 default:
844 target_type = host_type & 0xf /* SOCK_TYPE_MASK */;
845 break;
846 }
847
848 #if defined(SOCK_CLOEXEC)
849 if (host_type & SOCK_CLOEXEC) {
850 target_type |= TARGET_SOCK_CLOEXEC;
851 }
852 #endif
853
854 #if defined(SOCK_NONBLOCK)
855 if (host_type & SOCK_NONBLOCK) {
856 target_type |= TARGET_SOCK_NONBLOCK;
857 }
858 #endif
859
860 return target_type;
861 }
862
863 static abi_ulong target_brk;
864 static abi_ulong target_original_brk;
865 static abi_ulong brk_page;
866
867 void target_set_brk(abi_ulong new_brk)
868 {
869 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
870 brk_page = HOST_PAGE_ALIGN(target_brk);
871 }
872
873 //#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
874 #define DEBUGF_BRK(message, args...)
875
876 /* do_brk() must return target values and target errnos. */
877 abi_long do_brk(abi_ulong new_brk)
878 {
879 abi_long mapped_addr;
880 abi_ulong new_alloc_size;
881
882 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk);
883
884 if (!new_brk) {
885 DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk);
886 return target_brk;
887 }
888 if (new_brk < target_original_brk) {
889 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n",
890 target_brk);
891 return target_brk;
892 }
893
894 /* If the new brk is less than the highest page reserved to the
895 * target heap allocation, set it and we're almost done... */
896 if (new_brk <= brk_page) {
897 /* Heap contents are initialized to zero, as for anonymous
898 * mapped pages. */
899 if (new_brk > target_brk) {
900 memset(g2h(target_brk), 0, new_brk - target_brk);
901 }
902 target_brk = new_brk;
903 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk);
904 return target_brk;
905 }
906
907 /* We need to allocate more memory after the brk... Note that
908 * we don't use MAP_FIXED because that will map over the top of
909 * any existing mapping (like the one with the host libc or qemu
910 * itself); instead we treat "mapped but at wrong address" as
911 * a failure and unmap again.
912 */
913 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page);
914 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
915 PROT_READ|PROT_WRITE,
916 MAP_ANON|MAP_PRIVATE, 0, 0));
917
918 if (mapped_addr == brk_page) {
919 /* Heap contents are initialized to zero, as for anonymous
920 * mapped pages. Technically the new pages are already
921 * initialized to zero since they *are* anonymous mapped
922 * pages, however we have to take care with the contents that
923 * come from the remaining part of the previous page: it may
924 * contains garbage data due to a previous heap usage (grown
925 * then shrunken). */
926 memset(g2h(target_brk), 0, brk_page - target_brk);
927
928 target_brk = new_brk;
929 brk_page = HOST_PAGE_ALIGN(target_brk);
930 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n",
931 target_brk);
932 return target_brk;
933 } else if (mapped_addr != -1) {
934 /* Mapped but at wrong address, meaning there wasn't actually
935 * enough space for this brk.
936 */
937 target_munmap(mapped_addr, new_alloc_size);
938 mapped_addr = -1;
939 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk);
940 }
941 else {
942 DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk);
943 }
944
945 #if defined(TARGET_ALPHA)
946 /* We (partially) emulate OSF/1 on Alpha, which requires we
947 return a proper errno, not an unchanged brk value. */
948 return -TARGET_ENOMEM;
949 #endif
950 /* For everything else, return the previous break. */
951 return target_brk;
952 }
953
954 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
955 defined(TARGET_NR_pselect6)
956 static inline abi_long copy_from_user_fdset(fd_set *fds,
957 abi_ulong target_fds_addr,
958 int n)
959 {
960 int i, nw, j, k;
961 abi_ulong b, *target_fds;
962
963 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
964 if (!(target_fds = lock_user(VERIFY_READ,
965 target_fds_addr,
966 sizeof(abi_ulong) * nw,
967 1)))
968 return -TARGET_EFAULT;
969
970 FD_ZERO(fds);
971 k = 0;
972 for (i = 0; i < nw; i++) {
973 /* grab the abi_ulong */
974 __get_user(b, &target_fds[i]);
975 for (j = 0; j < TARGET_ABI_BITS; j++) {
976 /* check the bit inside the abi_ulong */
977 if ((b >> j) & 1)
978 FD_SET(k, fds);
979 k++;
980 }
981 }
982
983 unlock_user(target_fds, target_fds_addr, 0);
984
985 return 0;
986 }
987
988 static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr,
989 abi_ulong target_fds_addr,
990 int n)
991 {
992 if (target_fds_addr) {
993 if (copy_from_user_fdset(fds, target_fds_addr, n))
994 return -TARGET_EFAULT;
995 *fds_ptr = fds;
996 } else {
997 *fds_ptr = NULL;
998 }
999 return 0;
1000 }
1001
1002 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
1003 const fd_set *fds,
1004 int n)
1005 {
1006 int i, nw, j, k;
1007 abi_long v;
1008 abi_ulong *target_fds;
1009
1010 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
1011 if (!(target_fds = lock_user(VERIFY_WRITE,
1012 target_fds_addr,
1013 sizeof(abi_ulong) * nw,
1014 0)))
1015 return -TARGET_EFAULT;
1016
1017 k = 0;
1018 for (i = 0; i < nw; i++) {
1019 v = 0;
1020 for (j = 0; j < TARGET_ABI_BITS; j++) {
1021 v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j);
1022 k++;
1023 }
1024 __put_user(v, &target_fds[i]);
1025 }
1026
1027 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
1028
1029 return 0;
1030 }
1031 #endif
1032
1033 #if defined(__alpha__)
1034 #define HOST_HZ 1024
1035 #else
1036 #define HOST_HZ 100
1037 #endif
1038
1039 static inline abi_long host_to_target_clock_t(long ticks)
1040 {
1041 #if HOST_HZ == TARGET_HZ
1042 return ticks;
1043 #else
1044 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
1045 #endif
1046 }
1047
1048 static inline abi_long host_to_target_rusage(abi_ulong target_addr,
1049 const struct rusage *rusage)
1050 {
1051 struct target_rusage *target_rusage;
1052
1053 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
1054 return -TARGET_EFAULT;
1055 target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec);
1056 target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec);
1057 target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec);
1058 target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec);
1059 target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss);
1060 target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss);
1061 target_rusage->ru_idrss = tswapal(rusage->ru_idrss);
1062 target_rusage->ru_isrss = tswapal(rusage->ru_isrss);
1063 target_rusage->ru_minflt = tswapal(rusage->ru_minflt);
1064 target_rusage->ru_majflt = tswapal(rusage->ru_majflt);
1065 target_rusage->ru_nswap = tswapal(rusage->ru_nswap);
1066 target_rusage->ru_inblock = tswapal(rusage->ru_inblock);
1067 target_rusage->ru_oublock = tswapal(rusage->ru_oublock);
1068 target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd);
1069 target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv);
1070 target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals);
1071 target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw);
1072 target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw);
1073 unlock_user_struct(target_rusage, target_addr, 1);
1074
1075 return 0;
1076 }
1077
1078 #ifdef TARGET_NR_setrlimit
1079 static inline rlim_t target_to_host_rlim(abi_ulong target_rlim)
1080 {
1081 abi_ulong target_rlim_swap;
1082 rlim_t result;
1083
1084 target_rlim_swap = tswapal(target_rlim);
1085 if (target_rlim_swap == TARGET_RLIM_INFINITY)
1086 return RLIM_INFINITY;
1087
1088 result = target_rlim_swap;
1089 if (target_rlim_swap != (rlim_t)result)
1090 return RLIM_INFINITY;
1091
1092 return result;
1093 }
1094 #endif
1095
1096 #if defined(TARGET_NR_getrlimit) || defined(TARGET_NR_ugetrlimit)
1097 static inline abi_ulong host_to_target_rlim(rlim_t rlim)
1098 {
1099 abi_ulong target_rlim_swap;
1100 abi_ulong result;
1101
1102 if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim)
1103 target_rlim_swap = TARGET_RLIM_INFINITY;
1104 else
1105 target_rlim_swap = rlim;
1106 result = tswapal(target_rlim_swap);
1107
1108 return result;
1109 }
1110 #endif
1111
1112 static inline int target_to_host_resource(int code)
1113 {
1114 switch (code) {
1115 case TARGET_RLIMIT_AS:
1116 return RLIMIT_AS;
1117 case TARGET_RLIMIT_CORE:
1118 return RLIMIT_CORE;
1119 case TARGET_RLIMIT_CPU:
1120 return RLIMIT_CPU;
1121 case TARGET_RLIMIT_DATA:
1122 return RLIMIT_DATA;
1123 case TARGET_RLIMIT_FSIZE:
1124 return RLIMIT_FSIZE;
1125 case TARGET_RLIMIT_LOCKS:
1126 return RLIMIT_LOCKS;
1127 case TARGET_RLIMIT_MEMLOCK:
1128 return RLIMIT_MEMLOCK;
1129 case TARGET_RLIMIT_MSGQUEUE:
1130 return RLIMIT_MSGQUEUE;
1131 case TARGET_RLIMIT_NICE:
1132 return RLIMIT_NICE;
1133 case TARGET_RLIMIT_NOFILE:
1134 return RLIMIT_NOFILE;
1135 case TARGET_RLIMIT_NPROC:
1136 return RLIMIT_NPROC;
1137 case TARGET_RLIMIT_RSS:
1138 return RLIMIT_RSS;
1139 case TARGET_RLIMIT_RTPRIO:
1140 return RLIMIT_RTPRIO;
1141 case TARGET_RLIMIT_SIGPENDING:
1142 return RLIMIT_SIGPENDING;
1143 case TARGET_RLIMIT_STACK:
1144 return RLIMIT_STACK;
1145 default:
1146 return code;
1147 }
1148 }
1149
1150 static inline abi_long copy_from_user_timeval(struct timeval *tv,
1151 abi_ulong target_tv_addr)
1152 {
1153 struct target_timeval *target_tv;
1154
1155 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) {
1156 return -TARGET_EFAULT;
1157 }
1158
1159 __get_user(tv->tv_sec, &target_tv->tv_sec);
1160 __get_user(tv->tv_usec, &target_tv->tv_usec);
1161
1162 unlock_user_struct(target_tv, target_tv_addr, 0);
1163
1164 return 0;
1165 }
1166
1167 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
1168 const struct timeval *tv)
1169 {
1170 struct target_timeval *target_tv;
1171
1172 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) {
1173 return -TARGET_EFAULT;
1174 }
1175
1176 __put_user(tv->tv_sec, &target_tv->tv_sec);
1177 __put_user(tv->tv_usec, &target_tv->tv_usec);
1178
1179 unlock_user_struct(target_tv, target_tv_addr, 1);
1180
1181 return 0;
1182 }
1183
1184 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
1185 static inline abi_long copy_from_user_timeval64(struct timeval *tv,
1186 abi_ulong target_tv_addr)
1187 {
1188 struct target__kernel_sock_timeval *target_tv;
1189
1190 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) {
1191 return -TARGET_EFAULT;
1192 }
1193
1194 __get_user(tv->tv_sec, &target_tv->tv_sec);
1195 __get_user(tv->tv_usec, &target_tv->tv_usec);
1196
1197 unlock_user_struct(target_tv, target_tv_addr, 0);
1198
1199 return 0;
1200 }
1201 #endif
1202
1203 static inline abi_long copy_to_user_timeval64(abi_ulong target_tv_addr,
1204 const struct timeval *tv)
1205 {
1206 struct target__kernel_sock_timeval *target_tv;
1207
1208 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) {
1209 return -TARGET_EFAULT;
1210 }
1211
1212 __put_user(tv->tv_sec, &target_tv->tv_sec);
1213 __put_user(tv->tv_usec, &target_tv->tv_usec);
1214
1215 unlock_user_struct(target_tv, target_tv_addr, 1);
1216
1217 return 0;
1218 }
1219
1220 #if defined(TARGET_NR_futex) || \
1221 defined(TARGET_NR_rt_sigtimedwait) || \
1222 defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6) || \
1223 defined(TARGET_NR_nanosleep) || defined(TARGET_NR_clock_settime) || \
1224 defined(TARGET_NR_utimensat) || defined(TARGET_NR_mq_timedsend) || \
1225 defined(TARGET_NR_mq_timedreceive) || defined(TARGET_NR_ipc) || \
1226 defined(TARGET_NR_semop) || defined(TARGET_NR_semtimedop) || \
1227 defined(TARGET_NR_timer_settime) || \
1228 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
1229 static inline abi_long target_to_host_timespec(struct timespec *host_ts,
1230 abi_ulong target_addr)
1231 {
1232 struct target_timespec *target_ts;
1233
1234 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) {
1235 return -TARGET_EFAULT;
1236 }
1237 __get_user(host_ts->tv_sec, &target_ts->tv_sec);
1238 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1239 unlock_user_struct(target_ts, target_addr, 0);
1240 return 0;
1241 }
1242 #endif
1243
1244 #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
1245 defined(TARGET_NR_timer_settime64) || \
1246 defined(TARGET_NR_mq_timedsend_time64) || \
1247 defined(TARGET_NR_mq_timedreceive_time64) || \
1248 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)) || \
1249 defined(TARGET_NR_clock_nanosleep_time64) || \
1250 defined(TARGET_NR_rt_sigtimedwait_time64) || \
1251 defined(TARGET_NR_utimensat) || \
1252 defined(TARGET_NR_utimensat_time64) || \
1253 defined(TARGET_NR_semtimedop_time64)
1254 static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
1255 abi_ulong target_addr)
1256 {
1257 struct target__kernel_timespec *target_ts;
1258
1259 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) {
1260 return -TARGET_EFAULT;
1261 }
1262 __get_user(host_ts->tv_sec, &target_ts->tv_sec);
1263 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1264 /* in 32bit mode, this drops the padding */
1265 host_ts->tv_nsec = (long)(abi_long)host_ts->tv_nsec;
1266 unlock_user_struct(target_ts, target_addr, 0);
1267 return 0;
1268 }
1269 #endif
1270
1271 static inline abi_long host_to_target_timespec(abi_ulong target_addr,
1272 struct timespec *host_ts)
1273 {
1274 struct target_timespec *target_ts;
1275
1276 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) {
1277 return -TARGET_EFAULT;
1278 }
1279 __put_user(host_ts->tv_sec, &target_ts->tv_sec);
1280 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1281 unlock_user_struct(target_ts, target_addr, 1);
1282 return 0;
1283 }
1284
1285 static inline abi_long host_to_target_timespec64(abi_ulong target_addr,
1286 struct timespec *host_ts)
1287 {
1288 struct target__kernel_timespec *target_ts;
1289
1290 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) {
1291 return -TARGET_EFAULT;
1292 }
1293 __put_user(host_ts->tv_sec, &target_ts->tv_sec);
1294 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
1295 unlock_user_struct(target_ts, target_addr, 1);
1296 return 0;
1297 }
1298
1299 #if defined(TARGET_NR_gettimeofday)
1300 static inline abi_long copy_to_user_timezone(abi_ulong target_tz_addr,
1301 struct timezone *tz)
1302 {
1303 struct target_timezone *target_tz;
1304
1305 if (!lock_user_struct(VERIFY_WRITE, target_tz, target_tz_addr, 1)) {
1306 return -TARGET_EFAULT;
1307 }
1308
1309 __put_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1310 __put_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1311
1312 unlock_user_struct(target_tz, target_tz_addr, 1);
1313
1314 return 0;
1315 }
1316 #endif
1317
1318 #if defined(TARGET_NR_settimeofday)
1319 static inline abi_long copy_from_user_timezone(struct timezone *tz,
1320 abi_ulong target_tz_addr)
1321 {
1322 struct target_timezone *target_tz;
1323
1324 if (!lock_user_struct(VERIFY_READ, target_tz, target_tz_addr, 1)) {
1325 return -TARGET_EFAULT;
1326 }
1327
1328 __get_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1329 __get_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1330
1331 unlock_user_struct(target_tz, target_tz_addr, 0);
1332
1333 return 0;
1334 }
1335 #endif
1336
1337 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1338 #include <mqueue.h>
1339
1340 static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr,
1341 abi_ulong target_mq_attr_addr)
1342 {
1343 struct target_mq_attr *target_mq_attr;
1344
1345 if (!lock_user_struct(VERIFY_READ, target_mq_attr,
1346 target_mq_attr_addr, 1))
1347 return -TARGET_EFAULT;
1348
1349 __get_user(attr->mq_flags, &target_mq_attr->mq_flags);
1350 __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1351 __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1352 __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1353
1354 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0);
1355
1356 return 0;
1357 }
1358
1359 static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr,
1360 const struct mq_attr *attr)
1361 {
1362 struct target_mq_attr *target_mq_attr;
1363
1364 if (!lock_user_struct(VERIFY_WRITE, target_mq_attr,
1365 target_mq_attr_addr, 0))
1366 return -TARGET_EFAULT;
1367
1368 __put_user(attr->mq_flags, &target_mq_attr->mq_flags);
1369 __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1370 __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1371 __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1372
1373 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1);
1374
1375 return 0;
1376 }
1377 #endif
1378
1379 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
1380 /* do_select() must return target values and target errnos. */
1381 static abi_long do_select(int n,
1382 abi_ulong rfd_addr, abi_ulong wfd_addr,
1383 abi_ulong efd_addr, abi_ulong target_tv_addr)
1384 {
1385 fd_set rfds, wfds, efds;
1386 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
1387 struct timeval tv;
1388 struct timespec ts, *ts_ptr;
1389 abi_long ret;
1390
1391 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
1392 if (ret) {
1393 return ret;
1394 }
1395 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
1396 if (ret) {
1397 return ret;
1398 }
1399 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
1400 if (ret) {
1401 return ret;
1402 }
1403
1404 if (target_tv_addr) {
1405 if (copy_from_user_timeval(&tv, target_tv_addr))
1406 return -TARGET_EFAULT;
1407 ts.tv_sec = tv.tv_sec;
1408 ts.tv_nsec = tv.tv_usec * 1000;
1409 ts_ptr = &ts;
1410 } else {
1411 ts_ptr = NULL;
1412 }
1413
1414 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
1415 ts_ptr, NULL));
1416
1417 if (!is_error(ret)) {
1418 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
1419 return -TARGET_EFAULT;
1420 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
1421 return -TARGET_EFAULT;
1422 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
1423 return -TARGET_EFAULT;
1424
1425 if (target_tv_addr) {
1426 tv.tv_sec = ts.tv_sec;
1427 tv.tv_usec = ts.tv_nsec / 1000;
1428 if (copy_to_user_timeval(target_tv_addr, &tv)) {
1429 return -TARGET_EFAULT;
1430 }
1431 }
1432 }
1433
1434 return ret;
1435 }
1436
1437 #if defined(TARGET_WANT_OLD_SYS_SELECT)
1438 static abi_long do_old_select(abi_ulong arg1)
1439 {
1440 struct target_sel_arg_struct *sel;
1441 abi_ulong inp, outp, exp, tvp;
1442 long nsel;
1443
1444 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1)) {
1445 return -TARGET_EFAULT;
1446 }
1447
1448 nsel = tswapal(sel->n);
1449 inp = tswapal(sel->inp);
1450 outp = tswapal(sel->outp);
1451 exp = tswapal(sel->exp);
1452 tvp = tswapal(sel->tvp);
1453
1454 unlock_user_struct(sel, arg1, 0);
1455
1456 return do_select(nsel, inp, outp, exp, tvp);
1457 }
1458 #endif
1459 #endif
1460
1461 static abi_long do_pipe2(int host_pipe[], int flags)
1462 {
1463 #ifdef CONFIG_PIPE2
1464 return pipe2(host_pipe, flags);
1465 #else
1466 return -ENOSYS;
1467 #endif
1468 }
1469
1470 static abi_long do_pipe(void *cpu_env, abi_ulong pipedes,
1471 int flags, int is_pipe2)
1472 {
1473 int host_pipe[2];
1474 abi_long ret;
1475 ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe);
1476
1477 if (is_error(ret))
1478 return get_errno(ret);
1479
1480 /* Several targets have special calling conventions for the original
1481 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1482 if (!is_pipe2) {
1483 #if defined(TARGET_ALPHA)
1484 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1];
1485 return host_pipe[0];
1486 #elif defined(TARGET_MIPS)
1487 ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1];
1488 return host_pipe[0];
1489 #elif defined(TARGET_SH4)
1490 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
1491 return host_pipe[0];
1492 #elif defined(TARGET_SPARC)
1493 ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1];
1494 return host_pipe[0];
1495 #endif
1496 }
1497
1498 if (put_user_s32(host_pipe[0], pipedes)
1499 || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0])))
1500 return -TARGET_EFAULT;
1501 return get_errno(ret);
1502 }
1503
1504 static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn,
1505 abi_ulong target_addr,
1506 socklen_t len)
1507 {
1508 struct target_ip_mreqn *target_smreqn;
1509
1510 target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1);
1511 if (!target_smreqn)
1512 return -TARGET_EFAULT;
1513 mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr;
1514 mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr;
1515 if (len == sizeof(struct target_ip_mreqn))
1516 mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex);
1517 unlock_user(target_smreqn, target_addr, 0);
1518
1519 return 0;
1520 }
1521
1522 static inline abi_long target_to_host_sockaddr(int fd, struct sockaddr *addr,
1523 abi_ulong target_addr,
1524 socklen_t len)
1525 {
1526 const socklen_t unix_maxlen = sizeof (struct sockaddr_un);
1527 sa_family_t sa_family;
1528 struct target_sockaddr *target_saddr;
1529
1530 if (fd_trans_target_to_host_addr(fd)) {
1531 return fd_trans_target_to_host_addr(fd)(addr, target_addr, len);
1532 }
1533
1534 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1535 if (!target_saddr)
1536 return -TARGET_EFAULT;
1537
1538 sa_family = tswap16(target_saddr->sa_family);
1539
1540 /* Oops. The caller might send a incomplete sun_path; sun_path
1541 * must be terminated by \0 (see the manual page), but
1542 * unfortunately it is quite common to specify sockaddr_un
1543 * length as "strlen(x->sun_path)" while it should be
1544 * "strlen(...) + 1". We'll fix that here if needed.
1545 * Linux kernel has a similar feature.
1546 */
1547
1548 if (sa_family == AF_UNIX) {
1549 if (len < unix_maxlen && len > 0) {
1550 char *cp = (char*)target_saddr;
1551
1552 if ( cp[len-1] && !cp[len] )
1553 len++;
1554 }
1555 if (len > unix_maxlen)
1556 len = unix_maxlen;
1557 }
1558
1559 memcpy(addr, target_saddr, len);
1560 addr->sa_family = sa_family;
1561 if (sa_family == AF_NETLINK) {
1562 struct sockaddr_nl *nladdr;
1563
1564 nladdr = (struct sockaddr_nl *)addr;
1565 nladdr->nl_pid = tswap32(nladdr->nl_pid);
1566 nladdr->nl_groups = tswap32(nladdr->nl_groups);
1567 } else if (sa_family == AF_PACKET) {
1568 struct target_sockaddr_ll *lladdr;
1569
1570 lladdr = (struct target_sockaddr_ll *)addr;
1571 lladdr->sll_ifindex = tswap32(lladdr->sll_ifindex);
1572 lladdr->sll_hatype = tswap16(lladdr->sll_hatype);
1573 }
1574 unlock_user(target_saddr, target_addr, 0);
1575
1576 return 0;
1577 }
1578
1579 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
1580 struct sockaddr *addr,
1581 socklen_t len)
1582 {
1583 struct target_sockaddr *target_saddr;
1584
1585 if (len == 0) {
1586 return 0;
1587 }
1588 assert(addr);
1589
1590 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
1591 if (!target_saddr)
1592 return -TARGET_EFAULT;
1593 memcpy(target_saddr, addr, len);
1594 if (len >= offsetof(struct target_sockaddr, sa_family) +
1595 sizeof(target_saddr->sa_family)) {
1596 target_saddr->sa_family = tswap16(addr->sa_family);
1597 }
1598 if (addr->sa_family == AF_NETLINK &&
1599 len >= sizeof(struct target_sockaddr_nl)) {
1600 struct target_sockaddr_nl *target_nl =
1601 (struct target_sockaddr_nl *)target_saddr;
1602 target_nl->nl_pid = tswap32(target_nl->nl_pid);
1603 target_nl->nl_groups = tswap32(target_nl->nl_groups);
1604 } else if (addr->sa_family == AF_PACKET) {
1605 struct sockaddr_ll *target_ll = (struct sockaddr_ll *)target_saddr;
1606 target_ll->sll_ifindex = tswap32(target_ll->sll_ifindex);
1607 target_ll->sll_hatype = tswap16(target_ll->sll_hatype);
1608 } else if (addr->sa_family == AF_INET6 &&
1609 len >= sizeof(struct target_sockaddr_in6)) {
1610 struct target_sockaddr_in6 *target_in6 =
1611 (struct target_sockaddr_in6 *)target_saddr;
1612 target_in6->sin6_scope_id = tswap16(target_in6->sin6_scope_id);
1613 }
1614 unlock_user(target_saddr, target_addr, len);
1615
1616 return 0;
1617 }
1618
1619 static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
1620 struct target_msghdr *target_msgh)
1621 {
1622 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1623 abi_long msg_controllen;
1624 abi_ulong target_cmsg_addr;
1625 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
1626 socklen_t space = 0;
1627
1628 msg_controllen = tswapal(target_msgh->msg_controllen);
1629 if (msg_controllen < sizeof (struct target_cmsghdr))
1630 goto the_end;
1631 target_cmsg_addr = tswapal(target_msgh->msg_control);
1632 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
1633 target_cmsg_start = target_cmsg;
1634 if (!target_cmsg)
1635 return -TARGET_EFAULT;
1636
1637 while (cmsg && target_cmsg) {
1638 void *data = CMSG_DATA(cmsg);
1639 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1640
1641 int len = tswapal(target_cmsg->cmsg_len)
1642 - sizeof(struct target_cmsghdr);
1643
1644 space += CMSG_SPACE(len);
1645 if (space > msgh->msg_controllen) {
1646 space -= CMSG_SPACE(len);
1647 /* This is a QEMU bug, since we allocated the payload
1648 * area ourselves (unlike overflow in host-to-target
1649 * conversion, which is just the guest giving us a buffer
1650 * that's too small). It can't happen for the payload types
1651 * we currently support; if it becomes an issue in future
1652 * we would need to improve our allocation strategy to
1653 * something more intelligent than "twice the size of the
1654 * target buffer we're reading from".
1655 */
1656 qemu_log_mask(LOG_UNIMP,
1657 ("Unsupported ancillary data %d/%d: "
1658 "unhandled msg size\n"),
1659 tswap32(target_cmsg->cmsg_level),
1660 tswap32(target_cmsg->cmsg_type));
1661 break;
1662 }
1663
1664 if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) {
1665 cmsg->cmsg_level = SOL_SOCKET;
1666 } else {
1667 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
1668 }
1669 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
1670 cmsg->cmsg_len = CMSG_LEN(len);
1671
1672 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1673 int *fd = (int *)data;
1674 int *target_fd = (int *)target_data;
1675 int i, numfds = len / sizeof(int);
1676
1677 for (i = 0; i < numfds; i++) {
1678 __get_user(fd[i], target_fd + i);
1679 }
1680 } else if (cmsg->cmsg_level == SOL_SOCKET
1681 && cmsg->cmsg_type == SCM_CREDENTIALS) {
1682 struct ucred *cred = (struct ucred *)data;
1683 struct target_ucred *target_cred =
1684 (struct target_ucred *)target_data;
1685
1686 __get_user(cred->pid, &target_cred->pid);
1687 __get_user(cred->uid, &target_cred->uid);
1688 __get_user(cred->gid, &target_cred->gid);
1689 } else {
1690 qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n",
1691 cmsg->cmsg_level, cmsg->cmsg_type);
1692 memcpy(data, target_data, len);
1693 }
1694
1695 cmsg = CMSG_NXTHDR(msgh, cmsg);
1696 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1697 target_cmsg_start);
1698 }
1699 unlock_user(target_cmsg, target_cmsg_addr, 0);
1700 the_end:
1701 msgh->msg_controllen = space;
1702 return 0;
1703 }
1704
1705 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
1706 struct msghdr *msgh)
1707 {
1708 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
1709 abi_long msg_controllen;
1710 abi_ulong target_cmsg_addr;
1711 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
1712 socklen_t space = 0;
1713
1714 msg_controllen = tswapal(target_msgh->msg_controllen);
1715 if (msg_controllen < sizeof (struct target_cmsghdr))
1716 goto the_end;
1717 target_cmsg_addr = tswapal(target_msgh->msg_control);
1718 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
1719 target_cmsg_start = target_cmsg;
1720 if (!target_cmsg)
1721 return -TARGET_EFAULT;
1722
1723 while (cmsg && target_cmsg) {
1724 void *data = CMSG_DATA(cmsg);
1725 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1726
1727 int len = cmsg->cmsg_len - sizeof(struct cmsghdr);
1728 int tgt_len, tgt_space;
1729
1730 /* We never copy a half-header but may copy half-data;
1731 * this is Linux's behaviour in put_cmsg(). Note that
1732 * truncation here is a guest problem (which we report
1733 * to the guest via the CTRUNC bit), unlike truncation
1734 * in target_to_host_cmsg, which is a QEMU bug.
1735 */
1736 if (msg_controllen < sizeof(struct target_cmsghdr)) {
1737 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1738 break;
1739 }
1740
1741 if (cmsg->cmsg_level == SOL_SOCKET) {
1742 target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET);
1743 } else {
1744 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
1745 }
1746 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
1747
1748 /* Payload types which need a different size of payload on
1749 * the target must adjust tgt_len here.
1750 */
1751 tgt_len = len;
1752 switch (cmsg->cmsg_level) {
1753 case SOL_SOCKET:
1754 switch (cmsg->cmsg_type) {
1755 case SO_TIMESTAMP:
1756 tgt_len = sizeof(struct target_timeval);
1757 break;
1758 default:
1759 break;
1760 }
1761 break;
1762 default:
1763 break;
1764 }
1765
1766 if (msg_controllen < TARGET_CMSG_LEN(tgt_len)) {
1767 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1768 tgt_len = msg_controllen - sizeof(struct target_cmsghdr);
1769 }
1770
1771 /* We must now copy-and-convert len bytes of payload
1772 * into tgt_len bytes of destination space. Bear in mind
1773 * that in both source and destination we may be dealing
1774 * with a truncated value!
1775 */
1776 switch (cmsg->cmsg_level) {
1777 case SOL_SOCKET:
1778 switch (cmsg->cmsg_type) {
1779 case SCM_RIGHTS:
1780 {
1781 int *fd = (int *)data;
1782 int *target_fd = (int *)target_data;
1783 int i, numfds = tgt_len / sizeof(int);
1784
1785 for (i = 0; i < numfds; i++) {
1786 __put_user(fd[i], target_fd + i);
1787 }
1788 break;
1789 }
1790 case SO_TIMESTAMP:
1791 {
1792 struct timeval *tv = (struct timeval *)data;
1793 struct target_timeval *target_tv =
1794 (struct target_timeval *)target_data;
1795
1796 if (len != sizeof(struct timeval) ||
1797 tgt_len != sizeof(struct target_timeval)) {
1798 goto unimplemented;
1799 }
1800
1801 /* copy struct timeval to target */
1802 __put_user(tv->tv_sec, &target_tv->tv_sec);
1803 __put_user(tv->tv_usec, &target_tv->tv_usec);
1804 break;
1805 }
1806 case SCM_CREDENTIALS:
1807 {
1808 struct ucred *cred = (struct ucred *)data;
1809 struct target_ucred *target_cred =
1810 (struct target_ucred *)target_data;
1811
1812 __put_user(cred->pid, &target_cred->pid);
1813 __put_user(cred->uid, &target_cred->uid);
1814 __put_user(cred->gid, &target_cred->gid);
1815 break;
1816 }
1817 default:
1818 goto unimplemented;
1819 }
1820 break;
1821
1822 case SOL_IP:
1823 switch (cmsg->cmsg_type) {
1824 case IP_TTL:
1825 {
1826 uint32_t *v = (uint32_t *)data;
1827 uint32_t *t_int = (uint32_t *)target_data;
1828
1829 if (len != sizeof(uint32_t) ||
1830 tgt_len != sizeof(uint32_t)) {
1831 goto unimplemented;
1832 }
1833 __put_user(*v, t_int);
1834 break;
1835 }
1836 case IP_RECVERR:
1837 {
1838 struct errhdr_t {
1839 struct sock_extended_err ee;
1840 struct sockaddr_in offender;
1841 };
1842 struct errhdr_t *errh = (struct errhdr_t *)data;
1843 struct errhdr_t *target_errh =
1844 (struct errhdr_t *)target_data;
1845
1846 if (len != sizeof(struct errhdr_t) ||
1847 tgt_len != sizeof(struct errhdr_t)) {
1848 goto unimplemented;
1849 }
1850 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
1851 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
1852 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type);
1853 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
1854 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
1855 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
1856 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
1857 host_to_target_sockaddr((unsigned long) &target_errh->offender,
1858 (void *) &errh->offender, sizeof(errh->offender));
1859 break;
1860 }
1861 default:
1862 goto unimplemented;
1863 }
1864 break;
1865
1866 case SOL_IPV6:
1867 switch (cmsg->cmsg_type) {
1868 case IPV6_HOPLIMIT:
1869 {
1870 uint32_t *v = (uint32_t *)data;
1871 uint32_t *t_int = (uint32_t *)target_data;
1872
1873 if (len != sizeof(uint32_t) ||
1874 tgt_len != sizeof(uint32_t)) {
1875 goto unimplemented;
1876 }
1877 __put_user(*v, t_int);
1878 break;
1879 }
1880 case IPV6_RECVERR:
1881 {
1882 struct errhdr6_t {
1883 struct sock_extended_err ee;
1884 struct sockaddr_in6 offender;
1885 };
1886 struct errhdr6_t *errh = (struct errhdr6_t *)data;
1887 struct errhdr6_t *target_errh =
1888 (struct errhdr6_t *)target_data;
1889
1890 if (len != sizeof(struct errhdr6_t) ||
1891 tgt_len != sizeof(struct errhdr6_t)) {
1892 goto unimplemented;
1893 }
1894 __put_user(errh->ee.ee_errno, &target_errh->ee.ee_errno);
1895 __put_user(errh->ee.ee_origin, &target_errh->ee.ee_origin);
1896 __put_user(errh->ee.ee_type, &target_errh->ee.ee_type);
1897 __put_user(errh->ee.ee_code, &target_errh->ee.ee_code);
1898 __put_user(errh->ee.ee_pad, &target_errh->ee.ee_pad);
1899 __put_user(errh->ee.ee_info, &target_errh->ee.ee_info);
1900 __put_user(errh->ee.ee_data, &target_errh->ee.ee_data);
1901 host_to_target_sockaddr((unsigned long) &target_errh->offender,
1902 (void *) &errh->offender, sizeof(errh->offender));
1903 break;
1904 }
1905 default:
1906 goto unimplemented;
1907 }
1908 break;
1909
1910 default:
1911 unimplemented:
1912 qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n",
1913 cmsg->cmsg_level, cmsg->cmsg_type);
1914 memcpy(target_data, data, MIN(len, tgt_len));
1915 if (tgt_len > len) {
1916 memset(target_data + len, 0, tgt_len - len);
1917 }
1918 }
1919
1920 target_cmsg->cmsg_len = tswapal(TARGET_CMSG_LEN(tgt_len));
1921 tgt_space = TARGET_CMSG_SPACE(tgt_len);
1922 if (msg_controllen < tgt_space) {
1923 tgt_space = msg_controllen;
1924 }
1925 msg_controllen -= tgt_space;
1926 space += tgt_space;
1927 cmsg = CMSG_NXTHDR(msgh, cmsg);
1928 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1929 target_cmsg_start);
1930 }
1931 unlock_user(target_cmsg, target_cmsg_addr, space);
1932 the_end:
1933 target_msgh->msg_controllen = tswapal(space);
1934 return 0;
1935 }
1936
1937 /* do_setsockopt() Must return target values and target errnos. */
1938 static abi_long do_setsockopt(int sockfd, int level, int optname,
1939 abi_ulong optval_addr, socklen_t optlen)
1940 {
1941 abi_long ret;
1942 int val;
1943 struct ip_mreqn *ip_mreq;
1944 struct ip_mreq_source *ip_mreq_source;
1945
1946 switch(level) {
1947 case SOL_TCP:
1948 /* TCP options all take an 'int' value. */
1949 if (optlen < sizeof(uint32_t))
1950 return -TARGET_EINVAL;
1951
1952 if (get_user_u32(val, optval_addr))
1953 return -TARGET_EFAULT;
1954 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
1955 break;
1956 case SOL_IP:
1957 switch(optname) {
1958 case IP_TOS:
1959 case IP_TTL:
1960 case IP_HDRINCL:
1961 case IP_ROUTER_ALERT:
1962 case IP_RECVOPTS:
1963 case IP_RETOPTS:
1964 case IP_PKTINFO:
1965 case IP_MTU_DISCOVER:
1966 case IP_RECVERR:
1967 case IP_RECVTTL:
1968 case IP_RECVTOS:
1969 #ifdef IP_FREEBIND
1970 case IP_FREEBIND:
1971 #endif
1972 case IP_MULTICAST_TTL:
1973 case IP_MULTICAST_LOOP:
1974 val = 0;
1975 if (optlen >= sizeof(uint32_t)) {
1976 if (get_user_u32(val, optval_addr))
1977 return -TARGET_EFAULT;
1978 } else if (optlen >= 1) {
1979 if (get_user_u8(val, optval_addr))
1980 return -TARGET_EFAULT;
1981 }
1982 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
1983 break;
1984 case IP_ADD_MEMBERSHIP:
1985 case IP_DROP_MEMBERSHIP:
1986 if (optlen < sizeof (struct target_ip_mreq) ||
1987 optlen > sizeof (struct target_ip_mreqn))
1988 return -TARGET_EINVAL;
1989
1990 ip_mreq = (struct ip_mreqn *) alloca(optlen);
1991 target_to_host_ip_mreq(ip_mreq, optval_addr, optlen);
1992 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen));
1993 break;
1994
1995 case IP_BLOCK_SOURCE:
1996 case IP_UNBLOCK_SOURCE:
1997 case IP_ADD_SOURCE_MEMBERSHIP:
1998 case IP_DROP_SOURCE_MEMBERSHIP:
1999 if (optlen != sizeof (struct target_ip_mreq_source))
2000 return -TARGET_EINVAL;
2001
2002 ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2003 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen));
2004 unlock_user (ip_mreq_source, optval_addr, 0);
2005 break;
2006
2007 default:
2008 goto unimplemented;
2009 }
2010 break;
2011 case SOL_IPV6:
2012 switch (optname) {
2013 case IPV6_MTU_DISCOVER:
2014 case IPV6_MTU:
2015 case IPV6_V6ONLY:
2016 case IPV6_RECVPKTINFO:
2017 case IPV6_UNICAST_HOPS:
2018 case IPV6_MULTICAST_HOPS:
2019 case IPV6_MULTICAST_LOOP:
2020 case IPV6_RECVERR:
2021 case IPV6_RECVHOPLIMIT:
2022 case IPV6_2292HOPLIMIT:
2023 case IPV6_CHECKSUM:
2024 case IPV6_ADDRFORM:
2025 case IPV6_2292PKTINFO:
2026 case IPV6_RECVTCLASS:
2027 case IPV6_RECVRTHDR:
2028 case IPV6_2292RTHDR:
2029 case IPV6_RECVHOPOPTS:
2030 case IPV6_2292HOPOPTS:
2031 case IPV6_RECVDSTOPTS:
2032 case IPV6_2292DSTOPTS:
2033 case IPV6_TCLASS:
2034 #ifdef IPV6_RECVPATHMTU
2035 case IPV6_RECVPATHMTU:
2036 #endif
2037 #ifdef IPV6_TRANSPARENT
2038 case IPV6_TRANSPARENT:
2039 #endif
2040 #ifdef IPV6_FREEBIND
2041 case IPV6_FREEBIND:
2042 #endif
2043 #ifdef IPV6_RECVORIGDSTADDR
2044 case IPV6_RECVORIGDSTADDR:
2045 #endif
2046 val = 0;
2047 if (optlen < sizeof(uint32_t)) {
2048 return -TARGET_EINVAL;
2049 }
2050 if (get_user_u32(val, optval_addr)) {
2051 return -TARGET_EFAULT;
2052 }
2053 ret = get_errno(setsockopt(sockfd, level, optname,
2054 &val, sizeof(val)));
2055 break;
2056 case IPV6_PKTINFO:
2057 {
2058 struct in6_pktinfo pki;
2059
2060 if (optlen < sizeof(pki)) {
2061 return -TARGET_EINVAL;
2062 }
2063
2064 if (copy_from_user(&pki, optval_addr, sizeof(pki))) {
2065 return -TARGET_EFAULT;
2066 }
2067
2068 pki.ipi6_ifindex = tswap32(pki.ipi6_ifindex);
2069
2070 ret = get_errno(setsockopt(sockfd, level, optname,
2071 &pki, sizeof(pki)));
2072 break;
2073 }
2074 case IPV6_ADD_MEMBERSHIP:
2075 case IPV6_DROP_MEMBERSHIP:
2076 {
2077 struct ipv6_mreq ipv6mreq;
2078
2079 if (optlen < sizeof(ipv6mreq)) {
2080 return -TARGET_EINVAL;
2081 }
2082
2083 if (copy_from_user(&ipv6mreq, optval_addr, sizeof(ipv6mreq))) {
2084 return -TARGET_EFAULT;
2085 }
2086
2087 ipv6mreq.ipv6mr_interface = tswap32(ipv6mreq.ipv6mr_interface);
2088
2089 ret = get_errno(setsockopt(sockfd, level, optname,
2090 &ipv6mreq, sizeof(ipv6mreq)));
2091 break;
2092 }
2093 default:
2094 goto unimplemented;
2095 }
2096 break;
2097 case SOL_ICMPV6:
2098 switch (optname) {
2099 case ICMPV6_FILTER:
2100 {
2101 struct icmp6_filter icmp6f;
2102
2103 if (optlen > sizeof(icmp6f)) {
2104 optlen = sizeof(icmp6f);
2105 }
2106
2107 if (copy_from_user(&icmp6f, optval_addr, optlen)) {
2108 return -TARGET_EFAULT;
2109 }
2110
2111 for (val = 0; val < 8; val++) {
2112 icmp6f.data[val] = tswap32(icmp6f.data[val]);
2113 }
2114
2115 ret = get_errno(setsockopt(sockfd, level, optname,
2116 &icmp6f, optlen));
2117 break;
2118 }
2119 default:
2120 goto unimplemented;
2121 }
2122 break;
2123 case SOL_RAW:
2124 switch (optname) {
2125 case ICMP_FILTER:
2126 case IPV6_CHECKSUM:
2127 /* those take an u32 value */
2128 if (optlen < sizeof(uint32_t)) {
2129 return -TARGET_EINVAL;
2130 }
2131
2132 if (get_user_u32(val, optval_addr)) {
2133 return -TARGET_EFAULT;
2134 }
2135 ret = get_errno(setsockopt(sockfd, level, optname,
2136 &val, sizeof(val)));
2137 break;
2138
2139 default:
2140 goto unimplemented;
2141 }
2142 break;
2143 #if defined(SOL_ALG) && defined(ALG_SET_KEY) && defined(ALG_SET_AEAD_AUTHSIZE)
2144 case SOL_ALG:
2145 switch (optname) {
2146 case ALG_SET_KEY:
2147 {
2148 char *alg_key = g_malloc(optlen);
2149
2150 if (!alg_key) {
2151 return -TARGET_ENOMEM;
2152 }
2153 if (copy_from_user(alg_key, optval_addr, optlen)) {
2154 g_free(alg_key);
2155 return -TARGET_EFAULT;
2156 }
2157 ret = get_errno(setsockopt(sockfd, level, optname,
2158 alg_key, optlen));
2159 g_free(alg_key);
2160 break;
2161 }
2162 case ALG_SET_AEAD_AUTHSIZE:
2163 {
2164 ret = get_errno(setsockopt(sockfd, level, optname,
2165 NULL, optlen));
2166 break;
2167 }
2168 default:
2169 goto unimplemented;
2170 }
2171 break;
2172 #endif
2173 case TARGET_SOL_SOCKET:
2174 switch (optname) {
2175 case TARGET_SO_RCVTIMEO:
2176 {
2177 struct timeval tv;
2178
2179 optname = SO_RCVTIMEO;
2180
2181 set_timeout:
2182 if (optlen != sizeof(struct target_timeval)) {
2183 return -TARGET_EINVAL;
2184 }
2185
2186 if (copy_from_user_timeval(&tv, optval_addr)) {
2187 return -TARGET_EFAULT;
2188 }
2189
2190 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2191 &tv, sizeof(tv)));
2192 return ret;
2193 }
2194 case TARGET_SO_SNDTIMEO:
2195 optname = SO_SNDTIMEO;
2196 goto set_timeout;
2197 case TARGET_SO_ATTACH_FILTER:
2198 {
2199 struct target_sock_fprog *tfprog;
2200 struct target_sock_filter *tfilter;
2201 struct sock_fprog fprog;
2202 struct sock_filter *filter;
2203 int i;
2204
2205 if (optlen != sizeof(*tfprog)) {
2206 return -TARGET_EINVAL;
2207 }
2208 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) {
2209 return -TARGET_EFAULT;
2210 }
2211 if (!lock_user_struct(VERIFY_READ, tfilter,
2212 tswapal(tfprog->filter), 0)) {
2213 unlock_user_struct(tfprog, optval_addr, 1);
2214 return -TARGET_EFAULT;
2215 }
2216
2217 fprog.len = tswap16(tfprog->len);
2218 filter = g_try_new(struct sock_filter, fprog.len);
2219 if (filter == NULL) {
2220 unlock_user_struct(tfilter, tfprog->filter, 1);
2221 unlock_user_struct(tfprog, optval_addr, 1);
2222 return -TARGET_ENOMEM;
2223 }
2224 for (i = 0; i < fprog.len; i++) {
2225 filter[i].code = tswap16(tfilter[i].code);
2226 filter[i].jt = tfilter[i].jt;
2227 filter[i].jf = tfilter[i].jf;
2228 filter[i].k = tswap32(tfilter[i].k);
2229 }
2230 fprog.filter = filter;
2231
2232 ret = get_errno(setsockopt(sockfd, SOL_SOCKET,
2233 SO_ATTACH_FILTER, &fprog, sizeof(fprog)));
2234 g_free(filter);
2235
2236 unlock_user_struct(tfilter, tfprog->filter, 1);
2237 unlock_user_struct(tfprog, optval_addr, 1);
2238 return ret;
2239 }
2240 case TARGET_SO_BINDTODEVICE:
2241 {
2242 char *dev_ifname, *addr_ifname;
2243
2244 if (optlen > IFNAMSIZ - 1) {
2245 optlen = IFNAMSIZ - 1;
2246 }
2247 dev_ifname = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2248 if (!dev_ifname) {
2249 return -TARGET_EFAULT;
2250 }
2251 optname = SO_BINDTODEVICE;
2252 addr_ifname = alloca(IFNAMSIZ);
2253 memcpy(addr_ifname, dev_ifname, optlen);
2254 addr_ifname[optlen] = 0;
2255 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2256 addr_ifname, optlen));
2257 unlock_user (dev_ifname, optval_addr, 0);
2258 return ret;
2259 }
2260 case TARGET_SO_LINGER:
2261 {
2262 struct linger lg;
2263 struct target_linger *tlg;
2264
2265 if (optlen != sizeof(struct target_linger)) {
2266 return -TARGET_EINVAL;
2267 }
2268 if (!lock_user_struct(VERIFY_READ, tlg, optval_addr, 1)) {
2269 return -TARGET_EFAULT;
2270 }
2271 __get_user(lg.l_onoff, &tlg->l_onoff);
2272 __get_user(lg.l_linger, &tlg->l_linger);
2273 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, SO_LINGER,
2274 &lg, sizeof(lg)));
2275 unlock_user_struct(tlg, optval_addr, 0);
2276 return ret;
2277 }
2278 /* Options with 'int' argument. */
2279 case TARGET_SO_DEBUG:
2280 optname = SO_DEBUG;
2281 break;
2282 case TARGET_SO_REUSEADDR:
2283 optname = SO_REUSEADDR;
2284 break;
2285 #ifdef SO_REUSEPORT
2286 case TARGET_SO_REUSEPORT:
2287 optname = SO_REUSEPORT;
2288 break;
2289 #endif
2290 case TARGET_SO_TYPE:
2291 optname = SO_TYPE;
2292 break;
2293 case TARGET_SO_ERROR:
2294 optname = SO_ERROR;
2295 break;
2296 case TARGET_SO_DONTROUTE:
2297 optname = SO_DONTROUTE;
2298 break;
2299 case TARGET_SO_BROADCAST:
2300 optname = SO_BROADCAST;
2301 break;
2302 case TARGET_SO_SNDBUF:
2303 optname = SO_SNDBUF;
2304 break;
2305 case TARGET_SO_SNDBUFFORCE:
2306 optname = SO_SNDBUFFORCE;
2307 break;
2308 case TARGET_SO_RCVBUF:
2309 optname = SO_RCVBUF;
2310 break;
2311 case TARGET_SO_RCVBUFFORCE:
2312 optname = SO_RCVBUFFORCE;
2313 break;
2314 case TARGET_SO_KEEPALIVE:
2315 optname = SO_KEEPALIVE;
2316 break;
2317 case TARGET_SO_OOBINLINE:
2318 optname = SO_OOBINLINE;
2319 break;
2320 case TARGET_SO_NO_CHECK:
2321 optname = SO_NO_CHECK;
2322 break;
2323 case TARGET_SO_PRIORITY:
2324 optname = SO_PRIORITY;
2325 break;
2326 #ifdef SO_BSDCOMPAT
2327 case TARGET_SO_BSDCOMPAT:
2328 optname = SO_BSDCOMPAT;
2329 break;
2330 #endif
2331 case TARGET_SO_PASSCRED:
2332 optname = SO_PASSCRED;
2333 break;
2334 case TARGET_SO_PASSSEC:
2335 optname = SO_PASSSEC;
2336 break;
2337 case TARGET_SO_TIMESTAMP:
2338 optname = SO_TIMESTAMP;
2339 break;
2340 case TARGET_SO_RCVLOWAT:
2341 optname = SO_RCVLOWAT;
2342 break;
2343 default:
2344 goto unimplemented;
2345 }
2346 if (optlen < sizeof(uint32_t))
2347 return -TARGET_EINVAL;
2348
2349 if (get_user_u32(val, optval_addr))
2350 return -TARGET_EFAULT;
2351 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
2352 break;
2353 #ifdef SOL_NETLINK
2354 case SOL_NETLINK:
2355 switch (optname) {
2356 case NETLINK_PKTINFO:
2357 case NETLINK_ADD_MEMBERSHIP:
2358 case NETLINK_DROP_MEMBERSHIP:
2359 case NETLINK_BROADCAST_ERROR:
2360 case NETLINK_NO_ENOBUFS:
2361 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2362 case NETLINK_LISTEN_ALL_NSID:
2363 case NETLINK_CAP_ACK:
2364 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2365 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2366 case NETLINK_EXT_ACK:
2367 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2368 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2369 case NETLINK_GET_STRICT_CHK:
2370 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2371 break;
2372 default:
2373 goto unimplemented;
2374 }
2375 val = 0;
2376 if (optlen < sizeof(uint32_t)) {
2377 return -TARGET_EINVAL;
2378 }
2379 if (get_user_u32(val, optval_addr)) {
2380 return -TARGET_EFAULT;
2381 }
2382 ret = get_errno(setsockopt(sockfd, SOL_NETLINK, optname, &val,
2383 sizeof(val)));
2384 break;
2385 #endif /* SOL_NETLINK */
2386 default:
2387 unimplemented:
2388 qemu_log_mask(LOG_UNIMP, "Unsupported setsockopt level=%d optname=%d\n",
2389 level, optname);
2390 ret = -TARGET_ENOPROTOOPT;
2391 }
2392 return ret;
2393 }
2394
2395 /* do_getsockopt() Must return target values and target errnos. */
2396 static abi_long do_getsockopt(int sockfd, int level, int optname,
2397 abi_ulong optval_addr, abi_ulong optlen)
2398 {
2399 abi_long ret;
2400 int len, val;
2401 socklen_t lv;
2402
2403 switch(level) {
2404 case TARGET_SOL_SOCKET:
2405 level = SOL_SOCKET;
2406 switch (optname) {
2407 /* These don't just return a single integer */
2408 case TARGET_SO_PEERNAME:
2409 goto unimplemented;
2410 case TARGET_SO_RCVTIMEO: {
2411 struct timeval tv;
2412 socklen_t tvlen;
2413
2414 optname = SO_RCVTIMEO;
2415
2416 get_timeout:
2417 if (get_user_u32(len, optlen)) {
2418 return -TARGET_EFAULT;
2419 }
2420 if (len < 0) {
2421 return -TARGET_EINVAL;
2422 }
2423
2424 tvlen = sizeof(tv);
2425 ret = get_errno(getsockopt(sockfd, level, optname,
2426 &tv, &tvlen));
2427 if (ret < 0) {
2428 return ret;
2429 }
2430 if (len > sizeof(struct target_timeval)) {
2431 len = sizeof(struct target_timeval);
2432 }
2433 if (copy_to_user_timeval(optval_addr, &tv)) {
2434 return -TARGET_EFAULT;
2435 }
2436 if (put_user_u32(len, optlen)) {
2437 return -TARGET_EFAULT;
2438 }
2439 break;
2440 }
2441 case TARGET_SO_SNDTIMEO:
2442 optname = SO_SNDTIMEO;
2443 goto get_timeout;
2444 case TARGET_SO_PEERCRED: {
2445 struct ucred cr;
2446 socklen_t crlen;
2447 struct target_ucred *tcr;
2448
2449 if (get_user_u32(len, optlen)) {
2450 return -TARGET_EFAULT;
2451 }
2452 if (len < 0) {
2453 return -TARGET_EINVAL;
2454 }
2455
2456 crlen = sizeof(cr);
2457 ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED,
2458 &cr, &crlen));
2459 if (ret < 0) {
2460 return ret;
2461 }
2462 if (len > crlen) {
2463 len = crlen;
2464 }
2465 if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) {
2466 return -TARGET_EFAULT;
2467 }
2468 __put_user(cr.pid, &tcr->pid);
2469 __put_user(cr.uid, &tcr->uid);
2470 __put_user(cr.gid, &tcr->gid);
2471 unlock_user_struct(tcr, optval_addr, 1);
2472 if (put_user_u32(len, optlen)) {
2473 return -TARGET_EFAULT;
2474 }
2475 break;
2476 }
2477 case TARGET_SO_PEERSEC: {
2478 char *name;
2479
2480 if (get_user_u32(len, optlen)) {
2481 return -TARGET_EFAULT;
2482 }
2483 if (len < 0) {
2484 return -TARGET_EINVAL;
2485 }
2486 name = lock_user(VERIFY_WRITE, optval_addr, len, 0);
2487 if (!name) {
2488 return -TARGET_EFAULT;
2489 }
2490 lv = len;
2491 ret = get_errno(getsockopt(sockfd, level, SO_PEERSEC,
2492 name, &lv));
2493 if (put_user_u32(lv, optlen)) {
2494 ret = -TARGET_EFAULT;
2495 }
2496 unlock_user(name, optval_addr, lv);
2497 break;
2498 }
2499 case TARGET_SO_LINGER:
2500 {
2501 struct linger lg;
2502 socklen_t lglen;
2503 struct target_linger *tlg;
2504
2505 if (get_user_u32(len, optlen)) {
2506 return -TARGET_EFAULT;
2507 }
2508 if (len < 0) {
2509 return -TARGET_EINVAL;
2510 }
2511
2512 lglen = sizeof(lg);
2513 ret = get_errno(getsockopt(sockfd, level, SO_LINGER,
2514 &lg, &lglen));
2515 if (ret < 0) {
2516 return ret;
2517 }
2518 if (len > lglen) {
2519 len = lglen;
2520 }
2521 if (!lock_user_struct(VERIFY_WRITE, tlg, optval_addr, 0)) {
2522 return -TARGET_EFAULT;
2523 }
2524 __put_user(lg.l_onoff, &tlg->l_onoff);
2525 __put_user(lg.l_linger, &tlg->l_linger);
2526 unlock_user_struct(tlg, optval_addr, 1);
2527 if (put_user_u32(len, optlen)) {
2528 return -TARGET_EFAULT;
2529 }
2530 break;
2531 }
2532 /* Options with 'int' argument. */
2533 case TARGET_SO_DEBUG:
2534 optname = SO_DEBUG;
2535 goto int_case;
2536 case TARGET_SO_REUSEADDR:
2537 optname = SO_REUSEADDR;
2538 goto int_case;
2539 #ifdef SO_REUSEPORT
2540 case TARGET_SO_REUSEPORT:
2541 optname = SO_REUSEPORT;
2542 goto int_case;
2543 #endif
2544 case TARGET_SO_TYPE:
2545 optname = SO_TYPE;
2546 goto int_case;
2547 case TARGET_SO_ERROR:
2548 optname = SO_ERROR;
2549 goto int_case;
2550 case TARGET_SO_DONTROUTE:
2551 optname = SO_DONTROUTE;
2552 goto int_case;
2553 case TARGET_SO_BROADCAST:
2554 optname = SO_BROADCAST;
2555 goto int_case;
2556 case TARGET_SO_SNDBUF:
2557 optname = SO_SNDBUF;
2558 goto int_case;
2559 case TARGET_SO_RCVBUF:
2560 optname = SO_RCVBUF;
2561 goto int_case;
2562 case TARGET_SO_KEEPALIVE:
2563 optname = SO_KEEPALIVE;
2564 goto int_case;
2565 case TARGET_SO_OOBINLINE:
2566 optname = SO_OOBINLINE;
2567 goto int_case;
2568 case TARGET_SO_NO_CHECK:
2569 optname = SO_NO_CHECK;
2570 goto int_case;
2571 case TARGET_SO_PRIORITY:
2572 optname = SO_PRIORITY;
2573 goto int_case;
2574 #ifdef SO_BSDCOMPAT
2575 case TARGET_SO_BSDCOMPAT:
2576 optname = SO_BSDCOMPAT;
2577 goto int_case;
2578 #endif
2579 case TARGET_SO_PASSCRED:
2580 optname = SO_PASSCRED;
2581 goto int_case;
2582 case TARGET_SO_TIMESTAMP:
2583 optname = SO_TIMESTAMP;
2584 goto int_case;
2585 case TARGET_SO_RCVLOWAT:
2586 optname = SO_RCVLOWAT;
2587 goto int_case;
2588 case TARGET_SO_ACCEPTCONN:
2589 optname = SO_ACCEPTCONN;
2590 goto int_case;
2591 default:
2592 goto int_case;
2593 }
2594 break;
2595 case SOL_TCP:
2596 /* TCP options all take an 'int' value. */
2597 int_case:
2598 if (get_user_u32(len, optlen))
2599 return -TARGET_EFAULT;
2600 if (len < 0)
2601 return -TARGET_EINVAL;
2602 lv = sizeof(lv);
2603 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2604 if (ret < 0)
2605 return ret;
2606 if (optname == SO_TYPE) {
2607 val = host_to_target_sock_type(val);
2608 }
2609 if (len > lv)
2610 len = lv;
2611 if (len == 4) {
2612 if (put_user_u32(val, optval_addr))
2613 return -TARGET_EFAULT;
2614 } else {
2615 if (put_user_u8(val, optval_addr))
2616 return -TARGET_EFAULT;
2617 }
2618 if (put_user_u32(len, optlen))
2619 return -TARGET_EFAULT;
2620 break;
2621 case SOL_IP:
2622 switch(optname) {
2623 case IP_TOS:
2624 case IP_TTL:
2625 case IP_HDRINCL:
2626 case IP_ROUTER_ALERT:
2627 case IP_RECVOPTS:
2628 case IP_RETOPTS:
2629 case IP_PKTINFO:
2630 case IP_MTU_DISCOVER:
2631 case IP_RECVERR:
2632 case IP_RECVTOS:
2633 #ifdef IP_FREEBIND
2634 case IP_FREEBIND:
2635 #endif
2636 case IP_MULTICAST_TTL:
2637 case IP_MULTICAST_LOOP:
2638 if (get_user_u32(len, optlen))
2639 return -TARGET_EFAULT;
2640 if (len < 0)
2641 return -TARGET_EINVAL;
2642 lv = sizeof(lv);
2643 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2644 if (ret < 0)
2645 return ret;
2646 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2647 len = 1;
2648 if (put_user_u32(len, optlen)
2649 || put_user_u8(val, optval_addr))
2650 return -TARGET_EFAULT;
2651 } else {
2652 if (len > sizeof(int))
2653 len = sizeof(int);
2654 if (put_user_u32(len, optlen)
2655 || put_user_u32(val, optval_addr))
2656 return -TARGET_EFAULT;
2657 }
2658 break;
2659 default:
2660 ret = -TARGET_ENOPROTOOPT;
2661 break;
2662 }
2663 break;
2664 case SOL_IPV6:
2665 switch (optname) {
2666 case IPV6_MTU_DISCOVER:
2667 case IPV6_MTU:
2668 case IPV6_V6ONLY:
2669 case IPV6_RECVPKTINFO:
2670 case IPV6_UNICAST_HOPS:
2671 case IPV6_MULTICAST_HOPS:
2672 case IPV6_MULTICAST_LOOP:
2673 case IPV6_RECVERR:
2674 case IPV6_RECVHOPLIMIT:
2675 case IPV6_2292HOPLIMIT:
2676 case IPV6_CHECKSUM:
2677 case IPV6_ADDRFORM:
2678 case IPV6_2292PKTINFO:
2679 case IPV6_RECVTCLASS:
2680 case IPV6_RECVRTHDR:
2681 case IPV6_2292RTHDR:
2682 case IPV6_RECVHOPOPTS:
2683 case IPV6_2292HOPOPTS:
2684 case IPV6_RECVDSTOPTS:
2685 case IPV6_2292DSTOPTS:
2686 case IPV6_TCLASS:
2687 #ifdef IPV6_RECVPATHMTU
2688 case IPV6_RECVPATHMTU:
2689 #endif
2690 #ifdef IPV6_TRANSPARENT
2691 case IPV6_TRANSPARENT:
2692 #endif
2693 #ifdef IPV6_FREEBIND
2694 case IPV6_FREEBIND:
2695 #endif
2696 #ifdef IPV6_RECVORIGDSTADDR
2697 case IPV6_RECVORIGDSTADDR:
2698 #endif
2699 if (get_user_u32(len, optlen))
2700 return -TARGET_EFAULT;
2701 if (len < 0)
2702 return -TARGET_EINVAL;
2703 lv = sizeof(lv);
2704 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2705 if (ret < 0)
2706 return ret;
2707 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2708 len = 1;
2709 if (put_user_u32(len, optlen)
2710 || put_user_u8(val, optval_addr))
2711 return -TARGET_EFAULT;
2712 } else {
2713 if (len > sizeof(int))
2714 len = sizeof(int);
2715 if (put_user_u32(len, optlen)
2716 || put_user_u32(val, optval_addr))
2717 return -TARGET_EFAULT;
2718 }
2719 break;
2720 default:
2721 ret = -TARGET_ENOPROTOOPT;
2722 break;
2723 }
2724 break;
2725 #ifdef SOL_NETLINK
2726 case SOL_NETLINK:
2727 switch (optname) {
2728 case NETLINK_PKTINFO:
2729 case NETLINK_BROADCAST_ERROR:
2730 case NETLINK_NO_ENOBUFS:
2731 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2732 case NETLINK_LISTEN_ALL_NSID:
2733 case NETLINK_CAP_ACK:
2734 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2735 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
2736 case NETLINK_EXT_ACK:
2737 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2738 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
2739 case NETLINK_GET_STRICT_CHK:
2740 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
2741 if (get_user_u32(len, optlen)) {
2742 return -TARGET_EFAULT;
2743 }
2744 if (len != sizeof(val)) {
2745 return -TARGET_EINVAL;
2746 }
2747 lv = len;
2748 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2749 if (ret < 0) {
2750 return ret;
2751 }
2752 if (put_user_u32(lv, optlen)
2753 || put_user_u32(val, optval_addr)) {
2754 return -TARGET_EFAULT;
2755 }
2756 break;
2757 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
2758 case NETLINK_LIST_MEMBERSHIPS:
2759 {
2760 uint32_t *results;
2761 int i;
2762 if (get_user_u32(len, optlen)) {
2763 return -TARGET_EFAULT;
2764 }
2765 if (len < 0) {
2766 return -TARGET_EINVAL;
2767 }
2768 results = lock_user(VERIFY_WRITE, optval_addr, len, 1);
2769 if (!results) {
2770 return -TARGET_EFAULT;
2771 }
2772 lv = len;
2773 ret = get_errno(getsockopt(sockfd, level, optname, results, &lv));
2774 if (ret < 0) {
2775 unlock_user(results, optval_addr, 0);
2776 return ret;
2777 }
2778 /* swap host endianess to target endianess. */
2779 for (i = 0; i < (len / sizeof(uint32_t)); i++) {
2780 results[i] = tswap32(results[i]);
2781 }
2782 if (put_user_u32(lv, optlen)) {
2783 return -TARGET_EFAULT;
2784 }
2785 unlock_user(results, optval_addr, 0);
2786 break;
2787 }
2788 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
2789 default:
2790 goto unimplemented;
2791 }
2792 break;
2793 #endif /* SOL_NETLINK */
2794 default:
2795 unimplemented:
2796 qemu_log_mask(LOG_UNIMP,
2797 "getsockopt level=%d optname=%d not yet supported\n",
2798 level, optname);
2799 ret = -TARGET_EOPNOTSUPP;
2800 break;
2801 }
2802 return ret;
2803 }
2804
2805 /* Convert target low/high pair representing file offset into the host
2806 * low/high pair. This function doesn't handle offsets bigger than 64 bits
2807 * as the kernel doesn't handle them either.
2808 */
2809 static void target_to_host_low_high(abi_ulong tlow,
2810 abi_ulong thigh,
2811 unsigned long *hlow,
2812 unsigned long *hhigh)
2813 {
2814 uint64_t off = tlow |
2815 ((unsigned long long)thigh << TARGET_LONG_BITS / 2) <<
2816 TARGET_LONG_BITS / 2;
2817
2818 *hlow = off;
2819 *hhigh = (off >> HOST_LONG_BITS / 2) >> HOST_LONG_BITS / 2;
2820 }
2821
2822 static struct iovec *lock_iovec(int type, abi_ulong target_addr,
2823 abi_ulong count, int copy)
2824 {
2825 struct target_iovec *target_vec;
2826 struct iovec *vec;
2827 abi_ulong total_len, max_len;
2828 int i;
2829 int err = 0;
2830 bool bad_address = false;
2831
2832 if (count == 0) {
2833 errno = 0;
2834 return NULL;
2835 }
2836 if (count > IOV_MAX) {
2837 errno = EINVAL;
2838 return NULL;
2839 }
2840
2841 vec = g_try_new0(struct iovec, count);
2842 if (vec == NULL) {
2843 errno = ENOMEM;
2844 return NULL;
2845 }
2846
2847 target_vec = lock_user(VERIFY_READ, target_addr,
2848 count * sizeof(struct target_iovec), 1);
2849 if (target_vec == NULL) {
2850 err = EFAULT;
2851 goto fail2;
2852 }
2853
2854 /* ??? If host page size > target page size, this will result in a
2855 value larger than what we can actually support. */
2856 max_len = 0x7fffffff & TARGET_PAGE_MASK;
2857 total_len = 0;
2858
2859 for (i = 0; i < count; i++) {
2860 abi_ulong base = tswapal(target_vec[i].iov_base);
2861 abi_long len = tswapal(target_vec[i].iov_len);
2862
2863 if (len < 0) {
2864 err = EINVAL;
2865 goto fail;
2866 } else if (len == 0) {
2867 /* Zero length pointer is ignored. */
2868 vec[i].iov_base = 0;
2869 } else {
2870 vec[i].iov_base = lock_user(type, base, len, copy);
2871 /* If the first buffer pointer is bad, this is a fault. But
2872 * subsequent bad buffers will result in a partial write; this
2873 * is realized by filling the vector with null pointers and
2874 * zero lengths. */
2875 if (!vec[i].iov_base) {
2876 if (i == 0) {
2877 err = EFAULT;
2878 goto fail;
2879 } else {
2880 bad_address = true;
2881 }
2882 }
2883 if (bad_address) {
2884 len = 0;
2885 }
2886 if (len > max_len - total_len) {
2887 len = max_len - total_len;
2888 }
2889 }
2890 vec[i].iov_len = len;
2891 total_len += len;
2892 }
2893
2894 unlock_user(target_vec, target_addr, 0);
2895 return vec;
2896
2897 fail:
2898 while (--i >= 0) {
2899 if (tswapal(target_vec[i].iov_len) > 0) {
2900 unlock_user(vec[i].iov_base, tswapal(target_vec[i].iov_base), 0);
2901 }
2902 }
2903 unlock_user(target_vec, target_addr, 0);
2904 fail2:
2905 g_free(vec);
2906 errno = err;
2907 return NULL;
2908 }
2909
2910 static void unlock_iovec(struct iovec *vec, abi_ulong target_addr,
2911 abi_ulong count, int copy)
2912 {
2913 struct target_iovec *target_vec;
2914 int i;
2915
2916 target_vec = lock_user(VERIFY_READ, target_addr,
2917 count * sizeof(struct target_iovec), 1);
2918 if (target_vec) {
2919 for (i = 0; i < count; i++) {
2920 abi_ulong base = tswapal(target_vec[i].iov_base);
2921 abi_long len = tswapal(target_vec[i].iov_len);
2922 if (len < 0) {
2923 break;
2924 }
2925 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
2926 }
2927 unlock_user(target_vec, target_addr, 0);
2928 }
2929
2930 g_free(vec);
2931 }
2932
2933 static inline int target_to_host_sock_type(int *type)
2934 {
2935 int host_type = 0;
2936 int target_type = *type;
2937
2938 switch (target_type & TARGET_SOCK_TYPE_MASK) {
2939 case TARGET_SOCK_DGRAM:
2940 host_type = SOCK_DGRAM;
2941 break;
2942 case TARGET_SOCK_STREAM:
2943 host_type = SOCK_STREAM;
2944 break;
2945 default:
2946 host_type = target_type & TARGET_SOCK_TYPE_MASK;
2947 break;
2948 }
2949 if (target_type & TARGET_SOCK_CLOEXEC) {
2950 #if defined(SOCK_CLOEXEC)
2951 host_type |= SOCK_CLOEXEC;
2952 #else
2953 return -TARGET_EINVAL;
2954 #endif
2955 }
2956 if (target_type & TARGET_SOCK_NONBLOCK) {
2957 #if defined(SOCK_NONBLOCK)
2958 host_type |= SOCK_NONBLOCK;
2959 #elif !defined(O_NONBLOCK)
2960 return -TARGET_EINVAL;
2961 #endif
2962 }
2963 *type = host_type;
2964 return 0;
2965 }
2966
2967 /* Try to emulate socket type flags after socket creation. */
2968 static int sock_flags_fixup(int fd, int target_type)
2969 {
2970 #if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
2971 if (target_type & TARGET_SOCK_NONBLOCK) {
2972 int flags = fcntl(fd, F_GETFL);
2973 if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) {
2974 close(fd);
2975 return -TARGET_EINVAL;
2976 }
2977 }
2978 #endif
2979 return fd;
2980 }
2981
2982 /* do_socket() Must return target values and target errnos. */
2983 static abi_long do_socket(int domain, int type, int protocol)
2984 {
2985 int target_type = type;
2986 int ret;
2987
2988 ret = target_to_host_sock_type(&type);
2989 if (ret) {
2990 return ret;
2991 }
2992
2993 if (domain == PF_NETLINK && !(
2994 #ifdef CONFIG_RTNETLINK
2995 protocol == NETLINK_ROUTE ||
2996 #endif
2997 protocol == NETLINK_KOBJECT_UEVENT ||
2998 protocol == NETLINK_AUDIT)) {
2999 return -TARGET_EPROTONOSUPPORT;
3000 }
3001
3002 if (domain == AF_PACKET ||
3003 (domain == AF_INET && type == SOCK_PACKET)) {
3004 protocol = tswap16(protocol);
3005 }
3006
3007 ret = get_errno(socket(domain, type, protocol));
3008 if (ret >= 0) {
3009 ret = sock_flags_fixup(ret, target_type);
3010 if (type == SOCK_PACKET) {
3011 /* Manage an obsolete case :
3012 * if socket type is SOCK_PACKET, bind by name
3013 */
3014 fd_trans_register(ret, &target_packet_trans);
3015 } else if (domain == PF_NETLINK) {
3016 switch (protocol) {
3017 #ifdef CONFIG_RTNETLINK
3018 case NETLINK_ROUTE:
3019 fd_trans_register(ret, &target_netlink_route_trans);
3020 break;
3021 #endif
3022 case NETLINK_KOBJECT_UEVENT:
3023 /* nothing to do: messages are strings */
3024 break;
3025 case NETLINK_AUDIT:
3026 fd_trans_register(ret, &target_netlink_audit_trans);
3027 break;
3028 default:
3029 g_assert_not_reached();
3030 }
3031 }
3032 }
3033 return ret;
3034 }
3035
3036 /* do_bind() Must return target values and target errnos. */
3037 static abi_long do_bind(int sockfd, abi_ulong target_addr,
3038 socklen_t addrlen)
3039 {
3040 void *addr;
3041 abi_long ret;
3042
3043 if ((int)addrlen < 0) {
3044 return -TARGET_EINVAL;
3045 }
3046
3047 addr = alloca(addrlen+1);
3048
3049 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
3050 if (ret)
3051 return ret;
3052
3053 return get_errno(bind(sockfd, addr, addrlen));
3054 }
3055
3056 /* do_connect() Must return target values and target errnos. */
3057 static abi_long do_connect(int sockfd, abi_ulong target_addr,
3058 socklen_t addrlen)
3059 {
3060 void *addr;
3061 abi_long ret;
3062
3063 if ((int)addrlen < 0) {
3064 return -TARGET_EINVAL;
3065 }
3066
3067 addr = alloca(addrlen+1);
3068
3069 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
3070 if (ret)
3071 return ret;
3072
3073 return get_errno(safe_connect(sockfd, addr, addrlen));
3074 }
3075
3076 /* do_sendrecvmsg_locked() Must return target values and target errnos. */
3077 static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp,
3078 int flags, int send)
3079 {
3080 abi_long ret, len;
3081 struct msghdr msg;
3082 abi_ulong count;
3083 struct iovec *vec;
3084 abi_ulong target_vec;
3085
3086 if (msgp->msg_name) {
3087 msg.msg_namelen = tswap32(msgp->msg_namelen);
3088 msg.msg_name = alloca(msg.msg_namelen+1);
3089 ret = target_to_host_sockaddr(fd, msg.msg_name,
3090 tswapal(msgp->msg_name),
3091 msg.msg_namelen);
3092 if (ret == -TARGET_EFAULT) {
3093 /* For connected sockets msg_name and msg_namelen must
3094 * be ignored, so returning EFAULT immediately is wrong.
3095 * Instead, pass a bad msg_name to the host kernel, and
3096 * let it decide whether to return EFAULT or not.
3097 */
3098 msg.msg_name = (void *)-1;
3099 } else if (ret) {
3100 goto out2;
3101 }
3102 } else {
3103 msg.msg_name = NULL;
3104 msg.msg_namelen = 0;
3105 }
3106 msg.msg_controllen = 2 * tswapal(msgp->msg_controllen);
3107 msg.msg_control = alloca(msg.msg_controllen);
3108 memset(msg.msg_control, 0, msg.msg_controllen);
3109
3110 msg.msg_flags = tswap32(msgp->msg_flags);
3111
3112 count = tswapal(msgp->msg_iovlen);
3113 target_vec = tswapal(msgp->msg_iov);
3114
3115 if (count > IOV_MAX) {
3116 /* sendrcvmsg returns a different errno for this condition than
3117 * readv/writev, so we must catch it here before lock_iovec() does.
3118 */
3119 ret = -TARGET_EMSGSIZE;
3120 goto out2;
3121 }
3122
3123 vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,
3124 target_vec, count, send);
3125 if (vec == NULL) {
3126 ret = -host_to_target_errno(errno);
3127 goto out2;
3128 }
3129 msg.msg_iovlen = count;
3130 msg.msg_iov = vec;
3131
3132 if (send) {
3133 if (fd_trans_target_to_host_data(fd)) {
3134 void *host_msg;
3135
3136 host_msg = g_malloc(msg.msg_iov->iov_len);
3137 memcpy(host_msg, msg.msg_iov->iov_base, msg.msg_iov->iov_len);
3138 ret = fd_trans_target_to_host_data(fd)(host_msg,
3139 msg.msg_iov->iov_len);
3140 if (ret >= 0) {
3141 msg.msg_iov->iov_base = host_msg;
3142 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3143 }
3144 g_free(host_msg);
3145 } else {
3146 ret = target_to_host_cmsg(&msg, msgp);
3147 if (ret == 0) {
3148 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3149 }
3150 }
3151 } else {
3152 ret = get_errno(safe_recvmsg(fd, &msg, flags));
3153 if (!is_error(ret)) {
3154 len = ret;
3155 if (fd_trans_host_to_target_data(fd)) {
3156 ret = fd_trans_host_to_target_data(fd)(msg.msg_iov->iov_base,
3157 MIN(msg.msg_iov->iov_len, len));
3158 } else {
3159 ret = host_to_target_cmsg(msgp, &msg);
3160 }
3161 if (!is_error(ret)) {
3162 msgp->msg_namelen = tswap32(msg.msg_namelen);
3163 msgp->msg_flags = tswap32(msg.msg_flags);
3164 if (msg.msg_name != NULL && msg.msg_name != (void *)-1) {
3165 ret = host_to_target_sockaddr(tswapal(msgp->msg_name),
3166 msg.msg_name, msg.msg_namelen);
3167 if (ret) {
3168 goto out;
3169 }
3170 }
3171
3172 ret = len;
3173 }
3174 }
3175 }
3176
3177 out:
3178 unlock_iovec(vec, target_vec, count, !send);
3179 out2:
3180 return ret;
3181 }
3182
3183 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
3184 int flags, int send)
3185 {
3186 abi_long ret;
3187 struct target_msghdr *msgp;
3188
3189 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
3190 msgp,
3191 target_msg,
3192 send ? 1 : 0)) {
3193 return -TARGET_EFAULT;
3194 }
3195 ret = do_sendrecvmsg_locked(fd, msgp, flags, send);
3196 unlock_user_struct(msgp, target_msg, send ? 0 : 1);
3197 return ret;
3198 }
3199
3200 /* We don't rely on the C library to have sendmmsg/recvmmsg support,
3201 * so it might not have this *mmsg-specific flag either.
3202 */
3203 #ifndef MSG_WAITFORONE
3204 #define MSG_WAITFORONE 0x10000
3205 #endif
3206
3207 static abi_long do_sendrecvmmsg(int fd, abi_ulong target_msgvec,
3208 unsigned int vlen, unsigned int flags,
3209 int send)
3210 {
3211 struct target_mmsghdr *mmsgp;
3212 abi_long ret = 0;
3213 int i;
3214
3215 if (vlen > UIO_MAXIOV) {
3216 vlen = UIO_MAXIOV;
3217 }
3218
3219 mmsgp = lock_user(VERIFY_WRITE, target_msgvec, sizeof(*mmsgp) * vlen, 1);
3220 if (!mmsgp) {
3221 return -TARGET_EFAULT;
3222 }
3223
3224 for (i = 0; i < vlen; i++) {
3225 ret = do_sendrecvmsg_locked(fd, &mmsgp[i].msg_hdr, flags, send);
3226 if (is_error(ret)) {
3227 break;
3228 }
3229 mmsgp[i].msg_len = tswap32(ret);
3230 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3231 if (flags & MSG_WAITFORONE) {
3232 flags |= MSG_DONTWAIT;
3233 }
3234 }
3235
3236 unlock_user(mmsgp, target_msgvec, sizeof(*mmsgp) * i);
3237
3238 /* Return number of datagrams sent if we sent any at all;
3239 * otherwise return the error.
3240 */
3241 if (i) {
3242 return i;
3243 }
3244 return ret;
3245 }
3246
3247 /* do_accept4() Must return target values and target errnos. */
3248 static abi_long do_accept4(int fd, abi_ulong target_addr,
3249 abi_ulong target_addrlen_addr, int flags)
3250 {
3251 socklen_t addrlen, ret_addrlen;
3252 void *addr;
3253 abi_long ret;
3254 int host_flags;
3255
3256 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
3257
3258 if (target_addr == 0) {
3259 return get_errno(safe_accept4(fd, NULL, NULL, host_flags));
3260 }
3261
3262 /* linux returns EINVAL if addrlen pointer is invalid */
3263 if (get_user_u32(addrlen, target_addrlen_addr))
3264 return -TARGET_EINVAL;
3265
3266 if ((int)addrlen < 0) {
3267 return -TARGET_EINVAL;
3268 }
3269
3270 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3271 return -TARGET_EINVAL;
3272
3273 addr = alloca(addrlen);
3274
3275 ret_addrlen = addrlen;
3276 ret = get_errno(safe_accept4(fd, addr, &ret_addrlen, host_flags));
3277 if (!is_error(ret)) {
3278 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3279 if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3280 ret = -TARGET_EFAULT;
3281 }
3282 }
3283 return ret;
3284 }
3285
3286 /* do_getpeername() Must return target values and target errnos. */
3287 static abi_long do_getpeername(int fd, abi_ulong target_addr,
3288 abi_ulong target_addrlen_addr)
3289 {
3290 socklen_t addrlen, ret_addrlen;
3291 void *addr;
3292 abi_long ret;
3293
3294 if (get_user_u32(addrlen, target_addrlen_addr))
3295 return -TARGET_EFAULT;
3296
3297 if ((int)addrlen < 0) {
3298 return -TARGET_EINVAL;
3299 }
3300
3301 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3302 return -TARGET_EFAULT;
3303
3304 addr = alloca(addrlen);
3305
3306 ret_addrlen = addrlen;
3307 ret = get_errno(getpeername(fd, addr, &ret_addrlen));
3308 if (!is_error(ret)) {
3309 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3310 if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3311 ret = -TARGET_EFAULT;
3312 }
3313 }
3314 return ret;
3315 }
3316
3317 /* do_getsockname() Must return target values and target errnos. */
3318 static abi_long do_getsockname(int fd, abi_ulong target_addr,
3319 abi_ulong target_addrlen_addr)
3320 {
3321 socklen_t addrlen, ret_addrlen;
3322 void *addr;
3323 abi_long ret;
3324
3325 if (get_user_u32(addrlen, target_addrlen_addr))
3326 return -TARGET_EFAULT;
3327
3328 if ((int)addrlen < 0) {
3329 return -TARGET_EINVAL;
3330 }
3331
3332 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3333 return -TARGET_EFAULT;
3334
3335 addr = alloca(addrlen);
3336
3337 ret_addrlen = addrlen;
3338 ret = get_errno(getsockname(fd, addr, &ret_addrlen));
3339 if (!is_error(ret)) {
3340 host_to_target_sockaddr(target_addr, addr, MIN(addrlen, ret_addrlen));
3341 if (put_user_u32(ret_addrlen, target_addrlen_addr)) {
3342 ret = -TARGET_EFAULT;
3343 }
3344 }
3345 return ret;
3346 }
3347
3348 /* do_socketpair() Must return target values and target errnos. */
3349 static abi_long do_socketpair(int domain, int type, int protocol,
3350 abi_ulong target_tab_addr)
3351 {
3352 int tab[2];
3353 abi_long ret;
3354
3355 target_to_host_sock_type(&type);
3356
3357 ret = get_errno(socketpair(domain, type, protocol, tab));
3358 if (!is_error(ret)) {
3359 if (put_user_s32(tab[0], target_tab_addr)
3360 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
3361 ret = -TARGET_EFAULT;
3362 }
3363 return ret;
3364 }
3365
3366 /* do_sendto() Must return target values and target errnos. */
3367 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
3368 abi_ulong target_addr, socklen_t addrlen)
3369 {
3370 void *addr;
3371 void *host_msg;
3372 void *copy_msg = NULL;
3373 abi_long ret;
3374
3375 if ((int)addrlen < 0) {
3376 return -TARGET_EINVAL;
3377 }
3378
3379 host_msg = lock_user(VERIFY_READ, msg, len, 1);
3380 if (!host_msg)
3381 return -TARGET_EFAULT;
3382 if (fd_trans_target_to_host_data(fd)) {
3383 copy_msg = host_msg;
3384 host_msg = g_malloc(len);
3385 memcpy(host_msg, copy_msg, len);
3386 ret = fd_trans_target_to_host_data(fd)(host_msg, len);
3387 if (ret < 0) {
3388 goto fail;
3389 }
3390 }
3391 if (target_addr) {
3392 addr = alloca(addrlen+1);
3393 ret = target_to_host_sockaddr(fd, addr, target_addr, addrlen);
3394 if (ret) {
3395 goto fail;
3396 }
3397 ret = get_errno(safe_sendto(fd, host_msg, len, flags, addr, addrlen));
3398 } else {
3399 ret = get_errno(safe_sendto(fd, host_msg, len, flags, NULL, 0));
3400 }
3401 fail:
3402 if (copy_msg) {
3403 g_free(host_msg);
3404 host_msg = copy_msg;
3405 }
3406 unlock_user(host_msg, msg, 0);
3407 return ret;
3408 }
3409
3410 /* do_recvfrom() Must return target values and target errnos. */
3411 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
3412 abi_ulong target_addr,
3413 abi_ulong target_addrlen)
3414 {
3415 socklen_t addrlen, ret_addrlen;
3416 void *addr;
3417 void *host_msg;
3418 abi_long ret;
3419
3420 host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
3421 if (!host_msg)
3422 return -TARGET_EFAULT;
3423 if (target_addr) {
3424 if (get_user_u32(addrlen, target_addrlen)) {
3425 ret = -TARGET_EFAULT;
3426 goto fail;
3427 }
3428 if ((int)addrlen < 0) {
3429 ret = -TARGET_EINVAL;
3430 goto fail;
3431 }
3432 addr = alloca(addrlen);
3433 ret_addrlen = addrlen;
3434 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags,
3435 addr, &ret_addrlen));
3436 } else {
3437 addr = NULL; /* To keep compiler quiet. */
3438 addrlen = 0; /* To keep compiler quiet. */
3439 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, NULL, 0));
3440 }
3441 if (!is_error(ret)) {
3442 if (fd_trans_host_to_target_data(fd)) {
3443 abi_long trans;
3444 trans = fd_trans_host_to_target_data(fd)(host_msg, MIN(ret, len));
3445 if (is_error(trans)) {
3446 ret = trans;
3447 goto fail;
3448 }
3449 }
3450 if (target_addr) {
3451 host_to_target_sockaddr(target_addr, addr,
3452 MIN(addrlen, ret_addrlen));
3453 if (put_user_u32(ret_addrlen, target_addrlen)) {
3454 ret = -TARGET_EFAULT;
3455 goto fail;
3456 }
3457 }
3458 unlock_user(host_msg, msg, len);
3459 } else {
3460 fail:
3461 unlock_user(host_msg, msg, 0);
3462 }
3463 return ret;
3464 }
3465
3466 #ifdef TARGET_NR_socketcall
3467 /* do_socketcall() must return target values and target errnos. */
3468 static abi_long do_socketcall(int num, abi_ulong vptr)
3469 {
3470 static const unsigned nargs[] = { /* number of arguments per operation */
3471 [TARGET_SYS_SOCKET] = 3, /* domain, type, protocol */
3472 [TARGET_SYS_BIND] = 3, /* fd, addr, addrlen */
3473 [TARGET_SYS_CONNECT] = 3, /* fd, addr, addrlen */
3474 [TARGET_SYS_LISTEN] = 2, /* fd, backlog */
3475 [TARGET_SYS_ACCEPT] = 3, /* fd, addr, addrlen */
3476 [TARGET_SYS_GETSOCKNAME] = 3, /* fd, addr, addrlen */
3477 [TARGET_SYS_GETPEERNAME] = 3, /* fd, addr, addrlen */
3478 [TARGET_SYS_SOCKETPAIR] = 4, /* domain, type, protocol, tab */
3479 [TARGET_SYS_SEND] = 4, /* fd, msg, len, flags */
3480 [TARGET_SYS_RECV] = 4, /* fd, msg, len, flags */
3481 [TARGET_SYS_SENDTO] = 6, /* fd, msg, len, flags, addr, addrlen */
3482 [TARGET_SYS_RECVFROM] = 6, /* fd, msg, len, flags, addr, addrlen */
3483 [TARGET_SYS_SHUTDOWN] = 2, /* fd, how */
3484 [TARGET_SYS_SETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
3485 [TARGET_SYS_GETSOCKOPT] = 5, /* fd, level, optname, optval, optlen */
3486 [TARGET_SYS_SENDMSG] = 3, /* fd, msg, flags */
3487 [TARGET_SYS_RECVMSG] = 3, /* fd, msg, flags */
3488 [TARGET_SYS_ACCEPT4] = 4, /* fd, addr, addrlen, flags */
3489 [TARGET_SYS_RECVMMSG] = 4, /* fd, msgvec, vlen, flags */
3490 [TARGET_SYS_SENDMMSG] = 4, /* fd, msgvec, vlen, flags */
3491 };
3492 abi_long a[6]; /* max 6 args */
3493 unsigned i;
3494
3495 /* check the range of the first argument num */
3496 /* (TARGET_SYS_SENDMMSG is the highest among TARGET_SYS_xxx) */
3497 if (num < 1 || num > TARGET_SYS_SENDMMSG) {
3498 return -TARGET_EINVAL;
3499 }
3500 /* ensure we have space for args */
3501 if (nargs[num] > ARRAY_SIZE(a)) {
3502 return -TARGET_EINVAL;
3503 }
3504 /* collect the arguments in a[] according to nargs[] */
3505 for (i = 0; i < nargs[num]; ++i) {
3506 if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
3507 return -TARGET_EFAULT;
3508 }
3509 }
3510 /* now when we have the args, invoke the appropriate underlying function */
3511 switch (num) {
3512 case TARGET_SYS_SOCKET: /* domain, type, protocol */
3513 return do_socket(a[0], a[1], a[2]);
3514 case TARGET_SYS_BIND: /* sockfd, addr, addrlen */
3515 return do_bind(a[0], a[1], a[2]);
3516 case TARGET_SYS_CONNECT: /* sockfd, addr, addrlen */
3517 return do_connect(a[0], a[1], a[2]);
3518 case TARGET_SYS_LISTEN: /* sockfd, backlog */
3519 return get_errno(listen(a[0], a[1]));
3520 case TARGET_SYS_ACCEPT: /* sockfd, addr, addrlen */
3521 return do_accept4(a[0], a[1], a[2], 0);
3522 case TARGET_SYS_GETSOCKNAME: /* sockfd, addr, addrlen */
3523 return do_getsockname(a[0], a[1], a[2]);
3524 case TARGET_SYS_GETPEERNAME: /* sockfd, addr, addrlen */
3525 return do_getpeername(a[0], a[1], a[2]);
3526 case TARGET_SYS_SOCKETPAIR: /* domain, type, protocol, tab */
3527 return do_socketpair(a[0], a[1], a[2], a[3]);
3528 case TARGET_SYS_SEND: /* sockfd, msg, len, flags */
3529 return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
3530 case TARGET_SYS_RECV: /* sockfd, msg, len, flags */
3531 return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
3532 case TARGET_SYS_SENDTO: /* sockfd, msg, len, flags, addr, addrlen */
3533 return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
3534 case TARGET_SYS_RECVFROM: /* sockfd, msg, len, flags, addr, addrlen */
3535 return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
3536 case TARGET_SYS_SHUTDOWN: /* sockfd, how */
3537 return get_errno(shutdown(a[0], a[1]));
3538 case TARGET_SYS_SETSOCKOPT: /* sockfd, level, optname, optval, optlen */
3539 return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
3540 case TARGET_SYS_GETSOCKOPT: /* sockfd, level, optname, optval, optlen */
3541 return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
3542 case TARGET_SYS_SENDMSG: /* sockfd, msg, flags */
3543 return do_sendrecvmsg(a[0], a[1], a[2], 1);
3544 case TARGET_SYS_RECVMSG: /* sockfd, msg, flags */
3545 return do_sendrecvmsg(a[0], a[1], a[2], 0);
3546 case TARGET_SYS_ACCEPT4: /* sockfd, addr, addrlen, flags */
3547 return do_accept4(a[0], a[1], a[2], a[3]);
3548 case TARGET_SYS_RECVMMSG: /* sockfd, msgvec, vlen, flags */
3549 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
3550 case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */
3551 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
3552 default:
3553 qemu_log_mask(LOG_UNIMP, "Unsupported socketcall: %d\n", num);
3554 return -TARGET_EINVAL;
3555 }
3556 }
3557 #endif
3558
3559 #define N_SHM_REGIONS 32
3560
3561 static struct shm_region {
3562 abi_ulong start;
3563 abi_ulong size;
3564 bool in_use;
3565 } shm_regions[N_SHM_REGIONS];
3566
3567 #ifndef TARGET_SEMID64_DS
3568 /* asm-generic version of this struct */
3569 struct target_semid64_ds
3570 {
3571 struct target_ipc_perm sem_perm;
3572 abi_ulong sem_otime;
3573 #if TARGET_ABI_BITS == 32
3574 abi_ulong __unused1;
3575 #endif
3576 abi_ulong sem_ctime;
3577 #if TARGET_ABI_BITS == 32
3578 abi_ulong __unused2;
3579 #endif
3580 abi_ulong sem_nsems;
3581 abi_ulong __unused3;
3582 abi_ulong __unused4;
3583 };
3584 #endif
3585
3586 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
3587 abi_ulong target_addr)
3588 {
3589 struct target_ipc_perm *target_ip;
3590 struct target_semid64_ds *target_sd;
3591
3592 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3593 return -TARGET_EFAULT;
3594 target_ip = &(target_sd->sem_perm);
3595 host_ip->__key = tswap32(target_ip->__key);
3596 host_ip->uid = tswap32(target_ip->uid);
3597 host_ip->gid = tswap32(target_ip->gid);
3598 host_ip->cuid = tswap32(target_ip->cuid);
3599 host_ip->cgid = tswap32(target_ip->cgid);
3600 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3601 host_ip->mode = tswap32(target_ip->mode);
3602 #else
3603 host_ip->mode = tswap16(target_ip->mode);
3604 #endif
3605 #if defined(TARGET_PPC)
3606 host_ip->__seq = tswap32(target_ip->__seq);
3607 #else
3608 host_ip->__seq = tswap16(target_ip->__seq);
3609 #endif
3610 unlock_user_struct(target_sd, target_addr, 0);
3611 return 0;
3612 }
3613
3614 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
3615 struct ipc_perm *host_ip)
3616 {
3617 struct target_ipc_perm *target_ip;
3618 struct target_semid64_ds *target_sd;
3619
3620 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3621 return -TARGET_EFAULT;
3622 target_ip = &(target_sd->sem_perm);
3623 target_ip->__key = tswap32(host_ip->__key);
3624 target_ip->uid = tswap32(host_ip->uid);
3625 target_ip->gid = tswap32(host_ip->gid);
3626 target_ip->cuid = tswap32(host_ip->cuid);
3627 target_ip->cgid = tswap32(host_ip->cgid);
3628 #if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3629 target_ip->mode = tswap32(host_ip->mode);
3630 #else
3631 target_ip->mode = tswap16(host_ip->mode);
3632 #endif
3633 #if defined(TARGET_PPC)
3634 target_ip->__seq = tswap32(host_ip->__seq);
3635 #else
3636 target_ip->__seq = tswap16(host_ip->__seq);
3637 #endif
3638 unlock_user_struct(target_sd, target_addr, 1);
3639 return 0;
3640 }
3641
3642 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
3643 abi_ulong target_addr)
3644 {
3645 struct target_semid64_ds *target_sd;
3646
3647 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3648 return -TARGET_EFAULT;
3649 if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr))
3650 return -TARGET_EFAULT;
3651 host_sd->sem_nsems = tswapal(target_sd->sem_nsems);
3652 host_sd->sem_otime = tswapal(target_sd->sem_otime);
3653 host_sd->sem_ctime = tswapal(target_sd->sem_ctime);
3654 unlock_user_struct(target_sd, target_addr, 0);
3655 return 0;
3656 }
3657
3658 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
3659 struct semid_ds *host_sd)
3660 {
3661 struct target_semid64_ds *target_sd;
3662
3663 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3664 return -TARGET_EFAULT;
3665 if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)))
3666 return -TARGET_EFAULT;
3667 target_sd->sem_nsems = tswapal(host_sd->sem_nsems);
3668 target_sd->sem_otime = tswapal(host_sd->sem_otime);
3669 target_sd->sem_ctime = tswapal(host_sd->sem_ctime);
3670 unlock_user_struct(target_sd, target_addr, 1);
3671 return 0;
3672 }
3673
3674 struct target_seminfo {
3675 int semmap;
3676 int semmni;
3677 int semmns;
3678 int semmnu;
3679 int semmsl;
3680 int semopm;
3681 int semume;
3682 int semusz;
3683 int semvmx;
3684 int semaem;
3685 };
3686
3687 static inline abi_long host_to_target_seminfo(abi_ulong target_addr,
3688 struct seminfo *host_seminfo)
3689 {
3690 struct target_seminfo *target_seminfo;
3691 if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0))
3692 return -TARGET_EFAULT;
3693 __put_user(host_seminfo->semmap, &target_seminfo->semmap);
3694 __put_user(host_seminfo->semmni, &target_seminfo->semmni);
3695 __put_user(host_seminfo->semmns, &target_seminfo->semmns);
3696 __put_user(host_seminfo->semmnu, &target_seminfo->semmnu);
3697 __put_user(host_seminfo->semmsl, &target_seminfo->semmsl);
3698 __put_user(host_seminfo->semopm, &target_seminfo->semopm);
3699 __put_user(host_seminfo->semume, &target_seminfo->semume);
3700 __put_user(host_seminfo->semusz, &target_seminfo->semusz);
3701 __put_user(host_seminfo->semvmx, &target_seminfo->semvmx);
3702 __put_user(host_seminfo->semaem, &target_seminfo->semaem);
3703 unlock_user_struct(target_seminfo, target_addr, 1);
3704 return 0;
3705 }
3706
3707 union semun {
3708 int val;
3709 struct semid_ds *buf;
3710 unsigned short *array;
3711 struct seminfo *__buf;
3712 };
3713
3714 union target_semun {
3715 int val;
3716 abi_ulong buf;
3717 abi_ulong array;
3718 abi_ulong __buf;
3719 };
3720
3721 static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array,
3722 abi_ulong target_addr)
3723 {
3724 int nsems;
3725 unsigned short *array;
3726 union semun semun;
3727 struct semid_ds semid_ds;
3728 int i, ret;
3729
3730 semun.buf = &semid_ds;
3731
3732 ret = semctl(semid, 0, IPC_STAT, semun);
3733 if (ret == -1)
3734 return get_errno(ret);
3735
3736 nsems = semid_ds.sem_nsems;
3737
3738 *host_array = g_try_new(unsigned short, nsems);
3739 if (!*host_array) {
3740 return -TARGET_ENOMEM;
3741 }
3742 array = lock_user(VERIFY_READ, target_addr,
3743 nsems*sizeof(unsigned short), 1);
3744 if (!array) {
3745 g_free(*host_array);
3746 return -TARGET_EFAULT;
3747 }
3748
3749 for(i=0; i<nsems; i++) {
3750 __get_user((*host_array)[i], &array[i]);
3751 }
3752 unlock_user(array, target_addr, 0);
3753
3754 return 0;
3755 }
3756
3757 static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr,
3758 unsigned short **host_array)
3759 {
3760 int nsems;
3761 unsigned short *array;
3762 union semun semun;
3763 struct semid_ds semid_ds;
3764 int i, ret;
3765
3766 semun.buf = &semid_ds;
3767
3768 ret = semctl(semid, 0, IPC_STAT, semun);
3769 if (ret == -1)
3770 return get_errno(ret);
3771
3772 nsems = semid_ds.sem_nsems;
3773
3774 array = lock_user(VERIFY_WRITE, target_addr,
3775 nsems*sizeof(unsigned short), 0);
3776 if (!array)
3777 return -TARGET_EFAULT;
3778
3779 for(i=0; i<nsems; i++) {
3780 __put_user((*host_array)[i], &array[i]);
3781 }
3782 g_free(*host_array);
3783 unlock_user(array, target_addr, 1);
3784
3785 return 0;
3786 }
3787
3788 static inline abi_long do_semctl(int semid, int semnum, int cmd,
3789 abi_ulong target_arg)
3790 {
3791 union target_semun target_su = { .buf = target_arg };
3792 union semun arg;
3793 struct semid_ds dsarg;
3794 unsigned short *array = NULL;
3795 struct seminfo seminfo;
3796 abi_long ret = -TARGET_EINVAL;
3797 abi_long err;
3798 cmd &= 0xff;
3799
3800 switch( cmd ) {
3801 case GETVAL:
3802 case SETVAL:
3803 /* In 64 bit cross-endian situations, we will erroneously pick up
3804 * the wrong half of the union for the "val" element. To rectify
3805 * this, the entire 8-byte structure is byteswapped, followed by
3806 * a swap of the 4 byte val field. In other cases, the data is
3807 * already in proper host byte order. */
3808 if (sizeof(target_su.val) != (sizeof(target_su.buf))) {
3809 target_su.buf = tswapal(target_su.buf);
3810 arg.val = tswap32(target_su.val);
3811 } else {
3812 arg.val = target_su.val;
3813 }
3814 ret = get_errno(semctl(semid, semnum, cmd, arg));
3815 break;
3816 case GETALL:
3817 case SETALL:
3818 err = target_to_host_semarray(semid, &array, target_su.array);
3819 if (err)
3820 return err;
3821 arg.array = array;
3822 ret = get_errno(semctl(semid, semnum, cmd, arg));
3823 err = host_to_target_semarray(semid, target_su.array, &array);
3824 if (err)
3825 return err;
3826 break;
3827 case IPC_STAT:
3828 case IPC_SET:
3829 case SEM_STAT:
3830 err = target_to_host_semid_ds(&dsarg, target_su.buf);
3831 if (err)
3832 return err;
3833 arg.buf = &dsarg;
3834 ret = get_errno(semctl(semid, semnum, cmd, arg));
3835 err = host_to_target_semid_ds(target_su.buf, &dsarg);
3836 if (err)
3837 return err;
3838 break;
3839 case IPC_INFO:
3840 case SEM_INFO:
3841 arg.__buf = &seminfo;
3842 ret = get_errno(semctl(semid, semnum, cmd, arg));
3843 err = host_to_target_seminfo(target_su.__buf, &seminfo);
3844 if (err)
3845 return err;
3846 break;
3847 case IPC_RMID:
3848 case GETPID:
3849 case GETNCNT:
3850 case GETZCNT:
3851 ret = get_errno(semctl(semid, semnum, cmd, NULL));
3852 break;
3853 }
3854
3855 return ret;
3856 }
3857
3858 struct target_sembuf {
3859 unsigned short sem_num;
3860 short sem_op;
3861 short sem_flg;
3862 };
3863
3864 static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
3865 abi_ulong target_addr,
3866 unsigned nsops)
3867 {
3868 struct target_sembuf *target_sembuf;
3869 int i;
3870
3871 target_sembuf = lock_user(VERIFY_READ, target_addr,
3872 nsops*sizeof(struct target_sembuf), 1);
3873 if (!target_sembuf)
3874 return -TARGET_EFAULT;
3875
3876 for(i=0; i<nsops; i++) {
3877 __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num);
3878 __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op);
3879 __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg);
3880 }
3881
3882 unlock_user(target_sembuf, target_addr, 0);
3883
3884 return 0;
3885 }
3886
3887 #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
3888 defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
3889
3890 /*
3891 * This macro is required to handle the s390 variants, which passes the
3892 * arguments in a different order than default.
3893 */
3894 #ifdef __s390x__
3895 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
3896 (__nsops), (__timeout), (__sops)
3897 #else
3898 #define SEMTIMEDOP_IPC_ARGS(__nsops, __sops, __timeout) \
3899 (__nsops), 0, (__sops), (__timeout)
3900 #endif
3901
3902 static inline abi_long do_semtimedop(int semid,
3903 abi_long ptr,
3904 unsigned nsops,
3905 abi_long timeout, bool time64)
3906 {
3907 struct sembuf *sops;
3908 struct timespec ts, *pts = NULL;
3909 abi_long ret;
3910
3911 if (timeout) {
3912 pts = &ts;
3913 if (time64) {
3914 if (target_to_host_timespec64(pts, timeout)) {
3915 return -TARGET_EFAULT;
3916 }
3917 } else {
3918 if (target_to_host_timespec(pts, timeout)) {
3919 return -TARGET_EFAULT;
3920 }
3921 }
3922 }
3923
3924 if (nsops > TARGET_SEMOPM) {
3925 return -TARGET_E2BIG;
3926 }
3927
3928 sops = g_new(struct sembuf, nsops);
3929
3930 if (target_to_host_sembuf(sops, ptr, nsops)) {
3931 g_free(sops);
3932 return -TARGET_EFAULT;
3933 }
3934
3935 ret = -TARGET_ENOSYS;
3936 #ifdef __NR_semtimedop
3937 ret = get_errno(safe_semtimedop(semid, sops, nsops, pts));
3938 #endif
3939 #ifdef __NR_ipc
3940 if (ret == -TARGET_ENOSYS) {
3941 ret = get_errno(safe_ipc(IPCOP_semtimedop, semid,
3942 SEMTIMEDOP_IPC_ARGS(nsops, sops, (long)pts)));
3943 }
3944 #endif
3945 g_free(sops);
3946 return ret;
3947 }
3948 #endif
3949
3950 struct target_msqid_ds
3951 {
3952 struct target_ipc_perm msg_perm;
3953 abi_ulong msg_stime;
3954 #if TARGET_ABI_BITS == 32
3955 abi_ulong __unused1;
3956 #endif
3957 abi_ulong msg_rtime;
3958 #if TARGET_ABI_BITS == 32
3959 abi_ulong __unused2;
3960 #endif
3961 abi_ulong msg_ctime;
3962 #if TARGET_ABI_BITS == 32
3963 abi_ulong __unused3;
3964 #endif
3965 abi_ulong __msg_cbytes;
3966 abi_ulong msg_qnum;
3967 abi_ulong msg_qbytes;
3968 abi_ulong msg_lspid;
3969 abi_ulong msg_lrpid;
3970 abi_ulong __unused4;
3971 abi_ulong __unused5;
3972 };
3973
3974 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
3975 abi_ulong target_addr)
3976 {
3977 struct target_msqid_ds *target_md;
3978
3979 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
3980 return -TARGET_EFAULT;
3981 if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
3982 return -TARGET_EFAULT;
3983 host_md->msg_stime = tswapal(target_md->msg_stime);
3984 host_md->msg_rtime = tswapal(target_md->msg_rtime);
3985 host_md->msg_ctime = tswapal(target_md->msg_ctime);
3986 host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes);
3987 host_md->msg_qnum = tswapal(target_md->msg_qnum);
3988 host_md->msg_qbytes = tswapal(target_md->msg_qbytes);
3989 host_md->msg_lspid = tswapal(target_md->msg_lspid);
3990 host_md->msg_lrpid = tswapal(target_md->msg_lrpid);
3991 unlock_user_struct(target_md, target_addr, 0);
3992 return 0;
3993 }
3994
3995 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
3996 struct msqid_ds *host_md)
3997 {
3998 struct target_msqid_ds *target_md;
3999
4000 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
4001 return -TARGET_EFAULT;
4002 if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
4003 return -TARGET_EFAULT;
4004 target_md->msg_stime = tswapal(host_md->msg_stime);
4005 target_md->msg_rtime = tswapal(host_md->msg_rtime);
4006 target_md->msg_ctime = tswapal(host_md->msg_ctime);
4007 target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes);
4008 target_md->msg_qnum = tswapal(host_md->msg_qnum);
4009 target_md->msg_qbytes = tswapal(host_md->msg_qbytes);
4010 target_md->msg_lspid = tswapal(host_md->msg_lspid);
4011 target_md->msg_lrpid = tswapal(host_md->msg_lrpid);
4012 unlock_user_struct(target_md, target_addr, 1);
4013 return 0;
4014 }
4015
4016 struct target_msginfo {
4017 int msgpool;
4018 int msgmap;
4019 int msgmax;
4020 int msgmnb;
4021 int msgmni;
4022 int msgssz;
4023 int msgtql;
4024 unsigned short int msgseg;
4025 };
4026
4027 static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
4028 struct msginfo *host_msginfo)
4029 {
4030 struct target_msginfo *target_msginfo;
4031 if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
4032 return -TARGET_EFAULT;
4033 __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
4034 __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
4035 __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
4036 __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
4037 __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
4038 __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
4039 __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
4040 __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
4041 unlock_user_struct(target_msginfo, target_addr, 1);
4042 return 0;
4043 }
4044
4045 static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
4046 {
4047 struct msqid_ds dsarg;
4048 struct msginfo msginfo;
4049 abi_long ret = -TARGET_EINVAL;
4050
4051 cmd &= 0xff;
4052
4053 switch (cmd) {
4054 case IPC_STAT:
4055 case IPC_SET:
4056 case MSG_STAT:
4057 if (target_to_host_msqid_ds(&dsarg,ptr))
4058 return -TARGET_EFAULT;
4059 ret = get_errno(msgctl(msgid, cmd, &dsarg));
4060 if (host_to_target_msqid_ds(ptr,&dsarg))
4061 return -TARGET_EFAULT;
4062 break;
4063 case IPC_RMID:
4064 ret = get_errno(msgctl(msgid, cmd, NULL));
4065 break;
4066 case IPC_INFO:
4067 case MSG_INFO:
4068 ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
4069 if (host_to_target_msginfo(ptr, &msginfo))
4070 return -TARGET_EFAULT;
4071 break;
4072 }
4073
4074 return ret;
4075 }
4076
4077 struct target_msgbuf {
4078 abi_long mtype;
4079 char mtext[1];
4080 };
4081
4082 static inline abi_long do_msgsnd(int msqid, abi_long msgp,
4083 ssize_t msgsz, int msgflg)
4084 {
4085 struct target_msgbuf *target_mb;
4086 struct msgbuf *host_mb;
4087 abi_long ret = 0;
4088
4089 if (msgsz < 0) {
4090 return -TARGET_EINVAL;
4091 }
4092
4093 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
4094 return -TARGET_EFAULT;
4095 host_mb = g_try_malloc(msgsz + sizeof(long));
4096 if (!host_mb) {
4097 unlock_user_struct(target_mb, msgp, 0);
4098 return -TARGET_ENOMEM;
4099 }
4100 host_mb->mtype = (abi_long) tswapal(target_mb->mtype);
4101 memcpy(host_mb->mtext, target_mb->mtext, msgsz);
4102 ret = -TARGET_ENOSYS;
4103 #ifdef __NR_msgsnd
4104 ret = get_errno(safe_msgsnd(msqid, host_mb, msgsz, msgflg));
4105 #endif
4106 #ifdef __NR_ipc
4107 if (ret == -TARGET_ENOSYS) {
4108 #ifdef __s390x__
4109 ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg,
4110 host_mb));
4111 #else
4112 ret = get_errno(safe_ipc(IPCOP_msgsnd, msqid, msgsz, msgflg,
4113 host_mb, 0));
4114 #endif
4115 }
4116 #endif
4117 g_free(host_mb);
4118 unlock_user_struct(target_mb, msgp, 0);
4119
4120 return ret;
4121 }
4122
4123 #ifdef __NR_ipc
4124 #if defined(__sparc__)
4125 /* SPARC for msgrcv it does not use the kludge on final 2 arguments. */
4126 #define MSGRCV_ARGS(__msgp, __msgtyp) __msgp, __msgtyp
4127 #elif defined(__s390x__)
4128 /* The s390 sys_ipc variant has only five parameters. */
4129 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4130 ((long int[]){(long int)__msgp, __msgtyp})
4131 #else
4132 #define MSGRCV_ARGS(__msgp, __msgtyp) \
4133 ((long int[]){(long int)__msgp, __msgtyp}), 0
4134 #endif
4135 #endif
4136
4137 static inline abi_long do_msgrcv(int msqid, abi_long msgp,
4138 ssize_t msgsz, abi_long msgtyp,
4139 int msgflg)
4140 {
4141 struct target_msgbuf *target_mb;
4142 char *target_mtext;
4143 struct msgbuf *host_mb;
4144 abi_long ret = 0;
4145
4146 if (msgsz < 0) {
4147 return -TARGET_EINVAL;
4148 }
4149
4150 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
4151 return -TARGET_EFAULT;
4152
4153 host_mb = g_try_malloc(msgsz + sizeof(long));
4154 if (!host_mb) {
4155 ret = -TARGET_ENOMEM;
4156 goto end;
4157 }
4158 ret = -TARGET_ENOSYS;
4159 #ifdef __NR_msgrcv
4160 ret = get_errno(safe_msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg));
4161 #endif
4162 #ifdef __NR_ipc
4163 if (ret == -TARGET_ENOSYS) {
4164 ret = get_errno(safe_ipc(IPCOP_CALL(1, IPCOP_msgrcv), msqid, msgsz,
4165 msgflg, MSGRCV_ARGS(host_mb, msgtyp)));
4166 }
4167 #endif
4168
4169 if (ret > 0) {
4170 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
4171 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
4172 if (!target_mtext) {
4173 ret = -TARGET_EFAULT;
4174 goto end;
4175 }
4176 memcpy(target_mb->mtext, host_mb->mtext, ret);
4177 unlock_user(target_mtext, target_mtext_addr, ret);
4178 }
4179
4180 target_mb->mtype = tswapal(host_mb->mtype);
4181
4182 end:
4183 if (target_mb)
4184 unlock_user_struct(target_mb, msgp, 1);
4185 g_free(host_mb);
4186 return ret;
4187 }
4188
4189 static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
4190 abi_ulong target_addr)
4191 {
4192 struct target_shmid_ds *target_sd;
4193
4194 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4195 return -TARGET_EFAULT;
4196 if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr))
4197 return -TARGET_EFAULT;
4198 __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4199 __get_user(host_sd->shm_atime, &target_sd->shm_atime);
4200 __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4201 __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4202 __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4203 __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4204 __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4205 unlock_user_struct(target_sd, target_addr, 0);
4206 return 0;
4207 }
4208
4209 static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr,
4210 struct shmid_ds *host_sd)
4211 {
4212 struct target_shmid_ds *target_sd;
4213
4214 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4215 return -TARGET_EFAULT;
4216 if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm)))
4217 return -TARGET_EFAULT;
4218 __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4219 __put_user(host_sd->shm_atime, &target_sd->shm_atime);
4220 __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4221 __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4222 __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4223 __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4224 __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4225 unlock_user_struct(target_sd, target_addr, 1);
4226 return 0;
4227 }
4228
4229 struct target_shminfo {
4230 abi_ulong shmmax;
4231 abi_ulong shmmin;
4232 abi_ulong shmmni;
4233 abi_ulong shmseg;
4234 abi_ulong shmall;
4235 };
4236
4237 static inline abi_long host_to_target_shminfo(abi_ulong target_addr,
4238 struct shminfo *host_shminfo)
4239 {
4240 struct target_shminfo *target_shminfo;
4241 if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0))
4242 return -TARGET_EFAULT;
4243 __put_user(host_shminfo->shmmax, &target_shminfo->shmmax);
4244 __put_user(host_shminfo->shmmin, &target_shminfo->shmmin);
4245 __put_user(host_shminfo->shmmni, &target_shminfo->shmmni);
4246 __put_user(host_shminfo->shmseg, &target_shminfo->shmseg);
4247 __put_user(host_shminfo->shmall, &target_shminfo->shmall);
4248 unlock_user_struct(target_shminfo, target_addr, 1);
4249 return 0;
4250 }
4251
4252 struct target_shm_info {
4253 int used_ids;
4254 abi_ulong shm_tot;
4255 abi_ulong shm_rss;
4256 abi_ulong shm_swp;
4257 abi_ulong swap_attempts;
4258 abi_ulong swap_successes;
4259 };
4260
4261 static inline abi_long host_to_target_shm_info(abi_ulong target_addr,
4262 struct shm_info *host_shm_info)
4263 {
4264 struct target_shm_info *target_shm_info;
4265 if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0))
4266 return -TARGET_EFAULT;
4267 __put_user(host_shm_info->used_ids, &target_shm_info->used_ids);
4268 __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot);
4269 __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss);
4270 __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp);
4271 __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts);
4272 __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes);
4273 unlock_user_struct(target_shm_info, target_addr, 1);
4274 return 0;
4275 }
4276
4277 static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf)
4278 {
4279 struct shmid_ds dsarg;
4280 struct shminfo shminfo;
4281 struct shm_info shm_info;
4282 abi_long ret = -TARGET_EINVAL;
4283
4284 cmd &= 0xff;
4285
4286 switch(cmd) {
4287 case IPC_STAT:
4288 case IPC_SET:
4289 case SHM_STAT:
4290 if (target_to_host_shmid_ds(&dsarg, buf))
4291 return -TARGET_EFAULT;
4292 ret = get_errno(shmctl(shmid, cmd, &dsarg));
4293 if (host_to_target_shmid_ds(buf, &dsarg))
4294 return -TARGET_EFAULT;
4295 break;
4296 case IPC_INFO:
4297 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo));
4298 if (host_to_target_shminfo(buf, &shminfo))
4299 return -TARGET_EFAULT;
4300 break;
4301 case SHM_INFO:
4302 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info));
4303 if (host_to_target_shm_info(buf, &shm_info))
4304 return -TARGET_EFAULT;
4305 break;
4306 case IPC_RMID:
4307 case SHM_LOCK:
4308 case SHM_UNLOCK:
4309 ret = get_errno(shmctl(shmid, cmd, NULL));
4310 break;
4311 }
4312
4313 return ret;
4314 }
4315
4316 #ifndef TARGET_FORCE_SHMLBA
4317 /* For most architectures, SHMLBA is the same as the page size;
4318 * some architectures have larger values, in which case they should
4319 * define TARGET_FORCE_SHMLBA and provide a target_shmlba() function.
4320 * This corresponds to the kernel arch code defining __ARCH_FORCE_SHMLBA
4321 * and defining its own value for SHMLBA.
4322 *
4323 * The kernel also permits SHMLBA to be set by the architecture to a
4324 * value larger than the page size without setting __ARCH_FORCE_SHMLBA;
4325 * this means that addresses are rounded to the large size if
4326 * SHM_RND is set but addresses not aligned to that size are not rejected
4327 * as long as they are at least page-aligned. Since the only architecture
4328 * which uses this is ia64 this code doesn't provide for that oddity.
4329 */
4330 static inline abi_ulong target_shmlba(CPUArchState *cpu_env)
4331 {
4332 return TARGET_PAGE_SIZE;
4333 }
4334 #endif
4335
4336 static inline abi_ulong do_shmat(CPUArchState *cpu_env,
4337 int shmid, abi_ulong shmaddr, int shmflg)
4338 {
4339 abi_long raddr;
4340 void *host_raddr;
4341 struct shmid_ds shm_info;
4342 int i,ret;
4343 abi_ulong shmlba;
4344
4345 /* find out the length of the shared memory segment */
4346 ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
4347 if (is_error(ret)) {
4348 /* can't get length, bail out */
4349 return ret;
4350 }
4351
4352 shmlba = target_shmlba(cpu_env);
4353
4354 if (shmaddr & (shmlba - 1)) {
4355 if (shmflg & SHM_RND) {
4356 shmaddr &= ~(shmlba - 1);
4357 } else {
4358 return -TARGET_EINVAL;
4359 }
4360 }
4361 if (!guest_range_valid(shmaddr, shm_info.shm_segsz)) {
4362 return -TARGET_EINVAL;
4363 }
4364
4365 mmap_lock();
4366
4367 if (shmaddr)
4368 host_raddr = shmat(shmid, (void *)g2h(shmaddr), shmflg);
4369 else {
4370 abi_ulong mmap_start;
4371
4372 /* In order to use the host shmat, we need to honor host SHMLBA. */
4373 mmap_start = mmap_find_vma(0, shm_info.shm_segsz, MAX(SHMLBA, shmlba));
4374
4375 if (mmap_start == -1) {
4376 errno = ENOMEM;
4377 host_raddr = (void *)-1;
4378 } else
4379 host_raddr = shmat(shmid, g2h(mmap_start), shmflg | SHM_REMAP);
4380 }
4381
4382 if (host_raddr == (void *)-1) {
4383 mmap_unlock();
4384 return get_errno((long)host_raddr);
4385 }
4386 raddr=h2g((unsigned long)host_raddr);
4387
4388 page_set_flags(raddr, raddr + shm_info.shm_segsz,
4389 PAGE_VALID | PAGE_READ |
4390 ((shmflg & SHM_RDONLY)? 0 : PAGE_WRITE));
4391
4392 for (i = 0; i < N_SHM_REGIONS; i++) {
4393 if (!shm_regions[i].in_use) {
4394 shm_regions[i].in_use = true;
4395 shm_regions[i].start = raddr;
4396 shm_regions[i].size = shm_info.shm_segsz;
4397 break;
4398 }
4399 }
4400
4401 mmap_unlock();
4402 return raddr;
4403
4404 }
4405
4406 static inline abi_long do_shmdt(abi_ulong shmaddr)
4407 {
4408 int i;
4409 abi_long rv;
4410
4411 mmap_lock();
4412
4413 for (i = 0; i < N_SHM_REGIONS; ++i) {
4414 if (shm_regions[i].in_use && shm_regions[i].start == shmaddr) {
4415 shm_regions[i].in_use = false;
4416 page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0);
4417 break;
4418 }
4419 }
4420 rv = get_errno(shmdt(g2h(shmaddr)));
4421
4422 mmap_unlock();
4423
4424 return rv;
4425 }
4426
4427 #ifdef TARGET_NR_ipc
4428 /* ??? This only works with linear mappings. */
4429 /* do_ipc() must return target values and target errnos. */
4430 static abi_long do_ipc(CPUArchState *cpu_env,
4431 unsigned int call, abi_long first,
4432 abi_long second, abi_long third,
4433 abi_long ptr, abi_long fifth)
4434 {
4435 int version;
4436 abi_long ret = 0;
4437
4438 version = call >> 16;
4439 call &= 0xffff;
4440
4441 switch (call) {
4442 case IPCOP_semop:
4443 ret = do_semtimedop(first, ptr, second, 0, false);
4444 break;
4445 case IPCOP_semtimedop:
4446 /*
4447 * The s390 sys_ipc variant has only five parameters instead of six
4448 * (as for default variant) and the only difference is the handling of
4449 * SEMTIMEDOP where on s390 the third parameter is used as a pointer
4450 * to a struct timespec where the generic variant uses fifth parameter.
4451 */
4452 #if defined(TARGET_S390X)
4453 ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
4454 #else
4455 ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
4456 #endif
4457 break;
4458
4459 case IPCOP_semget:
4460 ret = get_errno(semget(first, second, third));
4461 break;
4462
4463 case IPCOP_semctl: {
4464 /* The semun argument to semctl is passed by value, so dereference the
4465 * ptr argument. */
4466 abi_ulong atptr;
4467 get_user_ual(atptr, ptr);
4468 ret = do_semctl(first, second, third, atptr);
4469 break;
4470 }
4471
4472 case IPCOP_msgget:
4473 ret = get_errno(msgget(first, second));
4474 break;
4475
4476 case IPCOP_msgsnd:
4477 ret = do_msgsnd(first, ptr, second, third);
4478 break;
4479
4480 case IPCOP_msgctl:
4481 ret = do_msgctl(first, second, ptr);
4482 break;
4483
4484 case IPCOP_msgrcv:
4485 switch (version) {
4486 case 0:
4487 {
4488 struct target_ipc_kludge {
4489 abi_long msgp;
4490 abi_long msgtyp;
4491 } *tmp;
4492
4493 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
4494 ret = -TARGET_EFAULT;
4495 break;
4496 }
4497
4498 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third);
4499
4500 unlock_user_struct(tmp, ptr, 0);
4501 break;
4502 }
4503 default:
4504 ret = do_msgrcv(first, ptr, second, fifth, third);
4505 }
4506 break;
4507
4508 case IPCOP_shmat:
4509 switch (version) {
4510 default:
4511 {
4512 abi_ulong raddr;
4513 raddr = do_shmat(cpu_env, first, ptr, second);
4514 if (is_error(raddr))
4515 return get_errno(raddr);
4516 if (put_user_ual(raddr, third))
4517 return -TARGET_EFAULT;
4518 break;
4519 }
4520 case 1:
4521 ret = -TARGET_EINVAL;
4522 break;
4523 }
4524 break;
4525 case IPCOP_shmdt:
4526 ret = do_shmdt(ptr);
4527 break;
4528
4529 case IPCOP_shmget:
4530 /* IPC_* flag values are the same on all linux platforms */
4531 ret = get_errno(shmget(first, second, third));
4532 break;
4533
4534 /* IPC_* and SHM_* command values are the same on all linux platforms */
4535 case IPCOP_shmctl:
4536 ret = do_shmctl(first, second, ptr);
4537 break;
4538 default:
4539 qemu_log_mask(LOG_UNIMP, "Unsupported ipc call: %d (version %d)\n",
4540 call, version);
4541 ret = -TARGET_ENOSYS;
4542 break;
4543 }
4544 return ret;
4545 }
4546 #endif
4547
4548 /* kernel structure types definitions */
4549
4550 #define STRUCT(name, ...) STRUCT_ ## name,
4551 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
4552 enum {
4553 #include "syscall_types.h"
4554 STRUCT_MAX
4555 };
4556 #undef STRUCT
4557 #undef STRUCT_SPECIAL
4558
4559 #define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
4560 #define STRUCT_SPECIAL(name)
4561 #include "syscall_types.h"
4562 #undef STRUCT
4563 #undef STRUCT_SPECIAL
4564
4565 #define MAX_STRUCT_SIZE 4096
4566
4567 #ifdef CONFIG_FIEMAP
4568 /* So fiemap access checks don't overflow on 32 bit systems.
4569 * This is very slightly smaller than the limit imposed by
4570 * the underlying kernel.
4571 */
4572 #define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
4573 / sizeof(struct fiemap_extent))
4574
4575 static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
4576 int fd, int cmd, abi_long arg)
4577 {
4578 /* The parameter for this ioctl is a struct fiemap followed
4579 * by an array of struct fiemap_extent whose size is set
4580 * in fiemap->fm_extent_count. The array is filled in by the
4581 * ioctl.
4582 */
4583 int target_size_in, target_size_out;
4584 struct fiemap *fm;
4585 const argtype *arg_type = ie->arg_type;
4586 const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) };
4587 void *argptr, *p;
4588 abi_long ret;
4589 int i, extent_size = thunk_type_size(extent_arg_type, 0);
4590 uint32_t outbufsz;
4591 int free_fm = 0;
4592
4593 assert(arg_type[0] == TYPE_PTR);
4594 assert(ie->access == IOC_RW);
4595 arg_type++;
4596 target_size_in = thunk_type_size(arg_type, 0);
4597 argptr = lock_user(VERIFY_READ, arg, target_size_in, 1);
4598 if (!argptr) {
4599 return -TARGET_EFAULT;
4600 }
4601 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4602 unlock_user(argptr, arg, 0);
4603 fm = (struct fiemap *)buf_temp;
4604 if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) {
4605 return -TARGET_EINVAL;
4606 }
4607
4608 outbufsz = sizeof (*fm) +
4609 (sizeof(struct fiemap_extent) * fm->fm_extent_count);
4610
4611 if (outbufsz > MAX_STRUCT_SIZE) {
4612 /* We can't fit all the extents into the fixed size buffer.
4613 * Allocate one that is large enough and use it instead.
4614 */
4615 fm = g_try_malloc(outbufsz);
4616 if (!fm) {
4617 return -TARGET_ENOMEM;
4618 }
4619 memcpy(fm, buf_temp, sizeof(struct fiemap));
4620 free_fm = 1;
4621 }
4622 ret = get_errno(safe_ioctl(fd, ie->host_cmd, fm));
4623 if (!is_error(ret)) {
4624 target_size_out = target_size_in;
4625 /* An extent_count of 0 means we were only counting the extents
4626 * so there are no structs to copy
4627 */
4628 if (fm->fm_extent_count != 0) {
4629 target_size_out += fm->fm_mapped_extents * extent_size;
4630 }
4631 argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0);
4632 if (!argptr) {
4633 ret = -TARGET_EFAULT;
4634 } else {
4635 /* Convert the struct fiemap */
4636 thunk_convert(argptr, fm, arg_type, THUNK_TARGET);
4637 if (fm->fm_extent_count != 0) {
4638 p = argptr + target_size_in;
4639 /* ...and then all the struct fiemap_extents */
4640 for (i = 0; i < fm->fm_mapped_extents; i++) {
4641 thunk_convert(p, &fm->fm_extents[i], extent_arg_type,
4642 THUNK_TARGET);
4643 p += extent_size;
4644 }
4645 }
4646 unlock_user(argptr, arg, target_size_out);
4647 }
4648 }
4649 if (free_fm) {
4650 g_free(fm);
4651 }
4652 return ret;
4653 }
4654 #endif
4655
4656 static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp,
4657 int fd, int cmd, abi_long arg)
4658 {
4659 const argtype *arg_type = ie->arg_type;
4660 int target_size;
4661 void *argptr;
4662 int ret;
4663 struct ifconf *host_ifconf;
4664 uint32_t outbufsz;
4665 const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) };
4666 int target_ifreq_size;
4667 int nb_ifreq;
4668 int free_buf = 0;
4669 int i;
4670 int target_ifc_len;
4671 abi_long target_ifc_buf;
4672 int host_ifc_len;
4673 char *host_ifc_buf;
4674
4675 assert(arg_type[0] == TYPE_PTR);
4676 assert(ie->access == IOC_RW);
4677
4678 arg_type++;
4679 target_size = thunk_type_size(arg_type, 0);
4680
4681 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4682 if (!argptr)
4683 return -TARGET_EFAULT;
4684 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4685 unlock_user(argptr, arg, 0);
4686
4687 host_ifconf = (struct ifconf *)(unsigned long)buf_temp;
4688 target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf;
4689 target_ifreq_size = thunk_type_size(ifreq_arg_type, 0);
4690
4691 if (target_ifc_buf != 0) {
4692 target_ifc_len = host_ifconf->ifc_len;
4693 nb_ifreq = target_ifc_len / target_ifreq_size;
4694 host_ifc_len = nb_ifreq * sizeof(struct ifreq);
4695
4696 outbufsz = sizeof(*host_ifconf) + host_ifc_len;
4697 if (outbufsz > MAX_STRUCT_SIZE) {
4698 /*
4699 * We can't fit all the extents into the fixed size buffer.
4700 * Allocate one that is large enough and use it instead.
4701 */
4702 host_ifconf = malloc(outbufsz);
4703 if (!host_ifconf) {
4704 return -TARGET_ENOMEM;
4705 }
4706 memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf));
4707 free_buf = 1;
4708 }
4709 host_ifc_buf = (char *)host_ifconf + sizeof(*host_ifconf);
4710
4711 host_ifconf->ifc_len = host_ifc_len;
4712 } else {
4713 host_ifc_buf = NULL;
4714 }
4715 host_ifconf->ifc_buf = host_ifc_buf;
4716
4717 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_ifconf));
4718 if (!is_error(ret)) {
4719 /* convert host ifc_len to target ifc_len */
4720
4721 nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq);
4722 target_ifc_len = nb_ifreq * target_ifreq_size;
4723 host_ifconf->ifc_len = target_ifc_len;
4724
4725 /* restore target ifc_buf */
4726
4727 host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf;
4728
4729 /* copy struct ifconf to target user */
4730
4731 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
4732 if (!argptr)
4733 return -TARGET_EFAULT;
4734 thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET);
4735 unlock_user(argptr, arg, target_size);
4736
4737 if (target_ifc_buf != 0) {
4738 /* copy ifreq[] to target user */
4739 argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0);
4740 for (i = 0; i < nb_ifreq ; i++) {
4741 thunk_convert(argptr + i * target_ifreq_size,
4742 host_ifc_buf + i * sizeof(struct ifreq),
4743 ifreq_arg_type, THUNK_TARGET);
4744 }
4745 unlock_user(argptr, target_ifc_buf, target_ifc_len);
4746 }
4747 }
4748
4749 if (free_buf) {
4750 free(host_ifconf);
4751 }
4752
4753 return ret;
4754 }
4755
4756 #if defined(CONFIG_USBFS)
4757 #if HOST_LONG_BITS > 64
4758 #error USBDEVFS thunks do not support >64 bit hosts yet.
4759 #endif
4760 struct live_urb {
4761 uint64_t target_urb_adr;
4762 uint64_t target_buf_adr;
4763 char *target_buf_ptr;
4764 struct usbdevfs_urb host_urb;
4765 };
4766
4767 static GHashTable *usbdevfs_urb_hashtable(void)
4768 {
4769 static GHashTable *urb_hashtable;
4770
4771 if (!urb_hashtable) {
4772 urb_hashtable = g_hash_table_new(g_int64_hash, g_int64_equal);
4773 }
4774 return urb_hashtable;
4775 }
4776
4777 static void urb_hashtable_insert(struct live_urb *urb)
4778 {
4779 GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4780 g_hash_table_insert(urb_hashtable, urb, urb);
4781 }
4782
4783 static struct live_urb *urb_hashtable_lookup(uint64_t target_urb_adr)
4784 {
4785 GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4786 return g_hash_table_lookup(urb_hashtable, &target_urb_adr);
4787 }
4788
4789 static void urb_hashtable_remove(struct live_urb *urb)
4790 {
4791 GHashTable *urb_hashtable = usbdevfs_urb_hashtable();
4792 g_hash_table_remove(urb_hashtable, urb);
4793 }
4794
4795 static abi_long
4796 do_ioctl_usbdevfs_reapurb(const IOCTLEntry *ie, uint8_t *buf_temp,
4797 int fd, int cmd, abi_long arg)
4798 {
4799 const argtype usbfsurb_arg_type[] = { MK_STRUCT(STRUCT_usbdevfs_urb) };
4800 const argtype ptrvoid_arg_type[] = { TYPE_PTRVOID, 0, 0 };
4801 struct live_urb *lurb;
4802 void *argptr;
4803 uint64_t hurb;
4804 int target_size;
4805 uintptr_t target_urb_adr;
4806 abi_long ret;
4807
4808 target_size = thunk_type_size(usbfsurb_arg_type, THUNK_TARGET);
4809
4810 memset(buf_temp, 0, sizeof(uint64_t));
4811 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
4812 if (is_error(ret)) {
4813 return ret;
4814 }
4815
4816 memcpy(&hurb, buf_temp, sizeof(uint64_t));
4817 lurb = (void *)((uintptr_t)hurb - offsetof(struct live_urb, host_urb));
4818 if (!lurb->target_urb_adr) {
4819 return -TARGET_EFAULT;
4820 }
4821 urb_hashtable_remove(lurb);
4822 unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr,
4823 lurb->host_urb.buffer_length);
4824 lurb->target_buf_ptr = NULL;
4825
4826 /* restore the guest buffer pointer */
4827 lurb->host_urb.buffer = (void *)(uintptr_t)lurb->target_buf_adr;
4828
4829 /* update the guest urb struct */
4830 argptr = lock_user(VERIFY_WRITE, lurb->target_urb_adr, target_size, 0);
4831 if (!argptr) {
4832 g_free(lurb);
4833 return -TARGET_EFAULT;
4834 }
4835 thunk_convert(argptr, &lurb->host_urb, usbfsurb_arg_type, THUNK_TARGET);
4836 unlock_user(argptr, lurb->target_urb_adr, target_size);
4837
4838 target_size = thunk_type_size(ptrvoid_arg_type, THUNK_TARGET);
4839 /* write back the urb handle */
4840 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
4841 if (!argptr) {
4842 g_free(lurb);
4843 return -TARGET_EFAULT;
4844 }
4845
4846 /* GHashTable uses 64-bit keys but thunk_convert expects uintptr_t */
4847 target_urb_adr = lurb->target_urb_adr;
4848 thunk_convert(argptr, &target_urb_adr, ptrvoid_arg_type, THUNK_TARGET);
4849 unlock_user(argptr, arg, target_size);
4850
4851 g_free(lurb);
4852 return ret;
4853 }
4854
4855 static abi_long
4856 do_ioctl_usbdevfs_discardurb(const IOCTLEntry *ie,
4857 uint8_t *buf_temp __attribute__((unused)),
4858 int fd, int cmd, abi_long arg)
4859 {
4860 struct live_urb *lurb;
4861
4862 /* map target address back to host URB with metadata. */
4863 lurb = urb_hashtable_lookup(arg);
4864 if (!lurb) {
4865 return -TARGET_EFAULT;
4866 }
4867 return get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb));
4868 }
4869
4870 static abi_long
4871 do_ioctl_usbdevfs_submiturb(const IOCTLEntry *ie, uint8_t *buf_temp,
4872 int fd, int cmd, abi_long arg)
4873 {
4874 const argtype *arg_type = ie->arg_type;
4875 int target_size;
4876 abi_long ret;
4877 void *argptr;
4878 int rw_dir;
4879 struct live_urb *lurb;
4880
4881 /*
4882 * each submitted URB needs to map to a unique ID for the
4883 * kernel, and that unique ID needs to be a pointer to
4884 * host memory. hence, we need to malloc for each URB.
4885 * isochronous transfers have a variable length struct.
4886 */
4887 arg_type++;
4888 target_size = thunk_type_size(arg_type, THUNK_TARGET);
4889
4890 /* construct host copy of urb and metadata */
4891 lurb = g_try_malloc0(sizeof(struct live_urb));
4892 if (!lurb) {
4893 return -TARGET_ENOMEM;
4894 }
4895
4896 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4897 if (!argptr) {
4898 g_free(lurb);
4899 return -TARGET_EFAULT;
4900 }
4901 thunk_convert(&lurb->host_urb, argptr, arg_type, THUNK_HOST);
4902 unlock_user(argptr, arg, 0);
4903
4904 lurb->target_urb_adr = arg;
4905 lurb->target_buf_adr = (uintptr_t)lurb->host_urb.buffer;
4906
4907 /* buffer space used depends on endpoint type so lock the entire buffer */
4908 /* control type urbs should check the buffer contents for true direction */
4909 rw_dir = lurb->host_urb.endpoint & USB_DIR_IN ? VERIFY_WRITE : VERIFY_READ;
4910 lurb->target_buf_ptr = lock_user(rw_dir, lurb->target_buf_adr,
4911 lurb->host_urb.buffer_length, 1);
4912 if (lurb->target_buf_ptr == NULL) {
4913 g_free(lurb);
4914 return -TARGET_EFAULT;
4915 }
4916
4917 /* update buffer pointer in host copy */
4918 lurb->host_urb.buffer = lurb->target_buf_ptr;
4919
4920 ret = get_errno(safe_ioctl(fd, ie->host_cmd, &lurb->host_urb));
4921 if (is_error(ret)) {
4922 unlock_user(lurb->target_buf_ptr, lurb->target_buf_adr, 0);
4923 g_free(lurb);
4924 } else {
4925 urb_hashtable_insert(lurb);
4926 }
4927
4928 return ret;
4929 }
4930 #endif /* CONFIG_USBFS */
4931
4932 static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
4933 int cmd, abi_long arg)
4934 {
4935 void *argptr;
4936 struct dm_ioctl *host_dm;
4937 abi_long guest_data;
4938 uint32_t guest_data_size;
4939 int target_size;
4940 const argtype *arg_type = ie->arg_type;
4941 abi_long ret;
4942 void *big_buf = NULL;
4943 char *host_data;
4944
4945 arg_type++;
4946 target_size = thunk_type_size(arg_type, 0);
4947 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4948 if (!argptr) {
4949 ret = -TARGET_EFAULT;
4950 goto out;
4951 }
4952 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4953 unlock_user(argptr, arg, 0);
4954
4955 /* buf_temp is too small, so fetch things into a bigger buffer */
4956 big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2);
4957 memcpy(big_buf, buf_temp, target_size);
4958 buf_temp = big_buf;
4959 host_dm = big_buf;
4960
4961 guest_data = arg + host_dm->data_start;
4962 if ((guest_data - arg) < 0) {
4963 ret = -TARGET_EINVAL;
4964 goto out;
4965 }
4966 guest_data_size = host_dm->data_size - host_dm->data_start;
4967 host_data = (char*)host_dm + host_dm->data_start;
4968
4969 argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1);
4970 if (!argptr) {
4971 ret = -TARGET_EFAULT;
4972 goto out;
4973 }
4974
4975 switch (ie->host_cmd) {
4976 case DM_REMOVE_ALL:
4977 case DM_LIST_DEVICES:
4978 case DM_DEV_CREATE:
4979 case DM_DEV_REMOVE:
4980 case DM_DEV_SUSPEND:
4981 case DM_DEV_STATUS:
4982 case DM_DEV_WAIT:
4983 case DM_TABLE_STATUS:
4984 case DM_TABLE_CLEAR:
4985 case DM_TABLE_DEPS:
4986 case DM_LIST_VERSIONS:
4987 /* no input data */
4988 break;
4989 case DM_DEV_RENAME:
4990 case DM_DEV_SET_GEOMETRY:
4991 /* data contains only strings */
4992 memcpy(host_data, argptr, guest_data_size);
4993 break;
4994 case DM_TARGET_MSG:
4995 memcpy(host_data, argptr, guest_data_size);
4996 *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr);
4997 break;
4998 case DM_TABLE_LOAD:
4999 {
5000 void *gspec = argptr;
5001 void *cur_data = host_data;
5002 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5003 int spec_size = thunk_type_size(arg_type, 0);
5004 int i;
5005
5006 for (i = 0; i < host_dm->target_count; i++) {
5007 struct dm_target_spec *spec = cur_data;
5008 uint32_t next;
5009 int slen;
5010
5011 thunk_convert(spec, gspec, arg_type, THUNK_HOST);
5012 slen = strlen((char*)gspec + spec_size) + 1;
5013 next = spec->next;
5014 spec->next = sizeof(*spec) + slen;
5015 strcpy((char*)&spec[1], gspec + spec_size);
5016 gspec += next;
5017 cur_data += spec->next;
5018 }
5019 break;
5020 }
5021 default:
5022 ret = -TARGET_EINVAL;
5023 unlock_user(argptr, guest_data, 0);
5024 goto out;
5025 }
5026 unlock_user(argptr, guest_data, 0);
5027
5028 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5029 if (!is_error(ret)) {
5030 guest_data = arg + host_dm->data_start;
5031 guest_data_size = host_dm->data_size - host_dm->data_start;
5032 argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0);
5033 switch (ie->host_cmd) {
5034 case DM_REMOVE_ALL:
5035 case DM_DEV_CREATE:
5036 case DM_DEV_REMOVE:
5037 case DM_DEV_RENAME:
5038 case DM_DEV_SUSPEND:
5039 case DM_DEV_STATUS:
5040 case DM_TABLE_LOAD:
5041 case DM_TABLE_CLEAR:
5042 case DM_TARGET_MSG:
5043 case DM_DEV_SET_GEOMETRY:
5044 /* no return data */
5045 break;
5046 case DM_LIST_DEVICES:
5047 {
5048 struct dm_name_list *nl = (void*)host_dm + host_dm->data_start;
5049 uint32_t remaining_data = guest_data_size;
5050 void *cur_data = argptr;
5051 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) };
5052 int nl_size = 12; /* can't use thunk_size due to alignment */
5053
5054 while (1) {
5055 uint32_t next = nl->next;
5056 if (next) {
5057 nl->next = nl_size + (strlen(nl->name) + 1);
5058 }
5059 if (remaining_data < nl->next) {
5060 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5061 break;
5062 }
5063 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET);
5064 strcpy(cur_data + nl_size, nl->name);
5065 cur_data += nl->next;
5066 remaining_data -= nl->next;
5067 if (!next) {
5068 break;
5069 }
5070 nl = (void*)nl + next;
5071 }
5072 break;
5073 }
5074 case DM_DEV_WAIT:
5075 case DM_TABLE_STATUS:
5076 {
5077 struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start;
5078 void *cur_data = argptr;
5079 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
5080 int spec_size = thunk_type_size(arg_type, 0);
5081 int i;
5082
5083 for (i = 0; i < host_dm->target_count; i++) {
5084 uint32_t next = spec->next;
5085 int slen = strlen((char*)&spec[1]) + 1;
5086 spec->next = (cur_data - argptr) + spec_size + slen;
5087 if (guest_data_size < spec->next) {
5088 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5089 break;
5090 }
5091 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET);
5092 strcpy(cur_data + spec_size, (char*)&spec[1]);
5093 cur_data = argptr + spec->next;
5094 spec = (void*)host_dm + host_dm->data_start + next;
5095 }
5096 break;
5097 }
5098 case DM_TABLE_DEPS:
5099 {
5100 void *hdata = (void*)host_dm + host_dm->data_start;
5101 int count = *(uint32_t*)hdata;
5102 uint64_t *hdev = hdata + 8;
5103 uint64_t *gdev = argptr + 8;
5104 int i;
5105
5106 *(uint32_t*)argptr = tswap32(count);
5107 for (i = 0; i < count; i++) {
5108 *gdev = tswap64(*hdev);
5109 gdev++;
5110 hdev++;
5111 }
5112 break;
5113 }
5114 case DM_LIST_VERSIONS:
5115 {
5116 struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start;
5117 uint32_t remaining_data = guest_data_size;
5118 void *cur_data = argptr;
5119 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) };
5120 int vers_size = thunk_type_size(arg_type, 0);
5121
5122 while (1) {
5123 uint32_t next = vers->next;
5124 if (next) {
5125 vers->next = vers_size + (strlen(vers->name) + 1);
5126 }
5127 if (remaining_data < vers->next) {
5128 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5129 break;
5130 }
5131 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET);
5132 strcpy(cur_data + vers_size, vers->name);
5133 cur_data += vers->next;
5134 remaining_data -= vers->next;
5135 if (!next) {
5136 break;
5137 }
5138 vers = (void*)vers + next;
5139 }
5140 break;
5141 }
5142 default:
5143 unlock_user(argptr, guest_data, 0);
5144 ret = -TARGET_EINVAL;
5145 goto out;
5146 }
5147 unlock_user(argptr, guest_data, guest_data_size);
5148
5149 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5150 if (!argptr) {
5151 ret = -TARGET_EFAULT;
5152 goto out;
5153 }
5154 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5155 unlock_user(argptr, arg, target_size);
5156 }
5157 out:
5158 g_free(big_buf);
5159 return ret;
5160 }
5161
5162 static abi_long do_ioctl_blkpg(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
5163 int cmd, abi_long arg)
5164 {
5165 void *argptr;
5166 int target_size;
5167 const argtype *arg_type = ie->arg_type;
5168 const argtype part_arg_type[] = { MK_STRUCT(STRUCT_blkpg_partition) };
5169 abi_long ret;
5170
5171 struct blkpg_ioctl_arg *host_blkpg = (void*)buf_temp;
5172 struct blkpg_partition host_part;
5173
5174 /* Read and convert blkpg */
5175 arg_type++;
5176 target_size = thunk_type_size(arg_type, 0);
5177 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5178 if (!argptr) {
5179 ret = -TARGET_EFAULT;
5180 goto out;
5181 }
5182 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5183 unlock_user(argptr, arg, 0);
5184
5185 switch (host_blkpg->op) {
5186 case BLKPG_ADD_PARTITION:
5187 case BLKPG_DEL_PARTITION:
5188 /* payload is struct blkpg_partition */
5189 break;
5190 default:
5191 /* Unknown opcode */
5192 ret = -TARGET_EINVAL;
5193 goto out;
5194 }
5195
5196 /* Read and convert blkpg->data */
5197 arg = (abi_long)(uintptr_t)host_blkpg->data;
5198 target_size = thunk_type_size(part_arg_type, 0);
5199 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5200 if (!argptr) {
5201 ret = -TARGET_EFAULT;
5202 goto out;
5203 }
5204 thunk_convert(&host_part, argptr, part_arg_type, THUNK_HOST);
5205 unlock_user(argptr, arg, 0);
5206
5207 /* Swizzle the data pointer to our local copy and call! */
5208 host_blkpg->data = &host_part;
5209 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_blkpg));
5210
5211 out:
5212 return ret;
5213 }
5214
5215 static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
5216 int fd, int cmd, abi_long arg)
5217 {
5218 const argtype *arg_type = ie->arg_type;
5219 const StructEntry *se;
5220 const argtype *field_types;
5221 const int *dst_offsets, *src_offsets;
5222 int target_size;
5223 void *argptr;
5224 abi_ulong *target_rt_dev_ptr = NULL;
5225 unsigned long *host_rt_dev_ptr = NULL;
5226 abi_long ret;
5227 int i;
5228
5229 assert(ie->access == IOC_W);
5230 assert(*arg_type == TYPE_PTR);
5231 arg_type++;
5232 assert(*arg_type == TYPE_STRUCT);
5233 target_size = thunk_type_size(arg_type, 0);
5234 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5235 if (!argptr) {
5236 return -TARGET_EFAULT;
5237 }
5238 arg_type++;
5239 assert(*arg_type == (int)STRUCT_rtentry);
5240 se = struct_entries + *arg_type++;
5241 assert(se->convert[0] == NULL);
5242 /* convert struct here to be able to catch rt_dev string */
5243 field_types = se->field_types;
5244 dst_offsets = se->field_offsets[THUNK_HOST];
5245 src_offsets = se->field_offsets[THUNK_TARGET];
5246 for (i = 0; i < se->nb_fields; i++) {
5247 if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) {
5248 assert(*field_types == TYPE_PTRVOID);
5249 target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]);
5250 host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]);
5251 if (*target_rt_dev_ptr != 0) {
5252 *host_rt_dev_ptr = (unsigned long)lock_user_string(
5253 tswapal(*target_rt_dev_ptr));
5254 if (!*host_rt_dev_ptr) {
5255 unlock_user(argptr, arg, 0);
5256 return -TARGET_EFAULT;
5257 }
5258 } else {
5259 *host_rt_dev_ptr = 0;
5260 }
5261 field_types++;
5262 continue;
5263 }
5264 field_types = thunk_convert(buf_temp + dst_offsets[i],
5265 argptr + src_offsets[i],
5266 field_types, THUNK_HOST);
5267 }
5268 unlock_user(argptr, arg, 0);
5269
5270 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5271
5272 assert(host_rt_dev_ptr != NULL);
5273 assert(target_rt_dev_ptr != NULL);
5274 if (*host_rt_dev_ptr != 0) {
5275 unlock_user((void *)*host_rt_dev_ptr,
5276 *target_rt_dev_ptr, 0);
5277 }
5278 return ret;
5279 }
5280
5281 static abi_long do_ioctl_kdsigaccept(const IOCTLEntry *ie, uint8_t *buf_temp,
5282 int fd, int cmd, abi_long arg)
5283 {
5284 int sig = target_to_host_signal(arg);
5285 return get_errno(safe_ioctl(fd, ie->host_cmd, sig));
5286 }
5287
5288 static abi_long do_ioctl_SIOCGSTAMP(const IOCTLEntry *ie, uint8_t *buf_temp,
5289 int fd, int cmd, abi_long arg)
5290 {
5291 struct timeval tv;
5292 abi_long ret;
5293
5294 ret = get_errno(safe_ioctl(fd, SIOCGSTAMP, &tv));
5295 if (is_error(ret)) {
5296 return ret;
5297 }
5298
5299 if (cmd == (int)TARGET_SIOCGSTAMP_OLD) {
5300 if (copy_to_user_timeval(arg, &tv)) {
5301 return -TARGET_EFAULT;
5302 }
5303 } else {
5304 if (copy_to_user_timeval64(arg, &tv)) {
5305 return -TARGET_EFAULT;
5306 }
5307 }
5308
5309 return ret;
5310 }
5311
5312 static abi_long do_ioctl_SIOCGSTAMPNS(const IOCTLEntry *ie, uint8_t *buf_temp,
5313 int fd, int cmd, abi_long arg)
5314 {
5315 struct timespec ts;
5316 abi_long ret;
5317
5318 ret = get_errno(safe_ioctl(fd, SIOCGSTAMPNS, &ts));
5319 if (is_error(ret)) {
5320 return ret;
5321 }
5322
5323 if (cmd == (int)TARGET_SIOCGSTAMPNS_OLD) {
5324 if (host_to_target_timespec(arg, &ts)) {
5325 return -TARGET_EFAULT;
5326 }
5327 } else{
5328 if (host_to_target_timespec64(arg, &ts)) {
5329 return -TARGET_EFAULT;
5330 }
5331 }
5332
5333 return ret;
5334 }
5335
5336 #ifdef TIOCGPTPEER
5337 static abi_long do_ioctl_tiocgptpeer(const IOCTLEntry *ie, uint8_t *buf_temp,
5338 int fd, int cmd, abi_long arg)
5339 {
5340 int flags = target_to_host_bitmask(arg, fcntl_flags_tbl);
5341 return get_errno(safe_ioctl(fd, ie->host_cmd, flags));
5342 }
5343 #endif
5344
5345 #ifdef HAVE_DRM_H
5346
5347 static void unlock_drm_version(struct drm_version *host_ver,
5348 struct target_drm_version *target_ver,
5349 bool copy)
5350 {
5351 unlock_user(host_ver->name, target_ver->name,
5352 copy ? host_ver->name_len : 0);
5353 unlock_user(host_ver->date, target_ver->date,
5354 copy ? host_ver->date_len : 0);
5355 unlock_user(host_ver->desc, target_ver->desc,
5356 copy ? host_ver->desc_len : 0);
5357 }
5358
5359 static inline abi_long target_to_host_drmversion(struct drm_version *host_ver,
5360 struct target_drm_version *target_ver)
5361 {
5362 memset(host_ver, 0, sizeof(*host_ver));
5363
5364 __get_user(host_ver->name_len, &target_ver->name_len);
5365 if (host_ver->name_len) {
5366 host_ver->name = lock_user(VERIFY_WRITE, target_ver->name,
5367 target_ver->name_len, 0);
5368 if (!host_ver->name) {
5369 return -EFAULT;
5370 }
5371 }
5372
5373 __get_user(host_ver->date_len, &target_ver->date_len);
5374 if (host_ver->date_len) {
5375 host_ver->date = lock_user(VERIFY_WRITE, target_ver->date,
5376 target_ver->date_len, 0);
5377 if (!host_ver->date) {
5378 goto err;
5379 }
5380 }
5381
5382 __get_user(host_ver->desc_len, &target_ver->desc_len);
5383 if (host_ver->desc_len) {
5384 host_ver->desc = lock_user(VERIFY_WRITE, target_ver->desc,
5385 target_ver->desc_len, 0);
5386 if (!host_ver->desc) {
5387 goto err;
5388 }
5389 }
5390
5391 return 0;
5392 err:
5393 unlock_drm_version(host_ver, target_ver, false);
5394 return -EFAULT;
5395 }
5396
5397 static inline void host_to_target_drmversion(
5398 struct target_drm_version *target_ver,
5399 struct drm_version *host_ver)
5400 {
5401 __put_user(host_ver->version_major, &target_ver->version_major);
5402 __put_user(host_ver->version_minor, &target_ver->version_minor);
5403 __put_user(host_ver->version_patchlevel, &target_ver->version_patchlevel);
5404 __put_user(host_ver->name_len, &target_ver->name_len);
5405 __put_user(host_ver->date_len, &target_ver->date_len);
5406 __put_user(host_ver->desc_len, &target_ver->desc_len);
5407 unlock_drm_version(host_ver, target_ver, true);
5408 }
5409
5410 static abi_long do_ioctl_drm(const IOCTLEntry *ie, uint8_t *buf_temp,
5411 int fd, int cmd, abi_long arg)
5412 {
5413 struct drm_version *ver;
5414 struct target_drm_version *target_ver;
5415 abi_long ret;
5416
5417 switch (ie->host_cmd) {
5418 case DRM_IOCTL_VERSION:
5419 if (!lock_user_struct(VERIFY_WRITE, target_ver, arg, 0)) {
5420 return -TARGET_EFAULT;
5421 }
5422 ver = (struct drm_version *)buf_temp;
5423 ret = target_to_host_drmversion(ver, target_ver);
5424 if (!is_error(ret)) {
5425 ret = get_errno(safe_ioctl(fd, ie->host_cmd, ver));
5426 if (is_error(ret)) {
5427 unlock_drm_version(ver, target_ver, false);
5428 } else {
5429 host_to_target_drmversion(target_ver, ver);
5430 }
5431 }
5432 unlock_user_struct(target_ver, arg, 0);
5433 return ret;
5434 }
5435 return -TARGET_ENOSYS;
5436 }
5437
5438 static abi_long do_ioctl_drm_i915_getparam(const IOCTLEntry *ie,
5439 struct drm_i915_getparam *gparam,
5440 int fd, abi_long arg)
5441 {
5442 abi_long ret;
5443 int value;
5444 struct target_drm_i915_getparam *target_gparam;
5445
5446 if (!lock_user_struct(VERIFY_READ, target_gparam, arg, 0)) {
5447 return -TARGET_EFAULT;
5448 }
5449
5450 __get_user(gparam->param, &target_gparam->param);
5451 gparam->value = &value;
5452 ret = get_errno(safe_ioctl(fd, ie->host_cmd, gparam));
5453 put_user_s32(value, target_gparam->value);
5454
5455 unlock_user_struct(target_gparam, arg, 0);
5456 return ret;
5457 }
5458
5459 static abi_long do_ioctl_drm_i915(const IOCTLEntry *ie, uint8_t *buf_temp,
5460 int fd, int cmd, abi_long arg)
5461 {
5462 switch (ie->host_cmd) {
5463 case DRM_IOCTL_I915_GETPARAM:
5464 return do_ioctl_drm_i915_getparam(ie,
5465 (struct drm_i915_getparam *)buf_temp,
5466 fd, arg);
5467 default:
5468 return -TARGET_ENOSYS;
5469 }
5470 }
5471
5472 #endif
5473
5474 IOCTLEntry ioctl_entries[] = {
5475 #define IOCTL(cmd, access, ...) \
5476 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5477 #define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5478 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
5479 #define IOCTL_IGNORE(cmd) \
5480 { TARGET_ ## cmd, 0, #cmd },
5481 #include "ioctls.h"
5482 { 0, 0, },
5483 };
5484
5485 /* ??? Implement proper locking for ioctls. */
5486 /* do_ioctl() Must return target values and target errnos. */
5487 static abi_long do_ioctl(int fd, int cmd, abi_long arg)
5488 {
5489 const IOCTLEntry *ie;
5490 const argtype *arg_type;
5491 abi_long ret;
5492 uint8_t buf_temp[MAX_STRUCT_SIZE];
5493 int target_size;
5494 void *argptr;
5495
5496 ie = ioctl_entries;
5497 for(;;) {
5498 if (ie->target_cmd == 0) {
5499 qemu_log_mask(
5500 LOG_UNIMP, "Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
5501 return -TARGET_ENOSYS;
5502 }
5503 if (ie->target_cmd == cmd)
5504 break;
5505 ie++;
5506 }
5507 arg_type = ie->arg_type;
5508 if (ie->do_ioctl) {
5509 return ie->do_ioctl(ie, buf_temp, fd, cmd, arg);
5510 } else if (!ie->host_cmd) {
5511 /* Some architectures define BSD ioctls in their headers
5512 that are not implemented in Linux. */
5513 return -TARGET_ENOSYS;
5514 }
5515
5516 switch(arg_type[0]) {
5517 case TYPE_NULL:
5518 /* no argument */
5519 ret = get_errno(safe_ioctl(fd, ie->host_cmd));
5520 break;
5521 case TYPE_PTRVOID:
5522 case TYPE_INT:
5523 case TYPE_LONG:
5524 case TYPE_ULONG:
5525 ret = get_errno(safe_ioctl(fd, ie->host_cmd, arg));
5526 break;
5527 case TYPE_PTR:
5528 arg_type++;
5529 target_size = thunk_type_size(arg_type, 0);
5530 switch(ie->access) {
5531 case IOC_R:
5532 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5533 if (!is_error(ret)) {
5534 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5535 if (!argptr)
5536 return -TARGET_EFAULT;
5537 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5538 unlock_user(argptr, arg, target_size);
5539 }
5540 break;
5541 case IOC_W:
5542 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5543 if (!argptr)
5544 return -TARGET_EFAULT;
5545 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5546 unlock_user(argptr, arg, 0);
5547 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5548 break;
5549 default:
5550 case IOC_RW:
5551 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5552 if (!argptr)
5553 return -TARGET_EFAULT;
5554 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5555 unlock_user(argptr, arg, 0);
5556 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
5557 if (!is_error(ret)) {
5558 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5559 if (!argptr)
5560 return -TARGET_EFAULT;
5561 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5562 unlock_user(argptr, arg, target_size);
5563 }
5564 break;
5565 }
5566 break;
5567 default:
5568 qemu_log_mask(LOG_UNIMP,
5569 "Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5570 (long)cmd, arg_type[0]);
5571 ret = -TARGET_ENOSYS;
5572 break;
5573 }
5574 return ret;
5575 }
5576
5577 static const bitmask_transtbl iflag_tbl[] = {
5578 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
5579 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
5580 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
5581 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
5582 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
5583 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
5584 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
5585 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
5586 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
5587 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
5588 { TARGET_IXON, TARGET_IXON, IXON, IXON },
5589 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
5590 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
5591 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
5592 { TARGET_IUTF8, TARGET_IUTF8, IUTF8, IUTF8},
5593 { 0, 0, 0, 0 }
5594 };
5595
5596 static const bitmask_transtbl oflag_tbl[] = {
5597 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
5598 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
5599 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
5600 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
5601 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
5602 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
5603 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
5604 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
5605 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
5606 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
5607 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
5608 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
5609 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
5610 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
5611 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
5612 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
5613 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
5614 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
5615 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
5616 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
5617 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
5618 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
5619 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
5620 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
5621 { 0, 0, 0, 0 }
5622 };
5623
5624 static const bitmask_transtbl cflag_tbl[] = {
5625 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
5626 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
5627 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
5628 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
5629 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
5630 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
5631 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
5632 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
5633 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
5634 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
5635 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
5636 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
5637 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
5638 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
5639 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
5640 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
5641 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
5642 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
5643 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
5644 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
5645 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
5646 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
5647 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
5648 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
5649 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
5650 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
5651 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
5652 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
5653 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
5654 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
5655 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
5656 { 0, 0, 0, 0 }
5657 };
5658
5659 static const bitmask_transtbl lflag_tbl[] = {
5660 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
5661 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
5662 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
5663 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
5664 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
5665 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
5666 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
5667 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
5668 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
5669 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
5670 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
5671 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
5672 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
5673 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
5674 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
5675 { TARGET_EXTPROC, TARGET_EXTPROC, EXTPROC, EXTPROC},
5676 { 0, 0, 0, 0 }
5677 };
5678
5679 static void target_to_host_termios (void *dst, const void *src)
5680 {
5681 struct host_termios *host = dst;
5682 const struct target_termios *target = src;
5683
5684 host->c_iflag =
5685 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
5686 host->c_oflag =
5687 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
5688 host->c_cflag =
5689 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
5690 host->c_lflag =
5691 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
5692 host->c_line = target->c_line;
5693
5694 memset(host->c_cc, 0, sizeof(host->c_cc));
5695 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
5696 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
5697 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
5698 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
5699 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
5700 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
5701 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
5702 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
5703 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
5704 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
5705 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
5706 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
5707 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
5708 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
5709 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
5710 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
5711 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
5712 }
5713
5714 static void host_to_target_termios (void *dst, const void *src)
5715 {
5716 struct target_termios *target = dst;
5717 const struct host_termios *host = src;
5718
5719 target->c_iflag =
5720 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
5721 target->c_oflag =
5722 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
5723 target->c_cflag =
5724 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
5725 target->c_lflag =
5726 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
5727 target->c_line = host->c_line;
5728
5729 memset(target->c_cc, 0, sizeof(target->c_cc));
5730 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
5731 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
5732 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
5733 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
5734 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
5735 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
5736 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
5737 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
5738 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
5739 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
5740 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
5741 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
5742 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
5743 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
5744 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
5745 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
5746 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
5747 }
5748
5749 static const StructEntry struct_termios_def = {
5750 .convert = { host_to_target_termios, target_to_host_termios },
5751 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
5752 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
5753 .print = print_termios,
5754 };
5755
5756 static bitmask_transtbl mmap_flags_tbl[] = {
5757 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
5758 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
5759 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
5760 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS,
5761 MAP_ANONYMOUS, MAP_ANONYMOUS },
5762 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN,
5763 MAP_GROWSDOWN, MAP_GROWSDOWN },
5764 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE,
5765 MAP_DENYWRITE, MAP_DENYWRITE },
5766 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE,
5767 MAP_EXECUTABLE, MAP_EXECUTABLE },
5768 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
5769 { TARGET_MAP_NORESERVE, TARGET_MAP_NORESERVE,
5770 MAP_NORESERVE, MAP_NORESERVE },
5771 { TARGET_MAP_HUGETLB, TARGET_MAP_HUGETLB, MAP_HUGETLB, MAP_HUGETLB },
5772 /* MAP_STACK had been ignored by the kernel for quite some time.
5773 Recognize it for the target insofar as we do not want to pass
5774 it through to the host. */
5775 { TARGET_MAP_STACK, TARGET_MAP_STACK, 0, 0 },
5776 { 0, 0, 0, 0 }
5777 };
5778
5779 /*
5780 * NOTE: TARGET_ABI32 is defined for TARGET_I386 (but not for TARGET_X86_64)
5781 * TARGET_I386 is defined if TARGET_X86_64 is defined
5782 */
5783 #if defined(TARGET_I386)
5784
5785 /* NOTE: there is really one LDT for all the threads */
5786 static uint8_t *ldt_table;
5787
5788 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
5789 {
5790 int size;
5791 void *p;
5792
5793 if (!ldt_table)
5794 return 0;
5795 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
5796 if (size > bytecount)
5797 size = bytecount;
5798 p = lock_user(VERIFY_WRITE, ptr, size, 0);
5799 if (!p)
5800 return -TARGET_EFAULT;
5801 /* ??? Should this by byteswapped? */
5802 memcpy(p, ldt_table, size);
5803 unlock_user(p, ptr, size);
5804 return size;
5805 }
5806
5807 /* XXX: add locking support */
5808 static abi_long write_ldt(CPUX86State *env,
5809 abi_ulong ptr, unsigned long bytecount, int oldmode)
5810 {
5811 struct target_modify_ldt_ldt_s ldt_info;
5812 struct target_modify_ldt_ldt_s *target_ldt_info;
5813 int seg_32bit, contents, read_exec_only, limit_in_pages;
5814 int seg_not_present, useable, lm;
5815 uint32_t *lp, entry_1, entry_2;
5816
5817 if (bytecount != sizeof(ldt_info))
5818 return -TARGET_EINVAL;
5819 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
5820 return -TARGET_EFAULT;
5821 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
5822 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
5823 ldt_info.limit = tswap32(target_ldt_info->limit);
5824 ldt_info.flags = tswap32(target_ldt_info->flags);
5825 unlock_user_struct(target_ldt_info, ptr, 0);
5826
5827 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
5828 return -TARGET_EINVAL;
5829 seg_32bit = ldt_info.flags & 1;
5830 contents = (ldt_info.flags >> 1) & 3;
5831 read_exec_only = (ldt_info.flags >> 3) & 1;
5832 limit_in_pages = (ldt_info.flags >> 4) & 1;
5833 seg_not_present = (ldt_info.flags >> 5) & 1;
5834 useable = (ldt_info.flags >> 6) & 1;
5835 #ifdef TARGET_ABI32
5836 lm = 0;
5837 #else
5838 lm = (ldt_info.flags >> 7) & 1;
5839 #endif
5840 if (contents == 3) {
5841 if (oldmode)
5842 return -TARGET_EINVAL;
5843 if (seg_not_present == 0)
5844 return -TARGET_EINVAL;
5845 }
5846 /* allocate the LDT */
5847 if (!ldt_table) {
5848 env->ldt.base = target_mmap(0,
5849 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
5850 PROT_READ|PROT_WRITE,
5851 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
5852 if (env->ldt.base == -1)
5853 return -TARGET_ENOMEM;
5854 memset(g2h(env->ldt.base), 0,
5855 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
5856 env->ldt.limit = 0xffff;
5857 ldt_table = g2h(env->ldt.base);
5858 }
5859
5860 /* NOTE: same code as Linux kernel */
5861 /* Allow LDTs to be cleared by the user. */
5862 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
5863 if (oldmode ||
5864 (contents == 0 &&
5865 read_exec_only == 1 &&
5866 seg_32bit == 0 &&
5867 limit_in_pages == 0 &&
5868 seg_not_present == 1 &&
5869 useable == 0 )) {
5870 entry_1 = 0;
5871 entry_2 = 0;
5872 goto install;
5873 }
5874 }
5875
5876 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
5877 (ldt_info.limit & 0x0ffff);
5878 entry_2 = (ldt_info.base_addr & 0xff000000) |
5879 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
5880 (ldt_info.limit & 0xf0000) |
5881 ((read_exec_only ^ 1) << 9) |
5882 (contents << 10) |
5883 ((seg_not_present ^ 1) << 15) |
5884 (seg_32bit << 22) |
5885 (limit_in_pages << 23) |
5886 (lm << 21) |
5887 0x7000;
5888 if (!oldmode)
5889 entry_2 |= (useable << 20);
5890
5891 /* Install the new entry ... */
5892 install:
5893 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
5894 lp[0] = tswap32(entry_1);
5895 lp[1] = tswap32(entry_2);
5896 return 0;
5897 }
5898
5899 /* specific and weird i386 syscalls */
5900 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
5901 unsigned long bytecount)
5902 {
5903 abi_long ret;
5904
5905 switch (func) {
5906 case 0:
5907 ret = read_ldt(ptr, bytecount);
5908 break;
5909 case 1:
5910 ret = write_ldt(env, ptr, bytecount, 1);
5911 break;
5912 case 0x11:
5913 ret = write_ldt(env, ptr, bytecount, 0);
5914 break;
5915 default:
5916 ret = -TARGET_ENOSYS;
5917 break;
5918 }
5919 return ret;
5920 }
5921
5922 #if defined(TARGET_ABI32)
5923 abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
5924 {
5925 uint64_t *gdt_table = g2h(env->gdt.base);
5926 struct target_modify_ldt_ldt_s ldt_info;
5927 struct target_modify_ldt_ldt_s *target_ldt_info;
5928 int seg_32bit, contents, read_exec_only, limit_in_pages;
5929 int seg_not_present, useable, lm;
5930 uint32_t *lp, entry_1, entry_2;
5931 int i;
5932
5933 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
5934 if (!target_ldt_info)
5935 return -TARGET_EFAULT;
5936 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
5937 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
5938 ldt_info.limit = tswap32(target_ldt_info->limit);
5939 ldt_info.flags = tswap32(target_ldt_info->flags);
5940 if (ldt_info.entry_number == -1) {
5941 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
5942 if (gdt_table[i] == 0) {
5943 ldt_info.entry_number = i;
5944 target_ldt_info->entry_number = tswap32(i);
5945 break;
5946 }
5947 }
5948 }
5949 unlock_user_struct(target_ldt_info, ptr, 1);
5950
5951 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
5952 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
5953 return -TARGET_EINVAL;
5954 seg_32bit = ldt_info.flags & 1;
5955 contents = (ldt_info.flags >> 1) & 3;
5956 read_exec_only = (ldt_info.flags >> 3) & 1;
5957 limit_in_pages = (ldt_info.flags >> 4) & 1;
5958 seg_not_present = (ldt_info.flags >> 5) & 1;
5959 useable = (ldt_info.flags >> 6) & 1;
5960 #ifdef TARGET_ABI32
5961 lm = 0;
5962 #else
5963 lm = (ldt_info.flags >> 7) & 1;
5964 #endif
5965
5966 if (contents == 3) {
5967 if (seg_not_present == 0)
5968 return -TARGET_EINVAL;
5969 }
5970
5971 /* NOTE: same code as Linux kernel */
5972 /* Allow LDTs to be cleared by the user. */
5973 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
5974 if ((contents == 0 &&
5975 read_exec_only == 1 &&
5976 seg_32bit == 0 &&
5977 limit_in_pages == 0 &&
5978 seg_not_present == 1 &&
5979 useable == 0 )) {
5980 entry_1 = 0;
5981 entry_2 = 0;
5982 goto install;
5983 }
5984 }
5985
5986 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
5987 (ldt_info.limit & 0x0ffff);
5988 entry_2 = (ldt_info.base_addr & 0xff000000) |
5989 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
5990 (ldt_info.limit & 0xf0000) |
5991 ((read_exec_only ^ 1) << 9) |
5992 (contents << 10) |
5993 ((seg_not_present ^ 1) << 15) |
5994 (seg_32bit << 22) |
5995 (limit_in_pages << 23) |
5996 (useable << 20) |
5997 (lm << 21) |
5998 0x7000;
5999
6000 /* Install the new entry ... */
6001 install:
6002 lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
6003 lp[0] = tswap32(entry_1);
6004 lp[1] = tswap32(entry_2);
6005 return 0;
6006 }
6007
6008 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
6009 {
6010 struct target_modify_ldt_ldt_s *target_ldt_info;
6011 uint64_t *gdt_table = g2h(env->gdt.base);
6012 uint32_t base_addr, limit, flags;
6013 int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
6014 int seg_not_present, useable, lm;
6015 uint32_t *lp, entry_1, entry_2;
6016
6017 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
6018 if (!target_ldt_info)
6019 return -TARGET_EFAULT;
6020 idx = tswap32(target_ldt_info->entry_number);
6021 if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
6022 idx > TARGET_GDT_ENTRY_TLS_MAX) {
6023 unlock_user_struct(target_ldt_info, ptr, 1);
6024 return -TARGET_EINVAL;
6025 }
6026 lp = (uint32_t *)(gdt_table + idx);
6027 entry_1 = tswap32(lp[0]);
6028 entry_2 = tswap32(lp[1]);
6029
6030 read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
6031 contents = (entry_2 >> 10) & 3;
6032 seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
6033 seg_32bit = (entry_2 >> 22) & 1;
6034 limit_in_pages = (entry_2 >> 23) & 1;
6035 useable = (entry_2 >> 20) & 1;
6036 #ifdef TARGET_ABI32
6037 lm = 0;
6038 #else
6039 lm = (entry_2 >> 21) & 1;
6040 #endif
6041 flags = (seg_32bit << 0) | (contents << 1) |
6042 (read_exec_only << 3) | (limit_in_pages << 4) |
6043 (seg_not_present << 5) | (useable << 6) | (lm << 7);
6044 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000);
6045 base_addr = (entry_1 >> 16) |
6046 (entry_2 & 0xff000000) |
6047 ((entry_2 & 0xff) << 16);
6048 target_ldt_info->base_addr = tswapal(base_addr);
6049 target_ldt_info->limit = tswap32(limit);
6050 target_ldt_info->flags = tswap32(flags);
6051 unlock_user_struct(target_ldt_info, ptr, 1);
6052 return 0;
6053 }
6054
6055 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
6056 {
6057 return -TARGET_ENOSYS;
6058 }
6059 #else
6060 abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
6061 {
6062 abi_long ret = 0;
6063 abi_ulong val;
6064 int idx;
6065
6066 switch(code) {
6067 case TARGET_ARCH_SET_GS:
6068 case TARGET_ARCH_SET_FS:
6069 if (code == TARGET_ARCH_SET_GS)
6070 idx = R_GS;
6071 else
6072 idx = R_FS;
6073 cpu_x86_load_seg(env, idx, 0);
6074 env->segs[idx].base = addr;
6075 break;
6076 case TARGET_ARCH_GET_GS:
6077 case TARGET_ARCH_GET_FS:
6078 if (code == TARGET_ARCH_GET_GS)
6079 idx = R_GS;
6080 else
6081 idx = R_FS;
6082 val = env->segs[idx].base;
6083 if (put_user(val, addr, abi_ulong))
6084 ret = -TARGET_EFAULT;
6085 break;
6086 default:
6087 ret = -TARGET_EINVAL;
6088 break;
6089 }
6090 return ret;
6091 }
6092 #endif /* defined(TARGET_ABI32 */
6093
6094 #endif /* defined(TARGET_I386) */
6095
6096 #define NEW_STACK_SIZE 0x40000
6097
6098
6099 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
6100 typedef struct {
6101 CPUArchState *env;
6102 pthread_mutex_t mutex;
6103 pthread_cond_t cond;
6104 pthread_t thread;
6105 uint32_t tid;
6106 abi_ulong child_tidptr;
6107 abi_ulong parent_tidptr;
6108 sigset_t sigmask;
6109 } new_thread_info;
6110
6111 static void *clone_func(void *arg)
6112 {
6113 new_thread_info *info = arg;
6114 CPUArchState *env;
6115 CPUState *cpu;
6116 TaskState *ts;
6117
6118 rcu_register_thread();
6119 tcg_register_thread();
6120 env = info->env;
6121 cpu = env_cpu(env);
6122 thread_cpu = cpu;
6123 ts = (TaskState *)cpu->opaque;
6124 info->tid = sys_gettid();
6125 task_settid(ts);
6126 if (info->child_tidptr)
6127 put_user_u32(info->tid, info->child_tidptr);
6128 if (info->parent_tidptr)
6129 put_user_u32(info->tid, info->parent_tidptr);
6130 qemu_guest_random_seed_thread_part2(cpu->random_seed);
6131 /* Enable signals. */
6132 sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
6133 /* Signal to the parent that we're ready. */
6134 pthread_mutex_lock(&info->mutex);
6135 pthread_cond_broadcast(&info->cond);
6136 pthread_mutex_unlock(&info->mutex);
6137 /* Wait until the parent has finished initializing the tls state. */
6138 pthread_mutex_lock(&clone_lock);
6139 pthread_mutex_unlock(&clone_lock);
6140 cpu_loop(env);
6141 /* never exits */
6142 return NULL;
6143 }
6144
6145 /* do_fork() Must return host values and target errnos (unlike most
6146 do_*() functions). */
6147 static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
6148 abi_ulong parent_tidptr, target_ulong newtls,
6149 abi_ulong child_tidptr)
6150 {
6151 CPUState *cpu = env_cpu(env);
6152 int ret;
6153 TaskState *ts;
6154 CPUState *new_cpu;
6155 CPUArchState *new_env;
6156 sigset_t sigmask;
6157
6158 flags &= ~CLONE_IGNORED_FLAGS;
6159
6160 /* Emulate vfork() with fork() */
6161 if (flags & CLONE_VFORK)
6162 flags &= ~(CLONE_VFORK | CLONE_VM);
6163
6164 if (flags & CLONE_VM) {
6165 TaskState *parent_ts = (TaskState *)cpu->opaque;
6166 new_thread_info info;
6167 pthread_attr_t attr;
6168
6169 if (((flags & CLONE_THREAD_FLAGS) != CLONE_THREAD_FLAGS) ||
6170 (flags & CLONE_INVALID_THREAD_FLAGS)) {
6171 return -TARGET_EINVAL;
6172 }
6173
6174 ts = g_new0(TaskState, 1);
6175 init_task_state(ts);
6176
6177 /* Grab a mutex so that thread setup appears atomic. */
6178 pthread_mutex_lock(&clone_lock);
6179
6180 /* we create a new CPU instance. */
6181 new_env = cpu_copy(env);
6182 /* Init regs that differ from the parent. */
6183 cpu_clone_regs_child(new_env, newsp, flags);
6184 cpu_clone_regs_parent(env, flags);
6185 new_cpu = env_cpu(new_env);
6186 new_cpu->opaque = ts;
6187 ts->bprm = parent_ts->bprm;
6188 ts->info = parent_ts->info;
6189 ts->signal_mask = parent_ts->signal_mask;
6190
6191 if (flags & CLONE_CHILD_CLEARTID) {
6192 ts->child_tidptr = child_tidptr;
6193 }
6194
6195 if (flags & CLONE_SETTLS) {
6196 cpu_set_tls (new_env, newtls);
6197 }
6198
6199 memset(&info, 0, sizeof(info));
6200 pthread_mutex_init(&info.mutex, NULL);
6201 pthread_mutex_lock(&info.mutex);
6202 pthread_cond_init(&info.cond, NULL);
6203 info.env = new_env;
6204 if (flags & CLONE_CHILD_SETTID) {
6205 info.child_tidptr = child_tidptr;
6206 }
6207 if (flags & CLONE_PARENT_SETTID) {
6208 info.parent_tidptr = parent_tidptr;
6209 }
6210
6211 ret = pthread_attr_init(&attr);
6212 ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE);
6213 ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
6214 /* It is not safe to deliver signals until the child has finished
6215 initializing, so temporarily block all signals. */
6216 sigfillset(&sigmask);
6217 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
6218 cpu->random_seed = qemu_guest_random_seed_thread_part1();
6219
6220 /* If this is our first additional thread, we need to ensure we
6221 * generate code for parallel execution and flush old translations.
6222 */
6223 if (!parallel_cpus) {
6224 parallel_cpus = true;
6225 tb_flush(cpu);
6226 }
6227
6228 ret = pthread_create(&info.thread, &attr, clone_func, &info);
6229 /* TODO: Free new CPU state if thread creation failed. */
6230
6231 sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
6232 pthread_attr_destroy(&attr);
6233 if (ret == 0) {
6234 /* Wait for the child to initialize. */
6235 pthread_cond_wait(&info.cond, &info.mutex);
6236 ret = info.tid;
6237 } else {
6238 ret = -1;
6239 }
6240 pthread_mutex_unlock(&info.mutex);
6241 pthread_cond_destroy(&info.cond);
6242 pthread_mutex_destroy(&info.mutex);
6243 pthread_mutex_unlock(&clone_lock);
6244 } else {
6245 /* if no CLONE_VM, we consider it is a fork */
6246 if (flags & CLONE_INVALID_FORK_FLAGS) {
6247 return -TARGET_EINVAL;
6248 }
6249
6250 /* We can't support custom termination signals */
6251 if ((flags & CSIGNAL) != TARGET_SIGCHLD) {
6252 return -TARGET_EINVAL;
6253 }
6254
6255 if (block_signals()) {
6256 return -TARGET_ERESTARTSYS;
6257 }
6258
6259 fork_start();
6260 ret = fork();
6261 if (ret == 0) {
6262 /* Child Process. */
6263 cpu_clone_regs_child(env, newsp, flags);
6264 fork_end(1);
6265 /* There is a race condition here. The parent process could
6266 theoretically read the TID in the child process before the child
6267 tid is set. This would require using either ptrace
6268 (not implemented) or having *_tidptr to point at a shared memory
6269 mapping. We can't repeat the spinlock hack used above because
6270 the child process gets its own copy of the lock. */
6271 if (flags & CLONE_CHILD_SETTID)
6272 put_user_u32(sys_gettid(), child_tidptr);
6273 if (flags & CLONE_PARENT_SETTID)
6274 put_user_u32(sys_gettid(), parent_tidptr);
6275 ts = (TaskState *)cpu->opaque;
6276 if (flags & CLONE_SETTLS)
6277 cpu_set_tls (env, newtls);
6278 if (flags & CLONE_CHILD_CLEARTID)
6279 ts->child_tidptr = child_tidptr;
6280 } else {
6281 cpu_clone_regs_parent(env, flags);
6282 fork_end(0);
6283 }
6284 }
6285 return ret;
6286 }
6287
6288 /* warning : doesn't handle linux specific flags... */
6289 static int target_to_host_fcntl_cmd(int cmd)
6290 {
6291 int ret;
6292
6293 switch(cmd) {
6294 case TARGET_F_DUPFD:
6295 case TARGET_F_GETFD:
6296 case TARGET_F_SETFD:
6297 case TARGET_F_GETFL:
6298 case TARGET_F_SETFL:
6299 case TARGET_F_OFD_GETLK:
6300 case TARGET_F_OFD_SETLK:
6301 case TARGET_F_OFD_SETLKW:
6302 ret = cmd;
6303 break;
6304 case TARGET_F_GETLK:
6305 ret = F_GETLK64;
6306 break;
6307 case TARGET_F_SETLK:
6308 ret = F_SETLK64;
6309 break;
6310 case TARGET_F_SETLKW:
6311 ret = F_SETLKW64;
6312 break;
6313 case TARGET_F_GETOWN:
6314 ret = F_GETOWN;
6315 break;
6316 case TARGET_F_SETOWN:
6317 ret = F_SETOWN;
6318 break;
6319 case TARGET_F_GETSIG:
6320 ret = F_GETSIG;
6321 break;
6322 case TARGET_F_SETSIG:
6323 ret = F_SETSIG;
6324 break;
6325 #if TARGET_ABI_BITS == 32
6326 case TARGET_F_GETLK64:
6327 ret = F_GETLK64;
6328 break;
6329 case TARGET_F_SETLK64:
6330 ret = F_SETLK64;
6331 break;
6332 case TARGET_F_SETLKW64:
6333 ret = F_SETLKW64;
6334 break;
6335 #endif
6336 case TARGET_F_SETLEASE:
6337 ret = F_SETLEASE;
6338 break;
6339 case TARGET_F_GETLEASE:
6340 ret = F_GETLEASE;
6341 break;
6342 #ifdef F_DUPFD_CLOEXEC
6343 case TARGET_F_DUPFD_CLOEXEC:
6344 ret = F_DUPFD_CLOEXEC;
6345 break;
6346 #endif
6347 case TARGET_F_NOTIFY:
6348 ret = F_NOTIFY;
6349 break;
6350 #ifdef F_GETOWN_EX
6351 case TARGET_F_GETOWN_EX:
6352 ret = F_GETOWN_EX;
6353 break;
6354 #endif
6355 #ifdef F_SETOWN_EX
6356 case TARGET_F_SETOWN_EX:
6357 ret = F_SETOWN_EX;
6358 break;
6359 #endif
6360 #ifdef F_SETPIPE_SZ
6361 case TARGET_F_SETPIPE_SZ:
6362 ret = F_SETPIPE_SZ;
6363 break;
6364 case TARGET_F_GETPIPE_SZ:
6365 ret = F_GETPIPE_SZ;
6366 break;
6367 #endif
6368 default:
6369 ret = -TARGET_EINVAL;
6370 break;
6371 }
6372
6373 #if defined(__powerpc64__)
6374 /* On PPC64, glibc headers has the F_*LK* defined to 12, 13 and 14 and
6375 * is not supported by kernel. The glibc fcntl call actually adjusts
6376 * them to 5, 6 and 7 before making the syscall(). Since we make the
6377 * syscall directly, adjust to what is supported by the kernel.
6378 */
6379 if (ret >= F_GETLK64 && ret <= F_SETLKW64) {
6380 ret -= F_GETLK64 - 5;
6381 }
6382 #endif
6383
6384 return ret;
6385 }
6386
6387 #define FLOCK_TRANSTBL \
6388 switch (type) { \
6389 TRANSTBL_CONVERT(F_RDLCK); \
6390 TRANSTBL_CONVERT(F_WRLCK); \
6391 TRANSTBL_CONVERT(F_UNLCK); \
6392 TRANSTBL_CONVERT(F_EXLCK); \
6393 TRANSTBL_CONVERT(F_SHLCK); \
6394 }
6395
6396 static int target_to_host_flock(int type)
6397 {
6398 #define TRANSTBL_CONVERT(a) case TARGET_##a: return a
6399 FLOCK_TRANSTBL
6400 #undef TRANSTBL_CONVERT
6401 return -TARGET_EINVAL;
6402 }
6403
6404 static int host_to_target_flock(int type)
6405 {
6406 #define TRANSTBL_CONVERT(a) case a: return TARGET_##a
6407 FLOCK_TRANSTBL
6408 #undef TRANSTBL_CONVERT
6409 /* if we don't know how to convert the value coming
6410 * from the host we copy to the target field as-is
6411 */
6412 return type;
6413 }
6414
6415 static inline abi_long copy_from_user_flock(struct flock64 *fl,
6416 abi_ulong target_flock_addr)
6417 {
6418 struct target_flock *target_fl;
6419 int l_type;
6420
6421 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6422 return -TARGET_EFAULT;
6423 }
6424
6425 __get_user(l_type, &target_fl->l_type);
6426 l_type = target_to_host_flock(l_type);
6427 if (l_type < 0) {
6428 return l_type;
6429 }
6430 fl->l_type = l_type;
6431 __get_user(fl->l_whence, &target_fl->l_whence);
6432 __get_user(fl->l_start, &target_fl->l_start);
6433 __get_user(fl->l_len, &target_fl->l_len);
6434 __get_user(fl->l_pid, &target_fl->l_pid);
6435 unlock_user_struct(target_fl, target_flock_addr, 0);
6436 return 0;
6437 }
6438
6439 static inline abi_long copy_to_user_flock(abi_ulong target_flock_addr,
6440 const struct flock64 *fl)
6441 {
6442 struct target_flock *target_fl;
6443 short l_type;
6444
6445 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6446 return -TARGET_EFAULT;
6447 }
6448
6449 l_type = host_to_target_flock(fl->l_type);
6450 __put_user(l_type, &target_fl->l_type);
6451 __put_user(fl->l_whence, &target_fl->l_whence);
6452 __put_user(fl->l_start, &target_fl->l_start);
6453 __put_user(fl->l_len, &target_fl->l_len);
6454 __put_user(fl->l_pid, &target_fl->l_pid);
6455 unlock_user_struct(target_fl, target_flock_addr, 1);
6456 return 0;
6457 }
6458
6459 typedef abi_long from_flock64_fn(struct flock64 *fl, abi_ulong target_addr);
6460 typedef abi_long to_flock64_fn(abi_ulong target_addr, const struct flock64 *fl);
6461
6462 #if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6463 static inline abi_long copy_from_user_oabi_flock64(struct flock64 *fl,
6464 abi_ulong target_flock_addr)
6465 {
6466 struct target_oabi_flock64 *target_fl;
6467 int l_type;
6468
6469 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6470 return -TARGET_EFAULT;
6471 }
6472
6473 __get_user(l_type, &target_fl->l_type);
6474 l_type = target_to_host_flock(l_type);
6475 if (l_type < 0) {
6476 return l_type;
6477 }
6478 fl->l_type = l_type;
6479 __get_user(fl->l_whence, &target_fl->l_whence);
6480 __get_user(fl->l_start, &target_fl->l_start);
6481 __get_user(fl->l_len, &target_fl->l_len);
6482 __get_user(fl->l_pid, &target_fl->l_pid);
6483 unlock_user_struct(target_fl, target_flock_addr, 0);
6484 return 0;
6485 }
6486
6487 static inline abi_long copy_to_user_oabi_flock64(abi_ulong target_flock_addr,
6488 const struct flock64 *fl)
6489 {
6490 struct target_oabi_flock64 *target_fl;
6491 short l_type;
6492
6493 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6494 return -TARGET_EFAULT;
6495 }
6496
6497 l_type = host_to_target_flock(fl->l_type);
6498 __put_user(l_type, &target_fl->l_type);
6499 __put_user(fl->l_whence, &target_fl->l_whence);
6500 __put_user(fl->l_start, &target_fl->l_start);
6501 __put_user(fl->l_len, &target_fl->l_len);
6502 __put_user(fl->l_pid, &target_fl->l_pid);
6503 unlock_user_struct(target_fl, target_flock_addr, 1);
6504 return 0;
6505 }
6506 #endif
6507
6508 static inline abi_long copy_from_user_flock64(struct flock64 *fl,
6509 abi_ulong target_flock_addr)
6510 {
6511 struct target_flock64 *target_fl;
6512 int l_type;
6513
6514 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6515 return -TARGET_EFAULT;
6516 }
6517
6518 __get_user(l_type, &target_fl->l_type);
6519 l_type = target_to_host_flock(l_type);
6520 if (l_type < 0) {
6521 return l_type;
6522 }
6523 fl->l_type = l_type;
6524 __get_user(fl->l_whence, &target_fl->l_whence);
6525 __get_user(fl->l_start, &target_fl->l_start);
6526 __get_user(fl->l_len, &target_fl->l_len);
6527 __get_user(fl->l_pid, &target_fl->l_pid);
6528 unlock_user_struct(target_fl, target_flock_addr, 0);
6529 return 0;
6530 }
6531
6532 static inline abi_long copy_to_user_flock64(abi_ulong target_flock_addr,
6533 const struct flock64 *fl)
6534 {
6535 struct target_flock64 *target_fl;
6536 short l_type;
6537
6538 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6539 return -TARGET_EFAULT;
6540 }
6541
6542 l_type = host_to_target_flock(fl->l_type);
6543 __put_user(l_type, &target_fl->l_type);
6544 __put_user(fl->l_whence, &target_fl->l_whence);
6545 __put_user(fl->l_start, &target_fl->l_start);
6546 __put_user(fl->l_len, &target_fl->l_len);
6547 __put_user(fl->l_pid, &target_fl->l_pid);
6548 unlock_user_struct(target_fl, target_flock_addr, 1);
6549 return 0;
6550 }
6551
6552 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
6553 {
6554 struct flock64 fl64;
6555 #ifdef F_GETOWN_EX
6556 struct f_owner_ex fox;
6557 struct target_f_owner_ex *target_fox;
6558 #endif
6559 abi_long ret;
6560 int host_cmd = target_to_host_fcntl_cmd(cmd);
6561
6562 if (host_cmd == -TARGET_EINVAL)
6563 return host_cmd;
6564
6565 switch(cmd) {
6566 case TARGET_F_GETLK:
6567 ret = copy_from_user_flock(&fl64, arg);
6568 if (ret) {
6569 return ret;
6570 }
6571 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
6572 if (ret == 0) {
6573 ret = copy_to_user_flock(arg, &fl64);
6574 }
6575 break;
6576
6577 case TARGET_F_SETLK:
6578 case TARGET_F_SETLKW:
6579 ret = copy_from_user_flock(&fl64, arg);
6580 if (ret) {
6581 return ret;
6582 }
6583 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
6584 break;
6585
6586 case TARGET_F_GETLK64:
6587 case TARGET_F_OFD_GETLK:
6588 ret = copy_from_user_flock64(&fl64, arg);
6589 if (ret) {
6590 return ret;
6591 }
6592 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
6593 if (ret == 0) {
6594 ret = copy_to_user_flock64(arg, &fl64);
6595 }
6596 break;
6597 case TARGET_F_SETLK64:
6598 case TARGET_F_SETLKW64:
6599 case TARGET_F_OFD_SETLK:
6600 case TARGET_F_OFD_SETLKW:
6601 ret = copy_from_user_flock64(&fl64, arg);
6602 if (ret) {
6603 return ret;
6604 }
6605 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
6606 break;
6607
6608 case TARGET_F_GETFL:
6609 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
6610 if (ret >= 0) {
6611 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
6612 }
6613 break;
6614
6615 case TARGET_F_SETFL:
6616 ret = get_errno(safe_fcntl(fd, host_cmd,
6617 target_to_host_bitmask(arg,
6618 fcntl_flags_tbl)));
6619 break;
6620
6621 #ifdef F_GETOWN_EX
6622 case TARGET_F_GETOWN_EX:
6623 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
6624 if (ret >= 0) {
6625 if (!lock_user_struct(VERIFY_WRITE, target_fox, arg, 0))
6626 return -TARGET_EFAULT;
6627 target_fox->type = tswap32(fox.type);
6628 target_fox->pid = tswap32(fox.pid);
6629 unlock_user_struct(target_fox, arg, 1);
6630 }
6631 break;
6632 #endif
6633
6634 #ifdef F_SETOWN_EX
6635 case TARGET_F_SETOWN_EX:
6636 if (!lock_user_struct(VERIFY_READ, target_fox, arg, 1))
6637 return -TARGET_EFAULT;
6638 fox.type = tswap32(target_fox->type);
6639 fox.pid = tswap32(target_fox->pid);
6640 unlock_user_struct(target_fox, arg, 0);
6641 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
6642 break;
6643 #endif
6644
6645 case TARGET_F_SETOWN:
6646 case TARGET_F_GETOWN:
6647 case TARGET_F_SETSIG:
6648 case TARGET_F_GETSIG:
6649 case TARGET_F_SETLEASE:
6650 case TARGET_F_GETLEASE:
6651 case TARGET_F_SETPIPE_SZ:
6652 case TARGET_F_GETPIPE_SZ:
6653 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
6654 break;
6655
6656 default:
6657 ret = get_errno(safe_fcntl(fd, cmd, arg));
6658 break;
6659 }
6660 return ret;
6661 }
6662
6663 #ifdef USE_UID16
6664
6665 static inline int high2lowuid(int uid)
6666 {
6667 if (uid > 65535)
6668 return 65534;
6669 else
6670 return uid;
6671 }
6672
6673 static inline int high2lowgid(int gid)
6674 {
6675 if (gid > 65535)
6676 return 65534;
6677 else
6678 return gid;
6679 }
6680
6681 static inline int low2highuid(int uid)
6682 {
6683 if ((int16_t)uid == -1)
6684 return -1;
6685 else
6686 return uid;
6687 }
6688
6689 static inline int low2highgid(int gid)
6690 {
6691 if ((int16_t)gid == -1)
6692 return -1;
6693 else
6694 return gid;
6695 }
6696 static inline int tswapid(int id)
6697 {
6698 return tswap16(id);
6699 }
6700
6701 #define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6702
6703 #else /* !USE_UID16 */
6704 static inline int high2lowuid(int uid)
6705 {
6706 return uid;
6707 }
6708 static inline int high2lowgid(int gid)
6709 {
6710 return gid;
6711 }
6712 static inline int low2highuid(int uid)
6713 {
6714 return uid;
6715 }
6716 static inline int low2highgid(int gid)
6717 {
6718 return gid;
6719 }
6720 static inline int tswapid(int id)
6721 {
6722 return tswap32(id);
6723 }
6724
6725 #define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6726
6727 #endif /* USE_UID16 */
6728
6729 /* We must do direct syscalls for setting UID/GID, because we want to
6730 * implement the Linux system call semantics of "change only for this thread",
6731 * not the libc/POSIX semantics of "change for all threads in process".
6732 * (See http://ewontfix.com/17/ for more details.)
6733 * We use the 32-bit version of the syscalls if present; if it is not
6734 * then either the host architecture supports 32-bit UIDs natively with
6735 * the standard syscall, or the 16-bit UID is the best we can do.
6736 */
6737 #ifdef __NR_setuid32
6738 #define __NR_sys_setuid __NR_setuid32
6739 #else
6740 #define __NR_sys_setuid __NR_setuid
6741 #endif
6742 #ifdef __NR_setgid32
6743 #define __NR_sys_setgid __NR_setgid32
6744 #else
6745 #define __NR_sys_setgid __NR_setgid
6746 #endif
6747 #ifdef __NR_setresuid32
6748 #define __NR_sys_setresuid __NR_setresuid32
6749 #else
6750 #define __NR_sys_setresuid __NR_setresuid
6751 #endif
6752 #ifdef __NR_setresgid32
6753 #define __NR_sys_setresgid __NR_setresgid32
6754 #else
6755 #define __NR_sys_setresgid __NR_setresgid
6756 #endif
6757
6758 _syscall1(int, sys_setuid, uid_t, uid)
6759 _syscall1(int, sys_setgid, gid_t, gid)
6760 _syscall3(int, sys_setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
6761 _syscall3(int, sys_setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
6762
6763 void syscall_init(void)
6764 {
6765 IOCTLEntry *ie;
6766 const argtype *arg_type;
6767 int size;
6768 int i;
6769
6770 thunk_init(STRUCT_MAX);
6771
6772 #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
6773 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
6774 #include "syscall_types.h"
6775 #undef STRUCT
6776 #undef STRUCT_SPECIAL
6777
6778 /* Build target_to_host_errno_table[] table from
6779 * host_to_target_errno_table[]. */
6780 for (i = 0; i < ERRNO_TABLE_SIZE; i++) {
6781 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
6782 }
6783
6784 /* we patch the ioctl size if necessary. We rely on the fact that
6785 no ioctl has all the bits at '1' in the size field */
6786 ie = ioctl_entries;
6787 while (ie->target_cmd != 0) {
6788 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
6789 TARGET_IOC_SIZEMASK) {
6790 arg_type = ie->arg_type;
6791 if (arg_type[0] != TYPE_PTR) {
6792 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
6793 ie->target_cmd);
6794 exit(1);
6795 }
6796 arg_type++;
6797 size = thunk_type_size(arg_type, 0);
6798 ie->target_cmd = (ie->target_cmd &
6799 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
6800 (size << TARGET_IOC_SIZESHIFT);
6801 }
6802
6803 /* automatic consistency check if same arch */
6804 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6805 (defined(__x86_64__) && defined(TARGET_X86_64))
6806 if (unlikely(ie->target_cmd != ie->host_cmd)) {
6807 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6808 ie->name, ie->target_cmd, ie->host_cmd);
6809 }
6810 #endif
6811 ie++;
6812 }
6813 }
6814
6815 #ifdef TARGET_NR_truncate64
6816 static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
6817 abi_long arg2,
6818 abi_long arg3,
6819 abi_long arg4)
6820 {
6821 if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) {
6822 arg2 = arg3;
6823 arg3 = arg4;
6824 }
6825 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
6826 }
6827 #endif
6828
6829 #ifdef TARGET_NR_ftruncate64
6830 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
6831 abi_long arg2,
6832 abi_long arg3,
6833 abi_long arg4)
6834 {
6835 if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) {
6836 arg2 = arg3;
6837 arg3 = arg4;
6838 }
6839 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
6840 }
6841 #endif
6842
6843 #if defined(TARGET_NR_timer_settime) || \
6844 (defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD))
6845 static inline abi_long target_to_host_itimerspec(struct itimerspec *host_its,
6846 abi_ulong target_addr)
6847 {
6848 if (target_to_host_timespec(&host_its->it_interval, target_addr +
6849 offsetof(struct target_itimerspec,
6850 it_interval)) ||
6851 target_to_host_timespec(&host_its->it_value, target_addr +
6852 offsetof(struct target_itimerspec,
6853 it_value))) {
6854 return -TARGET_EFAULT;
6855 }
6856
6857 return 0;
6858 }
6859 #endif
6860
6861 #if defined(TARGET_NR_timer_settime64) || \
6862 (defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD))
6863 static inline abi_long target_to_host_itimerspec64(struct itimerspec *host_its,
6864 abi_ulong target_addr)
6865 {
6866 if (target_to_host_timespec64(&host_its->it_interval, target_addr +
6867 offsetof(struct target__kernel_itimerspec,
6868 it_interval)) ||
6869 target_to_host_timespec64(&host_its->it_value, target_addr +
6870 offsetof(struct target__kernel_itimerspec,
6871 it_value))) {
6872 return -TARGET_EFAULT;
6873 }
6874
6875 return 0;
6876 }
6877 #endif
6878
6879 #if ((defined(TARGET_NR_timerfd_gettime) || \
6880 defined(TARGET_NR_timerfd_settime)) && defined(CONFIG_TIMERFD)) || \
6881 defined(TARGET_NR_timer_gettime) || defined(TARGET_NR_timer_settime)
6882 static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
6883 struct itimerspec *host_its)
6884 {
6885 if (host_to_target_timespec(target_addr + offsetof(struct target_itimerspec,
6886 it_interval),
6887 &host_its->it_interval) ||
6888 host_to_target_timespec(target_addr + offsetof(struct target_itimerspec,
6889 it_value),
6890 &host_its->it_value)) {
6891 return -TARGET_EFAULT;
6892 }
6893 return 0;
6894 }
6895 #endif
6896
6897 #if ((defined(TARGET_NR_timerfd_gettime64) || \
6898 defined(TARGET_NR_timerfd_settime64)) && defined(CONFIG_TIMERFD)) || \
6899 defined(TARGET_NR_timer_gettime64) || defined(TARGET_NR_timer_settime64)
6900 static inline abi_long host_to_target_itimerspec64(abi_ulong target_addr,
6901 struct itimerspec *host_its)
6902 {
6903 if (host_to_target_timespec64(target_addr +
6904 offsetof(struct target__kernel_itimerspec,
6905 it_interval),
6906 &host_its->it_interval) ||
6907 host_to_target_timespec64(target_addr +
6908 offsetof(struct target__kernel_itimerspec,
6909 it_value),
6910 &host_its->it_value)) {
6911 return -TARGET_EFAULT;
6912 }
6913 return 0;
6914 }
6915 #endif
6916
6917 #if defined(TARGET_NR_adjtimex) || \
6918 (defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME))
6919 static inline abi_long target_to_host_timex(struct timex *host_tx,
6920 abi_long target_addr)
6921 {
6922 struct target_timex *target_tx;
6923
6924 if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
6925 return -TARGET_EFAULT;
6926 }
6927
6928 __get_user(host_tx->modes, &target_tx->modes);
6929 __get_user(host_tx->offset, &target_tx->offset);
6930 __get_user(host_tx->freq, &target_tx->freq);
6931 __get_user(host_tx->maxerror, &target_tx->maxerror);
6932 __get_user(host_tx->esterror, &target_tx->esterror);
6933 __get_user(host_tx->status, &target_tx->status);
6934 __get_user(host_tx->constant, &target_tx->constant);
6935 __get_user(host_tx->precision, &target_tx->precision);
6936 __get_user(host_tx->tolerance, &target_tx->tolerance);
6937 __get_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
6938 __get_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
6939 __get_user(host_tx->tick, &target_tx->tick);
6940 __get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
6941 __get_user(host_tx->jitter, &target_tx->jitter);
6942 __get_user(host_tx->shift, &target_tx->shift);
6943 __get_user(host_tx->stabil, &target_tx->stabil);
6944 __get_user(host_tx->jitcnt, &target_tx->jitcnt);
6945 __get_user(host_tx->calcnt, &target_tx->calcnt);
6946 __get_user(host_tx->errcnt, &target_tx->errcnt);
6947 __get_user(host_tx->stbcnt, &target_tx->stbcnt);
6948 __get_user(host_tx->tai, &target_tx->tai);
6949
6950 unlock_user_struct(target_tx, target_addr, 0);
6951 return 0;
6952 }
6953
6954 static inline abi_long host_to_target_timex(abi_long target_addr,
6955 struct timex *host_tx)
6956 {
6957 struct target_timex *target_tx;
6958
6959 if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
6960 return -TARGET_EFAULT;
6961 }
6962
6963 __put_user(host_tx->modes, &target_tx->modes);
6964 __put_user(host_tx->offset, &target_tx->offset);
6965 __put_user(host_tx->freq, &target_tx->freq);
6966 __put_user(host_tx->maxerror, &target_tx->maxerror);
6967 __put_user(host_tx->esterror, &target_tx->esterror);
6968 __put_user(host_tx->status, &target_tx->status);
6969 __put_user(host_tx->constant, &target_tx->constant);
6970 __put_user(host_tx->precision, &target_tx->precision);
6971 __put_user(host_tx->tolerance, &target_tx->tolerance);
6972 __put_user(host_tx->time.tv_sec, &target_tx->time.tv_sec);
6973 __put_user(host_tx->time.tv_usec, &target_tx->time.tv_usec);
6974 __put_user(host_tx->tick, &target_tx->tick);
6975 __put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
6976 __put_user(host_tx->jitter, &target_tx->jitter);
6977 __put_user(host_tx->shift, &target_tx->shift);
6978 __put_user(host_tx->stabil, &target_tx->stabil);
6979 __put_user(host_tx->jitcnt, &target_tx->jitcnt);
6980 __put_user(host_tx->calcnt, &target_tx->calcnt);
6981 __put_user(host_tx->errcnt, &target_tx->errcnt);
6982 __put_user(host_tx->stbcnt, &target_tx->stbcnt);
6983 __put_user(host_tx->tai, &target_tx->tai);
6984
6985 unlock_user_struct(target_tx, target_addr, 1);
6986 return 0;
6987 }
6988 #endif
6989
6990
6991 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
6992 static inline abi_long target_to_host_timex64(struct timex *host_tx,
6993 abi_long target_addr)
6994 {
6995 struct target__kernel_timex *target_tx;
6996
6997 if (copy_from_user_timeval64(&host_tx->time, target_addr +
6998 offsetof(struct target__kernel_timex,
6999 time))) {
7000 return -TARGET_EFAULT;
7001 }
7002
7003 if (!lock_user_struct(VERIFY_READ, target_tx, target_addr, 1)) {
7004 return -TARGET_EFAULT;
7005 }
7006
7007 __get_user(host_tx->modes, &target_tx->modes);
7008 __get_user(host_tx->offset, &target_tx->offset);
7009 __get_user(host_tx->freq, &target_tx->freq);
7010 __get_user(host_tx->maxerror, &target_tx->maxerror);
7011 __get_user(host_tx->esterror, &target_tx->esterror);
7012 __get_user(host_tx->status, &target_tx->status);
7013 __get_user(host_tx->constant, &target_tx->constant);
7014 __get_user(host_tx->precision, &target_tx->precision);
7015 __get_user(host_tx->tolerance, &target_tx->tolerance);
7016 __get_user(host_tx->tick, &target_tx->tick);
7017 __get_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7018 __get_user(host_tx->jitter, &target_tx->jitter);
7019 __get_user(host_tx->shift, &target_tx->shift);
7020 __get_user(host_tx->stabil, &target_tx->stabil);
7021 __get_user(host_tx->jitcnt, &target_tx->jitcnt);
7022 __get_user(host_tx->calcnt, &target_tx->calcnt);
7023 __get_user(host_tx->errcnt, &target_tx->errcnt);
7024 __get_user(host_tx->stbcnt, &target_tx->stbcnt);
7025 __get_user(host_tx->tai, &target_tx->tai);
7026
7027 unlock_user_struct(target_tx, target_addr, 0);
7028 return 0;
7029 }
7030
7031 static inline abi_long host_to_target_timex64(abi_long target_addr,
7032 struct timex *host_tx)
7033 {
7034 struct target__kernel_timex *target_tx;
7035
7036 if (copy_to_user_timeval64(target_addr +
7037 offsetof(struct target__kernel_timex, time),
7038 &host_tx->time)) {
7039 return -TARGET_EFAULT;
7040 }
7041
7042 if (!lock_user_struct(VERIFY_WRITE, target_tx, target_addr, 0)) {
7043 return -TARGET_EFAULT;
7044 }
7045
7046 __put_user(host_tx->modes, &target_tx->modes);
7047 __put_user(host_tx->offset, &target_tx->offset);
7048 __put_user(host_tx->freq, &target_tx->freq);
7049 __put_user(host_tx->maxerror, &target_tx->maxerror);
7050 __put_user(host_tx->esterror, &target_tx->esterror);
7051 __put_user(host_tx->status, &target_tx->status);
7052 __put_user(host_tx->constant, &target_tx->constant);
7053 __put_user(host_tx->precision, &target_tx->precision);
7054 __put_user(host_tx->tolerance, &target_tx->tolerance);
7055 __put_user(host_tx->tick, &target_tx->tick);
7056 __put_user(host_tx->ppsfreq, &target_tx->ppsfreq);
7057 __put_user(host_tx->jitter, &target_tx->jitter);
7058 __put_user(host_tx->shift, &target_tx->shift);
7059 __put_user(host_tx->stabil, &target_tx->stabil);
7060 __put_user(host_tx->jitcnt, &target_tx->jitcnt);
7061 __put_user(host_tx->calcnt, &target_tx->calcnt);
7062 __put_user(host_tx->errcnt, &target_tx->errcnt);
7063 __put_user(host_tx->stbcnt, &target_tx->stbcnt);
7064 __put_user(host_tx->tai, &target_tx->tai);
7065
7066 unlock_user_struct(target_tx, target_addr, 1);
7067 return 0;
7068 }
7069 #endif
7070
7071 static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp,
7072 abi_ulong target_addr)
7073 {
7074 struct target_sigevent *target_sevp;
7075
7076 if (!lock_user_struct(VERIFY_READ, target_sevp, target_addr, 1)) {
7077 return -TARGET_EFAULT;
7078 }
7079
7080 /* This union is awkward on 64 bit systems because it has a 32 bit
7081 * integer and a pointer in it; we follow the conversion approach
7082 * used for handling sigval types in signal.c so the guest should get
7083 * the correct value back even if we did a 64 bit byteswap and it's
7084 * using the 32 bit integer.
7085 */
7086 host_sevp->sigev_value.sival_ptr =
7087 (void *)(uintptr_t)tswapal(target_sevp->sigev_value.sival_ptr);
7088 host_sevp->sigev_signo =
7089 target_to_host_signal(tswap32(target_sevp->sigev_signo));
7090 host_sevp->sigev_notify = tswap32(target_sevp->sigev_notify);
7091 host_sevp->_sigev_un._tid = tswap32(target_sevp->_sigev_un._tid);
7092
7093 unlock_user_struct(target_sevp, target_addr, 1);
7094 return 0;
7095 }
7096
7097 #if defined(TARGET_NR_mlockall)
7098 static inline int target_to_host_mlockall_arg(int arg)
7099 {
7100 int result = 0;
7101
7102 if (arg & TARGET_MCL_CURRENT) {
7103 result |= MCL_CURRENT;
7104 }
7105 if (arg & TARGET_MCL_FUTURE) {
7106 result |= MCL_FUTURE;
7107 }
7108 #ifdef MCL_ONFAULT
7109 if (arg & TARGET_MCL_ONFAULT) {
7110 result |= MCL_ONFAULT;
7111 }
7112 #endif
7113
7114 return result;
7115 }
7116 #endif
7117
7118 #if (defined(TARGET_NR_stat64) || defined(TARGET_NR_lstat64) || \
7119 defined(TARGET_NR_fstat64) || defined(TARGET_NR_fstatat64) || \
7120 defined(TARGET_NR_newfstatat))
7121 static inline abi_long host_to_target_stat64(void *cpu_env,
7122 abi_ulong target_addr,
7123 struct stat *host_st)
7124 {
7125 #if defined(TARGET_ARM) && defined(TARGET_ABI32)
7126 if (((CPUARMState *)cpu_env)->eabi) {
7127 struct target_eabi_stat64 *target_st;
7128
7129 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7130 return -TARGET_EFAULT;
7131 memset(target_st, 0, sizeof(struct target_eabi_stat64));
7132 __put_user(host_st->st_dev, &target_st->st_dev);
7133 __put_user(host_st->st_ino, &target_st->st_ino);
7134 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7135 __put_user(host_st->st_ino, &target_st->__st_ino);
7136 #endif
7137 __put_user(host_st->st_mode, &target_st->st_mode);
7138 __put_user(host_st->st_nlink, &target_st->st_nlink);
7139 __put_user(host_st->st_uid, &target_st->st_uid);
7140 __put_user(host_st->st_gid, &target_st->st_gid);
7141 __put_user(host_st->st_rdev, &target_st->st_rdev);
7142 __put_user(host_st->st_size, &target_st->st_size);
7143 __put_user(host_st->st_blksize, &target_st->st_blksize);
7144 __put_user(host_st->st_blocks, &target_st->st_blocks);
7145 __put_user(host_st->st_atime, &target_st->target_st_atime);
7146 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7147 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7148 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
7149 __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec);
7150 __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec);
7151 __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec);
7152 #endif
7153 unlock_user_struct(target_st, target_addr, 1);
7154 } else
7155 #endif
7156 {
7157 #if defined(TARGET_HAS_STRUCT_STAT64)
7158 struct target_stat64 *target_st;
7159 #else
7160 struct target_stat *target_st;
7161 #endif
7162
7163 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
7164 return -TARGET_EFAULT;
7165 memset(target_st, 0, sizeof(*target_st));
7166 __put_user(host_st->st_dev, &target_st->st_dev);
7167 __put_user(host_st->st_ino, &target_st->st_ino);
7168 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
7169 __put_user(host_st->st_ino, &target_st->__st_ino);
7170 #endif
7171 __put_user(host_st->st_mode, &target_st->st_mode);
7172 __put_user(host_st->st_nlink, &target_st->st_nlink);
7173 __put_user(host_st->st_uid, &target_st->st_uid);
7174 __put_user(host_st->st_gid, &target_st->st_gid);
7175 __put_user(host_st->st_rdev, &target_st->st_rdev);
7176 /* XXX: better use of kernel struct */
7177 __put_user(host_st->st_size, &target_st->st_size);
7178 __put_user(host_st->st_blksize, &target_st->st_blksize);
7179 __put_user(host_st->st_blocks, &target_st->st_blocks);
7180 __put_user(host_st->st_atime, &target_st->target_st_atime);
7181 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
7182 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
7183 #if _POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700
7184 __put_user(host_st->st_atim.tv_nsec, &target_st->target_st_atime_nsec);
7185 __put_user(host_st->st_mtim.tv_nsec, &target_st->target_st_mtime_nsec);
7186 __put_user(host_st->st_ctim.tv_nsec, &target_st->target_st_ctime_nsec);
7187 #endif
7188 unlock_user_struct(target_st, target_addr, 1);
7189 }
7190
7191 return 0;
7192 }
7193 #endif
7194
7195 #if defined(TARGET_NR_statx) && defined(__NR_statx)
7196 static inline abi_long host_to_target_statx(struct target_statx *host_stx,
7197 abi_ulong target_addr)
7198 {
7199 struct target_statx *target_stx;
7200
7201 if (!lock_user_struct(VERIFY_WRITE, target_stx, target_addr, 0)) {
7202 return -TARGET_EFAULT;
7203 }
7204 memset(target_stx, 0, sizeof(*target_stx));
7205
7206 __put_user(host_stx->stx_mask, &target_stx->stx_mask);
7207 __put_user(host_stx->stx_blksize, &target_stx->stx_blksize);
7208 __put_user(host_stx->stx_attributes, &target_stx->stx_attributes);
7209 __put_user(host_stx->stx_nlink, &target_stx->stx_nlink);
7210 __put_user(host_stx->stx_uid, &target_stx->stx_uid);
7211 __put_user(host_stx->stx_gid, &target_stx->stx_gid);
7212 __put_user(host_stx->stx_mode, &target_stx->stx_mode);
7213 __put_user(host_stx->stx_ino, &target_stx->stx_ino);
7214 __put_user(host_stx->stx_size, &target_stx->stx_size);
7215 __put_user(host_stx->stx_blocks, &target_stx->stx_blocks);
7216 __put_user(host_stx->stx_attributes_mask, &target_stx->stx_attributes_mask);
7217 __put_user(host_stx->stx_atime.tv_sec, &target_stx->stx_atime.tv_sec);
7218 __put_user(host_stx->stx_atime.tv_nsec, &target_stx->stx_atime.tv_nsec);
7219 __put_user(host_stx->stx_btime.tv_sec, &target_stx->stx_btime.tv_sec);
7220 __put_user(host_stx->stx_btime.tv_nsec, &target_stx->stx_btime.tv_nsec);
7221 __put_user(host_stx->stx_ctime.tv_sec, &target_stx->stx_ctime.tv_sec);
7222 __put_user(host_stx->stx_ctime.tv_nsec, &target_stx->stx_ctime.tv_nsec);
7223 __put_user(host_stx->stx_mtime.tv_sec, &target_stx->stx_mtime.tv_sec);
7224 __put_user(host_stx->stx_mtime.tv_nsec, &target_stx->stx_mtime.tv_nsec);
7225 __put_user(host_stx->stx_rdev_major, &target_stx->stx_rdev_major);
7226 __put_user(host_stx->stx_rdev_minor, &target_stx->stx_rdev_minor);
7227 __put_user(host_stx->stx_dev_major, &target_stx->stx_dev_major);
7228 __put_user(host_stx->stx_dev_minor, &target_stx->stx_dev_minor);
7229
7230 unlock_user_struct(target_stx, target_addr, 1);
7231
7232 return 0;
7233 }
7234 #endif
7235
7236 static int do_sys_futex(int *uaddr, int op, int val,
7237 const struct timespec *timeout, int *uaddr2,
7238 int val3)
7239 {
7240 #if HOST_LONG_BITS == 64
7241 #if defined(__NR_futex)
7242 /* always a 64-bit time_t, it doesn't define _time64 version */
7243 return sys_futex(uaddr, op, val, timeout, uaddr2, val3);
7244
7245 #endif
7246 #else /* HOST_LONG_BITS == 64 */
7247 #if defined(__NR_futex_time64)
7248 if (sizeof(timeout->tv_sec) == 8) {
7249 /* _time64 function on 32bit arch */
7250 return sys_futex_time64(uaddr, op, val, timeout, uaddr2, val3);
7251 }
7252 #endif
7253 #if defined(__NR_futex)
7254 /* old function on 32bit arch */
7255 return sys_futex(uaddr, op, val, timeout, uaddr2, val3);
7256 #endif
7257 #endif /* HOST_LONG_BITS == 64 */
7258 g_assert_not_reached();
7259 }
7260
7261 static int do_safe_futex(int *uaddr, int op, int val,
7262 const struct timespec *timeout, int *uaddr2,
7263 int val3)
7264 {
7265 #if HOST_LONG_BITS == 64
7266 #if defined(__NR_futex)
7267 /* always a 64-bit time_t, it doesn't define _time64 version */
7268 return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3));
7269 #endif
7270 #else /* HOST_LONG_BITS == 64 */
7271 #if defined(__NR_futex_time64)
7272 if (sizeof(timeout->tv_sec) == 8) {
7273 /* _time64 function on 32bit arch */
7274 return get_errno(safe_futex_time64(uaddr, op, val, timeout, uaddr2,
7275 val3));
7276 }
7277 #endif
7278 #if defined(__NR_futex)
7279 /* old function on 32bit arch */
7280 return get_errno(safe_futex(uaddr, op, val, timeout, uaddr2, val3));
7281 #endif
7282 #endif /* HOST_LONG_BITS == 64 */
7283 return -TARGET_ENOSYS;
7284 }
7285
7286 /* ??? Using host futex calls even when target atomic operations
7287 are not really atomic probably breaks things. However implementing
7288 futexes locally would make futexes shared between multiple processes
7289 tricky. However they're probably useless because guest atomic
7290 operations won't work either. */
7291 #if defined(TARGET_NR_futex)
7292 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
7293 target_ulong uaddr2, int val3)
7294 {
7295 struct timespec ts, *pts;
7296 int base_op;
7297
7298 /* ??? We assume FUTEX_* constants are the same on both host
7299 and target. */
7300 #ifdef FUTEX_CMD_MASK
7301 base_op = op & FUTEX_CMD_MASK;
7302 #else
7303 base_op = op;
7304 #endif
7305 switch (base_op) {
7306 case FUTEX_WAIT:
7307 case FUTEX_WAIT_BITSET:
7308 if (timeout) {
7309 pts = &ts;
7310 target_to_host_timespec(pts, timeout);
7311 } else {
7312 pts = NULL;
7313 }
7314 return do_safe_futex(g2h(uaddr), op, tswap32(val), pts, NULL, val3);
7315 case FUTEX_WAKE:
7316 return do_safe_futex(g2h(uaddr), op, val, NULL, NULL, 0);
7317 case FUTEX_FD:
7318 return do_safe_futex(g2h(uaddr), op, val, NULL, NULL, 0);
7319 case FUTEX_REQUEUE:
7320 case FUTEX_CMP_REQUEUE:
7321 case FUTEX_WAKE_OP:
7322 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7323 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7324 But the prototype takes a `struct timespec *'; insert casts
7325 to satisfy the compiler. We do not need to tswap TIMEOUT
7326 since it's not compared to guest memory. */
7327 pts = (struct timespec *)(uintptr_t) timeout;
7328 return do_safe_futex(g2h(uaddr), op, val, pts, g2h(uaddr2),
7329 (base_op == FUTEX_CMP_REQUEUE
7330 ? tswap32(val3)
7331 : val3));
7332 default:
7333 return -TARGET_ENOSYS;
7334 }
7335 }
7336 #endif
7337
7338 #if defined(TARGET_NR_futex_time64)
7339 static int do_futex_time64(target_ulong uaddr, int op, int val, target_ulong timeout,
7340 target_ulong uaddr2, int val3)
7341 {
7342 struct timespec ts, *pts;
7343 int base_op;
7344
7345 /* ??? We assume FUTEX_* constants are the same on both host
7346 and target. */
7347 #ifdef FUTEX_CMD_MASK
7348 base_op = op & FUTEX_CMD_MASK;
7349 #else
7350 base_op = op;
7351 #endif
7352 switch (base_op) {
7353 case FUTEX_WAIT:
7354 case FUTEX_WAIT_BITSET:
7355 if (timeout) {
7356 pts = &ts;
7357 target_to_host_timespec64(pts, timeout);
7358 } else {
7359 pts = NULL;
7360 }
7361 return do_safe_futex(g2h(uaddr), op, tswap32(val), pts, NULL, val3);
7362 case FUTEX_WAKE:
7363 return do_safe_futex(g2h(uaddr), op, val, NULL, NULL, 0);
7364 case FUTEX_FD:
7365 return do_safe_futex(g2h(uaddr), op, val, NULL, NULL, 0);
7366 case FUTEX_REQUEUE:
7367 case FUTEX_CMP_REQUEUE:
7368 case FUTEX_WAKE_OP:
7369 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
7370 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
7371 But the prototype takes a `struct timespec *'; insert casts
7372 to satisfy the compiler. We do not need to tswap TIMEOUT
7373 since it's not compared to guest memory. */
7374 pts = (struct timespec *)(uintptr_t) timeout;
7375 return do_safe_futex(g2h(uaddr), op, val, pts, g2h(uaddr2),
7376 (base_op == FUTEX_CMP_REQUEUE
7377 ? tswap32(val3)
7378 : val3));
7379 default:
7380 return -TARGET_ENOSYS;
7381 }
7382 }
7383 #endif
7384
7385 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7386 static abi_long do_name_to_handle_at(abi_long dirfd, abi_long pathname,
7387 abi_long handle, abi_long mount_id,
7388 abi_long flags)
7389 {
7390 struct file_handle *target_fh;
7391 struct file_handle *fh;
7392 int mid = 0;
7393 abi_long ret;
7394 char *name;
7395 unsigned int size, total_size;
7396
7397 if (get_user_s32(size, handle)) {
7398 return -TARGET_EFAULT;
7399 }
7400
7401 name = lock_user_string(pathname);
7402 if (!name) {
7403 return -TARGET_EFAULT;
7404 }
7405
7406 total_size = sizeof(struct file_handle) + size;
7407 target_fh = lock_user(VERIFY_WRITE, handle, total_size, 0);
7408 if (!target_fh) {
7409 unlock_user(name, pathname, 0);
7410 return -TARGET_EFAULT;
7411 }
7412
7413 fh = g_malloc0(total_size);
7414 fh->handle_bytes = size;
7415
7416 ret = get_errno(name_to_handle_at(dirfd, path(name), fh, &mid, flags));
7417 unlock_user(name, pathname, 0);
7418
7419 /* man name_to_handle_at(2):
7420 * Other than the use of the handle_bytes field, the caller should treat
7421 * the file_handle structure as an opaque data type
7422 */
7423
7424 memcpy(target_fh, fh, total_size);
7425 target_fh->handle_bytes = tswap32(fh->handle_bytes);
7426 target_fh->handle_type = tswap32(fh->handle_type);
7427 g_free(fh);
7428 unlock_user(target_fh, handle, total_size);
7429
7430 if (put_user_s32(mid, mount_id)) {
7431 return -TARGET_EFAULT;
7432 }
7433
7434 return ret;
7435
7436 }
7437 #endif
7438
7439 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7440 static abi_long do_open_by_handle_at(abi_long mount_fd, abi_long handle,
7441 abi_long flags)
7442 {
7443 struct file_handle *target_fh;
7444 struct file_handle *fh;
7445 unsigned int size, total_size;
7446 abi_long ret;
7447
7448 if (get_user_s32(size, handle)) {
7449 return -TARGET_EFAULT;
7450 }
7451
7452 total_size = sizeof(struct file_handle) + size;
7453 target_fh = lock_user(VERIFY_READ, handle, total_size, 1);
7454 if (!target_fh) {
7455 return -TARGET_EFAULT;
7456 }
7457
7458 fh = g_memdup(target_fh, total_size);
7459 fh->handle_bytes = size;
7460 fh->handle_type = tswap32(target_fh->handle_type);
7461
7462 ret = get_errno(open_by_handle_at(mount_fd, fh,
7463 target_to_host_bitmask(flags, fcntl_flags_tbl)));
7464
7465 g_free(fh);
7466
7467 unlock_user(target_fh, handle, total_size);
7468
7469 return ret;
7470 }
7471 #endif
7472
7473 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7474
7475 static abi_long do_signalfd4(int fd, abi_long mask, int flags)
7476 {
7477 int host_flags;
7478 target_sigset_t *target_mask;
7479 sigset_t host_mask;
7480 abi_long ret;
7481
7482 if (flags & ~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC)) {
7483 return -TARGET_EINVAL;
7484 }
7485 if (!lock_user_struct(VERIFY_READ, target_mask, mask, 1)) {
7486 return -TARGET_EFAULT;
7487 }
7488
7489 target_to_host_sigset(&host_mask, target_mask);
7490
7491 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
7492
7493 ret = get_errno(signalfd(fd, &host_mask, host_flags));
7494 if (ret >= 0) {
7495 fd_trans_register(ret, &target_signalfd_trans);
7496 }
7497
7498 unlock_user_struct(target_mask, mask, 0);
7499
7500 return ret;
7501 }
7502 #endif
7503
7504 /* Map host to target signal numbers for the wait family of syscalls.
7505 Assume all other status bits are the same. */
7506 int host_to_target_waitstatus(int status)
7507 {
7508 if (WIFSIGNALED(status)) {
7509 return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
7510 }
7511 if (WIFSTOPPED(status)) {
7512 return (host_to_target_signal(WSTOPSIG(status)) << 8)
7513 | (status & 0xff);
7514 }
7515 return status;
7516 }
7517
7518 static int open_self_cmdline(void *cpu_env, int fd)
7519 {
7520 CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
7521 struct linux_binprm *bprm = ((TaskState *)cpu->opaque)->bprm;
7522 int i;
7523
7524 for (i = 0; i < bprm->argc; i++) {
7525 size_t len = strlen(bprm->argv[i]) + 1;
7526
7527 if (write(fd, bprm->argv[i], len) != len) {
7528 return -1;
7529 }
7530 }
7531
7532 return 0;
7533 }
7534
7535 static int open_self_maps(void *cpu_env, int fd)
7536 {
7537 CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
7538 TaskState *ts = cpu->opaque;
7539 GSList *map_info = read_self_maps();
7540 GSList *s;
7541 int count;
7542
7543 for (s = map_info; s; s = g_slist_next(s)) {
7544 MapInfo *e = (MapInfo *) s->data;
7545
7546 if (h2g_valid(e->start)) {
7547 unsigned long min = e->start;
7548 unsigned long max = e->end;
7549 int flags = page_get_flags(h2g(min));
7550 const char *path;
7551
7552 max = h2g_valid(max - 1) ?
7553 max : (uintptr_t) g2h(GUEST_ADDR_MAX) + 1;
7554
7555 if (page_check_range(h2g(min), max - min, flags) == -1) {
7556 continue;
7557 }
7558
7559 if (h2g(min) == ts->info->stack_limit) {
7560 path = "[stack]";
7561 } else {
7562 path = e->path;
7563 }
7564
7565 count = dprintf(fd, TARGET_ABI_FMT_ptr "-" TARGET_ABI_FMT_ptr
7566 " %c%c%c%c %08" PRIx64 " %s %"PRId64,
7567 h2g(min), h2g(max - 1) + 1,
7568 e->is_read ? 'r' : '-',
7569 e->is_write ? 'w' : '-',
7570 e->is_exec ? 'x' : '-',
7571 e->is_priv ? 'p' : '-',
7572 (uint64_t) e->offset, e->dev, e->inode);
7573 if (path) {
7574 dprintf(fd, "%*s%s\n", 73 - count, "", path);
7575 } else {
7576 dprintf(fd, "\n");
7577 }
7578 }
7579 }
7580
7581 free_self_maps(map_info);
7582
7583 #ifdef TARGET_VSYSCALL_PAGE
7584 /*
7585 * We only support execution from the vsyscall page.
7586 * This is as if CONFIG_LEGACY_VSYSCALL_XONLY=y from v5.3.
7587 */
7588 count = dprintf(fd, TARGET_FMT_lx "-" TARGET_FMT_lx
7589 " --xp 00000000 00:00 0",
7590 TARGET_VSYSCALL_PAGE, TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE);
7591 dprintf(fd, "%*s%s\n", 73 - count, "", "[vsyscall]");
7592 #endif
7593
7594 return 0;
7595 }
7596
7597 static int open_self_stat(void *cpu_env, int fd)
7598 {
7599 CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
7600 TaskState *ts = cpu->opaque;
7601 g_autoptr(GString) buf = g_string_new(NULL);
7602 int i;
7603
7604 for (i = 0; i < 44; i++) {
7605 if (i == 0) {
7606 /* pid */
7607 g_string_printf(buf, FMT_pid " ", getpid());
7608 } else if (i == 1) {
7609 /* app name */
7610 gchar *bin = g_strrstr(ts->bprm->argv[0], "/");
7611 bin = bin ? bin + 1 : ts->bprm->argv[0];
7612 g_string_printf(buf, "(%.15s) ", bin);
7613 } else if (i == 27) {
7614 /* stack bottom */
7615 g_string_printf(buf, TARGET_ABI_FMT_ld " ", ts->info->start_stack);
7616 } else {
7617 /* for the rest, there is MasterCard */
7618 g_string_printf(buf, "0%c", i == 43 ? '\n' : ' ');
7619 }
7620
7621 if (write(fd, buf->str, buf->len) != buf->len) {
7622 return -1;
7623 }
7624 }
7625
7626 return 0;
7627 }
7628
7629 static int open_self_auxv(void *cpu_env, int fd)
7630 {
7631 CPUState *cpu = env_cpu((CPUArchState *)cpu_env);
7632 TaskState *ts = cpu->opaque;
7633 abi_ulong auxv = ts->info->saved_auxv;
7634 abi_ulong len = ts->info->auxv_len;
7635 char *ptr;
7636
7637 /*
7638 * Auxiliary vector is stored in target process stack.
7639 * read in whole auxv vector and copy it to file
7640 */
7641 ptr = lock_user(VERIFY_READ, auxv, len, 0);
7642 if (ptr != NULL) {
7643 while (len > 0) {
7644 ssize_t r;
7645 r = write(fd, ptr, len);
7646 if (r <= 0) {
7647 break;
7648 }
7649 len -= r;
7650 ptr += r;
7651 }
7652 lseek(fd, 0, SEEK_SET);
7653 unlock_user(ptr, auxv, len);
7654 }
7655
7656 return 0;
7657 }
7658
7659 static int is_proc_myself(const char *filename, const char *entry)
7660 {
7661 if (!strncmp(filename, "/proc/", strlen("/proc/"))) {
7662 filename += strlen("/proc/");
7663 if (!strncmp(filename, "self/", strlen("self/"))) {
7664 filename += strlen("self/");
7665 } else if (*filename >= '1' && *filename <= '9') {
7666 char myself[80];
7667 snprintf(myself, sizeof(myself), "%d/", getpid());
7668 if (!strncmp(filename, myself, strlen(myself))) {
7669 filename += strlen(myself);
7670 } else {
7671 return 0;
7672 }
7673 } else {
7674 return 0;
7675 }
7676 if (!strcmp(filename, entry)) {
7677 return 1;
7678 }
7679 }
7680 return 0;
7681 }
7682
7683 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) || \
7684 defined(TARGET_SPARC) || defined(TARGET_M68K) || defined(TARGET_HPPA)
7685 static int is_proc(const char *filename, const char *entry)
7686 {
7687 return strcmp(filename, entry) == 0;
7688 }
7689 #endif
7690
7691 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7692 static int open_net_route(void *cpu_env, int fd)
7693 {
7694 FILE *fp;
7695 char *line = NULL;
7696 size_t len = 0;
7697 ssize_t read;
7698
7699 fp = fopen("/proc/net/route", "r");
7700 if (fp == NULL) {
7701 return -1;
7702 }
7703
7704 /* read header */
7705
7706 read = getline(&line, &len, fp);
7707 dprintf(fd, "%s", line);
7708
7709 /* read routes */
7710
7711 while ((read = getline(&line, &len, fp)) != -1) {
7712 char iface[16];
7713 uint32_t dest, gw, mask;
7714 unsigned int flags, refcnt, use, metric, mtu, window, irtt;
7715 int fields;
7716
7717 fields = sscanf(line,
7718 "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7719 iface, &dest, &gw, &flags, &refcnt, &use, &metric,
7720 &mask, &mtu, &window, &irtt);
7721 if (fields != 11) {
7722 continue;
7723 }
7724 dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7725 iface, tswap32(dest), tswap32(gw), flags, refcnt, use,
7726 metric, tswap32(mask), mtu, window, irtt);
7727 }
7728
7729 free(line);
7730 fclose(fp);
7731
7732 return 0;
7733 }
7734 #endif
7735
7736 #if defined(TARGET_SPARC)
7737 static int open_cpuinfo(void *cpu_env, int fd)
7738 {
7739 dprintf(fd, "type\t\t: sun4u\n");
7740 return 0;
7741 }
7742 #endif
7743
7744 #if defined(TARGET_HPPA)
7745 static int open_cpuinfo(void *cpu_env, int fd)
7746 {
7747 dprintf(fd, "cpu family\t: PA-RISC 1.1e\n");
7748 dprintf(fd, "cpu\t\t: PA7300LC (PCX-L2)\n");
7749 dprintf(fd, "capabilities\t: os32\n");
7750 dprintf(fd, "model\t\t: 9000/778/B160L\n");
7751 dprintf(fd, "model name\t: Merlin L2 160 QEMU (9000/778/B160L)\n");
7752 return 0;
7753 }
7754 #endif
7755
7756 #if defined(TARGET_M68K)
7757 static int open_hardware(void *cpu_env, int fd)
7758 {
7759 dprintf(fd, "Model:\t\tqemu-m68k\n");
7760 return 0;
7761 }
7762 #endif
7763
7764 static int do_openat(void *cpu_env, int dirfd, const char *pathname, int flags, mode_t mode)
7765 {
7766 struct fake_open {
7767 const char *filename;
7768 int (*fill)(void *cpu_env, int fd);
7769 int (*cmp)(const char *s1, const char *s2);
7770 };
7771 const struct fake_open *fake_open;
7772 static const struct fake_open fakes[] = {
7773 { "maps", open_self_maps, is_proc_myself },
7774 { "stat", open_self_stat, is_proc_myself },
7775 { "auxv", open_self_auxv, is_proc_myself },
7776 { "cmdline", open_self_cmdline, is_proc_myself },
7777 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7778 { "/proc/net/route", open_net_route, is_proc },
7779 #endif
7780 #if defined(TARGET_SPARC) || defined(TARGET_HPPA)
7781 { "/proc/cpuinfo", open_cpuinfo, is_proc },
7782 #endif
7783 #if defined(TARGET_M68K)
7784 { "/proc/hardware", open_hardware, is_proc },
7785 #endif
7786 { NULL, NULL, NULL }
7787 };
7788
7789 if (is_proc_myself(pathname, "exe")) {
7790 int execfd = qemu_getauxval(AT_EXECFD);
7791 return execfd ? execfd : safe_openat(dirfd, exec_path, flags, mode);
7792 }
7793
7794 for (fake_open = fakes; fake_open->filename; fake_open++) {
7795 if (fake_open->cmp(pathname, fake_open->filename)) {
7796 break;
7797 }
7798 }
7799
7800 if (fake_open->filename) {
7801 const char *tmpdir;
7802 char filename[PATH_MAX];
7803 int fd, r;
7804
7805 /* create temporary file to map stat to */
7806 tmpdir = getenv("TMPDIR");
7807 if (!tmpdir)
7808 tmpdir = "/tmp";
7809 snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir);
7810 fd = mkstemp(filename);
7811 if (fd < 0) {
7812 return fd;
7813 }
7814 unlink(filename);
7815
7816 if ((r = fake_open->fill(cpu_env, fd))) {
7817 int e = errno;
7818 close(fd);
7819 errno = e;
7820 return r;
7821 }
7822 lseek(fd, 0, SEEK_SET);
7823
7824 return fd;
7825 }
7826
7827 return safe_openat(dirfd, path(pathname), flags, mode);
7828 }
7829
7830 #define TIMER_MAGIC 0x0caf0000
7831 #define TIMER_MAGIC_MASK 0xffff0000
7832
7833 /* Convert QEMU provided timer ID back to internal 16bit index format */
7834 static target_timer_t get_timer_id(abi_long arg)
7835 {
7836 target_timer_t timerid = arg;
7837
7838 if ((timerid & TIMER_MAGIC_MASK) != TIMER_MAGIC) {
7839 return -TARGET_EINVAL;
7840 }
7841
7842 timerid &= 0xffff;
7843
7844 if (timerid >= ARRAY_SIZE(g_posix_timers)) {
7845 return -TARGET_EINVAL;
7846 }
7847
7848 return timerid;
7849 }
7850
7851 static int target_to_host_cpu_mask(unsigned long *host_mask,
7852 size_t host_size,
7853 abi_ulong target_addr,
7854 size_t target_size)
7855 {
7856 unsigned target_bits = sizeof(abi_ulong) * 8;
7857 unsigned host_bits = sizeof(*host_mask) * 8;
7858 abi_ulong *target_mask;
7859 unsigned i, j;
7860
7861 assert(host_size >= target_size);
7862
7863 target_mask = lock_user(VERIFY_READ, target_addr, target_size, 1);
7864 if (!target_mask) {
7865 return -TARGET_EFAULT;
7866 }
7867 memset(host_mask, 0, host_size);
7868
7869 for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) {
7870 unsigned bit = i * target_bits;
7871 abi_ulong val;
7872
7873 __get_user(val, &target_mask[i]);
7874 for (j = 0; j < target_bits; j++, bit++) {
7875 if (val & (1UL << j)) {
7876 host_mask[bit / host_bits] |= 1UL << (bit % host_bits);
7877 }
7878 }
7879 }
7880
7881 unlock_user(target_mask, target_addr, 0);
7882 return 0;
7883 }
7884
7885 static int host_to_target_cpu_mask(const unsigned long *host_mask,
7886 size_t host_size,
7887 abi_ulong target_addr,
7888 size_t target_size)
7889 {
7890 unsigned target_bits = sizeof(abi_ulong) * 8;
7891 unsigned host_bits = sizeof(*host_mask) * 8;
7892 abi_ulong *target_mask;
7893 unsigned i, j;
7894
7895 assert(host_size >= target_size);
7896
7897 target_mask = lock_user(VERIFY_WRITE, target_addr, target_size, 0);
7898 if (!target_mask) {
7899 return -TARGET_EFAULT;
7900 }
7901
7902 for (i = 0 ; i < target_size / sizeof(abi_ulong); i++) {
7903 unsigned bit = i * target_bits;
7904 abi_ulong val = 0;
7905
7906 for (j = 0; j < target_bits; j++, bit++) {
7907 if (host_mask[bit / host_bits] & (1UL << (bit % host_bits))) {
7908 val |= 1UL << j;
7909 }
7910 }
7911 __put_user(val, &target_mask[i]);
7912 }
7913
7914 unlock_user(target_mask, target_addr, target_size);
7915 return 0;
7916 }
7917
7918 /* This is an internal helper for do_syscall so that it is easier
7919 * to have a single return point, so that actions, such as logging
7920 * of syscall results, can be performed.
7921 * All errnos that do_syscall() returns must be -TARGET_<errcode>.
7922 */
7923 static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
7924 abi_long arg2, abi_long arg3, abi_long arg4,
7925 abi_long arg5, abi_long arg6, abi_long arg7,
7926 abi_long arg8)
7927 {
7928 CPUState *cpu = env_cpu(cpu_env);
7929 abi_long ret;
7930 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) \
7931 || defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) \
7932 || defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) \
7933 || defined(TARGET_NR_statx)
7934 struct stat st;
7935 #endif
7936 #if defined(TARGET_NR_statfs) || defined(TARGET_NR_statfs64) \
7937 || defined(TARGET_NR_fstatfs)
7938 struct statfs stfs;
7939 #endif
7940 void *p;
7941
7942 switch(num) {
7943 case TARGET_NR_exit:
7944 /* In old applications this may be used to implement _exit(2).
7945 However in threaded applictions it is used for thread termination,
7946 and _exit_group is used for application termination.
7947 Do thread termination if we have more then one thread. */
7948
7949 if (block_signals()) {
7950 return -TARGET_ERESTARTSYS;
7951 }
7952
7953 pthread_mutex_lock(&clone_lock);
7954
7955 if (CPU_NEXT(first_cpu)) {
7956 TaskState *ts = cpu->opaque;
7957
7958 object_property_set_bool(OBJECT(cpu), "realized", false, NULL);
7959 object_unref(OBJECT(cpu));
7960 /*
7961 * At this point the CPU should be unrealized and removed
7962 * from cpu lists. We can clean-up the rest of the thread
7963 * data without the lock held.
7964 */
7965
7966 pthread_mutex_unlock(&clone_lock);
7967
7968 if (ts->child_tidptr) {
7969 put_user_u32(0, ts->child_tidptr);
7970 do_sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
7971 NULL, NULL, 0);
7972 }
7973 thread_cpu = NULL;
7974 g_free(ts);
7975 rcu_unregister_thread();
7976 pthread_exit(NULL);
7977 }
7978
7979 pthread_mutex_unlock(&clone_lock);
7980 preexit_cleanup(cpu_env, arg1);
7981 _exit(arg1);
7982 return 0; /* avoid warning */
7983 case TARGET_NR_read:
7984 if (arg2 == 0 && arg3 == 0) {
7985 return get_errno(safe_read(arg1, 0, 0));
7986 } else {
7987 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
7988 return -TARGET_EFAULT;
7989 ret = get_errno(safe_read(arg1, p, arg3));
7990 if (ret >= 0 &&
7991 fd_trans_host_to_target_data(arg1)) {
7992 ret = fd_trans_host_to_target_data(arg1)(p, ret);
7993 }
7994 unlock_user(p, arg2, ret);
7995 }
7996 return ret;
7997 case TARGET_NR_write:
7998 if (arg2 == 0 && arg3 == 0) {
7999 return get_errno(safe_write(arg1, 0, 0));
8000 }
8001 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
8002 return -TARGET_EFAULT;
8003 if (fd_trans_target_to_host_data(arg1)) {
8004 void *copy = g_malloc(arg3);
8005 memcpy(copy, p, arg3);
8006 ret = fd_trans_target_to_host_data(arg1)(copy, arg3);
8007 if (ret >= 0) {
8008 ret = get_errno(safe_write(arg1, copy, ret));
8009 }
8010 g_free(copy);
8011 } else {
8012 ret = get_errno(safe_write(arg1, p, arg3));
8013 }
8014 unlock_user(p, arg2, 0);
8015 return ret;
8016
8017 #ifdef TARGET_NR_open
8018 case TARGET_NR_open:
8019 if (!(p = lock_user_string(arg1)))
8020 return -TARGET_EFAULT;
8021 ret = get_errno(do_openat(cpu_env, AT_FDCWD, p,
8022 target_to_host_bitmask(arg2, fcntl_flags_tbl),
8023 arg3));
8024 fd_trans_unregister(ret);
8025 unlock_user(p, arg1, 0);
8026 return ret;
8027 #endif
8028 case TARGET_NR_openat:
8029 if (!(p = lock_user_string(arg2)))
8030 return -TARGET_EFAULT;
8031 ret = get_errno(do_openat(cpu_env, arg1, p,
8032 target_to_host_bitmask(arg3, fcntl_flags_tbl),
8033 arg4));
8034 fd_trans_unregister(ret);
8035 unlock_user(p, arg2, 0);
8036 return ret;
8037 #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8038 case TARGET_NR_name_to_handle_at:
8039 ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);
8040 return ret;
8041 #endif
8042 #if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
8043 case TARGET_NR_open_by_handle_at:
8044 ret = do_open_by_handle_at(arg1, arg2, arg3);
8045 fd_trans_unregister(ret);
8046 return ret;
8047 #endif
8048 case TARGET_NR_close:
8049 fd_trans_unregister(arg1);
8050 return get_errno(close(arg1));
8051
8052 case TARGET_NR_brk:
8053 return do_brk(arg1);
8054 #ifdef TARGET_NR_fork
8055 case TARGET_NR_fork:
8056 return get_errno(do_fork(cpu_env, TARGET_SIGCHLD, 0, 0, 0, 0));
8057 #endif
8058 #ifdef TARGET_NR_waitpid
8059 case TARGET_NR_waitpid:
8060 {
8061 int status;
8062 ret = get_errno(safe_wait4(arg1, &status, arg3, 0));
8063 if (!is_error(ret) && arg2 && ret
8064 && put_user_s32(host_to_target_waitstatus(status), arg2))
8065 return -TARGET_EFAULT;
8066 }
8067 return ret;
8068 #endif
8069 #ifdef TARGET_NR_waitid
8070 case TARGET_NR_waitid:
8071 {
8072 siginfo_t info;
8073 info.si_pid = 0;
8074 ret = get_errno(safe_waitid(arg1, arg2, &info, arg4, NULL));
8075 if (!is_error(ret) && arg3 && info.si_pid != 0) {
8076 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
8077 return -TARGET_EFAULT;
8078 host_to_target_siginfo(p, &info);
8079 unlock_user(p, arg3, sizeof(target_siginfo_t));
8080 }
8081 }
8082 return ret;
8083 #endif
8084 #ifdef TARGET_NR_creat /* not on alpha */
8085 case TARGET_NR_creat:
8086 if (!(p = lock_user_string(arg1)))
8087 return -TARGET_EFAULT;
8088 ret = get_errno(creat(p, arg2));
8089 fd_trans_unregister(ret);
8090 unlock_user(p, arg1, 0);
8091 return ret;
8092 #endif
8093 #ifdef TARGET_NR_link
8094 case TARGET_NR_link:
8095 {
8096 void * p2;
8097 p = lock_user_string(arg1);
8098 p2 = lock_user_string(arg2);
8099 if (!p || !p2)
8100 ret = -TARGET_EFAULT;
8101 else
8102 ret = get_errno(link(p, p2));
8103 unlock_user(p2, arg2, 0);
8104 unlock_user(p, arg1, 0);
8105 }
8106 return ret;
8107 #endif
8108 #if defined(TARGET_NR_linkat)
8109 case TARGET_NR_linkat:
8110 {
8111 void * p2 = NULL;
8112 if (!arg2 || !arg4)
8113 return -TARGET_EFAULT;
8114 p = lock_user_string(arg2);
8115 p2 = lock_user_string(arg4);
8116 if (!p || !p2)
8117 ret = -TARGET_EFAULT;
8118 else
8119 ret = get_errno(linkat(arg1, p, arg3, p2, arg5));
8120 unlock_user(p, arg2, 0);
8121 unlock_user(p2, arg4, 0);
8122 }
8123 return ret;
8124 #endif
8125 #ifdef TARGET_NR_unlink
8126 case TARGET_NR_unlink:
8127 if (!(p = lock_user_string(arg1)))
8128 return -TARGET_EFAULT;
8129 ret = get_errno(unlink(p));
8130 unlock_user(p, arg1, 0);
8131 return ret;
8132 #endif
8133 #if defined(TARGET_NR_unlinkat)
8134 case TARGET_NR_unlinkat:
8135 if (!(p = lock_user_string(arg2)))
8136 return -TARGET_EFAULT;
8137 ret = get_errno(unlinkat(arg1, p, arg3));
8138 unlock_user(p, arg2, 0);
8139 return ret;
8140 #endif
8141 case TARGET_NR_execve:
8142 {
8143 char **argp, **envp;
8144 int argc, envc;
8145 abi_ulong gp;
8146 abi_ulong guest_argp;
8147 abi_ulong guest_envp;
8148 abi_ulong addr;
8149 char **q;
8150 int total_size = 0;
8151
8152 argc = 0;
8153 guest_argp = arg2;
8154 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
8155 if (get_user_ual(addr, gp))
8156 return -TARGET_EFAULT;
8157 if (!addr)
8158 break;
8159 argc++;
8160 }
8161 envc = 0;
8162 guest_envp = arg3;
8163 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
8164 if (get_user_ual(addr, gp))
8165 return -TARGET_EFAULT;
8166 if (!addr)
8167 break;
8168 envc++;
8169 }
8170
8171 argp = g_new0(char *, argc + 1);
8172 envp = g_new0(char *, envc + 1);
8173
8174 for (gp = guest_argp, q = argp; gp;
8175 gp += sizeof(abi_ulong), q++) {
8176 if (get_user_ual(addr, gp))
8177 goto execve_efault;
8178 if (!addr)
8179 break;
8180 if (!(*q = lock_user_string(addr)))
8181 goto execve_efault;
8182 total_size += strlen(*q) + 1;
8183 }
8184 *q = NULL;
8185
8186 for (gp = guest_envp, q = envp; gp;
8187 gp += sizeof(abi_ulong), q++) {
8188 if (get_user_ual(addr, gp))
8189 goto execve_efault;
8190 if (!addr)
8191 break;
8192 if (!(*q = lock_user_string(addr)))
8193 goto execve_efault;
8194 total_size += strlen(*q) + 1;
8195 }
8196 *q = NULL;
8197
8198 if (!(p = lock_user_string(arg1)))
8199 goto execve_efault;
8200 /* Although execve() is not an interruptible syscall it is
8201 * a special case where we must use the safe_syscall wrapper:
8202 * if we allow a signal to happen before we make the host
8203 * syscall then we will 'lose' it, because at the point of
8204 * execve the process leaves QEMU's control. So we use the
8205 * safe syscall wrapper to ensure that we either take the
8206 * signal as a guest signal, or else it does not happen
8207 * before the execve completes and makes it the other
8208 * program's problem.
8209 */
8210 ret = get_errno(safe_execve(p, argp, envp));
8211 unlock_user(p, arg1, 0);
8212
8213 goto execve_end;
8214
8215 execve_efault:
8216 ret = -TARGET_EFAULT;
8217
8218 execve_end:
8219 for (gp = guest_argp, q = argp; *q;
8220 gp += sizeof(abi_ulong), q++) {
8221 if (get_user_ual(addr, gp)
8222 || !addr)
8223 break;
8224 unlock_user(*q, addr, 0);
8225 }
8226 for (gp = guest_envp, q = envp; *q;
8227 gp += sizeof(abi_ulong), q++) {
8228 if (get_user_ual(addr, gp)
8229 || !addr)
8230 break;
8231 unlock_user(*q, addr, 0);
8232 }
8233
8234 g_free(argp);
8235 g_free(envp);
8236 }
8237 return ret;
8238 case TARGET_NR_chdir:
8239 if (!(p = lock_user_string(arg1)))
8240 return -TARGET_EFAULT;
8241 ret = get_errno(chdir(p));
8242 unlock_user(p, arg1, 0);
8243 return ret;
8244 #ifdef TARGET_NR_time
8245 case TARGET_NR_time:
8246 {
8247 time_t host_time;
8248 ret = get_errno(time(&host_time));
8249 if (!is_error(ret)
8250 && arg1
8251 && put_user_sal(host_time, arg1))
8252 return -TARGET_EFAULT;
8253 }
8254 return ret;
8255 #endif
8256 #ifdef TARGET_NR_mknod
8257 case TARGET_NR_mknod:
8258 if (!(p = lock_user_string(arg1)))
8259 return -TARGET_EFAULT;
8260 ret = get_errno(mknod(p, arg2, arg3));
8261 unlock_user(p, arg1, 0);
8262 return ret;
8263 #endif
8264 #if defined(TARGET_NR_mknodat)
8265 case TARGET_NR_mknodat:
8266 if (!(p = lock_user_string(arg2)))
8267 return -TARGET_EFAULT;
8268 ret = get_errno(mknodat(arg1, p, arg3, arg4));
8269 unlock_user(p, arg2, 0);
8270 return ret;
8271 #endif
8272 #ifdef TARGET_NR_chmod
8273 case TARGET_NR_chmod:
8274 if (!(p = lock_user_string(arg1)))
8275 return -TARGET_EFAULT;
8276 ret = get_errno(chmod(p, arg2));
8277 unlock_user(p, arg1, 0);
8278 return ret;
8279 #endif
8280 #ifdef TARGET_NR_lseek
8281 case TARGET_NR_lseek:
8282 return get_errno(lseek(arg1, arg2, arg3));
8283 #endif
8284 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
8285 /* Alpha specific */
8286 case TARGET_NR_getxpid:
8287 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
8288 return get_errno(getpid());
8289 #endif
8290 #ifdef TARGET_NR_getpid
8291 case TARGET_NR_getpid:
8292 return get_errno(getpid());
8293 #endif
8294 case TARGET_NR_mount:
8295 {
8296 /* need to look at the data field */
8297 void *p2, *p3;
8298
8299 if (arg1) {
8300 p = lock_user_string(arg1);
8301 if (!p) {
8302 return -TARGET_EFAULT;
8303 }
8304 } else {
8305 p = NULL;
8306 }
8307
8308 p2 = lock_user_string(arg2);
8309 if (!p2) {
8310 if (arg1) {
8311 unlock_user(p, arg1, 0);
8312 }
8313 return -TARGET_EFAULT;
8314 }
8315
8316 if (arg3) {
8317 p3 = lock_user_string(arg3);
8318 if (!p3) {
8319 if (arg1) {
8320 unlock_user(p, arg1, 0);
8321 }
8322 unlock_user(p2, arg2, 0);
8323 return -TARGET_EFAULT;
8324 }
8325 } else {
8326 p3 = NULL;
8327 }
8328
8329 /* FIXME - arg5 should be locked, but it isn't clear how to
8330 * do that since it's not guaranteed to be a NULL-terminated
8331 * string.
8332 */
8333 if (!arg5) {
8334 ret = mount(p, p2, p3, (unsigned long)arg4, NULL);
8335 } else {
8336 ret = mount(p, p2, p3, (unsigned long)arg4, g2h(arg5));
8337 }
8338 ret = get_errno(ret);
8339
8340 if (arg1) {
8341 unlock_user(p, arg1, 0);
8342 }
8343 unlock_user(p2, arg2, 0);
8344 if (arg3) {
8345 unlock_user(p3, arg3, 0);
8346 }
8347 }
8348 return ret;
8349 #if defined(TARGET_NR_umount) || defined(TARGET_NR_oldumount)
8350 #if defined(TARGET_NR_umount)
8351 case TARGET_NR_umount:
8352 #endif
8353 #if defined(TARGET_NR_oldumount)
8354 case TARGET_NR_oldumount:
8355 #endif
8356 if (!(p = lock_user_string(arg1)))
8357 return -TARGET_EFAULT;
8358 ret = get_errno(umount(p));
8359 unlock_user(p, arg1, 0);
8360 return ret;
8361 #endif
8362 #ifdef TARGET_NR_stime /* not on alpha */
8363 case TARGET_NR_stime:
8364 {
8365 struct timespec ts;
8366 ts.tv_nsec = 0;
8367 if (get_user_sal(ts.tv_sec, arg1)) {
8368 return -TARGET_EFAULT;
8369 }
8370 return get_errno(clock_settime(CLOCK_REALTIME, &ts));
8371 }
8372 #endif
8373 #ifdef TARGET_NR_alarm /* not on alpha */
8374 case TARGET_NR_alarm:
8375 return alarm(arg1);
8376 #endif
8377 #ifdef TARGET_NR_pause /* not on alpha */
8378 case TARGET_NR_pause:
8379 if (!block_signals()) {
8380 sigsuspend(&((TaskState *)cpu->opaque)->signal_mask);
8381 }
8382 return -TARGET_EINTR;
8383 #endif
8384 #ifdef TARGET_NR_utime
8385 case TARGET_NR_utime:
8386 {
8387 struct utimbuf tbuf, *host_tbuf;
8388 struct target_utimbuf *target_tbuf;
8389 if (arg2) {
8390 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
8391 return -TARGET_EFAULT;
8392 tbuf.actime = tswapal(target_tbuf->actime);
8393 tbuf.modtime = tswapal(target_tbuf->modtime);
8394 unlock_user_struct(target_tbuf, arg2, 0);
8395 host_tbuf = &tbuf;
8396 } else {
8397 host_tbuf = NULL;
8398 }
8399 if (!(p = lock_user_string(arg1)))
8400 return -TARGET_EFAULT;
8401 ret = get_errno(utime(p, host_tbuf));
8402 unlock_user(p, arg1, 0);
8403 }
8404 return ret;
8405 #endif
8406 #ifdef TARGET_NR_utimes
8407 case TARGET_NR_utimes:
8408 {
8409 struct timeval *tvp, tv[2];
8410 if (arg2) {
8411 if (copy_from_user_timeval(&tv[0], arg2)
8412 || copy_from_user_timeval(&tv[1],
8413 arg2 + sizeof(struct target_timeval)))
8414 return -TARGET_EFAULT;
8415 tvp = tv;
8416 } else {
8417 tvp = NULL;
8418 }
8419 if (!(p = lock_user_string(arg1)))
8420 return -TARGET_EFAULT;
8421 ret = get_errno(utimes(p, tvp));
8422 unlock_user(p, arg1, 0);
8423 }
8424 return ret;
8425 #endif
8426 #if defined(TARGET_NR_futimesat)
8427 case TARGET_NR_futimesat:
8428 {
8429 struct timeval *tvp, tv[2];
8430 if (arg3) {
8431 if (copy_from_user_timeval(&tv[0], arg3)
8432 || copy_from_user_timeval(&tv[1],
8433 arg3 + sizeof(struct target_timeval)))
8434 return -TARGET_EFAULT;
8435 tvp = tv;
8436 } else {
8437 tvp = NULL;
8438 }
8439 if (!(p = lock_user_string(arg2))) {
8440 return -TARGET_EFAULT;
8441 }
8442 ret = get_errno(futimesat(arg1, path(p), tvp));
8443 unlock_user(p, arg2, 0);
8444 }
8445 return ret;
8446 #endif
8447 #ifdef TARGET_NR_access
8448 case TARGET_NR_access:
8449 if (!(p = lock_user_string(arg1))) {
8450 return -TARGET_EFAULT;
8451 }
8452 ret = get_errno(access(path(p), arg2));
8453 unlock_user(p, arg1, 0);
8454 return ret;
8455 #endif
8456 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
8457 case TARGET_NR_faccessat:
8458 if (!(p = lock_user_string(arg2))) {
8459 return -TARGET_EFAULT;
8460 }
8461 ret = get_errno(faccessat(arg1, p, arg3, 0));
8462 unlock_user(p, arg2, 0);
8463 return ret;
8464 #endif
8465 #ifdef TARGET_NR_nice /* not on alpha */
8466 case TARGET_NR_nice:
8467 return get_errno(nice(arg1));
8468 #endif
8469 case TARGET_NR_sync:
8470 sync();
8471 return 0;
8472 #if defined(TARGET_NR_syncfs) && defined(CONFIG_SYNCFS)
8473 case TARGET_NR_syncfs:
8474 return get_errno(syncfs(arg1));
8475 #endif
8476 case TARGET_NR_kill:
8477 return get_errno(safe_kill(arg1, target_to_host_signal(arg2)));
8478 #ifdef TARGET_NR_rename
8479 case TARGET_NR_rename:
8480 {
8481 void *p2;
8482 p = lock_user_string(arg1);
8483 p2 = lock_user_string(arg2);
8484 if (!p || !p2)
8485 ret = -TARGET_EFAULT;
8486 else
8487 ret = get_errno(rename(p, p2));
8488 unlock_user(p2, arg2, 0);
8489 unlock_user(p, arg1, 0);
8490 }
8491 return ret;
8492 #endif
8493 #if defined(TARGET_NR_renameat)
8494 case TARGET_NR_renameat:
8495 {
8496 void *p2;
8497 p = lock_user_string(arg2);
8498 p2 = lock_user_string(arg4);
8499 if (!p || !p2)
8500 ret = -TARGET_EFAULT;
8501 else
8502 ret = get_errno(renameat(arg1, p, arg3, p2));
8503 unlock_user(p2, arg4, 0);
8504 unlock_user(p, arg2, 0);
8505 }
8506 return ret;
8507 #endif
8508 #if defined(TARGET_NR_renameat2)
8509 case TARGET_NR_renameat2:
8510 {
8511 void *p2;
8512 p = lock_user_string(arg2);
8513 p2 = lock_user_string(arg4);
8514 if (!p || !p2) {
8515 ret = -TARGET_EFAULT;
8516 } else {
8517 ret = get_errno(sys_renameat2(arg1, p, arg3, p2, arg5));
8518 }
8519 unlock_user(p2, arg4, 0);
8520 unlock_user(p, arg2, 0);
8521 }
8522 return ret;
8523 #endif
8524 #ifdef TARGET_NR_mkdir
8525 case TARGET_NR_mkdir:
8526 if (!(p = lock_user_string(arg1)))
8527 return -TARGET_EFAULT;
8528 ret = get_errno(mkdir(p, arg2));
8529 unlock_user(p, arg1, 0);
8530 return ret;
8531 #endif
8532 #if defined(TARGET_NR_mkdirat)
8533 case TARGET_NR_mkdirat:
8534 if (!(p = lock_user_string(arg2)))
8535 return -TARGET_EFAULT;
8536 ret = get_errno(mkdirat(arg1, p, arg3));
8537 unlock_user(p, arg2, 0);
8538 return ret;
8539 #endif
8540 #ifdef TARGET_NR_rmdir
8541 case TARGET_NR_rmdir:
8542 if (!(p = lock_user_string(arg1)))
8543 return -TARGET_EFAULT;
8544 ret = get_errno(rmdir(p));
8545 unlock_user(p, arg1, 0);
8546 return ret;
8547 #endif
8548 case TARGET_NR_dup:
8549 ret = get_errno(dup(arg1));
8550 if (ret >= 0) {
8551 fd_trans_dup(arg1, ret);
8552 }
8553 return ret;
8554 #ifdef TARGET_NR_pipe
8555 case TARGET_NR_pipe:
8556 return do_pipe(cpu_env, arg1, 0, 0);
8557 #endif
8558 #ifdef TARGET_NR_pipe2
8559 case TARGET_NR_pipe2:
8560 return do_pipe(cpu_env, arg1,
8561 target_to_host_bitmask(arg2, fcntl_flags_tbl), 1);
8562 #endif
8563 case TARGET_NR_times:
8564 {
8565 struct target_tms *tmsp;
8566 struct tms tms;
8567 ret = get_errno(times(&tms));
8568 if (arg1) {
8569 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
8570 if (!tmsp)
8571 return -TARGET_EFAULT;
8572 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime));
8573 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime));
8574 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime));
8575 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime));
8576 }
8577 if (!is_error(ret))
8578 ret = host_to_target_clock_t(ret);
8579 }
8580 return ret;
8581 case TARGET_NR_acct:
8582 if (arg1 == 0) {
8583 ret = get_errno(acct(NULL));
8584 } else {
8585 if (!(p = lock_user_string(arg1))) {
8586 return -TARGET_EFAULT;
8587 }
8588 ret = get_errno(acct(path(p)));
8589 unlock_user(p, arg1, 0);
8590 }
8591 return ret;
8592 #ifdef TARGET_NR_umount2
8593 case TARGET_NR_umount2:
8594 if (!(p = lock_user_string(arg1)))
8595 return -TARGET_EFAULT;
8596 ret = get_errno(umount2(p, arg2));
8597 unlock_user(p, arg1, 0);
8598 return ret;
8599 #endif
8600 case TARGET_NR_ioctl:
8601 return do_ioctl(arg1, arg2, arg3);
8602 #ifdef TARGET_NR_fcntl
8603 case TARGET_NR_fcntl:
8604 return do_fcntl(arg1, arg2, arg3);
8605 #endif
8606 case TARGET_NR_setpgid:
8607 return get_errno(setpgid(arg1, arg2));
8608 case TARGET_NR_umask:
8609 return get_errno(umask(arg1));
8610 case TARGET_NR_chroot:
8611 if (!(p = lock_user_string(arg1)))
8612 return -TARGET_EFAULT;
8613 ret = get_errno(chroot(p));
8614 unlock_user(p, arg1, 0);
8615 return ret;
8616 #ifdef TARGET_NR_dup2
8617 case TARGET_NR_dup2:
8618 ret = get_errno(dup2(arg1, arg2));
8619 if (ret >= 0) {
8620 fd_trans_dup(arg1, arg2);
8621 }
8622 return ret;
8623 #endif
8624 #if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
8625 case TARGET_NR_dup3:
8626 {
8627 int host_flags;
8628
8629 if ((arg3 & ~TARGET_O_CLOEXEC) != 0) {
8630 return -EINVAL;
8631 }
8632 host_flags = target_to_host_bitmask(arg3, fcntl_flags_tbl);
8633 ret = get_errno(dup3(arg1, arg2, host_flags));
8634 if (ret >= 0) {
8635 fd_trans_dup(arg1, arg2);
8636 }
8637 return ret;
8638 }
8639 #endif
8640 #ifdef TARGET_NR_getppid /* not on alpha */
8641 case TARGET_NR_getppid:
8642 return get_errno(getppid());
8643 #endif
8644 #ifdef TARGET_NR_getpgrp
8645 case TARGET_NR_getpgrp:
8646 return get_errno(getpgrp());
8647 #endif
8648 case TARGET_NR_setsid:
8649 return get_errno(setsid());
8650 #ifdef TARGET_NR_sigaction
8651 case TARGET_NR_sigaction:
8652 {
8653 #if defined(TARGET_ALPHA)
8654 struct target_sigaction act, oact, *pact = 0;
8655 struct target_old_sigaction *old_act;
8656 if (arg2) {
8657 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8658 return -TARGET_EFAULT;
8659 act._sa_handler = old_act->_sa_handler;
8660 target_siginitset(&act.sa_mask, old_act->sa_mask);
8661 act.sa_flags = old_act->sa_flags;
8662 act.sa_restorer = 0;
8663 unlock_user_struct(old_act, arg2, 0);
8664 pact = &act;
8665 }
8666 ret = get_errno(do_sigaction(arg1, pact, &oact));
8667 if (!is_error(ret) && arg3) {
8668 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8669 return -TARGET_EFAULT;
8670 old_act->_sa_handler = oact._sa_handler;
8671 old_act->sa_mask = oact.sa_mask.sig[0];
8672 old_act->sa_flags = oact.sa_flags;
8673 unlock_user_struct(old_act, arg3, 1);
8674 }
8675 #elif defined(TARGET_MIPS)
8676 struct target_sigaction act, oact, *pact, *old_act;
8677
8678 if (arg2) {
8679 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8680 return -TARGET_EFAULT;
8681 act._sa_handler = old_act->_sa_handler;
8682 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
8683 act.sa_flags = old_act->sa_flags;
8684 unlock_user_struct(old_act, arg2, 0);
8685 pact = &act;
8686 } else {
8687 pact = NULL;
8688 }
8689
8690 ret = get_errno(do_sigaction(arg1, pact, &oact));
8691
8692 if (!is_error(ret) && arg3) {
8693 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8694 return -TARGET_EFAULT;
8695 old_act->_sa_handler = oact._sa_handler;
8696 old_act->sa_flags = oact.sa_flags;
8697 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
8698 old_act->sa_mask.sig[1] = 0;
8699 old_act->sa_mask.sig[2] = 0;
8700 old_act->sa_mask.sig[3] = 0;
8701 unlock_user_struct(old_act, arg3, 1);
8702 }
8703 #else
8704 struct target_old_sigaction *old_act;
8705 struct target_sigaction act, oact, *pact;
8706 if (arg2) {
8707 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
8708 return -TARGET_EFAULT;
8709 act._sa_handler = old_act->_sa_handler;
8710 target_siginitset(&act.sa_mask, old_act->sa_mask);
8711 act.sa_flags = old_act->sa_flags;
8712 act.sa_restorer = old_act->sa_restorer;
8713 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8714 act.ka_restorer = 0;
8715 #endif
8716 unlock_user_struct(old_act, arg2, 0);
8717 pact = &act;
8718 } else {
8719 pact = NULL;
8720 }
8721 ret = get_errno(do_sigaction(arg1, pact, &oact));
8722 if (!is_error(ret) && arg3) {
8723 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
8724 return -TARGET_EFAULT;
8725 old_act->_sa_handler = oact._sa_handler;
8726 old_act->sa_mask = oact.sa_mask.sig[0];
8727 old_act->sa_flags = oact.sa_flags;
8728 old_act->sa_restorer = oact.sa_restorer;
8729 unlock_user_struct(old_act, arg3, 1);
8730 }
8731 #endif
8732 }
8733 return ret;
8734 #endif
8735 case TARGET_NR_rt_sigaction:
8736 {
8737 #if defined(TARGET_ALPHA)
8738 /* For Alpha and SPARC this is a 5 argument syscall, with
8739 * a 'restorer' parameter which must be copied into the
8740 * sa_restorer field of the sigaction struct.
8741 * For Alpha that 'restorer' is arg5; for SPARC it is arg4,
8742 * and arg5 is the sigsetsize.
8743 * Alpha also has a separate rt_sigaction struct that it uses
8744 * here; SPARC uses the usual sigaction struct.
8745 */
8746 struct target_rt_sigaction *rt_act;
8747 struct target_sigaction act, oact, *pact = 0;
8748
8749 if (arg4 != sizeof(target_sigset_t)) {
8750 return -TARGET_EINVAL;
8751 }
8752 if (arg2) {
8753 if (!lock_user_struct(VERIFY_READ, rt_act, arg2, 1))
8754 return -TARGET_EFAULT;
8755 act._sa_handler = rt_act->_sa_handler;
8756 act.sa_mask = rt_act->sa_mask;
8757 act.sa_flags = rt_act->sa_flags;
8758 act.sa_restorer = arg5;
8759 unlock_user_struct(rt_act, arg2, 0);
8760 pact = &act;
8761 }
8762 ret = get_errno(do_sigaction(arg1, pact, &oact));
8763 if (!is_error(ret) && arg3) {
8764 if (!lock_user_struct(VERIFY_WRITE, rt_act, arg3, 0))
8765 return -TARGET_EFAULT;
8766 rt_act->_sa_handler = oact._sa_handler;
8767 rt_act->sa_mask = oact.sa_mask;
8768 rt_act->sa_flags = oact.sa_flags;
8769 unlock_user_struct(rt_act, arg3, 1);
8770 }
8771 #else
8772 #ifdef TARGET_SPARC
8773 target_ulong restorer = arg4;
8774 target_ulong sigsetsize = arg5;
8775 #else
8776 target_ulong sigsetsize = arg4;
8777 #endif
8778 struct target_sigaction *act;
8779 struct target_sigaction *oact;
8780
8781 if (sigsetsize != sizeof(target_sigset_t)) {
8782 return -TARGET_EINVAL;
8783 }
8784 if (arg2) {
8785 if (!lock_user_struct(VERIFY_READ, act, arg2, 1)) {
8786 return -TARGET_EFAULT;
8787 }
8788 #ifdef TARGET_ARCH_HAS_KA_RESTORER
8789 act->ka_restorer = restorer;
8790 #endif
8791 } else {
8792 act = NULL;
8793 }
8794 if (arg3) {
8795 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
8796 ret = -TARGET_EFAULT;
8797 goto rt_sigaction_fail;
8798 }
8799 } else
8800 oact = NULL;
8801 ret = get_errno(do_sigaction(arg1, act, oact));
8802 rt_sigaction_fail:
8803 if (act)
8804 unlock_user_struct(act, arg2, 0);
8805 if (oact)
8806 unlock_user_struct(oact, arg3, 1);
8807 #endif
8808 }
8809 return ret;
8810 #ifdef TARGET_NR_sgetmask /* not on alpha */
8811 case TARGET_NR_sgetmask:
8812 {
8813 sigset_t cur_set;
8814 abi_ulong target_set;
8815 ret = do_sigprocmask(0, NULL, &cur_set);
8816 if (!ret) {
8817 host_to_target_old_sigset(&target_set, &cur_set);
8818 ret = target_set;
8819 }
8820 }
8821 return ret;
8822 #endif
8823 #ifdef TARGET_NR_ssetmask /* not on alpha */
8824 case TARGET_NR_ssetmask:
8825 {
8826 sigset_t set, oset;
8827 abi_ulong target_set = arg1;
8828 target_to_host_old_sigset(&set, &target_set);
8829 ret = do_sigprocmask(SIG_SETMASK, &set, &oset);
8830 if (!ret) {
8831 host_to_target_old_sigset(&target_set, &oset);
8832 ret = target_set;
8833 }
8834 }
8835 return ret;
8836 #endif
8837 #ifdef TARGET_NR_sigprocmask
8838 case TARGET_NR_sigprocmask:
8839 {
8840 #if defined(TARGET_ALPHA)
8841 sigset_t set, oldset;
8842 abi_ulong mask;
8843 int how;
8844
8845 switch (arg1) {
8846 case TARGET_SIG_BLOCK:
8847 how = SIG_BLOCK;
8848 break;
8849 case TARGET_SIG_UNBLOCK:
8850 how = SIG_UNBLOCK;
8851 break;
8852 case TARGET_SIG_SETMASK:
8853 how = SIG_SETMASK;
8854 break;
8855 default:
8856 return -TARGET_EINVAL;
8857 }
8858 mask = arg2;
8859 target_to_host_old_sigset(&set, &mask);
8860
8861 ret = do_sigprocmask(how, &set, &oldset);
8862 if (!is_error(ret)) {
8863 host_to_target_old_sigset(&mask, &oldset);
8864 ret = mask;
8865 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */
8866 }
8867 #else
8868 sigset_t set, oldset, *set_ptr;
8869 int how;
8870
8871 if (arg2) {
8872 switch (arg1) {
8873 case TARGET_SIG_BLOCK:
8874 how = SIG_BLOCK;
8875 break;
8876 case TARGET_SIG_UNBLOCK:
8877 how = SIG_UNBLOCK;
8878 break;
8879 case TARGET_SIG_SETMASK:
8880 how = SIG_SETMASK;
8881 break;
8882 default:
8883 return -TARGET_EINVAL;
8884 }
8885 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
8886 return -TARGET_EFAULT;
8887 target_to_host_old_sigset(&set, p);
8888 unlock_user(p, arg2, 0);
8889 set_ptr = &set;
8890 } else {
8891 how = 0;
8892 set_ptr = NULL;
8893 }
8894 ret = do_sigprocmask(how, set_ptr, &oldset);
8895 if (!is_error(ret) && arg3) {
8896 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
8897 return -TARGET_EFAULT;
8898 host_to_target_old_sigset(p, &oldset);
8899 unlock_user(p, arg3, sizeof(target_sigset_t));
8900 }
8901 #endif
8902 }
8903 return ret;
8904 #endif
8905 case TARGET_NR_rt_sigprocmask:
8906 {
8907 int how = arg1;
8908 sigset_t set, oldset, *set_ptr;
8909
8910 if (arg4 != sizeof(target_sigset_t)) {
8911 return -TARGET_EINVAL;
8912 }
8913
8914 if (arg2) {
8915 switch(how) {
8916 case TARGET_SIG_BLOCK:
8917 how = SIG_BLOCK;
8918 break;
8919 case TARGET_SIG_UNBLOCK:
8920 how = SIG_UNBLOCK;
8921 break;
8922 case TARGET_SIG_SETMASK:
8923 how = SIG_SETMASK;
8924 break;
8925 default:
8926 return -TARGET_EINVAL;
8927 }
8928 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
8929 return -TARGET_EFAULT;
8930 target_to_host_sigset(&set, p);
8931 unlock_user(p, arg2, 0);
8932 set_ptr = &set;
8933 } else {
8934 how = 0;
8935 set_ptr = NULL;
8936 }
8937 ret = do_sigprocmask(how, set_ptr, &oldset);
8938 if (!is_error(ret) && arg3) {
8939 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
8940 return -TARGET_EFAULT;
8941 host_to_target_sigset(p, &oldset);
8942 unlock_user(p, arg3, sizeof(target_sigset_t));
8943 }
8944 }
8945 return ret;
8946 #ifdef TARGET_NR_sigpending
8947 case TARGET_NR_sigpending:
8948 {
8949 sigset_t set;
8950 ret = get_errno(sigpending(&set));
8951 if (!is_error(ret)) {
8952 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
8953 return -TARGET_EFAULT;
8954 host_to_target_old_sigset(p, &set);
8955 unlock_user(p, arg1, sizeof(target_sigset_t));
8956 }
8957 }
8958 return ret;
8959 #endif
8960 case TARGET_NR_rt_sigpending:
8961 {
8962 sigset_t set;
8963
8964 /* Yes, this check is >, not != like most. We follow the kernel's
8965 * logic and it does it like this because it implements
8966 * NR_sigpending through the same code path, and in that case
8967 * the old_sigset_t is smaller in size.
8968 */
8969 if (arg2 > sizeof(target_sigset_t)) {
8970 return -TARGET_EINVAL;
8971 }
8972
8973 ret = get_errno(sigpending(&set));
8974 if (!is_error(ret)) {
8975 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
8976 return -TARGET_EFAULT;
8977 host_to_target_sigset(p, &set);
8978 unlock_user(p, arg1, sizeof(target_sigset_t));
8979 }
8980 }
8981 return ret;
8982 #ifdef TARGET_NR_sigsuspend
8983 case TARGET_NR_sigsuspend:
8984 {
8985 TaskState *ts = cpu->opaque;
8986 #if defined(TARGET_ALPHA)
8987 abi_ulong mask = arg1;
8988 target_to_host_old_sigset(&ts->sigsuspend_mask, &mask);
8989 #else
8990 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
8991 return -TARGET_EFAULT;
8992 target_to_host_old_sigset(&ts->sigsuspend_mask, p);
8993 unlock_user(p, arg1, 0);
8994 #endif
8995 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
8996 SIGSET_T_SIZE));
8997 if (ret != -TARGET_ERESTARTSYS) {
8998 ts->in_sigsuspend = 1;
8999 }
9000 }
9001 return ret;
9002 #endif
9003 case TARGET_NR_rt_sigsuspend:
9004 {
9005 TaskState *ts = cpu->opaque;
9006
9007 if (arg2 != sizeof(target_sigset_t)) {
9008 return -TARGET_EINVAL;
9009 }
9010 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
9011 return -TARGET_EFAULT;
9012 target_to_host_sigset(&ts->sigsuspend_mask, p);
9013 unlock_user(p, arg1, 0);
9014 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
9015 SIGSET_T_SIZE));
9016 if (ret != -TARGET_ERESTARTSYS) {
9017 ts->in_sigsuspend = 1;
9018 }
9019 }
9020 return ret;
9021 #ifdef TARGET_NR_rt_sigtimedwait
9022 case TARGET_NR_rt_sigtimedwait:
9023 {
9024 sigset_t set;
9025 struct timespec uts, *puts;
9026 siginfo_t uinfo;
9027
9028 if (arg4 != sizeof(target_sigset_t)) {
9029 return -TARGET_EINVAL;
9030 }
9031
9032 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
9033 return -TARGET_EFAULT;
9034 target_to_host_sigset(&set, p);
9035 unlock_user(p, arg1, 0);
9036 if (arg3) {
9037 puts = &uts;
9038 if (target_to_host_timespec(puts, arg3)) {
9039 return -TARGET_EFAULT;
9040 }
9041 } else {
9042 puts = NULL;
9043 }
9044 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
9045 SIGSET_T_SIZE));
9046 if (!is_error(ret)) {
9047 if (arg2) {
9048 p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t),
9049 0);
9050 if (!p) {
9051 return -TARGET_EFAULT;
9052 }
9053 host_to_target_siginfo(p, &uinfo);
9054 unlock_user(p, arg2, sizeof(target_siginfo_t));
9055 }
9056 ret = host_to_target_signal(ret);
9057 }
9058 }
9059 return ret;
9060 #endif
9061 #ifdef TARGET_NR_rt_sigtimedwait_time64
9062 case TARGET_NR_rt_sigtimedwait_time64:
9063 {
9064 sigset_t set;
9065 struct timespec uts, *puts;
9066 siginfo_t uinfo;
9067
9068 if (arg4 != sizeof(target_sigset_t)) {
9069 return -TARGET_EINVAL;
9070 }
9071
9072 p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1);
9073 if (!p) {
9074 return -TARGET_EFAULT;
9075 }
9076 target_to_host_sigset(&set, p);
9077 unlock_user(p, arg1, 0);
9078 if (arg3) {
9079 puts = &uts;
9080 if (target_to_host_timespec64(puts, arg3)) {
9081 return -TARGET_EFAULT;
9082 }
9083 } else {
9084 puts = NULL;
9085 }
9086 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
9087 SIGSET_T_SIZE));
9088 if (!is_error(ret)) {
9089 if (arg2) {
9090 p = lock_user(VERIFY_WRITE, arg2,
9091 sizeof(target_siginfo_t), 0);
9092 if (!p) {
9093 return -TARGET_EFAULT;
9094 }
9095 host_to_target_siginfo(p, &uinfo);
9096 unlock_user(p, arg2, sizeof(target_siginfo_t));
9097 }
9098 ret = host_to_target_signal(ret);
9099 }
9100 }
9101 return ret;
9102 #endif
9103 case TARGET_NR_rt_sigqueueinfo:
9104 {
9105 siginfo_t uinfo;
9106
9107 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
9108 if (!p) {
9109 return -TARGET_EFAULT;
9110 }
9111 target_to_host_siginfo(&uinfo, p);
9112 unlock_user(p, arg3, 0);
9113 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
9114 }
9115 return ret;
9116 case TARGET_NR_rt_tgsigqueueinfo:
9117 {
9118 siginfo_t uinfo;
9119
9120 p = lock_user(VERIFY_READ, arg4, sizeof(target_siginfo_t), 1);
9121 if (!p) {
9122 return -TARGET_EFAULT;
9123 }
9124 target_to_host_siginfo(&uinfo, p);
9125 unlock_user(p, arg4, 0);
9126 ret = get_errno(sys_rt_tgsigqueueinfo(arg1, arg2, arg3, &uinfo));
9127 }
9128 return ret;
9129 #ifdef TARGET_NR_sigreturn
9130 case TARGET_NR_sigreturn:
9131 if (block_signals()) {
9132 return -TARGET_ERESTARTSYS;
9133 }
9134 return do_sigreturn(cpu_env);
9135 #endif
9136 case TARGET_NR_rt_sigreturn:
9137 if (block_signals()) {
9138 return -TARGET_ERESTARTSYS;
9139 }
9140 return do_rt_sigreturn(cpu_env);
9141 case TARGET_NR_sethostname:
9142 if (!(p = lock_user_string(arg1)))
9143 return -TARGET_EFAULT;
9144 ret = get_errno(sethostname(p, arg2));
9145 unlock_user(p, arg1, 0);
9146 return ret;
9147 #ifdef TARGET_NR_setrlimit
9148 case TARGET_NR_setrlimit:
9149 {
9150 int resource = target_to_host_resource(arg1);
9151 struct target_rlimit *target_rlim;
9152 struct rlimit rlim;
9153 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
9154 return -TARGET_EFAULT;
9155 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
9156 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
9157 unlock_user_struct(target_rlim, arg2, 0);
9158 /*
9159 * If we just passed through resource limit settings for memory then
9160 * they would also apply to QEMU's own allocations, and QEMU will
9161 * crash or hang or die if its allocations fail. Ideally we would
9162 * track the guest allocations in QEMU and apply the limits ourselves.
9163 * For now, just tell the guest the call succeeded but don't actually
9164 * limit anything.
9165 */
9166 if (resource != RLIMIT_AS &&
9167 resource != RLIMIT_DATA &&
9168 resource != RLIMIT_STACK) {
9169 return get_errno(setrlimit(resource, &rlim));
9170 } else {
9171 return 0;
9172 }
9173 }
9174 #endif
9175 #ifdef TARGET_NR_getrlimit
9176 case TARGET_NR_getrlimit:
9177 {
9178 int resource = target_to_host_resource(arg1);
9179 struct target_rlimit *target_rlim;
9180 struct rlimit rlim;
9181
9182 ret = get_errno(getrlimit(resource, &rlim));
9183 if (!is_error(ret)) {
9184 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
9185 return -TARGET_EFAULT;
9186 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
9187 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
9188 unlock_user_struct(target_rlim, arg2, 1);
9189 }
9190 }
9191 return ret;
9192 #endif
9193 case TARGET_NR_getrusage:
9194 {
9195 struct rusage rusage;
9196 ret = get_errno(getrusage(arg1, &rusage));
9197 if (!is_error(ret)) {
9198 ret = host_to_target_rusage(arg2, &rusage);
9199 }
9200 }
9201 return ret;
9202 #if defined(TARGET_NR_gettimeofday)
9203 case TARGET_NR_gettimeofday:
9204 {
9205 struct timeval tv;
9206 struct timezone tz;
9207
9208 ret = get_errno(gettimeofday(&tv, &tz));
9209 if (!is_error(ret)) {
9210 if (arg1 && copy_to_user_timeval(arg1, &tv)) {
9211 return -TARGET_EFAULT;
9212 }
9213 if (arg2 && copy_to_user_timezone(arg2, &tz)) {
9214 return -TARGET_EFAULT;
9215 }
9216 }
9217 }
9218 return ret;
9219 #endif
9220 #if defined(TARGET_NR_settimeofday)
9221 case TARGET_NR_settimeofday:
9222 {
9223 struct timeval tv, *ptv = NULL;
9224 struct timezone tz, *ptz = NULL;
9225
9226 if (arg1) {
9227 if (copy_from_user_timeval(&tv, arg1)) {
9228 return -TARGET_EFAULT;
9229 }
9230 ptv = &tv;
9231 }
9232
9233 if (arg2) {
9234 if (copy_from_user_timezone(&tz, arg2)) {
9235 return -TARGET_EFAULT;
9236 }
9237 ptz = &tz;
9238 }
9239
9240 return get_errno(settimeofday(ptv, ptz));
9241 }
9242 #endif
9243 #if defined(TARGET_NR_select)
9244 case TARGET_NR_select:
9245 #if defined(TARGET_WANT_NI_OLD_SELECT)
9246 /* some architectures used to have old_select here
9247 * but now ENOSYS it.
9248 */
9249 ret = -TARGET_ENOSYS;
9250 #elif defined(TARGET_WANT_OLD_SYS_SELECT)
9251 ret = do_old_select(arg1);
9252 #else
9253 ret = do_select(arg1, arg2, arg3, arg4, arg5);
9254 #endif
9255 return ret;
9256 #endif
9257 #ifdef TARGET_NR_pselect6
9258 case TARGET_NR_pselect6:
9259 {
9260 abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
9261 fd_set rfds, wfds, efds;
9262 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
9263 struct timespec ts, *ts_ptr;
9264
9265 /*
9266 * The 6th arg is actually two args smashed together,
9267 * so we cannot use the C library.
9268 */
9269 sigset_t set;
9270 struct {
9271 sigset_t *set;
9272 size_t size;
9273 } sig, *sig_ptr;
9274
9275 abi_ulong arg_sigset, arg_sigsize, *arg7;
9276 target_sigset_t *target_sigset;
9277
9278 n = arg1;
9279 rfd_addr = arg2;
9280 wfd_addr = arg3;
9281 efd_addr = arg4;
9282 ts_addr = arg5;
9283
9284 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
9285 if (ret) {
9286 return ret;
9287 }
9288 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
9289 if (ret) {
9290 return ret;
9291 }
9292 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
9293 if (ret) {
9294 return ret;
9295 }
9296
9297 /*
9298 * This takes a timespec, and not a timeval, so we cannot
9299 * use the do_select() helper ...
9300 */
9301 if (ts_addr) {
9302 if (target_to_host_timespec(&ts, ts_addr)) {
9303 return -TARGET_EFAULT;
9304 }
9305 ts_ptr = &ts;
9306 } else {
9307 ts_ptr = NULL;
9308 }
9309
9310 /* Extract the two packed args for the sigset */
9311 if (arg6) {
9312 sig_ptr = &sig;
9313 sig.size = SIGSET_T_SIZE;
9314
9315 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
9316 if (!arg7) {
9317 return -TARGET_EFAULT;
9318 }
9319 arg_sigset = tswapal(arg7[0]);
9320 arg_sigsize = tswapal(arg7[1]);
9321 unlock_user(arg7, arg6, 0);
9322
9323 if (arg_sigset) {
9324 sig.set = &set;
9325 if (arg_sigsize != sizeof(*target_sigset)) {
9326 /* Like the kernel, we enforce correct size sigsets */
9327 return -TARGET_EINVAL;
9328 }
9329 target_sigset = lock_user(VERIFY_READ, arg_sigset,
9330 sizeof(*target_sigset), 1);
9331 if (!target_sigset) {
9332 return -TARGET_EFAULT;
9333 }
9334 target_to_host_sigset(&set, target_sigset);
9335 unlock_user(target_sigset, arg_sigset, 0);
9336 } else {
9337 sig.set = NULL;
9338 }
9339 } else {
9340 sig_ptr = NULL;
9341 }
9342
9343 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
9344 ts_ptr, sig_ptr));
9345
9346 if (!is_error(ret)) {
9347 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
9348 return -TARGET_EFAULT;
9349 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
9350 return -TARGET_EFAULT;
9351 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
9352 return -TARGET_EFAULT;
9353
9354 if (ts_addr && host_to_target_timespec(ts_addr, &ts))
9355 return -TARGET_EFAULT;
9356 }
9357 }
9358 return ret;
9359 #endif
9360 #ifdef TARGET_NR_symlink
9361 case TARGET_NR_symlink:
9362 {
9363 void *p2;
9364 p = lock_user_string(arg1);
9365 p2 = lock_user_string(arg2);
9366 if (!p || !p2)
9367 ret = -TARGET_EFAULT;
9368 else
9369 ret = get_errno(symlink(p, p2));
9370 unlock_user(p2, arg2, 0);
9371 unlock_user(p, arg1, 0);
9372 }
9373 return ret;
9374 #endif
9375 #if defined(TARGET_NR_symlinkat)
9376 case TARGET_NR_symlinkat:
9377 {
9378 void *p2;
9379 p = lock_user_string(arg1);
9380 p2 = lock_user_string(arg3);
9381 if (!p || !p2)
9382 ret = -TARGET_EFAULT;
9383 else
9384 ret = get_errno(symlinkat(p, arg2, p2));
9385 unlock_user(p2, arg3, 0);
9386 unlock_user(p, arg1, 0);
9387 }
9388 return ret;
9389 #endif
9390 #ifdef TARGET_NR_readlink
9391 case TARGET_NR_readlink:
9392 {
9393 void *p2;
9394 p = lock_user_string(arg1);
9395 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
9396 if (!p || !p2) {
9397 ret = -TARGET_EFAULT;
9398 } else if (!arg3) {
9399 /* Short circuit this for the magic exe check. */
9400 ret = -TARGET_EINVAL;
9401 } else if (is_proc_myself((const char *)p, "exe")) {
9402 char real[PATH_MAX], *temp;
9403 temp = realpath(exec_path, real);
9404 /* Return value is # of bytes that we wrote to the buffer. */
9405 if (temp == NULL) {
9406 ret = get_errno(-1);
9407 } else {
9408 /* Don't worry about sign mismatch as earlier mapping
9409 * logic would have thrown a bad address error. */
9410 ret = MIN(strlen(real), arg3);
9411 /* We cannot NUL terminate the string. */
9412 memcpy(p2, real, ret);
9413 }
9414 } else {
9415 ret = get_errno(readlink(path(p), p2, arg3));
9416 }
9417 unlock_user(p2, arg2, ret);
9418 unlock_user(p, arg1, 0);
9419 }
9420 return ret;
9421 #endif
9422 #if defined(TARGET_NR_readlinkat)
9423 case TARGET_NR_readlinkat:
9424 {
9425 void *p2;
9426 p = lock_user_string(arg2);
9427 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
9428 if (!p || !p2) {
9429 ret = -TARGET_EFAULT;
9430 } else if (is_proc_myself((const char *)p, "exe")) {
9431 char real[PATH_MAX], *temp;
9432 temp = realpath(exec_path, real);
9433 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
9434 snprintf((char *)p2, arg4, "%s", real);
9435 } else {
9436 ret = get_errno(readlinkat(arg1, path(p), p2, arg4));
9437 }
9438 unlock_user(p2, arg3, ret);
9439 unlock_user(p, arg2, 0);
9440 }
9441 return ret;
9442 #endif
9443 #ifdef TARGET_NR_swapon
9444 case TARGET_NR_swapon:
9445 if (!(p = lock_user_string(arg1)))
9446 return -TARGET_EFAULT;
9447 ret = get_errno(swapon(p, arg2));
9448 unlock_user(p, arg1, 0);
9449 return ret;
9450 #endif
9451 case TARGET_NR_reboot:
9452 if (arg3 == LINUX_REBOOT_CMD_RESTART2) {
9453 /* arg4 must be ignored in all other cases */
9454 p = lock_user_string(arg4);
9455 if (!p) {
9456 return -TARGET_EFAULT;
9457 }
9458 ret = get_errno(reboot(arg1, arg2, arg3, p));
9459 unlock_user(p, arg4, 0);
9460 } else {
9461 ret = get_errno(reboot(arg1, arg2, arg3, NULL));
9462 }
9463 return ret;
9464 #ifdef TARGET_NR_mmap
9465 case TARGET_NR_mmap:
9466 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
9467 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
9468 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
9469 || defined(TARGET_S390X)
9470 {
9471 abi_ulong *v;
9472 abi_ulong v1, v2, v3, v4, v5, v6;
9473 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
9474 return -TARGET_EFAULT;
9475 v1 = tswapal(v[0]);
9476 v2 = tswapal(v[1]);
9477 v3 = tswapal(v[2]);
9478 v4 = tswapal(v[3]);
9479 v5 = tswapal(v[4]);
9480 v6 = tswapal(v[5]);
9481 unlock_user(v, arg1, 0);
9482 ret = get_errno(target_mmap(v1, v2, v3,
9483 target_to_host_bitmask(v4, mmap_flags_tbl),
9484 v5, v6));
9485 }
9486 #else
9487 ret = get_errno(target_mmap(arg1, arg2, arg3,
9488 target_to_host_bitmask(arg4, mmap_flags_tbl),
9489 arg5,
9490 arg6));
9491 #endif
9492 return ret;
9493 #endif
9494 #ifdef TARGET_NR_mmap2
9495 case TARGET_NR_mmap2:
9496 #ifndef MMAP_SHIFT
9497 #define MMAP_SHIFT 12
9498 #endif
9499 ret = target_mmap(arg1, arg2, arg3,
9500 target_to_host_bitmask(arg4, mmap_flags_tbl),
9501 arg5, arg6 << MMAP_SHIFT);
9502 return get_errno(ret);
9503 #endif
9504 case TARGET_NR_munmap:
9505 return get_errno(target_munmap(arg1, arg2));
9506 case TARGET_NR_mprotect:
9507 {
9508 TaskState *ts = cpu->opaque;
9509 /* Special hack to detect libc making the stack executable. */
9510 if ((arg3 & PROT_GROWSDOWN)
9511 && arg1 >= ts->info->stack_limit
9512 && arg1 <= ts->info->start_stack) {
9513 arg3 &= ~PROT_GROWSDOWN;
9514 arg2 = arg2 + arg1 - ts->info->stack_limit;
9515 arg1 = ts->info->stack_limit;
9516 }
9517 }
9518 return get_errno(target_mprotect(arg1, arg2, arg3));
9519 #ifdef TARGET_NR_mremap
9520 case TARGET_NR_mremap:
9521 return get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
9522 #endif
9523 /* ??? msync/mlock/munlock are broken for softmmu. */
9524 #ifdef TARGET_NR_msync
9525 case TARGET_NR_msync:
9526 return get_errno(msync(g2h(arg1), arg2, arg3));
9527 #endif
9528 #ifdef TARGET_NR_mlock
9529 case TARGET_NR_mlock:
9530 return get_errno(mlock(g2h(arg1), arg2));
9531 #endif
9532 #ifdef TARGET_NR_munlock
9533 case TARGET_NR_munlock:
9534 return get_errno(munlock(g2h(arg1), arg2));
9535 #endif
9536 #ifdef TARGET_NR_mlockall
9537 case TARGET_NR_mlockall:
9538 return get_errno(mlockall(target_to_host_mlockall_arg(arg1)));
9539 #endif
9540 #ifdef TARGET_NR_munlockall
9541 case TARGET_NR_munlockall:
9542 return get_errno(munlockall());
9543 #endif
9544 #ifdef TARGET_NR_truncate
9545 case TARGET_NR_truncate:
9546 if (!(p = lock_user_string(arg1)))
9547 return -TARGET_EFAULT;
9548 ret = get_errno(truncate(p, arg2));
9549 unlock_user(p, arg1, 0);
9550 return ret;
9551 #endif
9552 #ifdef TARGET_NR_ftruncate
9553 case TARGET_NR_ftruncate:
9554 return get_errno(ftruncate(arg1, arg2));
9555 #endif
9556 case TARGET_NR_fchmod:
9557 return get_errno(fchmod(arg1, arg2));
9558 #if defined(TARGET_NR_fchmodat)
9559 case TARGET_NR_fchmodat:
9560 if (!(p = lock_user_string(arg2)))
9561 return -TARGET_EFAULT;
9562 ret = get_errno(fchmodat(arg1, p, arg3, 0));
9563 unlock_user(p, arg2, 0);
9564 return ret;
9565 #endif
9566 case TARGET_NR_getpriority:
9567 /* Note that negative values are valid for getpriority, so we must
9568 differentiate based on errno settings. */
9569 errno = 0;
9570 ret = getpriority(arg1, arg2);
9571 if (ret == -1 && errno != 0) {
9572 return -host_to_target_errno(errno);
9573 }
9574 #ifdef TARGET_ALPHA
9575 /* Return value is the unbiased priority. Signal no error. */
9576 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0;
9577 #else
9578 /* Return value is a biased priority to avoid negative numbers. */
9579 ret = 20 - ret;
9580 #endif
9581 return ret;
9582 case TARGET_NR_setpriority:
9583 return get_errno(setpriority(arg1, arg2, arg3));
9584 #ifdef TARGET_NR_statfs
9585 case TARGET_NR_statfs:
9586 if (!(p = lock_user_string(arg1))) {
9587 return -TARGET_EFAULT;
9588 }
9589 ret = get_errno(statfs(path(p), &stfs));
9590 unlock_user(p, arg1, 0);
9591 convert_statfs:
9592 if (!is_error(ret)) {
9593 struct target_statfs *target_stfs;
9594
9595 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
9596 return -TARGET_EFAULT;
9597 __put_user(stfs.f_type, &target_stfs->f_type);
9598 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
9599 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
9600 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
9601 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
9602 __put_user(stfs.f_files, &target_stfs->f_files);
9603 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
9604 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
9605 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
9606 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
9607 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
9608 #ifdef _STATFS_F_FLAGS
9609 __put_user(stfs.f_flags, &target_stfs->f_flags);
9610 #else
9611 __put_user(0, &target_stfs->f_flags);
9612 #endif
9613 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
9614 unlock_user_struct(target_stfs, arg2, 1);
9615 }
9616 return ret;
9617 #endif
9618 #ifdef TARGET_NR_fstatfs
9619 case TARGET_NR_fstatfs:
9620 ret = get_errno(fstatfs(arg1, &stfs));
9621 goto convert_statfs;
9622 #endif
9623 #ifdef TARGET_NR_statfs64
9624 case TARGET_NR_statfs64:
9625 if (!(p = lock_user_string(arg1))) {
9626 return -TARGET_EFAULT;
9627 }
9628 ret = get_errno(statfs(path(p), &stfs));
9629 unlock_user(p, arg1, 0);
9630 convert_statfs64:
9631 if (!is_error(ret)) {
9632 struct target_statfs64 *target_stfs;
9633
9634 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
9635 return -TARGET_EFAULT;
9636 __put_user(stfs.f_type, &target_stfs->f_type);
9637 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
9638 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
9639 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
9640 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
9641 __put_user(stfs.f_files, &target_stfs->f_files);
9642 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
9643 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
9644 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
9645 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
9646 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
9647 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
9648 unlock_user_struct(target_stfs, arg3, 1);
9649 }
9650 return ret;
9651 case TARGET_NR_fstatfs64:
9652 ret = get_errno(fstatfs(arg1, &stfs));
9653 goto convert_statfs64;
9654 #endif
9655 #ifdef TARGET_NR_socketcall
9656 case TARGET_NR_socketcall:
9657 return do_socketcall(arg1, arg2);
9658 #endif
9659 #ifdef TARGET_NR_accept
9660 case TARGET_NR_accept:
9661 return do_accept4(arg1, arg2, arg3, 0);
9662 #endif
9663 #ifdef TARGET_NR_accept4
9664 case TARGET_NR_accept4:
9665 return do_accept4(arg1, arg2, arg3, arg4);
9666 #endif
9667 #ifdef TARGET_NR_bind
9668 case TARGET_NR_bind:
9669 return do_bind(arg1, arg2, arg3);
9670 #endif
9671 #ifdef TARGET_NR_connect
9672 case TARGET_NR_connect:
9673 return do_connect(arg1, arg2, arg3);
9674 #endif
9675 #ifdef TARGET_NR_getpeername
9676 case TARGET_NR_getpeername:
9677 return do_getpeername(arg1, arg2, arg3);
9678 #endif
9679 #ifdef TARGET_NR_getsockname
9680 case TARGET_NR_getsockname:
9681 return do_getsockname(arg1, arg2, arg3);
9682 #endif
9683 #ifdef TARGET_NR_getsockopt
9684 case TARGET_NR_getsockopt:
9685 return do_getsockopt(arg1, arg2, arg3, arg4, arg5);
9686 #endif
9687 #ifdef TARGET_NR_listen
9688 case TARGET_NR_listen:
9689 return get_errno(listen(arg1, arg2));
9690 #endif
9691 #ifdef TARGET_NR_recv
9692 case TARGET_NR_recv:
9693 return do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
9694 #endif
9695 #ifdef TARGET_NR_recvfrom
9696 case TARGET_NR_recvfrom:
9697 return do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
9698 #endif
9699 #ifdef TARGET_NR_recvmsg
9700 case TARGET_NR_recvmsg:
9701 return do_sendrecvmsg(arg1, arg2, arg3, 0);
9702 #endif
9703 #ifdef TARGET_NR_send
9704 case TARGET_NR_send:
9705 return do_sendto(arg1, arg2, arg3, arg4, 0, 0);
9706 #endif
9707 #ifdef TARGET_NR_sendmsg
9708 case TARGET_NR_sendmsg:
9709 return do_sendrecvmsg(arg1, arg2, arg3, 1);
9710 #endif
9711 #ifdef TARGET_NR_sendmmsg
9712 case TARGET_NR_sendmmsg:
9713 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1);
9714 #endif
9715 #ifdef TARGET_NR_recvmmsg
9716 case TARGET_NR_recvmmsg:
9717 return do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0);
9718 #endif
9719 #ifdef TARGET_NR_sendto
9720 case TARGET_NR_sendto:
9721 return do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
9722 #endif
9723 #ifdef TARGET_NR_shutdown
9724 case TARGET_NR_shutdown:
9725 return get_errno(shutdown(arg1, arg2));
9726 #endif
9727 #if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
9728 case TARGET_NR_getrandom:
9729 p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
9730 if (!p) {
9731 return -TARGET_EFAULT;
9732 }
9733 ret = get_errno(getrandom(p, arg2, arg3));
9734 unlock_user(p, arg1, ret);
9735 return ret;
9736 #endif
9737 #ifdef TARGET_NR_socket
9738 case TARGET_NR_socket:
9739 return do_socket(arg1, arg2, arg3);
9740 #endif
9741 #ifdef TARGET_NR_socketpair
9742 case TARGET_NR_socketpair:
9743 return do_socketpair(arg1, arg2, arg3, arg4);
9744 #endif
9745 #ifdef TARGET_NR_setsockopt
9746 case TARGET_NR_setsockopt:
9747 return do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
9748 #endif
9749 #if defined(TARGET_NR_syslog)
9750 case TARGET_NR_syslog:
9751 {
9752 int len = arg2;
9753
9754 switch (arg1) {
9755 case TARGET_SYSLOG_ACTION_CLOSE: /* Close log */
9756 case TARGET_SYSLOG_ACTION_OPEN: /* Open log */
9757 case TARGET_SYSLOG_ACTION_CLEAR: /* Clear ring buffer */
9758 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging */
9759 case TARGET_SYSLOG_ACTION_CONSOLE_ON: /* Enable logging */
9760 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: /* Set messages level */
9761 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: /* Number of chars */
9762 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: /* Size of the buffer */
9763 return get_errno(sys_syslog((int)arg1, NULL, (int)arg3));
9764 case TARGET_SYSLOG_ACTION_READ: /* Read from log */
9765 case TARGET_SYSLOG_ACTION_READ_CLEAR: /* Read/clear msgs */
9766 case TARGET_SYSLOG_ACTION_READ_ALL: /* Read last messages */
9767 {
9768 if (len < 0) {
9769 return -TARGET_EINVAL;
9770 }
9771 if (len == 0) {
9772 return 0;
9773 }
9774 p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
9775 if (!p) {
9776 return -TARGET_EFAULT;
9777 }
9778 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
9779 unlock_user(p, arg2, arg3);
9780 }
9781 return ret;
9782 default:
9783 return -TARGET_EINVAL;
9784 }
9785 }
9786 break;
9787 #endif
9788 case TARGET_NR_setitimer:
9789 {
9790 struct itimerval value, ovalue, *pvalue;
9791
9792 if (arg2) {
9793 pvalue = &value;
9794 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
9795 || copy_from_user_timeval(&pvalue->it_value,
9796 arg2 + sizeof(struct target_timeval)))
9797 return -TARGET_EFAULT;
9798 } else {
9799 pvalue = NULL;
9800 }
9801 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
9802 if (!is_error(ret) && arg3) {
9803 if (copy_to_user_timeval(arg3,
9804 &ovalue.it_interval)
9805 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
9806 &ovalue.it_value))
9807 return -TARGET_EFAULT;
9808 }
9809 }
9810 return ret;
9811 case TARGET_NR_getitimer:
9812 {
9813 struct itimerval value;
9814
9815 ret = get_errno(getitimer(arg1, &value));
9816 if (!is_error(ret) && arg2) {
9817 if (copy_to_user_timeval(arg2,
9818 &value.it_interval)
9819 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
9820 &value.it_value))
9821 return -TARGET_EFAULT;
9822 }
9823 }
9824 return ret;
9825 #ifdef TARGET_NR_stat
9826 case TARGET_NR_stat:
9827 if (!(p = lock_user_string(arg1))) {
9828 return -TARGET_EFAULT;
9829 }
9830 ret = get_errno(stat(path(p), &st));
9831 unlock_user(p, arg1, 0);
9832 goto do_stat;
9833 #endif
9834 #ifdef TARGET_NR_lstat
9835 case TARGET_NR_lstat:
9836 if (!(p = lock_user_string(arg1))) {
9837 return -TARGET_EFAULT;
9838 }
9839 ret = get_errno(lstat(path(p), &st));
9840 unlock_user(p, arg1, 0);
9841 goto do_stat;
9842 #endif
9843 #ifdef TARGET_NR_fstat
9844 case TARGET_NR_fstat:
9845 {
9846 ret = get_errno(fstat(arg1, &st));
9847 #if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
9848 do_stat:
9849 #endif
9850 if (!is_error(ret)) {
9851 struct target_stat *target_st;
9852
9853 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
9854 return -TARGET_EFAULT;
9855 memset(target_st, 0, sizeof(*target_st));
9856 __put_user(st.st_dev, &target_st->st_dev);
9857 __put_user(st.st_ino, &target_st->st_ino);
9858 __put_user(st.st_mode, &target_st->st_mode);
9859 __put_user(st.st_uid, &target_st->st_uid);
9860 __put_user(st.st_gid, &target_st->st_gid);
9861 __put_user(st.st_nlink, &target_st->st_nlink);
9862 __put_user(st.st_rdev, &target_st->st_rdev);
9863 __put_user(st.st_size, &target_st->st_size);
9864 __put_user(st.st_blksize, &target_st->st_blksize);
9865 __put_user(st.st_blocks, &target_st->st_blocks);
9866 __put_user(st.st_atime, &target_st->target_st_atime);
9867 __put_user(st.st_mtime, &target_st->target_st_mtime);
9868 __put_user(st.st_ctime, &target_st->target_st_ctime);
9869 #if (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700) && \
9870 defined(TARGET_STAT_HAVE_NSEC)
9871 __put_user(st.st_atim.tv_nsec,
9872 &target_st->target_st_atime_nsec);
9873 __put_user(st.st_mtim.tv_nsec,
9874 &target_st->target_st_mtime_nsec);
9875 __put_user(st.st_ctim.tv_nsec,
9876 &target_st->target_st_ctime_nsec);
9877 #endif
9878 unlock_user_struct(target_st, arg2, 1);
9879 }
9880 }
9881 return ret;
9882 #endif
9883 case TARGET_NR_vhangup:
9884 return get_errno(vhangup());
9885 #ifdef TARGET_NR_syscall
9886 case TARGET_NR_syscall:
9887 return do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5,
9888 arg6, arg7, arg8, 0);
9889 #endif
9890 #if defined(TARGET_NR_wait4)
9891 case TARGET_NR_wait4:
9892 {
9893 int status;
9894 abi_long status_ptr = arg2;
9895 struct rusage rusage, *rusage_ptr;
9896 abi_ulong target_rusage = arg4;
9897 abi_long rusage_err;
9898 if (target_rusage)
9899 rusage_ptr = &rusage;
9900 else
9901 rusage_ptr = NULL;
9902 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr));
9903 if (!is_error(ret)) {
9904 if (status_ptr && ret) {
9905 status = host_to_target_waitstatus(status);
9906 if (put_user_s32(status, status_ptr))
9907 return -TARGET_EFAULT;
9908 }
9909 if (target_rusage) {
9910 rusage_err = host_to_target_rusage(target_rusage, &rusage);
9911 if (rusage_err) {
9912 ret = rusage_err;
9913 }
9914 }
9915 }
9916 }
9917 return ret;
9918 #endif
9919 #ifdef TARGET_NR_swapoff
9920 case TARGET_NR_swapoff:
9921 if (!(p = lock_user_string(arg1)))
9922 return -TARGET_EFAULT;
9923 ret = get_errno(swapoff(p));
9924 unlock_user(p, arg1, 0);
9925 return ret;
9926 #endif
9927 case TARGET_NR_sysinfo:
9928 {
9929 struct target_sysinfo *target_value;
9930 struct sysinfo value;
9931 ret = get_errno(sysinfo(&value));
9932 if (!is_error(ret) && arg1)
9933 {
9934 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
9935 return -TARGET_EFAULT;
9936 __put_user(value.uptime, &target_value->uptime);
9937 __put_user(value.loads[0], &target_value->loads[0]);
9938 __put_user(value.loads[1], &target_value->loads[1]);
9939 __put_user(value.loads[2], &target_value->loads[2]);
9940 __put_user(value.totalram, &target_value->totalram);
9941 __put_user(value.freeram, &target_value->freeram);
9942 __put_user(value.sharedram, &target_value->sharedram);
9943 __put_user(value.bufferram, &target_value->bufferram);
9944 __put_user(value.totalswap, &target_value->totalswap);
9945 __put_user(value.freeswap, &target_value->freeswap);
9946 __put_user(value.procs, &target_value->procs);
9947 __put_user(value.totalhigh, &target_value->totalhigh);
9948 __put_user(value.freehigh, &target_value->freehigh);
9949 __put_user(value.mem_unit, &target_value->mem_unit);
9950 unlock_user_struct(target_value, arg1, 1);
9951 }
9952 }
9953 return ret;
9954 #ifdef TARGET_NR_ipc
9955 case TARGET_NR_ipc:
9956 return do_ipc(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
9957 #endif
9958 #ifdef TARGET_NR_semget
9959 case TARGET_NR_semget:
9960 return get_errno(semget(arg1, arg2, arg3));
9961 #endif
9962 #ifdef TARGET_NR_semop
9963 case TARGET_NR_semop:
9964 return do_semtimedop(arg1, arg2, arg3, 0, false);
9965 #endif
9966 #ifdef TARGET_NR_semtimedop
9967 case TARGET_NR_semtimedop:
9968 return do_semtimedop(arg1, arg2, arg3, arg4, false);
9969 #endif
9970 #ifdef TARGET_NR_semtimedop_time64
9971 case TARGET_NR_semtimedop_time64:
9972 return do_semtimedop(arg1, arg2, arg3, arg4, true);
9973 #endif
9974 #ifdef TARGET_NR_semctl
9975 case TARGET_NR_semctl:
9976 return do_semctl(arg1, arg2, arg3, arg4);
9977 #endif
9978 #ifdef TARGET_NR_msgctl
9979 case TARGET_NR_msgctl:
9980 return do_msgctl(arg1, arg2, arg3);
9981 #endif
9982 #ifdef TARGET_NR_msgget
9983 case TARGET_NR_msgget:
9984 return get_errno(msgget(arg1, arg2));
9985 #endif
9986 #ifdef TARGET_NR_msgrcv
9987 case TARGET_NR_msgrcv:
9988 return do_msgrcv(arg1, arg2, arg3, arg4, arg5);
9989 #endif
9990 #ifdef TARGET_NR_msgsnd
9991 case TARGET_NR_msgsnd:
9992 return do_msgsnd(arg1, arg2, arg3, arg4);
9993 #endif
9994 #ifdef TARGET_NR_shmget
9995 case TARGET_NR_shmget:
9996 return get_errno(shmget(arg1, arg2, arg3));
9997 #endif
9998 #ifdef TARGET_NR_shmctl
9999 case TARGET_NR_shmctl:
10000 return do_shmctl(arg1, arg2, arg3);
10001 #endif
10002 #ifdef TARGET_NR_shmat
10003 case TARGET_NR_shmat:
10004 return do_shmat(cpu_env, arg1, arg2, arg3);
10005 #endif
10006 #ifdef TARGET_NR_shmdt
10007 case TARGET_NR_shmdt:
10008 return do_shmdt(arg1);
10009 #endif
10010 case TARGET_NR_fsync:
10011 return get_errno(fsync(arg1));
10012 case TARGET_NR_clone:
10013 /* Linux manages to have three different orderings for its
10014 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
10015 * match the kernel's CONFIG_CLONE_* settings.
10016 * Microblaze is further special in that it uses a sixth
10017 * implicit argument to clone for the TLS pointer.
10018 */
10019 #if defined(TARGET_MICROBLAZE)
10020 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5));
10021 #elif defined(TARGET_CLONE_BACKWARDS)
10022 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
10023 #elif defined(TARGET_CLONE_BACKWARDS2)
10024 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
10025 #else
10026 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
10027 #endif
10028 return ret;
10029 #ifdef __NR_exit_group
10030 /* new thread calls */
10031 case TARGET_NR_exit_group:
10032 preexit_cleanup(cpu_env, arg1);
10033 return get_errno(exit_group(arg1));
10034 #endif
10035 case TARGET_NR_setdomainname:
10036 if (!(p = lock_user_string(arg1)))
10037 return -TARGET_EFAULT;
10038 ret = get_errno(setdomainname(p, arg2));
10039 unlock_user(p, arg1, 0);
10040 return ret;
10041 case TARGET_NR_uname:
10042 /* no need to transcode because we use the linux syscall */
10043 {
10044 struct new_utsname * buf;
10045
10046 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
10047 return -TARGET_EFAULT;
10048 ret = get_errno(sys_uname(buf));
10049 if (!is_error(ret)) {
10050 /* Overwrite the native machine name with whatever is being
10051 emulated. */
10052 g_strlcpy(buf->machine, cpu_to_uname_machine(cpu_env),
10053 sizeof(buf->machine));
10054 /* Allow the user to override the reported release. */
10055 if (qemu_uname_release && *qemu_uname_release) {
10056 g_strlcpy(buf->release, qemu_uname_release,
10057 sizeof(buf->release));
10058 }
10059 }
10060 unlock_user_struct(buf, arg1, 1);
10061 }
10062 return ret;
10063 #ifdef TARGET_I386
10064 case TARGET_NR_modify_ldt:
10065 return do_modify_ldt(cpu_env, arg1, arg2, arg3);
10066 #if !defined(TARGET_X86_64)
10067 case TARGET_NR_vm86:
10068 return do_vm86(cpu_env, arg1, arg2);
10069 #endif
10070 #endif
10071 #if defined(TARGET_NR_adjtimex)
10072 case TARGET_NR_adjtimex:
10073 {
10074 struct timex host_buf;
10075
10076 if (target_to_host_timex(&host_buf, arg1) != 0) {
10077 return -TARGET_EFAULT;
10078 }
10079 ret = get_errno(adjtimex(&host_buf));
10080 if (!is_error(ret)) {
10081 if (host_to_target_timex(arg1, &host_buf) != 0) {
10082 return -TARGET_EFAULT;
10083 }
10084 }
10085 }
10086 return ret;
10087 #endif
10088 #if defined(TARGET_NR_clock_adjtime) && defined(CONFIG_CLOCK_ADJTIME)
10089 case TARGET_NR_clock_adjtime:
10090 {
10091 struct timex htx, *phtx = &htx;
10092
10093 if (target_to_host_timex(phtx, arg2) != 0) {
10094 return -TARGET_EFAULT;
10095 }
10096 ret = get_errno(clock_adjtime(arg1, phtx));
10097 if (!is_error(ret) && phtx) {
10098 if (host_to_target_timex(arg2, phtx) != 0) {
10099 return -TARGET_EFAULT;
10100 }
10101 }
10102 }
10103 return ret;
10104 #endif
10105 #if defined(TARGET_NR_clock_adjtime64) && defined(CONFIG_CLOCK_ADJTIME)
10106 case TARGET_NR_clock_adjtime64:
10107 {
10108 struct timex htx;
10109
10110 if (target_to_host_timex64(&htx, arg2) != 0) {
10111 return -TARGET_EFAULT;
10112 }
10113 ret = get_errno(clock_adjtime(arg1, &htx));
10114 if (!is_error(ret) && host_to_target_timex64(arg2, &htx)) {
10115 return -TARGET_EFAULT;
10116 }
10117 }
10118 return ret;
10119 #endif
10120 case TARGET_NR_getpgid:
10121 return get_errno(getpgid(arg1));
10122 case TARGET_NR_fchdir:
10123 return get_errno(fchdir(arg1));
10124 case TARGET_NR_personality:
10125 return get_errno(personality(arg1));
10126 #ifdef TARGET_NR__llseek /* Not on alpha */
10127 case TARGET_NR__llseek:
10128 {
10129 int64_t res;
10130 #if !defined(__NR_llseek)
10131 res = lseek(arg1, ((uint64_t)arg2 << 32) | (abi_ulong)arg3, arg5);
10132 if (res == -1) {
10133 ret = get_errno(res);
10134 } else {
10135 ret = 0;
10136 }
10137 #else
10138 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
10139 #endif
10140 if ((ret == 0) && put_user_s64(res, arg4)) {
10141 return -TARGET_EFAULT;
10142 }
10143 }
10144 return ret;
10145 #endif
10146 #ifdef TARGET_NR_getdents
10147 case TARGET_NR_getdents:
10148 #ifdef EMULATE_GETDENTS_WITH_GETDENTS
10149 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
10150 {
10151 struct target_dirent *target_dirp;
10152 struct linux_dirent *dirp;
10153 abi_long count = arg3;
10154
10155 dirp = g_try_malloc(count);
10156 if (!dirp) {
10157 return -TARGET_ENOMEM;
10158 }
10159
10160 ret = get_errno(sys_getdents(arg1, dirp, count));
10161 if (!is_error(ret)) {
10162 struct linux_dirent *de;
10163 struct target_dirent *tde;
10164 int len = ret;
10165 int reclen, treclen;
10166 int count1, tnamelen;
10167
10168 count1 = 0;
10169 de = dirp;
10170 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
10171 return -TARGET_EFAULT;
10172 tde = target_dirp;
10173 while (len > 0) {
10174 reclen = de->d_reclen;
10175 tnamelen = reclen - offsetof(struct linux_dirent, d_name);
10176 assert(tnamelen >= 0);
10177 treclen = tnamelen + offsetof(struct target_dirent, d_name);
10178 assert(count1 + treclen <= count);
10179 tde->d_reclen = tswap16(treclen);
10180 tde->d_ino = tswapal(de->d_ino);
10181 tde->d_off = tswapal(de->d_off);
10182 memcpy(tde->d_name, de->d_name, tnamelen);
10183 de = (struct linux_dirent *)((char *)de + reclen);
10184 len -= reclen;
10185 tde = (struct target_dirent *)((char *)tde + treclen);
10186 count1 += treclen;
10187 }
10188 ret = count1;
10189 unlock_user(target_dirp, arg2, ret);
10190 }
10191 g_free(dirp);
10192 }
10193 #else
10194 {
10195 struct linux_dirent *dirp;
10196 abi_long count = arg3;
10197
10198 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
10199 return -TARGET_EFAULT;
10200 ret = get_errno(sys_getdents(arg1, dirp, count));
10201 if (!is_error(ret)) {
10202 struct linux_dirent *de;
10203 int len = ret;
10204 int reclen;
10205 de = dirp;
10206 while (len > 0) {
10207 reclen = de->d_reclen;
10208 if (reclen > len)
10209 break;
10210 de->d_reclen = tswap16(reclen);
10211 tswapls(&de->d_ino);
10212 tswapls(&de->d_off);
10213 de = (struct linux_dirent *)((char *)de + reclen);
10214 len -= reclen;
10215 }
10216 }
10217 unlock_user(dirp, arg2, ret);
10218 }
10219 #endif
10220 #else
10221 /* Implement getdents in terms of getdents64 */
10222 {
10223 struct linux_dirent64 *dirp;
10224 abi_long count = arg3;
10225
10226 dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
10227 if (!dirp) {
10228 return -TARGET_EFAULT;
10229 }
10230 ret = get_errno(sys_getdents64(arg1, dirp, count));
10231 if (!is_error(ret)) {
10232 /* Convert the dirent64 structs to target dirent. We do this
10233 * in-place, since we can guarantee that a target_dirent is no
10234 * larger than a dirent64; however this means we have to be
10235 * careful to read everything before writing in the new format.
10236 */
10237 struct linux_dirent64 *de;
10238 struct target_dirent *tde;
10239 int len = ret;
10240 int tlen = 0;
10241
10242 de = dirp;
10243 tde = (struct target_dirent *)dirp;
10244 while (len > 0) {
10245 int namelen, treclen;
10246 int reclen = de->d_reclen;
10247 uint64_t ino = de->d_ino;
10248 int64_t off = de->d_off;
10249 uint8_t type = de->d_type;
10250
10251 namelen = strlen(de->d_name);
10252 treclen = offsetof(struct target_dirent, d_name)
10253 + namelen + 2;
10254 treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
10255
10256 memmove(tde->d_name, de->d_name, namelen + 1);
10257 tde->d_ino = tswapal(ino);
10258 tde->d_off = tswapal(off);
10259 tde->d_reclen = tswap16(treclen);
10260 /* The target_dirent type is in what was formerly a padding
10261 * byte at the end of the structure:
10262 */
10263 *(((char *)tde) + treclen - 1) = type;
10264
10265 de = (struct linux_dirent64 *)((char *)de + reclen);
10266 tde = (struct target_dirent *)((char *)tde + treclen);
10267 len -= reclen;
10268 tlen += treclen;
10269 }
10270 ret = tlen;
10271 }
10272 unlock_user(dirp, arg2, ret);
10273 }
10274 #endif
10275 return ret;
10276 #endif /* TARGET_NR_getdents */
10277 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
10278 case TARGET_NR_getdents64:
10279 {
10280 struct linux_dirent64 *dirp;
10281 abi_long count = arg3;
10282 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
10283 return -TARGET_EFAULT;
10284 ret = get_errno(sys_getdents64(arg1, dirp, count));
10285 if (!is_error(ret)) {
10286 struct linux_dirent64 *de;
10287 int len = ret;
10288 int reclen;
10289 de = dirp;
10290 while (len > 0) {
10291 reclen = de->d_reclen;
10292 if (reclen > len)
10293 break;
10294 de->d_reclen = tswap16(reclen);
10295 tswap64s((uint64_t *)&de->d_ino);
10296 tswap64s((uint64_t *)&de->d_off);
10297 de = (struct linux_dirent64 *)((char *)de + reclen);
10298 len -= reclen;
10299 }
10300 }
10301 unlock_user(dirp, arg2, ret);
10302 }
10303 return ret;
10304 #endif /* TARGET_NR_getdents64 */
10305 #if defined(TARGET_NR__newselect)
10306 case TARGET_NR__newselect:
10307 return do_select(arg1, arg2, arg3, arg4, arg5);
10308 #endif
10309 #if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
10310 # ifdef TARGET_NR_poll
10311 case TARGET_NR_poll:
10312 # endif
10313 # ifdef TARGET_NR_ppoll
10314 case TARGET_NR_ppoll:
10315 # endif
10316 {
10317 struct target_pollfd *target_pfd;
10318 unsigned int nfds = arg2;
10319 struct pollfd *pfd;
10320 unsigned int i;
10321
10322 pfd = NULL;
10323 target_pfd = NULL;
10324 if (nfds) {
10325 if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
10326 return -TARGET_EINVAL;
10327 }
10328
10329 target_pfd = lock_user(VERIFY_WRITE, arg1,
10330 sizeof(struct target_pollfd) * nfds, 1);
10331 if (!target_pfd) {
10332 return -TARGET_EFAULT;
10333 }
10334
10335 pfd = alloca(sizeof(struct pollfd) * nfds);
10336 for (i = 0; i < nfds; i++) {
10337 pfd[i].fd = tswap32(target_pfd[i].fd);
10338 pfd[i].events = tswap16(target_pfd[i].events);
10339 }
10340 }
10341
10342 switch (num) {
10343 # ifdef TARGET_NR_ppoll
10344 case TARGET_NR_ppoll:
10345 {
10346 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
10347 target_sigset_t *target_set;
10348 sigset_t _set, *set = &_set;
10349
10350 if (arg3) {
10351 if (target_to_host_timespec(timeout_ts, arg3)) {
10352 unlock_user(target_pfd, arg1, 0);
10353 return -TARGET_EFAULT;
10354 }
10355 } else {
10356 timeout_ts = NULL;
10357 }
10358
10359 if (arg4) {
10360 if (arg5 != sizeof(target_sigset_t)) {
10361 unlock_user(target_pfd, arg1, 0);
10362 return -TARGET_EINVAL;
10363 }
10364
10365 target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
10366 if (!target_set) {
10367 unlock_user(target_pfd, arg1, 0);
10368 return -TARGET_EFAULT;
10369 }
10370 target_to_host_sigset(set, target_set);
10371 } else {
10372 set = NULL;
10373 }
10374
10375 ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
10376 set, SIGSET_T_SIZE));
10377
10378 if (!is_error(ret) && arg3) {
10379 host_to_target_timespec(arg3, timeout_ts);
10380 }
10381 if (arg4) {
10382 unlock_user(target_set, arg4, 0);
10383 }
10384 break;
10385 }
10386 # endif
10387 # ifdef TARGET_NR_poll
10388 case TARGET_NR_poll:
10389 {
10390 struct timespec ts, *pts;
10391
10392 if (arg3 >= 0) {
10393 /* Convert ms to secs, ns */
10394 ts.tv_sec = arg3 / 1000;
10395 ts.tv_nsec = (arg3 % 1000) * 1000000LL;
10396 pts = &ts;
10397 } else {
10398 /* -ve poll() timeout means "infinite" */
10399 pts = NULL;
10400 }
10401 ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
10402 break;
10403 }
10404 # endif
10405 default:
10406 g_assert_not_reached();
10407 }
10408
10409 if (!is_error(ret)) {
10410 for(i = 0; i < nfds; i++) {
10411 target_pfd[i].revents = tswap16(pfd[i].revents);
10412 }
10413 }
10414 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
10415 }
10416 return ret;
10417 #endif
10418 case TARGET_NR_flock:
10419 /* NOTE: the flock constant seems to be the same for every
10420 Linux platform */
10421 return get_errno(safe_flock(arg1, arg2));
10422 case TARGET_NR_readv:
10423 {
10424 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10425 if (vec != NULL) {
10426 ret = get_errno(safe_readv(arg1, vec, arg3));
10427 unlock_iovec(vec, arg2, arg3, 1);
10428 } else {
10429 ret = -host_to_target_errno(errno);
10430 }
10431 }
10432 return ret;
10433 case TARGET_NR_writev:
10434 {
10435 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10436 if (vec != NULL) {
10437 ret = get_errno(safe_writev(arg1, vec, arg3));
10438 unlock_iovec(vec, arg2, arg3, 0);
10439 } else {
10440 ret = -host_to_target_errno(errno);
10441 }
10442 }
10443 return ret;
10444 #if defined(TARGET_NR_preadv)
10445 case TARGET_NR_preadv:
10446 {
10447 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
10448 if (vec != NULL) {
10449 unsigned long low, high;
10450
10451 target_to_host_low_high(arg4, arg5, &low, &high);
10452 ret = get_errno(safe_preadv(arg1, vec, arg3, low, high));
10453 unlock_iovec(vec, arg2, arg3, 1);
10454 } else {
10455 ret = -host_to_target_errno(errno);
10456 }
10457 }
10458 return ret;
10459 #endif
10460 #if defined(TARGET_NR_pwritev)
10461 case TARGET_NR_pwritev:
10462 {
10463 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
10464 if (vec != NULL) {
10465 unsigned long low, high;
10466
10467 target_to_host_low_high(arg4, arg5, &low, &high);
10468 ret = get_errno(safe_pwritev(arg1, vec, arg3, low, high));
10469 unlock_iovec(vec, arg2, arg3, 0);
10470 } else {
10471 ret = -host_to_target_errno(errno);
10472 }
10473 }
10474 return ret;
10475 #endif
10476 case TARGET_NR_getsid:
10477 return get_errno(getsid(arg1));
10478 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
10479 case TARGET_NR_fdatasync:
10480 return get_errno(fdatasync(arg1));
10481 #endif
10482 #ifdef TARGET_NR__sysctl
10483 case TARGET_NR__sysctl:
10484 /* We don't implement this, but ENOTDIR is always a safe
10485 return value. */
10486 return -TARGET_ENOTDIR;
10487 #endif
10488 case TARGET_NR_sched_getaffinity:
10489 {
10490 unsigned int mask_size;
10491 unsigned long *mask;
10492
10493 /*
10494 * sched_getaffinity needs multiples of ulong, so need to take
10495 * care of mismatches between target ulong and host ulong sizes.
10496 */
10497 if (arg2 & (sizeof(abi_ulong) - 1)) {
10498 return -TARGET_EINVAL;
10499 }
10500 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10501
10502 mask = alloca(mask_size);
10503 memset(mask, 0, mask_size);
10504 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
10505
10506 if (!is_error(ret)) {
10507 if (ret > arg2) {
10508 /* More data returned than the caller's buffer will fit.
10509 * This only happens if sizeof(abi_long) < sizeof(long)
10510 * and the caller passed us a buffer holding an odd number
10511 * of abi_longs. If the host kernel is actually using the
10512 * extra 4 bytes then fail EINVAL; otherwise we can just
10513 * ignore them and only copy the interesting part.
10514 */
10515 int numcpus = sysconf(_SC_NPROCESSORS_CONF);
10516 if (numcpus > arg2 * 8) {
10517 return -TARGET_EINVAL;
10518 }
10519 ret = arg2;
10520 }
10521
10522 if (host_to_target_cpu_mask(mask, mask_size, arg3, ret)) {
10523 return -TARGET_EFAULT;
10524 }
10525 }
10526 }
10527 return ret;
10528 case TARGET_NR_sched_setaffinity:
10529 {
10530 unsigned int mask_size;
10531 unsigned long *mask;
10532
10533 /*
10534 * sched_setaffinity needs multiples of ulong, so need to take
10535 * care of mismatches between target ulong and host ulong sizes.
10536 */
10537 if (arg2 & (sizeof(abi_ulong) - 1)) {
10538 return -TARGET_EINVAL;
10539 }
10540 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
10541 mask = alloca(mask_size);
10542
10543 ret = target_to_host_cpu_mask(mask, mask_size, arg3, arg2);
10544 if (ret) {
10545 return ret;
10546 }
10547
10548 return get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
10549 }
10550 case TARGET_NR_getcpu:
10551 {
10552 unsigned cpu, node;
10553 ret = get_errno(sys_getcpu(arg1 ? &cpu : NULL,
10554 arg2 ? &node : NULL,
10555 NULL));
10556 if (is_error(ret)) {
10557 return ret;
10558 }
10559 if (arg1 && put_user_u32(cpu, arg1)) {
10560 return -TARGET_EFAULT;
10561 }
10562 if (arg2 && put_user_u32(node, arg2)) {
10563 return -TARGET_EFAULT;
10564 }
10565 }
10566 return ret;
10567 case TARGET_NR_sched_setparam:
10568 {
10569 struct sched_param *target_schp;
10570 struct sched_param schp;
10571
10572 if (arg2 == 0) {
10573 return -TARGET_EINVAL;
10574 }
10575 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
10576 return -TARGET_EFAULT;
10577 schp.sched_priority = tswap32(target_schp->sched_priority);
10578 unlock_user_struct(target_schp, arg2, 0);
10579 return get_errno(sched_setparam(arg1, &schp));
10580 }
10581 case TARGET_NR_sched_getparam:
10582 {
10583 struct sched_param *target_schp;
10584 struct sched_param schp;
10585
10586 if (arg2 == 0) {
10587 return -TARGET_EINVAL;
10588 }
10589 ret = get_errno(sched_getparam(arg1, &schp));
10590 if (!is_error(ret)) {
10591 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
10592 return -TARGET_EFAULT;
10593 target_schp->sched_priority = tswap32(schp.sched_priority);
10594 unlock_user_struct(target_schp, arg2, 1);
10595 }
10596 }
10597 return ret;
10598 case TARGET_NR_sched_setscheduler:
10599 {
10600 struct sched_param *target_schp;
10601 struct sched_param schp;
10602 if (arg3 == 0) {
10603 return -TARGET_EINVAL;
10604 }
10605 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
10606 return -TARGET_EFAULT;
10607 schp.sched_priority = tswap32(target_schp->sched_priority);
10608 unlock_user_struct(target_schp, arg3, 0);
10609 return get_errno(sched_setscheduler(arg1, arg2, &schp));
10610 }
10611 case TARGET_NR_sched_getscheduler:
10612 return get_errno(sched_getscheduler(arg1));
10613 case TARGET_NR_sched_yield:
10614 return get_errno(sched_yield());
10615 case TARGET_NR_sched_get_priority_max:
10616 return get_errno(sched_get_priority_max(arg1));
10617 case TARGET_NR_sched_get_priority_min:
10618 return get_errno(sched_get_priority_min(arg1));
10619 #ifdef TARGET_NR_sched_rr_get_interval
10620 case TARGET_NR_sched_rr_get_interval:
10621 {
10622 struct timespec ts;
10623 ret = get_errno(sched_rr_get_interval(arg1, &ts));
10624 if (!is_error(ret)) {
10625 ret = host_to_target_timespec(arg2, &ts);
10626 }
10627 }
10628 return ret;
10629 #endif
10630 #ifdef TARGET_NR_sched_rr_get_interval_time64
10631 case TARGET_NR_sched_rr_get_interval_time64:
10632 {
10633 struct timespec ts;
10634 ret = get_errno(sched_rr_get_interval(arg1, &ts));
10635 if (!is_error(ret)) {
10636 ret = host_to_target_timespec64(arg2, &ts);
10637 }
10638 }
10639 return ret;
10640 #endif
10641 #if defined(TARGET_NR_nanosleep)
10642 case TARGET_NR_nanosleep:
10643 {
10644 struct timespec req, rem;
10645 target_to_host_timespec(&req, arg1);
10646 ret = get_errno(safe_nanosleep(&req, &rem));
10647 if (is_error(ret) && arg2) {
10648 host_to_target_timespec(arg2, &rem);
10649 }
10650 }
10651 return ret;
10652 #endif
10653 case TARGET_NR_prctl:
10654 switch (arg1) {
10655 case PR_GET_PDEATHSIG:
10656 {
10657 int deathsig;
10658 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
10659 if (!is_error(ret) && arg2
10660 && put_user_ual(deathsig, arg2)) {
10661 return -TARGET_EFAULT;
10662 }
10663 return ret;
10664 }
10665 #ifdef PR_GET_NAME
10666 case PR_GET_NAME:
10667 {
10668 void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
10669 if (!name) {
10670 return -TARGET_EFAULT;
10671 }
10672 ret = get_errno(prctl(arg1, (unsigned long)name,
10673 arg3, arg4, arg5));
10674 unlock_user(name, arg2, 16);
10675 return ret;
10676 }
10677 case PR_SET_NAME:
10678 {
10679 void *name = lock_user(VERIFY_READ, arg2, 16, 1);
10680 if (!name) {
10681 return -TARGET_EFAULT;
10682 }
10683 ret = get_errno(prctl(arg1, (unsigned long)name,
10684 arg3, arg4, arg5));
10685 unlock_user(name, arg2, 0);
10686 return ret;
10687 }
10688 #endif
10689 #ifdef TARGET_MIPS
10690 case TARGET_PR_GET_FP_MODE:
10691 {
10692 CPUMIPSState *env = ((CPUMIPSState *)cpu_env);
10693 ret = 0;
10694 if (env->CP0_Status & (1 << CP0St_FR)) {
10695 ret |= TARGET_PR_FP_MODE_FR;
10696 }
10697 if (env->CP0_Config5 & (1 << CP0C5_FRE)) {
10698 ret |= TARGET_PR_FP_MODE_FRE;
10699 }
10700 return ret;
10701 }
10702 case TARGET_PR_SET_FP_MODE:
10703 {
10704 CPUMIPSState *env = ((CPUMIPSState *)cpu_env);
10705 bool old_fr = env->CP0_Status & (1 << CP0St_FR);
10706 bool old_fre = env->CP0_Config5 & (1 << CP0C5_FRE);
10707 bool new_fr = arg2 & TARGET_PR_FP_MODE_FR;
10708 bool new_fre = arg2 & TARGET_PR_FP_MODE_FRE;
10709
10710 const unsigned int known_bits = TARGET_PR_FP_MODE_FR |
10711 TARGET_PR_FP_MODE_FRE;
10712
10713 /* If nothing to change, return right away, successfully. */
10714 if (old_fr == new_fr && old_fre == new_fre) {
10715 return 0;
10716 }
10717 /* Check the value is valid */
10718 if (arg2 & ~known_bits) {
10719 return -TARGET_EOPNOTSUPP;
10720 }
10721 /* Setting FRE without FR is not supported. */
10722 if (new_fre && !new_fr) {
10723 return -TARGET_EOPNOTSUPP;
10724 }
10725 if (new_fr && !(env->active_fpu.fcr0 & (1 << FCR0_F64))) {
10726 /* FR1 is not supported */
10727 return -TARGET_EOPNOTSUPP;
10728 }
10729 if (!new_fr && (env->active_fpu.fcr0 & (1 << FCR0_F64))
10730 && !(env->CP0_Status_rw_bitmask & (1 << CP0St_FR))) {
10731 /* cannot set FR=0 */
10732 return -TARGET_EOPNOTSUPP;
10733 }
10734 if (new_fre && !(env->active_fpu.fcr0 & (1 << FCR0_FREP))) {
10735 /* Cannot set FRE=1 */
10736 return -TARGET_EOPNOTSUPP;
10737 }
10738
10739 int i;
10740 fpr_t *fpr = env->active_fpu.fpr;
10741 for (i = 0; i < 32 ; i += 2) {
10742 if (!old_fr && new_fr) {
10743 fpr[i].w[!FP_ENDIAN_IDX] = fpr[i + 1].w[FP_ENDIAN_IDX];
10744 } else if (old_fr && !new_fr) {
10745 fpr[i + 1].w[FP_ENDIAN_IDX] = fpr[i].w[!FP_ENDIAN_IDX];
10746 }
10747 }
10748
10749 if (new_fr) {
10750 env->CP0_Status |= (1 << CP0St_FR);
10751 env->hflags |= MIPS_HFLAG_F64;
10752 } else {
10753 env->CP0_Status &= ~(1 << CP0St_FR);
10754 env->hflags &= ~MIPS_HFLAG_F64;
10755 }
10756 if (new_fre) {
10757 env->CP0_Config5 |= (1 << CP0C5_FRE);
10758 if (env->active_fpu.fcr0 & (1 << FCR0_FREP)) {
10759 env->hflags |= MIPS_HFLAG_FRE;
10760 }
10761 } else {
10762 env->CP0_Config5 &= ~(1 << CP0C5_FRE);
10763 env->hflags &= ~MIPS_HFLAG_FRE;
10764 }
10765
10766 return 0;
10767 }
10768 #endif /* MIPS */
10769 #ifdef TARGET_AARCH64
10770 case TARGET_PR_SVE_SET_VL:
10771 /*
10772 * We cannot support either PR_SVE_SET_VL_ONEXEC or
10773 * PR_SVE_VL_INHERIT. Note the kernel definition
10774 * of sve_vl_valid allows for VQ=512, i.e. VL=8192,
10775 * even though the current architectural maximum is VQ=16.
10776 */
10777 ret = -TARGET_EINVAL;
10778 if (cpu_isar_feature(aa64_sve, env_archcpu(cpu_env))
10779 && arg2 >= 0 && arg2 <= 512 * 16 && !(arg2 & 15)) {
10780 CPUARMState *env = cpu_env;
10781 ARMCPU *cpu = env_archcpu(env);
10782 uint32_t vq, old_vq;
10783
10784 old_vq = (env->vfp.zcr_el[1] & 0xf) + 1;
10785 vq = MAX(arg2 / 16, 1);
10786 vq = MIN(vq, cpu->sve_max_vq);
10787
10788 if (vq < old_vq) {
10789 aarch64_sve_narrow_vq(env, vq);
10790 }
10791 env->vfp.zcr_el[1] = vq - 1;
10792 arm_rebuild_hflags(env);
10793 ret = vq * 16;
10794 }
10795 return ret;
10796 case TARGET_PR_SVE_GET_VL:
10797 ret = -TARGET_EINVAL;
10798 {
10799 ARMCPU *cpu = env_archcpu(cpu_env);
10800 if (cpu_isar_feature(aa64_sve, cpu)) {
10801 ret = ((cpu->env.vfp.zcr_el[1] & 0xf) + 1) * 16;
10802 }
10803 }
10804 return ret;
10805 case TARGET_PR_PAC_RESET_KEYS:
10806 {
10807 CPUARMState *env = cpu_env;
10808 ARMCPU *cpu = env_archcpu(env);
10809
10810 if (arg3 || arg4 || arg5) {
10811 return -TARGET_EINVAL;
10812 }
10813 if (cpu_isar_feature(aa64_pauth, cpu)) {
10814 int all = (TARGET_PR_PAC_APIAKEY | TARGET_PR_PAC_APIBKEY |
10815 TARGET_PR_PAC_APDAKEY | TARGET_PR_PAC_APDBKEY |
10816 TARGET_PR_PAC_APGAKEY);
10817 int ret = 0;
10818 Error *err = NULL;
10819
10820 if (arg2 == 0) {
10821 arg2 = all;
10822 } else if (arg2 & ~all) {
10823 return -TARGET_EINVAL;
10824 }
10825 if (arg2 & TARGET_PR_PAC_APIAKEY) {
10826 ret |= qemu_guest_getrandom(&env->keys.apia,
10827 sizeof(ARMPACKey), &err);
10828 }
10829 if (arg2 & TARGET_PR_PAC_APIBKEY) {
10830 ret |= qemu_guest_getrandom(&env->keys.apib,
10831 sizeof(ARMPACKey), &err);
10832 }
10833 if (arg2 & TARGET_PR_PAC_APDAKEY) {
10834 ret |= qemu_guest_getrandom(&env->keys.apda,
10835 sizeof(ARMPACKey), &err);
10836 }
10837 if (arg2 & TARGET_PR_PAC_APDBKEY) {
10838 ret |= qemu_guest_getrandom(&env->keys.apdb,
10839 sizeof(ARMPACKey), &err);
10840 }
10841 if (arg2 & TARGET_PR_PAC_APGAKEY) {
10842 ret |= qemu_guest_getrandom(&env->keys.apga,
10843 sizeof(ARMPACKey), &err);
10844 }
10845 if (ret != 0) {
10846 /*
10847 * Some unknown failure in the crypto. The best
10848 * we can do is log it and fail the syscall.
10849 * The real syscall cannot fail this way.
10850 */
10851 qemu_log_mask(LOG_UNIMP,
10852 "PR_PAC_RESET_KEYS: Crypto failure: %s",
10853 error_get_pretty(err));
10854 error_free(err);
10855 return -TARGET_EIO;
10856 }
10857 return 0;
10858 }
10859 }
10860 return -TARGET_EINVAL;
10861 #endif /* AARCH64 */
10862 case PR_GET_SECCOMP:
10863 case PR_SET_SECCOMP:
10864 /* Disable seccomp to prevent the target disabling syscalls we
10865 * need. */
10866 return -TARGET_EINVAL;
10867 default:
10868 /* Most prctl options have no pointer arguments */
10869 return get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
10870 }
10871 break;
10872 #ifdef TARGET_NR_arch_prctl
10873 case TARGET_NR_arch_prctl:
10874 return do_arch_prctl(cpu_env, arg1, arg2);
10875 #endif
10876 #ifdef TARGET_NR_pread64
10877 case TARGET_NR_pread64:
10878 if (regpairs_aligned(cpu_env, num)) {
10879 arg4 = arg5;
10880 arg5 = arg6;
10881 }
10882 if (arg2 == 0 && arg3 == 0) {
10883 /* Special-case NULL buffer and zero length, which should succeed */
10884 p = 0;
10885 } else {
10886 p = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10887 if (!p) {
10888 return -TARGET_EFAULT;
10889 }
10890 }
10891 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
10892 unlock_user(p, arg2, ret);
10893 return ret;
10894 case TARGET_NR_pwrite64:
10895 if (regpairs_aligned(cpu_env, num)) {
10896 arg4 = arg5;
10897 arg5 = arg6;
10898 }
10899 if (arg2 == 0 && arg3 == 0) {
10900 /* Special-case NULL buffer and zero length, which should succeed */
10901 p = 0;
10902 } else {
10903 p = lock_user(VERIFY_READ, arg2, arg3, 1);
10904 if (!p) {
10905 return -TARGET_EFAULT;
10906 }
10907 }
10908 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
10909 unlock_user(p, arg2, 0);
10910 return ret;
10911 #endif
10912 case TARGET_NR_getcwd:
10913 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
10914 return -TARGET_EFAULT;
10915 ret = get_errno(sys_getcwd1(p, arg2));
10916 unlock_user(p, arg1, ret);
10917 return ret;
10918 case TARGET_NR_capget:
10919 case TARGET_NR_capset:
10920 {
10921 struct target_user_cap_header *target_header;
10922 struct target_user_cap_data *target_data = NULL;
10923 struct __user_cap_header_struct header;
10924 struct __user_cap_data_struct data[2];
10925 struct __user_cap_data_struct *dataptr = NULL;
10926 int i, target_datalen;
10927 int data_items = 1;
10928
10929 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
10930 return -TARGET_EFAULT;
10931 }
10932 header.version = tswap32(target_header->version);
10933 header.pid = tswap32(target_header->pid);
10934
10935 if (header.version != _LINUX_CAPABILITY_VERSION) {
10936 /* Version 2 and up takes pointer to two user_data structs */
10937 data_items = 2;
10938 }
10939
10940 target_datalen = sizeof(*target_data) * data_items;
10941
10942 if (arg2) {
10943 if (num == TARGET_NR_capget) {
10944 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0);
10945 } else {
10946 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1);
10947 }
10948 if (!target_data) {
10949 unlock_user_struct(target_header, arg1, 0);
10950 return -TARGET_EFAULT;
10951 }
10952
10953 if (num == TARGET_NR_capset) {
10954 for (i = 0; i < data_items; i++) {
10955 data[i].effective = tswap32(target_data[i].effective);
10956 data[i].permitted = tswap32(target_data[i].permitted);
10957 data[i].inheritable = tswap32(target_data[i].inheritable);
10958 }
10959 }
10960
10961 dataptr = data;
10962 }
10963
10964 if (num == TARGET_NR_capget) {
10965 ret = get_errno(capget(&header, dataptr));
10966 } else {
10967 ret = get_errno(capset(&header, dataptr));
10968 }
10969
10970 /* The kernel always updates version for both capget and capset */
10971 target_header->version = tswap32(header.version);
10972 unlock_user_struct(target_header, arg1, 1);
10973
10974 if (arg2) {
10975 if (num == TARGET_NR_capget) {
10976 for (i = 0; i < data_items; i++) {
10977 target_data[i].effective = tswap32(data[i].effective);
10978 target_data[i].permitted = tswap32(data[i].permitted);
10979 target_data[i].inheritable = tswap32(data[i].inheritable);
10980 }
10981 unlock_user(target_data, arg2, target_datalen);
10982 } else {
10983 unlock_user(target_data, arg2, 0);
10984 }
10985 }
10986 return ret;
10987 }
10988 case TARGET_NR_sigaltstack:
10989 return do_sigaltstack(arg1, arg2,
10990 get_sp_from_cpustate((CPUArchState *)cpu_env));
10991
10992 #ifdef CONFIG_SENDFILE
10993 #ifdef TARGET_NR_sendfile
10994 case TARGET_NR_sendfile:
10995 {
10996 off_t *offp = NULL;
10997 off_t off;
10998 if (arg3) {
10999 ret = get_user_sal(off, arg3);
11000 if (is_error(ret)) {
11001 return ret;
11002 }
11003 offp = &off;
11004 }
11005 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
11006 if (!is_error(ret) && arg3) {
11007 abi_long ret2 = put_user_sal(off, arg3);
11008 if (is_error(ret2)) {
11009 ret = ret2;
11010 }
11011 }
11012 return ret;
11013 }
11014 #endif
11015 #ifdef TARGET_NR_sendfile64
11016 case TARGET_NR_sendfile64:
11017 {
11018 off_t *offp = NULL;
11019 off_t off;
11020 if (arg3) {
11021 ret = get_user_s64(off, arg3);
11022 if (is_error(ret)) {
11023 return ret;
11024 }
11025 offp = &off;
11026 }
11027 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
11028 if (!is_error(ret) && arg3) {
11029 abi_long ret2 = put_user_s64(off, arg3);
11030 if (is_error(ret2)) {
11031 ret = ret2;
11032 }
11033 }
11034 return ret;
11035 }
11036 #endif
11037 #endif
11038 #ifdef TARGET_NR_vfork
11039 case TARGET_NR_vfork:
11040 return get_errno(do_fork(cpu_env,
11041 CLONE_VFORK | CLONE_VM | TARGET_SIGCHLD,
11042 0, 0, 0, 0));
11043 #endif
11044 #ifdef TARGET_NR_ugetrlimit
11045 case TARGET_NR_ugetrlimit:
11046 {
11047 struct rlimit rlim;
11048 int resource = target_to_host_resource(arg1);
11049 ret = get_errno(getrlimit(resource, &rlim));
11050 if (!is_error(ret)) {
11051 struct target_rlimit *target_rlim;
11052 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
11053 return -TARGET_EFAULT;
11054 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
11055 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
11056 unlock_user_struct(target_rlim, arg2, 1);
11057 }
11058 return ret;
11059 }
11060 #endif
11061 #ifdef TARGET_NR_truncate64
11062 case TARGET_NR_truncate64:
11063 if (!(p = lock_user_string(arg1)))
11064 return -TARGET_EFAULT;
11065 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
11066 unlock_user(p, arg1, 0);
11067 return ret;
11068 #endif
11069 #ifdef TARGET_NR_ftruncate64
11070 case TARGET_NR_ftruncate64:
11071 return target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
11072 #endif
11073 #ifdef TARGET_NR_stat64
11074 case TARGET_NR_stat64:
11075 if (!(p = lock_user_string(arg1))) {
11076 return -TARGET_EFAULT;
11077 }
11078 ret = get_errno(stat(path(p), &st));
11079 unlock_user(p, arg1, 0);
11080 if (!is_error(ret))
11081 ret = host_to_target_stat64(cpu_env, arg2, &st);
11082 return ret;
11083 #endif
11084 #ifdef TARGET_NR_lstat64
11085 case TARGET_NR_lstat64:
11086 if (!(p = lock_user_string(arg1))) {
11087 return -TARGET_EFAULT;
11088 }
11089 ret = get_errno(lstat(path(p), &st));
11090 unlock_user(p, arg1, 0);
11091 if (!is_error(ret))
11092 ret = host_to_target_stat64(cpu_env, arg2, &st);
11093 return ret;
11094 #endif
11095 #ifdef TARGET_NR_fstat64
11096 case TARGET_NR_fstat64:
11097 ret = get_errno(fstat(arg1, &st));
11098 if (!is_error(ret))
11099 ret = host_to_target_stat64(cpu_env, arg2, &st);
11100 return ret;
11101 #endif
11102 #if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
11103 #ifdef TARGET_NR_fstatat64
11104 case TARGET_NR_fstatat64:
11105 #endif
11106 #ifdef TARGET_NR_newfstatat
11107 case TARGET_NR_newfstatat:
11108 #endif
11109 if (!(p = lock_user_string(arg2))) {
11110 return -TARGET_EFAULT;
11111 }
11112 ret = get_errno(fstatat(arg1, path(p), &st, arg4));
11113 unlock_user(p, arg2, 0);
11114 if (!is_error(ret))
11115 ret = host_to_target_stat64(cpu_env, arg3, &st);
11116 return ret;
11117 #endif
11118 #if defined(TARGET_NR_statx)
11119 case TARGET_NR_statx:
11120 {
11121 struct target_statx *target_stx;
11122 int dirfd = arg1;
11123 int flags = arg3;
11124
11125 p = lock_user_string(arg2);
11126 if (p == NULL) {
11127 return -TARGET_EFAULT;
11128 }
11129 #if defined(__NR_statx)
11130 {
11131 /*
11132 * It is assumed that struct statx is architecture independent.
11133 */
11134 struct target_statx host_stx;
11135 int mask = arg4;
11136
11137 ret = get_errno(sys_statx(dirfd, p, flags, mask, &host_stx));
11138 if (!is_error(ret)) {
11139 if (host_to_target_statx(&host_stx, arg5) != 0) {
11140 unlock_user(p, arg2, 0);
11141 return -TARGET_EFAULT;
11142 }
11143 }
11144
11145 if (ret != -TARGET_ENOSYS) {
11146 unlock_user(p, arg2, 0);
11147 return ret;
11148 }
11149 }
11150 #endif
11151 ret = get_errno(fstatat(dirfd, path(p), &st, flags));
11152 unlock_user(p, arg2, 0);
11153
11154 if (!is_error(ret)) {
11155 if (!lock_user_struct(VERIFY_WRITE, target_stx, arg5, 0)) {
11156 return -TARGET_EFAULT;
11157 }
11158 memset(target_stx, 0, sizeof(*target_stx));
11159 __put_user(major(st.st_dev), &target_stx->stx_dev_major);
11160 __put_user(minor(st.st_dev), &target_stx->stx_dev_minor);
11161 __put_user(st.st_ino, &target_stx->stx_ino);
11162 __put_user(st.st_mode, &target_stx->stx_mode);
11163 __put_user(st.st_uid, &target_stx->stx_uid);
11164 __put_user(st.st_gid, &target_stx->stx_gid);
11165 __put_user(st.st_nlink, &target_stx->stx_nlink);
11166 __put_user(major(st.st_rdev), &target_stx->stx_rdev_major);
11167 __put_user(minor(st.st_rdev), &target_stx->stx_rdev_minor);
11168 __put_user(st.st_size, &target_stx->stx_size);
11169 __put_user(st.st_blksize, &target_stx->stx_blksize);
11170 __put_user(st.st_blocks, &target_stx->stx_blocks);
11171 __put_user(st.st_atime, &target_stx->stx_atime.tv_sec);
11172 __put_user(st.st_mtime, &target_stx->stx_mtime.tv_sec);
11173 __put_user(st.st_ctime, &target_stx->stx_ctime.tv_sec);
11174 unlock_user_struct(target_stx, arg5, 1);
11175 }
11176 }
11177 return ret;
11178 #endif
11179 #ifdef TARGET_NR_lchown
11180 case TARGET_NR_lchown:
11181 if (!(p = lock_user_string(arg1)))
11182 return -TARGET_EFAULT;
11183 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
11184 unlock_user(p, arg1, 0);
11185 return ret;
11186 #endif
11187 #ifdef TARGET_NR_getuid
11188 case TARGET_NR_getuid:
11189 return get_errno(high2lowuid(getuid()));
11190 #endif
11191 #ifdef TARGET_NR_getgid
11192 case TARGET_NR_getgid:
11193 return get_errno(high2lowgid(getgid()));
11194 #endif
11195 #ifdef TARGET_NR_geteuid
11196 case TARGET_NR_geteuid:
11197 return get_errno(high2lowuid(geteuid()));
11198 #endif
11199 #ifdef TARGET_NR_getegid
11200 case TARGET_NR_getegid:
11201 return get_errno(high2lowgid(getegid()));
11202 #endif
11203 case TARGET_NR_setreuid:
11204 return get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
11205 case TARGET_NR_setregid:
11206 return get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
11207 case TARGET_NR_getgroups:
11208 {
11209 int gidsetsize = arg1;
11210 target_id *target_grouplist;
11211 gid_t *grouplist;
11212 int i;
11213
11214 grouplist = alloca(gidsetsize * sizeof(gid_t));
11215 ret = get_errno(getgroups(gidsetsize, grouplist));
11216 if (gidsetsize == 0)
11217 return ret;
11218 if (!is_error(ret)) {
11219 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
11220 if (!target_grouplist)
11221 return -TARGET_EFAULT;
11222 for(i = 0;i < ret; i++)
11223 target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
11224 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
11225 }
11226 }
11227 return ret;
11228 case TARGET_NR_setgroups:
11229 {
11230 int gidsetsize = arg1;
11231 target_id *target_grouplist;
11232 gid_t *grouplist = NULL;
11233 int i;
11234 if (gidsetsize) {
11235 grouplist = alloca(gidsetsize * sizeof(gid_t));
11236 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
11237 if (!target_grouplist) {
11238 return -TARGET_EFAULT;
11239 }
11240 for (i = 0; i < gidsetsize; i++) {
11241 grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
11242 }
11243 unlock_user(target_grouplist, arg2, 0);
11244 }
11245 return get_errno(setgroups(gidsetsize, grouplist));
11246 }
11247 case TARGET_NR_fchown:
11248 return get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
11249 #if defined(TARGET_NR_fchownat)
11250 case TARGET_NR_fchownat:
11251 if (!(p = lock_user_string(arg2)))
11252 return -TARGET_EFAULT;
11253 ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
11254 low2highgid(arg4), arg5));
11255 unlock_user(p, arg2, 0);
11256 return ret;
11257 #endif
11258 #ifdef TARGET_NR_setresuid
11259 case TARGET_NR_setresuid:
11260 return get_errno(sys_setresuid(low2highuid(arg1),
11261 low2highuid(arg2),
11262 low2highuid(arg3)));
11263 #endif
11264 #ifdef TARGET_NR_getresuid
11265 case TARGET_NR_getresuid:
11266 {
11267 uid_t ruid, euid, suid;
11268 ret = get_errno(getresuid(&ruid, &euid, &suid));
11269 if (!is_error(ret)) {
11270 if (put_user_id(high2lowuid(ruid), arg1)
11271 || put_user_id(high2lowuid(euid), arg2)
11272 || put_user_id(high2lowuid(suid), arg3))
11273 return -TARGET_EFAULT;
11274 }
11275 }
11276 return ret;
11277 #endif
11278 #ifdef TARGET_NR_getresgid
11279 case TARGET_NR_setresgid:
11280 return get_errno(sys_setresgid(low2highgid(arg1),
11281 low2highgid(arg2),
11282 low2highgid(arg3)));
11283 #endif
11284 #ifdef TARGET_NR_getresgid
11285 case TARGET_NR_getresgid:
11286 {
11287 gid_t rgid, egid, sgid;
11288 ret = get_errno(getresgid(&rgid, &egid, &sgid));
11289 if (!is_error(ret)) {
11290 if (put_user_id(high2lowgid(rgid), arg1)
11291 || put_user_id(high2lowgid(egid), arg2)
11292 || put_user_id(high2lowgid(sgid), arg3))
11293 return -TARGET_EFAULT;
11294 }
11295 }
11296 return ret;
11297 #endif
11298 #ifdef TARGET_NR_chown
11299 case TARGET_NR_chown:
11300 if (!(p = lock_user_string(arg1)))
11301 return -TARGET_EFAULT;
11302 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
11303 unlock_user(p, arg1, 0);
11304 return ret;
11305 #endif
11306 case TARGET_NR_setuid:
11307 return get_errno(sys_setuid(low2highuid(arg1)));
11308 case TARGET_NR_setgid:
11309 return get_errno(sys_setgid(low2highgid(arg1)));
11310 case TARGET_NR_setfsuid:
11311 return get_errno(setfsuid(arg1));
11312 case TARGET_NR_setfsgid:
11313 return get_errno(setfsgid(arg1));
11314
11315 #ifdef TARGET_NR_lchown32
11316 case TARGET_NR_lchown32:
11317 if (!(p = lock_user_string(arg1)))
11318 return -TARGET_EFAULT;
11319 ret = get_errno(lchown(p, arg2, arg3));
11320 unlock_user(p, arg1, 0);
11321 return ret;
11322 #endif
11323 #ifdef TARGET_NR_getuid32
11324 case TARGET_NR_getuid32:
11325 return get_errno(getuid());
11326 #endif
11327
11328 #if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
11329 /* Alpha specific */
11330 case TARGET_NR_getxuid:
11331 {
11332 uid_t euid;
11333 euid=geteuid();
11334 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
11335 }
11336 return get_errno(getuid());
11337 #endif
11338 #if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
11339 /* Alpha specific */
11340 case TARGET_NR_getxgid:
11341 {
11342 uid_t egid;
11343 egid=getegid();
11344 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
11345 }
11346 return get_errno(getgid());
11347 #endif
11348 #if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
11349 /* Alpha specific */
11350 case TARGET_NR_osf_getsysinfo:
11351 ret = -TARGET_EOPNOTSUPP;
11352 switch (arg1) {
11353 case TARGET_GSI_IEEE_FP_CONTROL:
11354 {
11355 uint64_t fpcr = cpu_alpha_load_fpcr(cpu_env);
11356 uint64_t swcr = ((CPUAlphaState *)cpu_env)->swcr;
11357
11358 swcr &= ~SWCR_STATUS_MASK;
11359 swcr |= (fpcr >> 35) & SWCR_STATUS_MASK;
11360
11361 if (put_user_u64 (swcr, arg2))
11362 return -TARGET_EFAULT;
11363 ret = 0;
11364 }
11365 break;
11366
11367 /* case GSI_IEEE_STATE_AT_SIGNAL:
11368 -- Not implemented in linux kernel.
11369 case GSI_UACPROC:
11370 -- Retrieves current unaligned access state; not much used.
11371 case GSI_PROC_TYPE:
11372 -- Retrieves implver information; surely not used.
11373 case GSI_GET_HWRPB:
11374 -- Grabs a copy of the HWRPB; surely not used.
11375 */
11376 }
11377 return ret;
11378 #endif
11379 #if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
11380 /* Alpha specific */
11381 case TARGET_NR_osf_setsysinfo:
11382 ret = -TARGET_EOPNOTSUPP;
11383 switch (arg1) {
11384 case TARGET_SSI_IEEE_FP_CONTROL:
11385 {
11386 uint64_t swcr, fpcr;
11387
11388 if (get_user_u64 (swcr, arg2)) {
11389 return -TARGET_EFAULT;
11390 }
11391
11392 /*
11393 * The kernel calls swcr_update_status to update the
11394 * status bits from the fpcr at every point that it
11395 * could be queried. Therefore, we store the status
11396 * bits only in FPCR.
11397 */
11398 ((CPUAlphaState *)cpu_env)->swcr
11399 = swcr & (SWCR_TRAP_ENABLE_MASK | SWCR_MAP_MASK);
11400
11401 fpcr = cpu_alpha_load_fpcr(cpu_env);
11402 fpcr &= ((uint64_t)FPCR_DYN_MASK << 32);
11403 fpcr |= alpha_ieee_swcr_to_fpcr(swcr);
11404 cpu_alpha_store_fpcr(cpu_env, fpcr);
11405 ret = 0;
11406 }
11407 break;
11408
11409 case TARGET_SSI_IEEE_RAISE_EXCEPTION:
11410 {
11411 uint64_t exc, fpcr, fex;
11412
11413 if (get_user_u64(exc, arg2)) {
11414 return -TARGET_EFAULT;
11415 }
11416 exc &= SWCR_STATUS_MASK;
11417 fpcr = cpu_alpha_load_fpcr(cpu_env);
11418
11419 /* Old exceptions are not signaled. */
11420 fex = alpha_ieee_fpcr_to_swcr(fpcr);
11421 fex = exc & ~fex;
11422 fex >>= SWCR_STATUS_TO_EXCSUM_SHIFT;
11423 fex &= ((CPUArchState *)cpu_env)->swcr;
11424
11425 /* Update the hardware fpcr. */
11426 fpcr |= alpha_ieee_swcr_to_fpcr(exc);
11427 cpu_alpha_store_fpcr(cpu_env, fpcr);
11428
11429 if (fex) {
11430 int si_code = TARGET_FPE_FLTUNK;
11431 target_siginfo_t info;
11432
11433 if (fex & SWCR_TRAP_ENABLE_DNO) {
11434 si_code = TARGET_FPE_FLTUND;
11435 }
11436 if (fex & SWCR_TRAP_ENABLE_INE) {
11437 si_code = TARGET_FPE_FLTRES;
11438 }
11439 if (fex & SWCR_TRAP_ENABLE_UNF) {
11440 si_code = TARGET_FPE_FLTUND;
11441 }
11442 if (fex & SWCR_TRAP_ENABLE_OVF) {
11443 si_code = TARGET_FPE_FLTOVF;
11444 }
11445 if (fex & SWCR_TRAP_ENABLE_DZE) {
11446 si_code = TARGET_FPE_FLTDIV;
11447 }
11448 if (fex & SWCR_TRAP_ENABLE_INV) {
11449 si_code = TARGET_FPE_FLTINV;
11450 }
11451
11452 info.si_signo = SIGFPE;
11453 info.si_errno = 0;
11454 info.si_code = si_code;
11455 info._sifields._sigfault._addr
11456 = ((CPUArchState *)cpu_env)->pc;
11457 queue_signal((CPUArchState *)cpu_env, info.si_signo,
11458 QEMU_SI_FAULT, &info);
11459 }
11460 ret = 0;
11461 }
11462 break;
11463
11464 /* case SSI_NVPAIRS:
11465 -- Used with SSIN_UACPROC to enable unaligned accesses.
11466 case SSI_IEEE_STATE_AT_SIGNAL:
11467 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
11468 -- Not implemented in linux kernel
11469 */
11470 }
11471 return ret;
11472 #endif
11473 #ifdef TARGET_NR_osf_sigprocmask
11474 /* Alpha specific. */
11475 case TARGET_NR_osf_sigprocmask:
11476 {
11477 abi_ulong mask;
11478 int how;
11479 sigset_t set, oldset;
11480
11481 switch(arg1) {
11482 case TARGET_SIG_BLOCK:
11483 how = SIG_BLOCK;
11484 break;
11485 case TARGET_SIG_UNBLOCK:
11486 how = SIG_UNBLOCK;
11487 break;
11488 case TARGET_SIG_SETMASK:
11489 how = SIG_SETMASK;
11490 break;
11491 default:
11492 return -TARGET_EINVAL;
11493 }
11494 mask = arg2;
11495 target_to_host_old_sigset(&set, &mask);
11496 ret = do_sigprocmask(how, &set, &oldset);
11497 if (!ret) {
11498 host_to_target_old_sigset(&mask, &oldset);
11499 ret = mask;
11500 }
11501 }
11502 return ret;
11503 #endif
11504
11505 #ifdef TARGET_NR_getgid32
11506 case TARGET_NR_getgid32:
11507 return get_errno(getgid());
11508 #endif
11509 #ifdef TARGET_NR_geteuid32
11510 case TARGET_NR_geteuid32:
11511 return get_errno(geteuid());
11512 #endif
11513 #ifdef TARGET_NR_getegid32
11514 case TARGET_NR_getegid32:
11515 return get_errno(getegid());
11516 #endif
11517 #ifdef TARGET_NR_setreuid32
11518 case TARGET_NR_setreuid32:
11519 return get_errno(setreuid(arg1, arg2));
11520 #endif
11521 #ifdef TARGET_NR_setregid32
11522 case TARGET_NR_setregid32:
11523 return get_errno(setregid(arg1, arg2));
11524 #endif
11525 #ifdef TARGET_NR_getgroups32
11526 case TARGET_NR_getgroups32:
11527 {
11528 int gidsetsize = arg1;
11529 uint32_t *target_grouplist;
11530 gid_t *grouplist;
11531 int i;
11532
11533 grouplist = alloca(gidsetsize * sizeof(gid_t));
11534 ret = get_errno(getgroups(gidsetsize, grouplist));
11535 if (gidsetsize == 0)
11536 return ret;
11537 if (!is_error(ret)) {
11538 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
11539 if (!target_grouplist) {
11540 return -TARGET_EFAULT;
11541 }
11542 for(i = 0;i < ret; i++)
11543 target_grouplist[i] = tswap32(grouplist[i]);
11544 unlock_user(target_grouplist, arg2, gidsetsize * 4);
11545 }
11546 }
11547 return ret;
11548 #endif
11549 #ifdef TARGET_NR_setgroups32
11550 case TARGET_NR_setgroups32:
11551 {
11552 int gidsetsize = arg1;
11553 uint32_t *target_grouplist;
11554 gid_t *grouplist;
11555 int i;
11556
11557 grouplist = alloca(gidsetsize * sizeof(gid_t));
11558 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
11559 if (!target_grouplist) {
11560 return -TARGET_EFAULT;
11561 }
11562 for(i = 0;i < gidsetsize; i++)
11563 grouplist[i] = tswap32(target_grouplist[i]);
11564 unlock_user(target_grouplist, arg2, 0);
11565 return get_errno(setgroups(gidsetsize, grouplist));
11566 }
11567 #endif
11568 #ifdef TARGET_NR_fchown32
11569 case TARGET_NR_fchown32:
11570 return get_errno(fchown(arg1, arg2, arg3));
11571 #endif
11572 #ifdef TARGET_NR_setresuid32
11573 case TARGET_NR_setresuid32:
11574 return get_errno(sys_setresuid(arg1, arg2, arg3));
11575 #endif
11576 #ifdef TARGET_NR_getresuid32
11577 case TARGET_NR_getresuid32:
11578 {
11579 uid_t ruid, euid, suid;
11580 ret = get_errno(getresuid(&ruid, &euid, &suid));
11581 if (!is_error(ret)) {
11582 if (put_user_u32(ruid, arg1)
11583 || put_user_u32(euid, arg2)
11584 || put_user_u32(suid, arg3))
11585 return -TARGET_EFAULT;
11586 }
11587 }
11588 return ret;
11589 #endif
11590 #ifdef TARGET_NR_setresgid32
11591 case TARGET_NR_setresgid32:
11592 return get_errno(sys_setresgid(arg1, arg2, arg3));
11593 #endif
11594 #ifdef TARGET_NR_getresgid32
11595 case TARGET_NR_getresgid32:
11596 {
11597 gid_t rgid, egid, sgid;
11598 ret = get_errno(getresgid(&rgid, &egid, &sgid));
11599 if (!is_error(ret)) {
11600 if (put_user_u32(rgid, arg1)
11601 || put_user_u32(egid, arg2)
11602 || put_user_u32(sgid, arg3))
11603 return -TARGET_EFAULT;
11604 }
11605 }
11606 return ret;
11607 #endif
11608 #ifdef TARGET_NR_chown32
11609 case TARGET_NR_chown32:
11610 if (!(p = lock_user_string(arg1)))
11611 return -TARGET_EFAULT;
11612 ret = get_errno(chown(p, arg2, arg3));
11613 unlock_user(p, arg1, 0);
11614 return ret;
11615 #endif
11616 #ifdef TARGET_NR_setuid32
11617 case TARGET_NR_setuid32:
11618 return get_errno(sys_setuid(arg1));
11619 #endif
11620 #ifdef TARGET_NR_setgid32
11621 case TARGET_NR_setgid32:
11622 return get_errno(sys_setgid(arg1));
11623 #endif
11624 #ifdef TARGET_NR_setfsuid32
11625 case TARGET_NR_setfsuid32:
11626 return get_errno(setfsuid(arg1));
11627 #endif
11628 #ifdef TARGET_NR_setfsgid32
11629 case TARGET_NR_setfsgid32:
11630 return get_errno(setfsgid(arg1));
11631 #endif
11632 #ifdef TARGET_NR_mincore
11633 case TARGET_NR_mincore:
11634 {
11635 void *a = lock_user(VERIFY_READ, arg1, arg2, 0);
11636 if (!a) {
11637 return -TARGET_ENOMEM;
11638 }
11639 p = lock_user_string(arg3);
11640 if (!p) {
11641 ret = -TARGET_EFAULT;
11642 } else {
11643 ret = get_errno(mincore(a, arg2, p));
11644 unlock_user(p, arg3, ret);
11645 }
11646 unlock_user(a, arg1, 0);
11647 }
11648 return ret;
11649 #endif
11650 #ifdef TARGET_NR_arm_fadvise64_64
11651 case TARGET_NR_arm_fadvise64_64:
11652 /* arm_fadvise64_64 looks like fadvise64_64 but
11653 * with different argument order: fd, advice, offset, len
11654 * rather than the usual fd, offset, len, advice.
11655 * Note that offset and len are both 64-bit so appear as
11656 * pairs of 32-bit registers.
11657 */
11658 ret = posix_fadvise(arg1, target_offset64(arg3, arg4),
11659 target_offset64(arg5, arg6), arg2);
11660 return -host_to_target_errno(ret);
11661 #endif
11662
11663 #if TARGET_ABI_BITS == 32
11664
11665 #ifdef TARGET_NR_fadvise64_64
11666 case TARGET_NR_fadvise64_64:
11667 #if defined(TARGET_PPC) || defined(TARGET_XTENSA)
11668 /* 6 args: fd, advice, offset (high, low), len (high, low) */
11669 ret = arg2;
11670 arg2 = arg3;
11671 arg3 = arg4;
11672 arg4 = arg5;
11673 arg5 = arg6;
11674 arg6 = ret;
11675 #else
11676 /* 6 args: fd, offset (high, low), len (high, low), advice */
11677 if (regpairs_aligned(cpu_env, num)) {
11678 /* offset is in (3,4), len in (5,6) and advice in 7 */
11679 arg2 = arg3;
11680 arg3 = arg4;
11681 arg4 = arg5;
11682 arg5 = arg6;
11683 arg6 = arg7;
11684 }
11685 #endif
11686 ret = posix_fadvise(arg1, target_offset64(arg2, arg3),
11687 target_offset64(arg4, arg5), arg6);
11688 return -host_to_target_errno(ret);
11689 #endif
11690
11691 #ifdef TARGET_NR_fadvise64
11692 case TARGET_NR_fadvise64:
11693 /* 5 args: fd, offset (high, low), len, advice */
11694 if (regpairs_aligned(cpu_env, num)) {
11695 /* offset is in (3,4), len in 5 and advice in 6 */
11696 arg2 = arg3;
11697 arg3 = arg4;
11698 arg4 = arg5;
11699 arg5 = arg6;
11700 }
11701 ret = posix_fadvise(arg1, target_offset64(arg2, arg3), arg4, arg5);
11702 return -host_to_target_errno(ret);
11703 #endif
11704
11705 #else /* not a 32-bit ABI */
11706 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
11707 #ifdef TARGET_NR_fadvise64_64
11708 case TARGET_NR_fadvise64_64:
11709 #endif
11710 #ifdef TARGET_NR_fadvise64
11711 case TARGET_NR_fadvise64:
11712 #endif
11713 #ifdef TARGET_S390X
11714 switch (arg4) {
11715 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
11716 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
11717 case 6: arg4 = POSIX_FADV_DONTNEED; break;
11718 case 7: arg4 = POSIX_FADV_NOREUSE; break;
11719 default: break;
11720 }
11721 #endif
11722 return -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4));
11723 #endif
11724 #endif /* end of 64-bit ABI fadvise handling */
11725
11726 #ifdef TARGET_NR_madvise
11727 case TARGET_NR_madvise:
11728 /* A straight passthrough may not be safe because qemu sometimes
11729 turns private file-backed mappings into anonymous mappings.
11730 This will break MADV_DONTNEED.
11731 This is a hint, so ignoring and returning success is ok. */
11732 return 0;
11733 #endif
11734 #ifdef TARGET_NR_fcntl64
11735 case TARGET_NR_fcntl64:
11736 {
11737 int cmd;
11738 struct flock64 fl;
11739 from_flock64_fn *copyfrom = copy_from_user_flock64;
11740 to_flock64_fn *copyto = copy_to_user_flock64;
11741
11742 #ifdef TARGET_ARM
11743 if (!((CPUARMState *)cpu_env)->eabi) {
11744 copyfrom = copy_from_user_oabi_flock64;
11745 copyto = copy_to_user_oabi_flock64;
11746 }
11747 #endif
11748
11749 cmd = target_to_host_fcntl_cmd(arg2);
11750 if (cmd == -TARGET_EINVAL) {
11751 return cmd;
11752 }
11753
11754 switch(arg2) {
11755 case TARGET_F_GETLK64:
11756 ret = copyfrom(&fl, arg3);
11757 if (ret) {
11758 break;
11759 }
11760 ret = get_errno(safe_fcntl(arg1, cmd, &fl));
11761 if (ret == 0) {
11762 ret = copyto(arg3, &fl);
11763 }
11764 break;
11765
11766 case TARGET_F_SETLK64:
11767 case TARGET_F_SETLKW64:
11768 ret = copyfrom(&fl, arg3);
11769 if (ret) {
11770 break;
11771 }
11772 ret = get_errno(safe_fcntl(arg1, cmd, &fl));
11773 break;
11774 default:
11775 ret = do_fcntl(arg1, arg2, arg3);
11776 break;
11777 }
11778 return ret;
11779 }
11780 #endif
11781 #ifdef TARGET_NR_cacheflush
11782 case TARGET_NR_cacheflush:
11783 /* self-modifying code is handled automatically, so nothing needed */
11784 return 0;
11785 #endif
11786 #ifdef TARGET_NR_getpagesize
11787 case TARGET_NR_getpagesize:
11788 return TARGET_PAGE_SIZE;
11789 #endif
11790 case TARGET_NR_gettid:
11791 return get_errno(sys_gettid());
11792 #ifdef TARGET_NR_readahead
11793 case TARGET_NR_readahead:
11794 #if TARGET_ABI_BITS == 32
11795 if (regpairs_aligned(cpu_env, num)) {
11796 arg2 = arg3;
11797 arg3 = arg4;
11798 arg4 = arg5;
11799 }
11800 ret = get_errno(readahead(arg1, target_offset64(arg2, arg3) , arg4));
11801 #else
11802 ret = get_errno(readahead(arg1, arg2, arg3));
11803 #endif
11804 return ret;
11805 #endif
11806 #ifdef CONFIG_ATTR
11807 #ifdef TARGET_NR_setxattr
11808 case TARGET_NR_listxattr:
11809 case TARGET_NR_llistxattr:
11810 {
11811 void *p, *b = 0;
11812 if (arg2) {
11813 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11814 if (!b) {
11815 return -TARGET_EFAULT;
11816 }
11817 }
11818 p = lock_user_string(arg1);
11819 if (p) {
11820 if (num == TARGET_NR_listxattr) {
11821 ret = get_errno(listxattr(p, b, arg3));
11822 } else {
11823 ret = get_errno(llistxattr(p, b, arg3));
11824 }
11825 } else {
11826 ret = -TARGET_EFAULT;
11827 }
11828 unlock_user(p, arg1, 0);
11829 unlock_user(b, arg2, arg3);
11830 return ret;
11831 }
11832 case TARGET_NR_flistxattr:
11833 {
11834 void *b = 0;
11835 if (arg2) {
11836 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
11837 if (!b) {
11838 return -TARGET_EFAULT;
11839 }
11840 }
11841 ret = get_errno(flistxattr(arg1, b, arg3));
11842 unlock_user(b, arg2, arg3);
11843 return ret;
11844 }
11845 case TARGET_NR_setxattr:
11846 case TARGET_NR_lsetxattr:
11847 {
11848 void *p, *n, *v = 0;
11849 if (arg3) {
11850 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11851 if (!v) {
11852 return -TARGET_EFAULT;
11853 }
11854 }
11855 p = lock_user_string(arg1);
11856 n = lock_user_string(arg2);
11857 if (p && n) {
11858 if (num == TARGET_NR_setxattr) {
11859 ret = get_errno(setxattr(p, n, v, arg4, arg5));
11860 } else {
11861 ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
11862 }
11863 } else {
11864 ret = -TARGET_EFAULT;
11865 }
11866 unlock_user(p, arg1, 0);
11867 unlock_user(n, arg2, 0);
11868 unlock_user(v, arg3, 0);
11869 }
11870 return ret;
11871 case TARGET_NR_fsetxattr:
11872 {
11873 void *n, *v = 0;
11874 if (arg3) {
11875 v = lock_user(VERIFY_READ, arg3, arg4, 1);
11876 if (!v) {
11877 return -TARGET_EFAULT;
11878 }
11879 }
11880 n = lock_user_string(arg2);
11881 if (n) {
11882 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
11883 } else {
11884 ret = -TARGET_EFAULT;
11885 }
11886 unlock_user(n, arg2, 0);
11887 unlock_user(v, arg3, 0);
11888 }
11889 return ret;
11890 case TARGET_NR_getxattr:
11891 case TARGET_NR_lgetxattr:
11892 {
11893 void *p, *n, *v = 0;
11894 if (arg3) {
11895 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
11896 if (!v) {
11897 return -TARGET_EFAULT;
11898 }
11899 }
11900 p = lock_user_string(arg1);
11901 n = lock_user_string(arg2);
11902 if (p && n) {
11903 if (num == TARGET_NR_getxattr) {
11904 ret = get_errno(getxattr(p, n, v, arg4));
11905 } else {
11906 ret = get_errno(lgetxattr(p, n, v, arg4));
11907 }
11908 } else {
11909 ret = -TARGET_EFAULT;
11910 }
11911 unlock_user(p, arg1, 0);
11912 unlock_user(n, arg2, 0);
11913 unlock_user(v, arg3, arg4);
11914 }
11915 return ret;
11916 case TARGET_NR_fgetxattr:
11917 {
11918 void *n, *v = 0;
11919 if (arg3) {
11920 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
11921 if (!v) {
11922 return -TARGET_EFAULT;
11923 }
11924 }
11925 n = lock_user_string(arg2);
11926 if (n) {
11927 ret = get_errno(fgetxattr(arg1, n, v, arg4));
11928 } else {
11929 ret = -TARGET_EFAULT;
11930 }
11931 unlock_user(n, arg2, 0);
11932 unlock_user(v, arg3, arg4);
11933 }
11934 return ret;
11935 case TARGET_NR_removexattr:
11936 case TARGET_NR_lremovexattr:
11937 {
11938 void *p, *n;
11939 p = lock_user_string(arg1);
11940 n = lock_user_string(arg2);
11941 if (p && n) {
11942 if (num == TARGET_NR_removexattr) {
11943 ret = get_errno(removexattr(p, n));
11944 } else {
11945 ret = get_errno(lremovexattr(p, n));
11946 }
11947 } else {
11948 ret = -TARGET_EFAULT;
11949 }
11950 unlock_user(p, arg1, 0);
11951 unlock_user(n, arg2, 0);
11952 }
11953 return ret;
11954 case TARGET_NR_fremovexattr:
11955 {
11956 void *n;
11957 n = lock_user_string(arg2);
11958 if (n) {
11959 ret = get_errno(fremovexattr(arg1, n));
11960 } else {
11961 ret = -TARGET_EFAULT;
11962 }
11963 unlock_user(n, arg2, 0);
11964 }
11965 return ret;
11966 #endif
11967 #endif /* CONFIG_ATTR */
11968 #ifdef TARGET_NR_set_thread_area
11969 case TARGET_NR_set_thread_area:
11970 #if defined(TARGET_MIPS)
11971 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1;
11972 return 0;
11973 #elif defined(TARGET_CRIS)
11974 if (arg1 & 0xff)
11975 ret = -TARGET_EINVAL;
11976 else {
11977 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
11978 ret = 0;
11979 }
11980 return ret;
11981 #elif defined(TARGET_I386) && defined(TARGET_ABI32)
11982 return do_set_thread_area(cpu_env, arg1);
11983 #elif defined(TARGET_M68K)
11984 {
11985 TaskState *ts = cpu->opaque;
11986 ts->tp_value = arg1;
11987 return 0;
11988 }
11989 #else
11990 return -TARGET_ENOSYS;
11991 #endif
11992 #endif
11993 #ifdef TARGET_NR_get_thread_area
11994 case TARGET_NR_get_thread_area:
11995 #if defined(TARGET_I386) && defined(TARGET_ABI32)
11996 return do_get_thread_area(cpu_env, arg1);
11997 #elif defined(TARGET_M68K)
11998 {
11999 TaskState *ts = cpu->opaque;
12000 return ts->tp_value;
12001 }
12002 #else
12003 return -TARGET_ENOSYS;
12004 #endif
12005 #endif
12006 #ifdef TARGET_NR_getdomainname
12007 case TARGET_NR_getdomainname:
12008 return -TARGET_ENOSYS;
12009 #endif
12010
12011 #ifdef TARGET_NR_clock_settime
12012 case TARGET_NR_clock_settime:
12013 {
12014 struct timespec ts;
12015
12016 ret = target_to_host_timespec(&ts, arg2);
12017 if (!is_error(ret)) {
12018 ret = get_errno(clock_settime(arg1, &ts));
12019 }
12020 return ret;
12021 }
12022 #endif
12023 #ifdef TARGET_NR_clock_settime64
12024 case TARGET_NR_clock_settime64:
12025 {
12026 struct timespec ts;
12027
12028 ret = target_to_host_timespec64(&ts, arg2);
12029 if (!is_error(ret)) {
12030 ret = get_errno(clock_settime(arg1, &ts));
12031 }
12032 return ret;
12033 }
12034 #endif
12035 #ifdef TARGET_NR_clock_gettime
12036 case TARGET_NR_clock_gettime:
12037 {
12038 struct timespec ts;
12039 ret = get_errno(clock_gettime(arg1, &ts));
12040 if (!is_error(ret)) {
12041 ret = host_to_target_timespec(arg2, &ts);
12042 }
12043 return ret;
12044 }
12045 #endif
12046 #ifdef TARGET_NR_clock_gettime64
12047 case TARGET_NR_clock_gettime64:
12048 {
12049 struct timespec ts;
12050 ret = get_errno(clock_gettime(arg1, &ts));
12051 if (!is_error(ret)) {
12052 ret = host_to_target_timespec64(arg2, &ts);
12053 }
12054 return ret;
12055 }
12056 #endif
12057 #ifdef TARGET_NR_clock_getres
12058 case TARGET_NR_clock_getres:
12059 {
12060 struct timespec ts;
12061 ret = get_errno(clock_getres(arg1, &ts));
12062 if (!is_error(ret)) {
12063 host_to_target_timespec(arg2, &ts);
12064 }
12065 return ret;
12066 }
12067 #endif
12068 #ifdef TARGET_NR_clock_getres_time64
12069 case TARGET_NR_clock_getres_time64:
12070 {
12071 struct timespec ts;
12072 ret = get_errno(clock_getres(arg1, &ts));
12073 if (!is_error(ret)) {
12074 host_to_target_timespec64(arg2, &ts);
12075 }
12076 return ret;
12077 }
12078 #endif
12079 #ifdef TARGET_NR_clock_nanosleep
12080 case TARGET_NR_clock_nanosleep:
12081 {
12082 struct timespec ts;
12083 if (target_to_host_timespec(&ts, arg3)) {
12084 return -TARGET_EFAULT;
12085 }
12086 ret = get_errno(safe_clock_nanosleep(arg1, arg2,
12087 &ts, arg4 ? &ts : NULL));
12088 /*
12089 * if the call is interrupted by a signal handler, it fails
12090 * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not
12091 * TIMER_ABSTIME, it returns the remaining unslept time in arg4.
12092 */
12093 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME &&
12094 host_to_target_timespec(arg4, &ts)) {
12095 return -TARGET_EFAULT;
12096 }
12097
12098 return ret;
12099 }
12100 #endif
12101 #ifdef TARGET_NR_clock_nanosleep_time64
12102 case TARGET_NR_clock_nanosleep_time64:
12103 {
12104 struct timespec ts;
12105
12106 if (target_to_host_timespec64(&ts, arg3)) {
12107 return -TARGET_EFAULT;
12108 }
12109
12110 ret = get_errno(safe_clock_nanosleep(arg1, arg2,
12111 &ts, arg4 ? &ts : NULL));
12112
12113 if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME &&
12114 host_to_target_timespec64(arg4, &ts)) {
12115 return -TARGET_EFAULT;
12116 }
12117 return ret;
12118 }
12119 #endif
12120
12121 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
12122 case TARGET_NR_set_tid_address:
12123 return get_errno(set_tid_address((int *)g2h(arg1)));
12124 #endif
12125
12126 case TARGET_NR_tkill:
12127 return get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2)));
12128
12129 case TARGET_NR_tgkill:
12130 return get_errno(safe_tgkill((int)arg1, (int)arg2,
12131 target_to_host_signal(arg3)));
12132
12133 #ifdef TARGET_NR_set_robust_list
12134 case TARGET_NR_set_robust_list:
12135 case TARGET_NR_get_robust_list:
12136 /* The ABI for supporting robust futexes has userspace pass
12137 * the kernel a pointer to a linked list which is updated by
12138 * userspace after the syscall; the list is walked by the kernel
12139 * when the thread exits. Since the linked list in QEMU guest
12140 * memory isn't a valid linked list for the host and we have
12141 * no way to reliably intercept the thread-death event, we can't
12142 * support these. Silently return ENOSYS so that guest userspace
12143 * falls back to a non-robust futex implementation (which should
12144 * be OK except in the corner case of the guest crashing while
12145 * holding a mutex that is shared with another process via
12146 * shared memory).
12147 */
12148 return -TARGET_ENOSYS;
12149 #endif
12150
12151 #if defined(TARGET_NR_utimensat)
12152 case TARGET_NR_utimensat:
12153 {
12154 struct timespec *tsp, ts[2];
12155 if (!arg3) {
12156 tsp = NULL;
12157 } else {
12158 if (target_to_host_timespec(ts, arg3)) {
12159 return -TARGET_EFAULT;
12160 }
12161 if (target_to_host_timespec(ts + 1, arg3 +
12162 sizeof(struct target_timespec))) {
12163 return -TARGET_EFAULT;
12164 }
12165 tsp = ts;
12166 }
12167 if (!arg2)
12168 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
12169 else {
12170 if (!(p = lock_user_string(arg2))) {
12171 return -TARGET_EFAULT;
12172 }
12173 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
12174 unlock_user(p, arg2, 0);
12175 }
12176 }
12177 return ret;
12178 #endif
12179 #ifdef TARGET_NR_utimensat_time64
12180 case TARGET_NR_utimensat_time64:
12181 {
12182 struct timespec *tsp, ts[2];
12183 if (!arg3) {
12184 tsp = NULL;
12185 } else {
12186 if (target_to_host_timespec64(ts, arg3)) {
12187 return -TARGET_EFAULT;
12188 }
12189 if (target_to_host_timespec64(ts + 1, arg3 +
12190 sizeof(struct target__kernel_timespec))) {
12191 return -TARGET_EFAULT;
12192 }
12193 tsp = ts;
12194 }
12195 if (!arg2)
12196 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
12197 else {
12198 p = lock_user_string(arg2);
12199 if (!p) {
12200 return -TARGET_EFAULT;
12201 }
12202 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
12203 unlock_user(p, arg2, 0);
12204 }
12205 }
12206 return ret;
12207 #endif
12208 #ifdef TARGET_NR_futex
12209 case TARGET_NR_futex:
12210 return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
12211 #endif
12212 #ifdef TARGET_NR_futex_time64
12213 case TARGET_NR_futex_time64:
12214 return do_futex_time64(arg1, arg2, arg3, arg4, arg5, arg6);
12215 #endif
12216 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
12217 case TARGET_NR_inotify_init:
12218 ret = get_errno(sys_inotify_init());
12219 if (ret >= 0) {
12220 fd_trans_register(ret, &target_inotify_trans);
12221 }
12222 return ret;
12223 #endif
12224 #ifdef CONFIG_INOTIFY1
12225 #if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
12226 case TARGET_NR_inotify_init1:
12227 ret = get_errno(sys_inotify_init1(target_to_host_bitmask(arg1,
12228 fcntl_flags_tbl)));
12229 if (ret >= 0) {
12230 fd_trans_register(ret, &target_inotify_trans);
12231 }
12232 return ret;
12233 #endif
12234 #endif
12235 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
12236 case TARGET_NR_inotify_add_watch:
12237 p = lock_user_string(arg2);
12238 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
12239 unlock_user(p, arg2, 0);
12240 return ret;
12241 #endif
12242 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
12243 case TARGET_NR_inotify_rm_watch:
12244 return get_errno(sys_inotify_rm_watch(arg1, arg2));
12245 #endif
12246
12247 #if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
12248 case TARGET_NR_mq_open:
12249 {
12250 struct mq_attr posix_mq_attr;
12251 struct mq_attr *pposix_mq_attr;
12252 int host_flags;
12253
12254 host_flags = target_to_host_bitmask(arg2, fcntl_flags_tbl);
12255 pposix_mq_attr = NULL;
12256 if (arg4) {
12257 if (copy_from_user_mq_attr(&posix_mq_attr, arg4) != 0) {
12258 return -TARGET_EFAULT;
12259 }
12260 pposix_mq_attr = &posix_mq_attr;
12261 }
12262 p = lock_user_string(arg1 - 1);
12263 if (!p) {
12264 return -TARGET_EFAULT;
12265 }
12266 ret = get_errno(mq_open(p, host_flags, arg3, pposix_mq_attr));
12267 unlock_user (p, arg1, 0);
12268 }
12269 return ret;
12270
12271 case TARGET_NR_mq_unlink:
12272 p = lock_user_string(arg1 - 1);
12273 if (!p) {
12274 return -TARGET_EFAULT;
12275 }
12276 ret = get_errno(mq_unlink(p));
12277 unlock_user (p, arg1, 0);
12278 return ret;
12279
12280 #ifdef TARGET_NR_mq_timedsend
12281 case TARGET_NR_mq_timedsend:
12282 {
12283 struct timespec ts;
12284
12285 p = lock_user (VERIFY_READ, arg2, arg3, 1);
12286 if (arg5 != 0) {
12287 if (target_to_host_timespec(&ts, arg5)) {
12288 return -TARGET_EFAULT;
12289 }
12290 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
12291 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) {
12292 return -TARGET_EFAULT;
12293 }
12294 } else {
12295 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
12296 }
12297 unlock_user (p, arg2, arg3);
12298 }
12299 return ret;
12300 #endif
12301 #ifdef TARGET_NR_mq_timedsend_time64
12302 case TARGET_NR_mq_timedsend_time64:
12303 {
12304 struct timespec ts;
12305
12306 p = lock_user(VERIFY_READ, arg2, arg3, 1);
12307 if (arg5 != 0) {
12308 if (target_to_host_timespec64(&ts, arg5)) {
12309 return -TARGET_EFAULT;
12310 }
12311 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
12312 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) {
12313 return -TARGET_EFAULT;
12314 }
12315 } else {
12316 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
12317 }
12318 unlock_user(p, arg2, arg3);
12319 }
12320 return ret;
12321 #endif
12322
12323 #ifdef TARGET_NR_mq_timedreceive
12324 case TARGET_NR_mq_timedreceive:
12325 {
12326 struct timespec ts;
12327 unsigned int prio;
12328
12329 p = lock_user (VERIFY_READ, arg2, arg3, 1);
12330 if (arg5 != 0) {
12331 if (target_to_host_timespec(&ts, arg5)) {
12332 return -TARGET_EFAULT;
12333 }
12334 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12335 &prio, &ts));
12336 if (!is_error(ret) && host_to_target_timespec(arg5, &ts)) {
12337 return -TARGET_EFAULT;
12338 }
12339 } else {
12340 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12341 &prio, NULL));
12342 }
12343 unlock_user (p, arg2, arg3);
12344 if (arg4 != 0)
12345 put_user_u32(prio, arg4);
12346 }
12347 return ret;
12348 #endif
12349 #ifdef TARGET_NR_mq_timedreceive_time64
12350 case TARGET_NR_mq_timedreceive_time64:
12351 {
12352 struct timespec ts;
12353 unsigned int prio;
12354
12355 p = lock_user(VERIFY_READ, arg2, arg3, 1);
12356 if (arg5 != 0) {
12357 if (target_to_host_timespec64(&ts, arg5)) {
12358 return -TARGET_EFAULT;
12359 }
12360 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12361 &prio, &ts));
12362 if (!is_error(ret) && host_to_target_timespec64(arg5, &ts)) {
12363 return -TARGET_EFAULT;
12364 }
12365 } else {
12366 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
12367 &prio, NULL));
12368 }
12369 unlock_user(p, arg2, arg3);
12370 if (arg4 != 0) {
12371 put_user_u32(prio, arg4);
12372 }
12373 }
12374 return ret;
12375 #endif
12376
12377 /* Not implemented for now... */
12378 /* case TARGET_NR_mq_notify: */
12379 /* break; */
12380
12381 case TARGET_NR_mq_getsetattr:
12382 {
12383 struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
12384 ret = 0;
12385 if (arg2 != 0) {
12386 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
12387 ret = get_errno(mq_setattr(arg1, &posix_mq_attr_in,
12388 &posix_mq_attr_out));
12389 } else if (arg3 != 0) {
12390 ret = get_errno(mq_getattr(arg1, &posix_mq_attr_out));
12391 }
12392 if (ret == 0 && arg3 != 0) {
12393 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
12394 }
12395 }
12396 return ret;
12397 #endif
12398
12399 #ifdef CONFIG_SPLICE
12400 #ifdef TARGET_NR_tee
12401 case TARGET_NR_tee:
12402 {
12403 ret = get_errno(tee(arg1,arg2,arg3,arg4));
12404 }
12405 return ret;
12406 #endif
12407 #ifdef TARGET_NR_splice
12408 case TARGET_NR_splice:
12409 {
12410 loff_t loff_in, loff_out;
12411 loff_t *ploff_in = NULL, *ploff_out = NULL;
12412 if (arg2) {
12413 if (get_user_u64(loff_in, arg2)) {
12414 return -TARGET_EFAULT;
12415 }
12416 ploff_in = &loff_in;
12417 }
12418 if (arg4) {
12419 if (get_user_u64(loff_out, arg4)) {
12420 return -TARGET_EFAULT;
12421 }
12422 ploff_out = &loff_out;
12423 }
12424 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
12425 if (arg2) {
12426 if (put_user_u64(loff_in, arg2)) {
12427 return -TARGET_EFAULT;
12428 }
12429 }
12430 if (arg4) {
12431 if (put_user_u64(loff_out, arg4)) {
12432 return -TARGET_EFAULT;
12433 }
12434 }
12435 }
12436 return ret;
12437 #endif
12438 #ifdef TARGET_NR_vmsplice
12439 case TARGET_NR_vmsplice:
12440 {
12441 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
12442 if (vec != NULL) {
12443 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
12444 unlock_iovec(vec, arg2, arg3, 0);
12445 } else {
12446 ret = -host_to_target_errno(errno);
12447 }
12448 }
12449 return ret;
12450 #endif
12451 #endif /* CONFIG_SPLICE */
12452 #ifdef CONFIG_EVENTFD
12453 #if defined(TARGET_NR_eventfd)
12454 case TARGET_NR_eventfd:
12455 ret = get_errno(eventfd(arg1, 0));
12456 if (ret >= 0) {
12457 fd_trans_register(ret, &target_eventfd_trans);
12458 }
12459 return ret;
12460 #endif
12461 #if defined(TARGET_NR_eventfd2)
12462 case TARGET_NR_eventfd2:
12463 {
12464 int host_flags = arg2 & (~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC));
12465 if (arg2 & TARGET_O_NONBLOCK) {
12466 host_flags |= O_NONBLOCK;
12467 }
12468 if (arg2 & TARGET_O_CLOEXEC) {
12469 host_flags |= O_CLOEXEC;
12470 }
12471 ret = get_errno(eventfd(arg1, host_flags));
12472 if (ret >= 0) {
12473 fd_trans_register(ret, &target_eventfd_trans);
12474 }
12475 return ret;
12476 }
12477 #endif
12478 #endif /* CONFIG_EVENTFD */
12479 #if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
12480 case TARGET_NR_fallocate:
12481 #if TARGET_ABI_BITS == 32
12482 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
12483 target_offset64(arg5, arg6)));
12484 #else
12485 ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
12486 #endif
12487 return ret;
12488 #endif
12489 #if defined(CONFIG_SYNC_FILE_RANGE)
12490 #if defined(TARGET_NR_sync_file_range)
12491 case TARGET_NR_sync_file_range:
12492 #if TARGET_ABI_BITS == 32
12493 #if defined(TARGET_MIPS)
12494 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
12495 target_offset64(arg5, arg6), arg7));
12496 #else
12497 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
12498 target_offset64(arg4, arg5), arg6));
12499 #endif /* !TARGET_MIPS */
12500 #else
12501 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
12502 #endif
12503 return ret;
12504 #endif
12505 #if defined(TARGET_NR_sync_file_range2) || \
12506 defined(TARGET_NR_arm_sync_file_range)
12507 #if defined(TARGET_NR_sync_file_range2)
12508 case TARGET_NR_sync_file_range2:
12509 #endif
12510 #if defined(TARGET_NR_arm_sync_file_range)
12511 case TARGET_NR_arm_sync_file_range:
12512 #endif
12513 /* This is like sync_file_range but the arguments are reordered */
12514 #if TARGET_ABI_BITS == 32
12515 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
12516 target_offset64(arg5, arg6), arg2));
12517 #else
12518 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
12519 #endif
12520 return ret;
12521 #endif
12522 #endif
12523 #if defined(TARGET_NR_signalfd4)
12524 case TARGET_NR_signalfd4:
12525 return do_signalfd4(arg1, arg2, arg4);
12526 #endif
12527 #if defined(TARGET_NR_signalfd)
12528 case TARGET_NR_signalfd:
12529 return do_signalfd4(arg1, arg2, 0);
12530 #endif
12531 #if defined(CONFIG_EPOLL)
12532 #if defined(TARGET_NR_epoll_create)
12533 case TARGET_NR_epoll_create:
12534 return get_errno(epoll_create(arg1));
12535 #endif
12536 #if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
12537 case TARGET_NR_epoll_create1:
12538 return get_errno(epoll_create1(target_to_host_bitmask(arg1, fcntl_flags_tbl)));
12539 #endif
12540 #if defined(TARGET_NR_epoll_ctl)
12541 case TARGET_NR_epoll_ctl:
12542 {
12543 struct epoll_event ep;
12544 struct epoll_event *epp = 0;
12545 if (arg4) {
12546 struct target_epoll_event *target_ep;
12547 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
12548 return -TARGET_EFAULT;
12549 }
12550 ep.events = tswap32(target_ep->events);
12551 /* The epoll_data_t union is just opaque data to the kernel,
12552 * so we transfer all 64 bits across and need not worry what
12553 * actual data type it is.
12554 */
12555 ep.data.u64 = tswap64(target_ep->data.u64);
12556 unlock_user_struct(target_ep, arg4, 0);
12557 epp = &ep;
12558 }
12559 return get_errno(epoll_ctl(arg1, arg2, arg3, epp));
12560 }
12561 #endif
12562
12563 #if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
12564 #if defined(TARGET_NR_epoll_wait)
12565 case TARGET_NR_epoll_wait:
12566 #endif
12567 #if defined(TARGET_NR_epoll_pwait)
12568 case TARGET_NR_epoll_pwait:
12569 #endif
12570 {
12571 struct target_epoll_event *target_ep;
12572 struct epoll_event *ep;
12573 int epfd = arg1;
12574 int maxevents = arg3;
12575 int timeout = arg4;
12576
12577 if (maxevents <= 0 || maxevents > TARGET_EP_MAX_EVENTS) {
12578 return -TARGET_EINVAL;
12579 }
12580
12581 target_ep = lock_user(VERIFY_WRITE, arg2,
12582 maxevents * sizeof(struct target_epoll_event), 1);
12583 if (!target_ep) {
12584 return -TARGET_EFAULT;
12585 }
12586
12587 ep = g_try_new(struct epoll_event, maxevents);
12588 if (!ep) {
12589 unlock_user(target_ep, arg2, 0);
12590 return -TARGET_ENOMEM;
12591 }
12592
12593 switch (num) {
12594 #if defined(TARGET_NR_epoll_pwait)
12595 case TARGET_NR_epoll_pwait:
12596 {
12597 target_sigset_t *target_set;
12598 sigset_t _set, *set = &_set;
12599
12600 if (arg5) {
12601 if (arg6 != sizeof(target_sigset_t)) {
12602 ret = -TARGET_EINVAL;
12603 break;
12604 }
12605
12606 target_set = lock_user(VERIFY_READ, arg5,
12607 sizeof(target_sigset_t), 1);
12608 if (!target_set) {
12609 ret = -TARGET_EFAULT;
12610 break;
12611 }
12612 target_to_host_sigset(set, target_set);
12613 unlock_user(target_set, arg5, 0);
12614 } else {
12615 set = NULL;
12616 }
12617
12618 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12619 set, SIGSET_T_SIZE));
12620 break;
12621 }
12622 #endif
12623 #if defined(TARGET_NR_epoll_wait)
12624 case TARGET_NR_epoll_wait:
12625 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
12626 NULL, 0));
12627 break;
12628 #endif
12629 default:
12630 ret = -TARGET_ENOSYS;
12631 }
12632 if (!is_error(ret)) {
12633 int i;
12634 for (i = 0; i < ret; i++) {
12635 target_ep[i].events = tswap32(ep[i].events);
12636 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
12637 }
12638 unlock_user(target_ep, arg2,
12639 ret * sizeof(struct target_epoll_event));
12640 } else {
12641 unlock_user(target_ep, arg2, 0);
12642 }
12643 g_free(ep);
12644 return ret;
12645 }
12646 #endif
12647 #endif
12648 #ifdef TARGET_NR_prlimit64
12649 case TARGET_NR_prlimit64:
12650 {
12651 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
12652 struct target_rlimit64 *target_rnew, *target_rold;
12653 struct host_rlimit64 rnew, rold, *rnewp = 0;
12654 int resource = target_to_host_resource(arg2);
12655
12656 if (arg3 && (resource != RLIMIT_AS &&
12657 resource != RLIMIT_DATA &&
12658 resource != RLIMIT_STACK)) {
12659 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
12660 return -TARGET_EFAULT;
12661 }
12662 rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
12663 rnew.rlim_max = tswap64(target_rnew->rlim_max);
12664 unlock_user_struct(target_rnew, arg3, 0);
12665 rnewp = &rnew;
12666 }
12667
12668 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0));
12669 if (!is_error(ret) && arg4) {
12670 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
12671 return -TARGET_EFAULT;
12672 }
12673 target_rold->rlim_cur = tswap64(rold.rlim_cur);
12674 target_rold->rlim_max = tswap64(rold.rlim_max);
12675 unlock_user_struct(target_rold, arg4, 1);
12676 }
12677 return ret;
12678 }
12679 #endif
12680 #ifdef TARGET_NR_gethostname
12681 case TARGET_NR_gethostname:
12682 {
12683 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
12684 if (name) {
12685 ret = get_errno(gethostname(name, arg2));
12686 unlock_user(name, arg1, arg2);
12687 } else {
12688 ret = -TARGET_EFAULT;
12689 }
12690 return ret;
12691 }
12692 #endif
12693 #ifdef TARGET_NR_atomic_cmpxchg_32
12694 case TARGET_NR_atomic_cmpxchg_32:
12695 {
12696 /* should use start_exclusive from main.c */
12697 abi_ulong mem_value;
12698 if (get_user_u32(mem_value, arg6)) {
12699 target_siginfo_t info;
12700 info.si_signo = SIGSEGV;
12701 info.si_errno = 0;
12702 info.si_code = TARGET_SEGV_MAPERR;
12703 info._sifields._sigfault._addr = arg6;
12704 queue_signal((CPUArchState *)cpu_env, info.si_signo,
12705 QEMU_SI_FAULT, &info);
12706 ret = 0xdeadbeef;
12707
12708 }
12709 if (mem_value == arg2)
12710 put_user_u32(arg1, arg6);
12711 return mem_value;
12712 }
12713 #endif
12714 #ifdef TARGET_NR_atomic_barrier
12715 case TARGET_NR_atomic_barrier:
12716 /* Like the kernel implementation and the
12717 qemu arm barrier, no-op this? */
12718 return 0;
12719 #endif
12720
12721 #ifdef TARGET_NR_timer_create
12722 case TARGET_NR_timer_create:
12723 {
12724 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
12725
12726 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
12727
12728 int clkid = arg1;
12729 int timer_index = next_free_host_timer();
12730
12731 if (timer_index < 0) {
12732 ret = -TARGET_EAGAIN;
12733 } else {
12734 timer_t *phtimer = g_posix_timers + timer_index;
12735
12736 if (arg2) {
12737 phost_sevp = &host_sevp;
12738 ret = target_to_host_sigevent(phost_sevp, arg2);
12739 if (ret != 0) {
12740 return ret;
12741 }
12742 }
12743
12744 ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
12745 if (ret) {
12746 phtimer = NULL;
12747 } else {
12748 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) {
12749 return -TARGET_EFAULT;
12750 }
12751 }
12752 }
12753 return ret;
12754 }
12755 #endif
12756
12757 #ifdef TARGET_NR_timer_settime
12758 case TARGET_NR_timer_settime:
12759 {
12760 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
12761 * struct itimerspec * old_value */
12762 target_timer_t timerid = get_timer_id(arg1);
12763
12764 if (timerid < 0) {
12765 ret = timerid;
12766 } else if (arg3 == 0) {
12767 ret = -TARGET_EINVAL;
12768 } else {
12769 timer_t htimer = g_posix_timers[timerid];
12770 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
12771
12772 if (target_to_host_itimerspec(&hspec_new, arg3)) {
12773 return -TARGET_EFAULT;
12774 }
12775 ret = get_errno(
12776 timer_settime(htimer, arg2, &hspec_new, &hspec_old));
12777 if (arg4 && host_to_target_itimerspec(arg4, &hspec_old)) {
12778 return -TARGET_EFAULT;
12779 }
12780 }
12781 return ret;
12782 }
12783 #endif
12784
12785 #ifdef TARGET_NR_timer_settime64
12786 case TARGET_NR_timer_settime64:
12787 {
12788 target_timer_t timerid = get_timer_id(arg1);
12789
12790 if (timerid < 0) {
12791 ret = timerid;
12792 } else if (arg3 == 0) {
12793 ret = -TARGET_EINVAL;
12794 } else {
12795 timer_t htimer = g_posix_timers[timerid];
12796 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
12797
12798 if (target_to_host_itimerspec64(&hspec_new, arg3)) {
12799 return -TARGET_EFAULT;
12800 }
12801 ret = get_errno(
12802 timer_settime(htimer, arg2, &hspec_new, &hspec_old));
12803 if (arg4 && host_to_target_itimerspec64(arg4, &hspec_old)) {
12804 return -TARGET_EFAULT;
12805 }
12806 }
12807 return ret;
12808 }
12809 #endif
12810
12811 #ifdef TARGET_NR_timer_gettime
12812 case TARGET_NR_timer_gettime:
12813 {
12814 /* args: timer_t timerid, struct itimerspec *curr_value */
12815 target_timer_t timerid = get_timer_id(arg1);
12816
12817 if (timerid < 0) {
12818 ret = timerid;
12819 } else if (!arg2) {
12820 ret = -TARGET_EFAULT;
12821 } else {
12822 timer_t htimer = g_posix_timers[timerid];
12823 struct itimerspec hspec;
12824 ret = get_errno(timer_gettime(htimer, &hspec));
12825
12826 if (host_to_target_itimerspec(arg2, &hspec)) {
12827 ret = -TARGET_EFAULT;
12828 }
12829 }
12830 return ret;
12831 }
12832 #endif
12833
12834 #ifdef TARGET_NR_timer_gettime64
12835 case TARGET_NR_timer_gettime64:
12836 {
12837 /* args: timer_t timerid, struct itimerspec64 *curr_value */
12838 target_timer_t timerid = get_timer_id(arg1);
12839
12840 if (timerid < 0) {
12841 ret = timerid;
12842 } else if (!arg2) {
12843 ret = -TARGET_EFAULT;
12844 } else {
12845 timer_t htimer = g_posix_timers[timerid];
12846 struct itimerspec hspec;
12847 ret = get_errno(timer_gettime(htimer, &hspec));
12848
12849 if (host_to_target_itimerspec64(arg2, &hspec)) {
12850 ret = -TARGET_EFAULT;
12851 }
12852 }
12853 return ret;
12854 }
12855 #endif
12856
12857 #ifdef TARGET_NR_timer_getoverrun
12858 case TARGET_NR_timer_getoverrun:
12859 {
12860 /* args: timer_t timerid */
12861 target_timer_t timerid = get_timer_id(arg1);
12862
12863 if (timerid < 0) {
12864 ret = timerid;
12865 } else {
12866 timer_t htimer = g_posix_timers[timerid];
12867 ret = get_errno(timer_getoverrun(htimer));
12868 }
12869 return ret;
12870 }
12871 #endif
12872
12873 #ifdef TARGET_NR_timer_delete
12874 case TARGET_NR_timer_delete:
12875 {
12876 /* args: timer_t timerid */
12877 target_timer_t timerid = get_timer_id(arg1);
12878
12879 if (timerid < 0) {
12880 ret = timerid;
12881 } else {
12882 timer_t htimer = g_posix_timers[timerid];
12883 ret = get_errno(timer_delete(htimer));
12884 g_posix_timers[timerid] = 0;
12885 }
12886 return ret;
12887 }
12888 #endif
12889
12890 #if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
12891 case TARGET_NR_timerfd_create:
12892 return get_errno(timerfd_create(arg1,
12893 target_to_host_bitmask(arg2, fcntl_flags_tbl)));
12894 #endif
12895
12896 #if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
12897 case TARGET_NR_timerfd_gettime:
12898 {
12899 struct itimerspec its_curr;
12900
12901 ret = get_errno(timerfd_gettime(arg1, &its_curr));
12902
12903 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) {
12904 return -TARGET_EFAULT;
12905 }
12906 }
12907 return ret;
12908 #endif
12909
12910 #if defined(TARGET_NR_timerfd_gettime64) && defined(CONFIG_TIMERFD)
12911 case TARGET_NR_timerfd_gettime64:
12912 {
12913 struct itimerspec its_curr;
12914
12915 ret = get_errno(timerfd_gettime(arg1, &its_curr));
12916
12917 if (arg2 && host_to_target_itimerspec64(arg2, &its_curr)) {
12918 return -TARGET_EFAULT;
12919 }
12920 }
12921 return ret;
12922 #endif
12923
12924 #if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
12925 case TARGET_NR_timerfd_settime:
12926 {
12927 struct itimerspec its_new, its_old, *p_new;
12928
12929 if (arg3) {
12930 if (target_to_host_itimerspec(&its_new, arg3)) {
12931 return -TARGET_EFAULT;
12932 }
12933 p_new = &its_new;
12934 } else {
12935 p_new = NULL;
12936 }
12937
12938 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
12939
12940 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) {
12941 return -TARGET_EFAULT;
12942 }
12943 }
12944 return ret;
12945 #endif
12946
12947 #if defined(TARGET_NR_timerfd_settime64) && defined(CONFIG_TIMERFD)
12948 case TARGET_NR_timerfd_settime64:
12949 {
12950 struct itimerspec its_new, its_old, *p_new;
12951
12952 if (arg3) {
12953 if (target_to_host_itimerspec64(&its_new, arg3)) {
12954 return -TARGET_EFAULT;
12955 }
12956 p_new = &its_new;
12957 } else {
12958 p_new = NULL;
12959 }
12960
12961 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
12962
12963 if (arg4 && host_to_target_itimerspec64(arg4, &its_old)) {
12964 return -TARGET_EFAULT;
12965 }
12966 }
12967 return ret;
12968 #endif
12969
12970 #if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
12971 case TARGET_NR_ioprio_get:
12972 return get_errno(ioprio_get(arg1, arg2));
12973 #endif
12974
12975 #if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
12976 case TARGET_NR_ioprio_set:
12977 return get_errno(ioprio_set(arg1, arg2, arg3));
12978 #endif
12979
12980 #if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
12981 case TARGET_NR_setns:
12982 return get_errno(setns(arg1, arg2));
12983 #endif
12984 #if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
12985 case TARGET_NR_unshare:
12986 return get_errno(unshare(arg1));
12987 #endif
12988 #if defined(TARGET_NR_kcmp) && defined(__NR_kcmp)
12989 case TARGET_NR_kcmp:
12990 return get_errno(kcmp(arg1, arg2, arg3, arg4, arg5));
12991 #endif
12992 #ifdef TARGET_NR_swapcontext
12993 case TARGET_NR_swapcontext:
12994 /* PowerPC specific. */
12995 return do_swapcontext(cpu_env, arg1, arg2, arg3);
12996 #endif
12997 #ifdef TARGET_NR_memfd_create
12998 case TARGET_NR_memfd_create:
12999 p = lock_user_string(arg1);
13000 if (!p) {
13001 return -TARGET_EFAULT;
13002 }
13003 ret = get_errno(memfd_create(p, arg2));
13004 fd_trans_unregister(ret);
13005 unlock_user(p, arg1, 0);
13006 return ret;
13007 #endif
13008 #if defined TARGET_NR_membarrier && defined __NR_membarrier
13009 case TARGET_NR_membarrier:
13010 return get_errno(membarrier(arg1, arg2));
13011 #endif
13012
13013 default:
13014 qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num);
13015 return -TARGET_ENOSYS;
13016 }
13017 return ret;
13018 }
13019
13020 abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
13021 abi_long arg2, abi_long arg3, abi_long arg4,
13022 abi_long arg5, abi_long arg6, abi_long arg7,
13023 abi_long arg8)
13024 {
13025 CPUState *cpu = env_cpu(cpu_env);
13026 abi_long ret;
13027
13028 #ifdef DEBUG_ERESTARTSYS
13029 /* Debug-only code for exercising the syscall-restart code paths
13030 * in the per-architecture cpu main loops: restart every syscall
13031 * the guest makes once before letting it through.
13032 */
13033 {
13034 static bool flag;
13035 flag = !flag;
13036 if (flag) {
13037 return -TARGET_ERESTARTSYS;
13038 }
13039 }
13040 #endif
13041
13042 record_syscall_start(cpu, num, arg1,
13043 arg2, arg3, arg4, arg5, arg6, arg7, arg8);
13044
13045 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
13046 print_syscall(cpu_env, num, arg1, arg2, arg3, arg4, arg5, arg6);
13047 }
13048
13049 ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4,
13050 arg5, arg6, arg7, arg8);
13051
13052 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
13053 print_syscall_ret(cpu_env, num, ret, arg1, arg2,
13054 arg3, arg4, arg5, arg6);
13055 }
13056
13057 record_syscall_return(cpu, num, ret);
13058 return ret;
13059 }
AR7 emulation for QEMU