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