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