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