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