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