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