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