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