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, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 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 <dirent.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/prctl.h> 40 #include <sys/resource.h> 41 #include <sys/mman.h> 42 #include <sys/swap.h> 43 #include <signal.h> 44 #include <sched.h> 45 #include <sys/socket.h> 46 #include <sys/uio.h> 47 #include <sys/poll.h> 48 #include <sys/times.h> 49 #include <sys/shm.h> 50 #include <sys/sem.h> 51 #include <sys/statfs.h> 52 #include <utime.h> 53 #include <sys/sysinfo.h> 54 //#include <sys/user.h> 55 #include <netinet/ip.h> 56 #include <netinet/tcp.h> 57 #include <qemu-common.h> 58 59 #define termios host_termios 60 #define winsize host_winsize 61 #define termio host_termio 62 #define sgttyb host_sgttyb /* same as target */ 63 #define tchars host_tchars /* same as target */ 64 #define ltchars host_ltchars /* same as target */ 65 66 #include <linux/termios.h> 67 #include <linux/unistd.h> 68 #include <linux/utsname.h> 69 #include <linux/cdrom.h> 70 #include <linux/hdreg.h> 71 #include <linux/soundcard.h> 72 #include <linux/kd.h> 73 #include <linux/mtio.h> 74 #include "linux_loop.h" 75 76 #include "qemu.h" 77 #include "qemu-common.h" 78 79 #if defined(USE_NPTL) 80 #include <linux/futex.h> 81 #define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \ 82 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID) 83 #else 84 /* XXX: Hardcode the above values. */ 85 #define CLONE_NPTL_FLAGS2 0 86 #endif 87 88 //#define DEBUG 89 90 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \ 91 || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS) 92 /* 16 bit uid wrappers emulation */ 93 #define USE_UID16 94 #endif 95 96 //#include <linux/msdos_fs.h> 97 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2]) 98 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2]) 99 100 101 #undef _syscall0 102 #undef _syscall1 103 #undef _syscall2 104 #undef _syscall3 105 #undef _syscall4 106 #undef _syscall5 107 #undef _syscall6 108 109 #define _syscall0(type,name) \ 110 static type name (void) \ 111 { \ 112 return syscall(__NR_##name); \ 113 } 114 115 #define _syscall1(type,name,type1,arg1) \ 116 static type name (type1 arg1) \ 117 { \ 118 return syscall(__NR_##name, arg1); \ 119 } 120 121 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 122 static type name (type1 arg1,type2 arg2) \ 123 { \ 124 return syscall(__NR_##name, arg1, arg2); \ 125 } 126 127 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 128 static type name (type1 arg1,type2 arg2,type3 arg3) \ 129 { \ 130 return syscall(__NR_##name, arg1, arg2, arg3); \ 131 } 132 133 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 134 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \ 135 { \ 136 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \ 137 } 138 139 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 140 type5,arg5) \ 141 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \ 142 { \ 143 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \ 144 } 145 146 147 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 148 type5,arg5,type6,arg6) \ 149 static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \ 150 type6 arg6) \ 151 { \ 152 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \ 153 } 154 155 156 #define __NR_sys_uname __NR_uname 157 #define __NR_sys_faccessat __NR_faccessat 158 #define __NR_sys_fchmodat __NR_fchmodat 159 #define __NR_sys_fchownat __NR_fchownat 160 #define __NR_sys_fstatat64 __NR_fstatat64 161 #define __NR_sys_futimesat __NR_futimesat 162 #define __NR_sys_getcwd1 __NR_getcwd 163 #define __NR_sys_getdents __NR_getdents 164 #define __NR_sys_getdents64 __NR_getdents64 165 #define __NR_sys_getpriority __NR_getpriority 166 #define __NR_sys_linkat __NR_linkat 167 #define __NR_sys_mkdirat __NR_mkdirat 168 #define __NR_sys_mknodat __NR_mknodat 169 #define __NR_sys_openat __NR_openat 170 #define __NR_sys_readlinkat __NR_readlinkat 171 #define __NR_sys_renameat __NR_renameat 172 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo 173 #define __NR_sys_symlinkat __NR_symlinkat 174 #define __NR_sys_syslog __NR_syslog 175 #define __NR_sys_tgkill __NR_tgkill 176 #define __NR_sys_tkill __NR_tkill 177 #define __NR_sys_unlinkat __NR_unlinkat 178 #define __NR_sys_utimensat __NR_utimensat 179 #define __NR_sys_futex __NR_futex 180 #define __NR_sys_inotify_init __NR_inotify_init 181 #define __NR_sys_inotify_add_watch __NR_inotify_add_watch 182 #define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch 183 184 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__) 185 #define __NR__llseek __NR_lseek 186 #endif 187 188 #ifdef __NR_gettid 189 _syscall0(int, gettid) 190 #else 191 /* This is a replacement for the host gettid() and must return a host 192 errno. */ 193 static int gettid(void) { 194 return -ENOSYS; 195 } 196 #endif 197 _syscall1(int,sys_uname,struct new_utsname *,buf) 198 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat) 199 _syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags) 200 #endif 201 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat) 202 _syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname, 203 mode_t,mode,int,flags) 204 #endif 205 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16) 206 _syscall5(int,sys_fchownat,int,dirfd,const char *,pathname, 207 uid_t,owner,gid_t,group,int,flags) 208 #endif 209 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64) 210 _syscall4(int,sys_fstatat64,int,dirfd,const char *,pathname, 211 struct stat *,buf,int,flags) 212 #endif 213 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat) 214 _syscall3(int,sys_futimesat,int,dirfd,const char *,pathname, 215 const struct timeval *,times) 216 #endif 217 _syscall2(int,sys_getcwd1,char *,buf,size_t,size) 218 #if TARGET_ABI_BITS == 32 219 _syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count); 220 #endif 221 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) 222 _syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count); 223 #endif 224 _syscall2(int, sys_getpriority, int, which, int, who); 225 #if !defined (__x86_64__) 226 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, 227 loff_t *, res, uint, wh); 228 #endif 229 #if defined(TARGET_NR_linkat) && defined(__NR_linkat) 230 _syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath, 231 int,newdirfd,const char *,newpath,int,flags) 232 #endif 233 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat) 234 _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode) 235 #endif 236 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat) 237 _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname, 238 mode_t,mode,dev_t,dev) 239 #endif 240 #if defined(TARGET_NR_openat) && defined(__NR_openat) 241 _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode) 242 #endif 243 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat) 244 _syscall4(int,sys_readlinkat,int,dirfd,const char *,pathname, 245 char *,buf,size_t,bufsize) 246 #endif 247 #if defined(TARGET_NR_renameat) && defined(__NR_renameat) 248 _syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath, 249 int,newdirfd,const char *,newpath) 250 #endif 251 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo) 252 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat) 253 _syscall3(int,sys_symlinkat,const char *,oldpath, 254 int,newdirfd,const char *,newpath) 255 #endif 256 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len) 257 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill) 258 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig) 259 #endif 260 #if defined(TARGET_NR_tkill) && defined(__NR_tkill) 261 _syscall2(int,sys_tkill,int,tid,int,sig) 262 #endif 263 #ifdef __NR_exit_group 264 _syscall1(int,exit_group,int,error_code) 265 #endif 266 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) 267 _syscall1(int,set_tid_address,int *,tidptr) 268 #endif 269 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat) 270 _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags) 271 #endif 272 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat) 273 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname, 274 const struct timespec *,tsp,int,flags) 275 #endif 276 #if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init) 277 _syscall0(int,sys_inotify_init) 278 #endif 279 #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch) 280 _syscall3(int,sys_inotify_add_watch,int,fd,const char *,pathname,uint32_t,mask) 281 #endif 282 #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch) 283 _syscall2(int,sys_inotify_rm_watch,int,fd,uint32_t,wd) 284 #endif 285 #if defined(USE_NPTL) 286 #if defined(TARGET_NR_futex) && defined(__NR_futex) 287 _syscall6(int,sys_futex,int *,uaddr,int,op,int,val, 288 const struct timespec *,timeout,int *,uaddr2,int,val3) 289 #endif 290 #endif 291 292 extern int personality(int); 293 extern int flock(int, int); 294 extern int setfsuid(int); 295 extern int setfsgid(int); 296 extern int setgroups(int, gid_t *); 297 298 #define ERRNO_TABLE_SIZE 1200 299 300 /* target_to_host_errno_table[] is initialized from 301 * host_to_target_errno_table[] in syscall_init(). */ 302 static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = { 303 }; 304 305 /* 306 * This list is the union of errno values overridden in asm-<arch>/errno.h 307 * minus the errnos that are not actually generic to all archs. 308 */ 309 static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = { 310 [EIDRM] = TARGET_EIDRM, 311 [ECHRNG] = TARGET_ECHRNG, 312 [EL2NSYNC] = TARGET_EL2NSYNC, 313 [EL3HLT] = TARGET_EL3HLT, 314 [EL3RST] = TARGET_EL3RST, 315 [ELNRNG] = TARGET_ELNRNG, 316 [EUNATCH] = TARGET_EUNATCH, 317 [ENOCSI] = TARGET_ENOCSI, 318 [EL2HLT] = TARGET_EL2HLT, 319 [EDEADLK] = TARGET_EDEADLK, 320 [ENOLCK] = TARGET_ENOLCK, 321 [EBADE] = TARGET_EBADE, 322 [EBADR] = TARGET_EBADR, 323 [EXFULL] = TARGET_EXFULL, 324 [ENOANO] = TARGET_ENOANO, 325 [EBADRQC] = TARGET_EBADRQC, 326 [EBADSLT] = TARGET_EBADSLT, 327 [EBFONT] = TARGET_EBFONT, 328 [ENOSTR] = TARGET_ENOSTR, 329 [ENODATA] = TARGET_ENODATA, 330 [ETIME] = TARGET_ETIME, 331 [ENOSR] = TARGET_ENOSR, 332 [ENONET] = TARGET_ENONET, 333 [ENOPKG] = TARGET_ENOPKG, 334 [EREMOTE] = TARGET_EREMOTE, 335 [ENOLINK] = TARGET_ENOLINK, 336 [EADV] = TARGET_EADV, 337 [ESRMNT] = TARGET_ESRMNT, 338 [ECOMM] = TARGET_ECOMM, 339 [EPROTO] = TARGET_EPROTO, 340 [EDOTDOT] = TARGET_EDOTDOT, 341 [EMULTIHOP] = TARGET_EMULTIHOP, 342 [EBADMSG] = TARGET_EBADMSG, 343 [ENAMETOOLONG] = TARGET_ENAMETOOLONG, 344 [EOVERFLOW] = TARGET_EOVERFLOW, 345 [ENOTUNIQ] = TARGET_ENOTUNIQ, 346 [EBADFD] = TARGET_EBADFD, 347 [EREMCHG] = TARGET_EREMCHG, 348 [ELIBACC] = TARGET_ELIBACC, 349 [ELIBBAD] = TARGET_ELIBBAD, 350 [ELIBSCN] = TARGET_ELIBSCN, 351 [ELIBMAX] = TARGET_ELIBMAX, 352 [ELIBEXEC] = TARGET_ELIBEXEC, 353 [EILSEQ] = TARGET_EILSEQ, 354 [ENOSYS] = TARGET_ENOSYS, 355 [ELOOP] = TARGET_ELOOP, 356 [ERESTART] = TARGET_ERESTART, 357 [ESTRPIPE] = TARGET_ESTRPIPE, 358 [ENOTEMPTY] = TARGET_ENOTEMPTY, 359 [EUSERS] = TARGET_EUSERS, 360 [ENOTSOCK] = TARGET_ENOTSOCK, 361 [EDESTADDRREQ] = TARGET_EDESTADDRREQ, 362 [EMSGSIZE] = TARGET_EMSGSIZE, 363 [EPROTOTYPE] = TARGET_EPROTOTYPE, 364 [ENOPROTOOPT] = TARGET_ENOPROTOOPT, 365 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT, 366 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT, 367 [EOPNOTSUPP] = TARGET_EOPNOTSUPP, 368 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT, 369 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT, 370 [EADDRINUSE] = TARGET_EADDRINUSE, 371 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL, 372 [ENETDOWN] = TARGET_ENETDOWN, 373 [ENETUNREACH] = TARGET_ENETUNREACH, 374 [ENETRESET] = TARGET_ENETRESET, 375 [ECONNABORTED] = TARGET_ECONNABORTED, 376 [ECONNRESET] = TARGET_ECONNRESET, 377 [ENOBUFS] = TARGET_ENOBUFS, 378 [EISCONN] = TARGET_EISCONN, 379 [ENOTCONN] = TARGET_ENOTCONN, 380 [EUCLEAN] = TARGET_EUCLEAN, 381 [ENOTNAM] = TARGET_ENOTNAM, 382 [ENAVAIL] = TARGET_ENAVAIL, 383 [EISNAM] = TARGET_EISNAM, 384 [EREMOTEIO] = TARGET_EREMOTEIO, 385 [ESHUTDOWN] = TARGET_ESHUTDOWN, 386 [ETOOMANYREFS] = TARGET_ETOOMANYREFS, 387 [ETIMEDOUT] = TARGET_ETIMEDOUT, 388 [ECONNREFUSED] = TARGET_ECONNREFUSED, 389 [EHOSTDOWN] = TARGET_EHOSTDOWN, 390 [EHOSTUNREACH] = TARGET_EHOSTUNREACH, 391 [EALREADY] = TARGET_EALREADY, 392 [EINPROGRESS] = TARGET_EINPROGRESS, 393 [ESTALE] = TARGET_ESTALE, 394 [ECANCELED] = TARGET_ECANCELED, 395 [ENOMEDIUM] = TARGET_ENOMEDIUM, 396 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE, 397 #ifdef ENOKEY 398 [ENOKEY] = TARGET_ENOKEY, 399 #endif 400 #ifdef EKEYEXPIRED 401 [EKEYEXPIRED] = TARGET_EKEYEXPIRED, 402 #endif 403 #ifdef EKEYREVOKED 404 [EKEYREVOKED] = TARGET_EKEYREVOKED, 405 #endif 406 #ifdef EKEYREJECTED 407 [EKEYREJECTED] = TARGET_EKEYREJECTED, 408 #endif 409 #ifdef EOWNERDEAD 410 [EOWNERDEAD] = TARGET_EOWNERDEAD, 411 #endif 412 #ifdef ENOTRECOVERABLE 413 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE, 414 #endif 415 }; 416 417 static inline int host_to_target_errno(int err) 418 { 419 if(host_to_target_errno_table[err]) 420 return host_to_target_errno_table[err]; 421 return err; 422 } 423 424 static inline int target_to_host_errno(int err) 425 { 426 if (target_to_host_errno_table[err]) 427 return target_to_host_errno_table[err]; 428 return err; 429 } 430 431 static inline abi_long get_errno(abi_long ret) 432 { 433 if (ret == -1) 434 return -host_to_target_errno(errno); 435 else 436 return ret; 437 } 438 439 static inline int is_error(abi_long ret) 440 { 441 return (abi_ulong)ret >= (abi_ulong)(-4096); 442 } 443 444 char *target_strerror(int err) 445 { 446 return strerror(target_to_host_errno(err)); 447 } 448 449 static abi_ulong target_brk; 450 static abi_ulong target_original_brk; 451 452 void target_set_brk(abi_ulong new_brk) 453 { 454 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk); 455 } 456 457 /* do_brk() must return target values and target errnos. */ 458 abi_long do_brk(abi_ulong new_brk) 459 { 460 abi_ulong brk_page; 461 abi_long mapped_addr; 462 int new_alloc_size; 463 464 if (!new_brk) 465 return target_brk; 466 if (new_brk < target_original_brk) 467 return target_brk; 468 469 brk_page = HOST_PAGE_ALIGN(target_brk); 470 471 /* If the new brk is less than this, set it and we're done... */ 472 if (new_brk < brk_page) { 473 target_brk = new_brk; 474 return target_brk; 475 } 476 477 /* We need to allocate more memory after the brk... */ 478 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1); 479 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size, 480 PROT_READ|PROT_WRITE, 481 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0)); 482 483 if (!is_error(mapped_addr)) 484 target_brk = new_brk; 485 486 return target_brk; 487 } 488 489 static inline abi_long copy_from_user_fdset(fd_set *fds, 490 abi_ulong target_fds_addr, 491 int n) 492 { 493 int i, nw, j, k; 494 abi_ulong b, *target_fds; 495 496 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS; 497 if (!(target_fds = lock_user(VERIFY_READ, 498 target_fds_addr, 499 sizeof(abi_ulong) * nw, 500 1))) 501 return -TARGET_EFAULT; 502 503 FD_ZERO(fds); 504 k = 0; 505 for (i = 0; i < nw; i++) { 506 /* grab the abi_ulong */ 507 __get_user(b, &target_fds[i]); 508 for (j = 0; j < TARGET_ABI_BITS; j++) { 509 /* check the bit inside the abi_ulong */ 510 if ((b >> j) & 1) 511 FD_SET(k, fds); 512 k++; 513 } 514 } 515 516 unlock_user(target_fds, target_fds_addr, 0); 517 518 return 0; 519 } 520 521 static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr, 522 const fd_set *fds, 523 int n) 524 { 525 int i, nw, j, k; 526 abi_long v; 527 abi_ulong *target_fds; 528 529 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS; 530 if (!(target_fds = lock_user(VERIFY_WRITE, 531 target_fds_addr, 532 sizeof(abi_ulong) * nw, 533 0))) 534 return -TARGET_EFAULT; 535 536 k = 0; 537 for (i = 0; i < nw; i++) { 538 v = 0; 539 for (j = 0; j < TARGET_ABI_BITS; j++) { 540 v |= ((FD_ISSET(k, fds) != 0) << j); 541 k++; 542 } 543 __put_user(v, &target_fds[i]); 544 } 545 546 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw); 547 548 return 0; 549 } 550 551 #if defined(__alpha__) 552 #define HOST_HZ 1024 553 #else 554 #define HOST_HZ 100 555 #endif 556 557 static inline abi_long host_to_target_clock_t(long ticks) 558 { 559 #if HOST_HZ == TARGET_HZ 560 return ticks; 561 #else 562 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ; 563 #endif 564 } 565 566 static inline abi_long host_to_target_rusage(abi_ulong target_addr, 567 const struct rusage *rusage) 568 { 569 struct target_rusage *target_rusage; 570 571 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0)) 572 return -TARGET_EFAULT; 573 target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec); 574 target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec); 575 target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec); 576 target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec); 577 target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss); 578 target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss); 579 target_rusage->ru_idrss = tswapl(rusage->ru_idrss); 580 target_rusage->ru_isrss = tswapl(rusage->ru_isrss); 581 target_rusage->ru_minflt = tswapl(rusage->ru_minflt); 582 target_rusage->ru_majflt = tswapl(rusage->ru_majflt); 583 target_rusage->ru_nswap = tswapl(rusage->ru_nswap); 584 target_rusage->ru_inblock = tswapl(rusage->ru_inblock); 585 target_rusage->ru_oublock = tswapl(rusage->ru_oublock); 586 target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd); 587 target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv); 588 target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals); 589 target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw); 590 target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw); 591 unlock_user_struct(target_rusage, target_addr, 1); 592 593 return 0; 594 } 595 596 static inline abi_long copy_from_user_timeval(struct timeval *tv, 597 abi_ulong target_tv_addr) 598 { 599 struct target_timeval *target_tv; 600 601 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1)) 602 return -TARGET_EFAULT; 603 604 __get_user(tv->tv_sec, &target_tv->tv_sec); 605 __get_user(tv->tv_usec, &target_tv->tv_usec); 606 607 unlock_user_struct(target_tv, target_tv_addr, 0); 608 609 return 0; 610 } 611 612 static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr, 613 const struct timeval *tv) 614 { 615 struct target_timeval *target_tv; 616 617 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0)) 618 return -TARGET_EFAULT; 619 620 __put_user(tv->tv_sec, &target_tv->tv_sec); 621 __put_user(tv->tv_usec, &target_tv->tv_usec); 622 623 unlock_user_struct(target_tv, target_tv_addr, 1); 624 625 return 0; 626 } 627 628 629 /* do_select() must return target values and target errnos. */ 630 static abi_long do_select(int n, 631 abi_ulong rfd_addr, abi_ulong wfd_addr, 632 abi_ulong efd_addr, abi_ulong target_tv_addr) 633 { 634 fd_set rfds, wfds, efds; 635 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr; 636 struct timeval tv, *tv_ptr; 637 abi_long ret; 638 639 if (rfd_addr) { 640 if (copy_from_user_fdset(&rfds, rfd_addr, n)) 641 return -TARGET_EFAULT; 642 rfds_ptr = &rfds; 643 } else { 644 rfds_ptr = NULL; 645 } 646 if (wfd_addr) { 647 if (copy_from_user_fdset(&wfds, wfd_addr, n)) 648 return -TARGET_EFAULT; 649 wfds_ptr = &wfds; 650 } else { 651 wfds_ptr = NULL; 652 } 653 if (efd_addr) { 654 if (copy_from_user_fdset(&efds, efd_addr, n)) 655 return -TARGET_EFAULT; 656 efds_ptr = &efds; 657 } else { 658 efds_ptr = NULL; 659 } 660 661 if (target_tv_addr) { 662 if (copy_from_user_timeval(&tv, target_tv_addr)) 663 return -TARGET_EFAULT; 664 tv_ptr = &tv; 665 } else { 666 tv_ptr = NULL; 667 } 668 669 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr)); 670 671 if (!is_error(ret)) { 672 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) 673 return -TARGET_EFAULT; 674 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) 675 return -TARGET_EFAULT; 676 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) 677 return -TARGET_EFAULT; 678 679 if (target_tv_addr && copy_to_user_timeval(target_tv_addr, &tv)) 680 return -TARGET_EFAULT; 681 } 682 683 return ret; 684 } 685 686 static inline abi_long target_to_host_sockaddr(struct sockaddr *addr, 687 abi_ulong target_addr, 688 socklen_t len) 689 { 690 struct target_sockaddr *target_saddr; 691 692 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1); 693 if (!target_saddr) 694 return -TARGET_EFAULT; 695 memcpy(addr, target_saddr, len); 696 addr->sa_family = tswap16(target_saddr->sa_family); 697 unlock_user(target_saddr, target_addr, 0); 698 699 return 0; 700 } 701 702 static inline abi_long host_to_target_sockaddr(abi_ulong target_addr, 703 struct sockaddr *addr, 704 socklen_t len) 705 { 706 struct target_sockaddr *target_saddr; 707 708 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0); 709 if (!target_saddr) 710 return -TARGET_EFAULT; 711 memcpy(target_saddr, addr, len); 712 target_saddr->sa_family = tswap16(addr->sa_family); 713 unlock_user(target_saddr, target_addr, len); 714 715 return 0; 716 } 717 718 /* ??? Should this also swap msgh->name? */ 719 static inline abi_long target_to_host_cmsg(struct msghdr *msgh, 720 struct target_msghdr *target_msgh) 721 { 722 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh); 723 abi_long msg_controllen; 724 abi_ulong target_cmsg_addr; 725 struct target_cmsghdr *target_cmsg; 726 socklen_t space = 0; 727 728 msg_controllen = tswapl(target_msgh->msg_controllen); 729 if (msg_controllen < sizeof (struct target_cmsghdr)) 730 goto the_end; 731 target_cmsg_addr = tswapl(target_msgh->msg_control); 732 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1); 733 if (!target_cmsg) 734 return -TARGET_EFAULT; 735 736 while (cmsg && target_cmsg) { 737 void *data = CMSG_DATA(cmsg); 738 void *target_data = TARGET_CMSG_DATA(target_cmsg); 739 740 int len = tswapl(target_cmsg->cmsg_len) 741 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr)); 742 743 space += CMSG_SPACE(len); 744 if (space > msgh->msg_controllen) { 745 space -= CMSG_SPACE(len); 746 gemu_log("Host cmsg overflow\n"); 747 break; 748 } 749 750 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level); 751 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type); 752 cmsg->cmsg_len = CMSG_LEN(len); 753 754 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) { 755 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type); 756 memcpy(data, target_data, len); 757 } else { 758 int *fd = (int *)data; 759 int *target_fd = (int *)target_data; 760 int i, numfds = len / sizeof(int); 761 762 for (i = 0; i < numfds; i++) 763 fd[i] = tswap32(target_fd[i]); 764 } 765 766 cmsg = CMSG_NXTHDR(msgh, cmsg); 767 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg); 768 } 769 unlock_user(target_cmsg, target_cmsg_addr, 0); 770 the_end: 771 msgh->msg_controllen = space; 772 return 0; 773 } 774 775 /* ??? Should this also swap msgh->name? */ 776 static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh, 777 struct msghdr *msgh) 778 { 779 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh); 780 abi_long msg_controllen; 781 abi_ulong target_cmsg_addr; 782 struct target_cmsghdr *target_cmsg; 783 socklen_t space = 0; 784 785 msg_controllen = tswapl(target_msgh->msg_controllen); 786 if (msg_controllen < sizeof (struct target_cmsghdr)) 787 goto the_end; 788 target_cmsg_addr = tswapl(target_msgh->msg_control); 789 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0); 790 if (!target_cmsg) 791 return -TARGET_EFAULT; 792 793 while (cmsg && target_cmsg) { 794 void *data = CMSG_DATA(cmsg); 795 void *target_data = TARGET_CMSG_DATA(target_cmsg); 796 797 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr)); 798 799 space += TARGET_CMSG_SPACE(len); 800 if (space > msg_controllen) { 801 space -= TARGET_CMSG_SPACE(len); 802 gemu_log("Target cmsg overflow\n"); 803 break; 804 } 805 806 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level); 807 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type); 808 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len)); 809 810 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) { 811 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type); 812 memcpy(target_data, data, len); 813 } else { 814 int *fd = (int *)data; 815 int *target_fd = (int *)target_data; 816 int i, numfds = len / sizeof(int); 817 818 for (i = 0; i < numfds; i++) 819 target_fd[i] = tswap32(fd[i]); 820 } 821 822 cmsg = CMSG_NXTHDR(msgh, cmsg); 823 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg); 824 } 825 unlock_user(target_cmsg, target_cmsg_addr, space); 826 the_end: 827 target_msgh->msg_controllen = tswapl(space); 828 return 0; 829 } 830 831 /* do_setsockopt() Must return target values and target errnos. */ 832 static abi_long do_setsockopt(int sockfd, int level, int optname, 833 abi_ulong optval_addr, socklen_t optlen) 834 { 835 abi_long ret; 836 int val; 837 838 switch(level) { 839 case SOL_TCP: 840 /* TCP options all take an 'int' value. */ 841 if (optlen < sizeof(uint32_t)) 842 return -TARGET_EINVAL; 843 844 if (get_user_u32(val, optval_addr)) 845 return -TARGET_EFAULT; 846 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val))); 847 break; 848 case SOL_IP: 849 switch(optname) { 850 case IP_TOS: 851 case IP_TTL: 852 case IP_HDRINCL: 853 case IP_ROUTER_ALERT: 854 case IP_RECVOPTS: 855 case IP_RETOPTS: 856 case IP_PKTINFO: 857 case IP_MTU_DISCOVER: 858 case IP_RECVERR: 859 case IP_RECVTOS: 860 #ifdef IP_FREEBIND 861 case IP_FREEBIND: 862 #endif 863 case IP_MULTICAST_TTL: 864 case IP_MULTICAST_LOOP: 865 val = 0; 866 if (optlen >= sizeof(uint32_t)) { 867 if (get_user_u32(val, optval_addr)) 868 return -TARGET_EFAULT; 869 } else if (optlen >= 1) { 870 if (get_user_u8(val, optval_addr)) 871 return -TARGET_EFAULT; 872 } 873 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val))); 874 break; 875 default: 876 goto unimplemented; 877 } 878 break; 879 case TARGET_SOL_SOCKET: 880 switch (optname) { 881 /* Options with 'int' argument. */ 882 case TARGET_SO_DEBUG: 883 optname = SO_DEBUG; 884 break; 885 case TARGET_SO_REUSEADDR: 886 optname = SO_REUSEADDR; 887 break; 888 case TARGET_SO_TYPE: 889 optname = SO_TYPE; 890 break; 891 case TARGET_SO_ERROR: 892 optname = SO_ERROR; 893 break; 894 case TARGET_SO_DONTROUTE: 895 optname = SO_DONTROUTE; 896 break; 897 case TARGET_SO_BROADCAST: 898 optname = SO_BROADCAST; 899 break; 900 case TARGET_SO_SNDBUF: 901 optname = SO_SNDBUF; 902 break; 903 case TARGET_SO_RCVBUF: 904 optname = SO_RCVBUF; 905 break; 906 case TARGET_SO_KEEPALIVE: 907 optname = SO_KEEPALIVE; 908 break; 909 case TARGET_SO_OOBINLINE: 910 optname = SO_OOBINLINE; 911 break; 912 case TARGET_SO_NO_CHECK: 913 optname = SO_NO_CHECK; 914 break; 915 case TARGET_SO_PRIORITY: 916 optname = SO_PRIORITY; 917 break; 918 #ifdef SO_BSDCOMPAT 919 case TARGET_SO_BSDCOMPAT: 920 optname = SO_BSDCOMPAT; 921 break; 922 #endif 923 case TARGET_SO_PASSCRED: 924 optname = SO_PASSCRED; 925 break; 926 case TARGET_SO_TIMESTAMP: 927 optname = SO_TIMESTAMP; 928 break; 929 case TARGET_SO_RCVLOWAT: 930 optname = SO_RCVLOWAT; 931 break; 932 case TARGET_SO_RCVTIMEO: 933 optname = SO_RCVTIMEO; 934 break; 935 case TARGET_SO_SNDTIMEO: 936 optname = SO_SNDTIMEO; 937 break; 938 break; 939 default: 940 goto unimplemented; 941 } 942 if (optlen < sizeof(uint32_t)) 943 return -TARGET_EINVAL; 944 945 if (get_user_u32(val, optval_addr)) 946 return -TARGET_EFAULT; 947 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val))); 948 break; 949 default: 950 unimplemented: 951 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname); 952 ret = -TARGET_ENOPROTOOPT; 953 } 954 return ret; 955 } 956 957 /* do_getsockopt() Must return target values and target errnos. */ 958 static abi_long do_getsockopt(int sockfd, int level, int optname, 959 abi_ulong optval_addr, abi_ulong optlen) 960 { 961 abi_long ret; 962 int len, val; 963 socklen_t lv; 964 965 switch(level) { 966 case TARGET_SOL_SOCKET: 967 level = SOL_SOCKET; 968 switch (optname) { 969 case TARGET_SO_LINGER: 970 case TARGET_SO_RCVTIMEO: 971 case TARGET_SO_SNDTIMEO: 972 case TARGET_SO_PEERCRED: 973 case TARGET_SO_PEERNAME: 974 /* These don't just return a single integer */ 975 goto unimplemented; 976 default: 977 goto int_case; 978 } 979 break; 980 case SOL_TCP: 981 /* TCP options all take an 'int' value. */ 982 int_case: 983 if (get_user_u32(len, optlen)) 984 return -TARGET_EFAULT; 985 if (len < 0) 986 return -TARGET_EINVAL; 987 lv = sizeof(int); 988 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 989 if (ret < 0) 990 return ret; 991 val = tswap32(val); 992 if (len > lv) 993 len = lv; 994 if (len == 4) { 995 if (put_user_u32(val, optval_addr)) 996 return -TARGET_EFAULT; 997 } else { 998 if (put_user_u8(val, optval_addr)) 999 return -TARGET_EFAULT; 1000 } 1001 if (put_user_u32(len, optlen)) 1002 return -TARGET_EFAULT; 1003 break; 1004 case SOL_IP: 1005 switch(optname) { 1006 case IP_TOS: 1007 case IP_TTL: 1008 case IP_HDRINCL: 1009 case IP_ROUTER_ALERT: 1010 case IP_RECVOPTS: 1011 case IP_RETOPTS: 1012 case IP_PKTINFO: 1013 case IP_MTU_DISCOVER: 1014 case IP_RECVERR: 1015 case IP_RECVTOS: 1016 #ifdef IP_FREEBIND 1017 case IP_FREEBIND: 1018 #endif 1019 case IP_MULTICAST_TTL: 1020 case IP_MULTICAST_LOOP: 1021 if (get_user_u32(len, optlen)) 1022 return -TARGET_EFAULT; 1023 if (len < 0) 1024 return -TARGET_EINVAL; 1025 lv = sizeof(int); 1026 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv)); 1027 if (ret < 0) 1028 return ret; 1029 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) { 1030 len = 1; 1031 if (put_user_u32(len, optlen) 1032 || put_user_u8(val, optval_addr)) 1033 return -TARGET_EFAULT; 1034 } else { 1035 if (len > sizeof(int)) 1036 len = sizeof(int); 1037 if (put_user_u32(len, optlen) 1038 || put_user_u32(val, optval_addr)) 1039 return -TARGET_EFAULT; 1040 } 1041 break; 1042 default: 1043 ret = -TARGET_ENOPROTOOPT; 1044 break; 1045 } 1046 break; 1047 default: 1048 unimplemented: 1049 gemu_log("getsockopt level=%d optname=%d not yet supported\n", 1050 level, optname); 1051 ret = -TARGET_EOPNOTSUPP; 1052 break; 1053 } 1054 return ret; 1055 } 1056 1057 /* FIXME 1058 * lock_iovec()/unlock_iovec() have a return code of 0 for success where 1059 * other lock functions have a return code of 0 for failure. 1060 */ 1061 static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr, 1062 int count, int copy) 1063 { 1064 struct target_iovec *target_vec; 1065 abi_ulong base; 1066 int i, j; 1067 1068 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1); 1069 if (!target_vec) 1070 return -TARGET_EFAULT; 1071 for(i = 0;i < count; i++) { 1072 base = tswapl(target_vec[i].iov_base); 1073 vec[i].iov_len = tswapl(target_vec[i].iov_len); 1074 if (vec[i].iov_len != 0) { 1075 vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy); 1076 if (!vec[i].iov_base && vec[i].iov_len) 1077 goto fail; 1078 } else { 1079 /* zero length pointer is ignored */ 1080 vec[i].iov_base = NULL; 1081 } 1082 } 1083 unlock_user (target_vec, target_addr, 0); 1084 return 0; 1085 fail: 1086 /* failure - unwind locks */ 1087 for (j = 0; j < i; j++) { 1088 base = tswapl(target_vec[j].iov_base); 1089 unlock_user(vec[j].iov_base, base, 0); 1090 } 1091 unlock_user (target_vec, target_addr, 0); 1092 return -TARGET_EFAULT; 1093 } 1094 1095 static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr, 1096 int count, int copy) 1097 { 1098 struct target_iovec *target_vec; 1099 abi_ulong base; 1100 int i; 1101 1102 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1); 1103 if (!target_vec) 1104 return -TARGET_EFAULT; 1105 for(i = 0;i < count; i++) { 1106 base = tswapl(target_vec[i].iov_base); 1107 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0); 1108 } 1109 unlock_user (target_vec, target_addr, 0); 1110 1111 return 0; 1112 } 1113 1114 /* do_socket() Must return target values and target errnos. */ 1115 static abi_long do_socket(int domain, int type, int protocol) 1116 { 1117 #if defined(TARGET_MIPS) 1118 switch(type) { 1119 case TARGET_SOCK_DGRAM: 1120 type = SOCK_DGRAM; 1121 break; 1122 case TARGET_SOCK_STREAM: 1123 type = SOCK_STREAM; 1124 break; 1125 case TARGET_SOCK_RAW: 1126 type = SOCK_RAW; 1127 break; 1128 case TARGET_SOCK_RDM: 1129 type = SOCK_RDM; 1130 break; 1131 case TARGET_SOCK_SEQPACKET: 1132 type = SOCK_SEQPACKET; 1133 break; 1134 case TARGET_SOCK_PACKET: 1135 type = SOCK_PACKET; 1136 break; 1137 } 1138 #endif 1139 if (domain == PF_NETLINK) 1140 return -EAFNOSUPPORT; /* do not NETLINK socket connections possible */ 1141 return get_errno(socket(domain, type, protocol)); 1142 } 1143 1144 /* do_bind() Must return target values and target errnos. */ 1145 static abi_long do_bind(int sockfd, abi_ulong target_addr, 1146 socklen_t addrlen) 1147 { 1148 void *addr = alloca(addrlen); 1149 1150 target_to_host_sockaddr(addr, target_addr, addrlen); 1151 return get_errno(bind(sockfd, addr, addrlen)); 1152 } 1153 1154 /* do_connect() Must return target values and target errnos. */ 1155 static abi_long do_connect(int sockfd, abi_ulong target_addr, 1156 socklen_t addrlen) 1157 { 1158 void *addr = alloca(addrlen); 1159 1160 target_to_host_sockaddr(addr, target_addr, addrlen); 1161 return get_errno(connect(sockfd, addr, addrlen)); 1162 } 1163 1164 /* do_sendrecvmsg() Must return target values and target errnos. */ 1165 static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg, 1166 int flags, int send) 1167 { 1168 abi_long ret; 1169 struct target_msghdr *msgp; 1170 struct msghdr msg; 1171 int count; 1172 struct iovec *vec; 1173 abi_ulong target_vec; 1174 1175 /* FIXME */ 1176 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE, 1177 msgp, 1178 target_msg, 1179 send ? 1 : 0)) 1180 return -TARGET_EFAULT; 1181 if (msgp->msg_name) { 1182 msg.msg_namelen = tswap32(msgp->msg_namelen); 1183 msg.msg_name = alloca(msg.msg_namelen); 1184 target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name), 1185 msg.msg_namelen); 1186 } else { 1187 msg.msg_name = NULL; 1188 msg.msg_namelen = 0; 1189 } 1190 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen); 1191 msg.msg_control = alloca(msg.msg_controllen); 1192 msg.msg_flags = tswap32(msgp->msg_flags); 1193 1194 count = tswapl(msgp->msg_iovlen); 1195 vec = alloca(count * sizeof(struct iovec)); 1196 target_vec = tswapl(msgp->msg_iov); 1197 lock_iovec(send ? VERIFY_READ : VERIFY_WRITE, vec, target_vec, count, send); 1198 msg.msg_iovlen = count; 1199 msg.msg_iov = vec; 1200 1201 if (send) { 1202 ret = target_to_host_cmsg(&msg, msgp); 1203 if (ret == 0) 1204 ret = get_errno(sendmsg(fd, &msg, flags)); 1205 } else { 1206 ret = get_errno(recvmsg(fd, &msg, flags)); 1207 if (!is_error(ret)) 1208 ret = host_to_target_cmsg(msgp, &msg); 1209 } 1210 unlock_iovec(vec, target_vec, count, !send); 1211 unlock_user_struct(msgp, target_msg, send ? 0 : 1); 1212 return ret; 1213 } 1214 1215 /* do_accept() Must return target values and target errnos. */ 1216 static abi_long do_accept(int fd, abi_ulong target_addr, 1217 abi_ulong target_addrlen_addr) 1218 { 1219 socklen_t addrlen; 1220 void *addr; 1221 abi_long ret; 1222 1223 if (get_user_u32(addrlen, target_addrlen_addr)) 1224 return -TARGET_EFAULT; 1225 1226 addr = alloca(addrlen); 1227 1228 ret = get_errno(accept(fd, addr, &addrlen)); 1229 if (!is_error(ret)) { 1230 host_to_target_sockaddr(target_addr, addr, addrlen); 1231 if (put_user_u32(addrlen, target_addrlen_addr)) 1232 ret = -TARGET_EFAULT; 1233 } 1234 return ret; 1235 } 1236 1237 /* do_getpeername() Must return target values and target errnos. */ 1238 static abi_long do_getpeername(int fd, abi_ulong target_addr, 1239 abi_ulong target_addrlen_addr) 1240 { 1241 socklen_t addrlen; 1242 void *addr; 1243 abi_long ret; 1244 1245 if (get_user_u32(addrlen, target_addrlen_addr)) 1246 return -TARGET_EFAULT; 1247 1248 addr = alloca(addrlen); 1249 1250 ret = get_errno(getpeername(fd, addr, &addrlen)); 1251 if (!is_error(ret)) { 1252 host_to_target_sockaddr(target_addr, addr, addrlen); 1253 if (put_user_u32(addrlen, target_addrlen_addr)) 1254 ret = -TARGET_EFAULT; 1255 } 1256 return ret; 1257 } 1258 1259 /* do_getsockname() Must return target values and target errnos. */ 1260 static abi_long do_getsockname(int fd, abi_ulong target_addr, 1261 abi_ulong target_addrlen_addr) 1262 { 1263 socklen_t addrlen; 1264 void *addr; 1265 abi_long ret; 1266 1267 if (get_user_u32(addrlen, target_addrlen_addr)) 1268 return -TARGET_EFAULT; 1269 1270 addr = alloca(addrlen); 1271 1272 ret = get_errno(getsockname(fd, addr, &addrlen)); 1273 if (!is_error(ret)) { 1274 host_to_target_sockaddr(target_addr, addr, addrlen); 1275 if (put_user_u32(addrlen, target_addrlen_addr)) 1276 ret = -TARGET_EFAULT; 1277 } 1278 return ret; 1279 } 1280 1281 /* do_socketpair() Must return target values and target errnos. */ 1282 static abi_long do_socketpair(int domain, int type, int protocol, 1283 abi_ulong target_tab_addr) 1284 { 1285 int tab[2]; 1286 abi_long ret; 1287 1288 ret = get_errno(socketpair(domain, type, protocol, tab)); 1289 if (!is_error(ret)) { 1290 if (put_user_s32(tab[0], target_tab_addr) 1291 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0]))) 1292 ret = -TARGET_EFAULT; 1293 } 1294 return ret; 1295 } 1296 1297 /* do_sendto() Must return target values and target errnos. */ 1298 static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags, 1299 abi_ulong target_addr, socklen_t addrlen) 1300 { 1301 void *addr; 1302 void *host_msg; 1303 abi_long ret; 1304 1305 host_msg = lock_user(VERIFY_READ, msg, len, 1); 1306 if (!host_msg) 1307 return -TARGET_EFAULT; 1308 if (target_addr) { 1309 addr = alloca(addrlen); 1310 target_to_host_sockaddr(addr, target_addr, addrlen); 1311 ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen)); 1312 } else { 1313 ret = get_errno(send(fd, host_msg, len, flags)); 1314 } 1315 unlock_user(host_msg, msg, 0); 1316 return ret; 1317 } 1318 1319 /* do_recvfrom() Must return target values and target errnos. */ 1320 static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags, 1321 abi_ulong target_addr, 1322 abi_ulong target_addrlen) 1323 { 1324 socklen_t addrlen; 1325 void *addr; 1326 void *host_msg; 1327 abi_long ret; 1328 1329 host_msg = lock_user(VERIFY_WRITE, msg, len, 0); 1330 if (!host_msg) 1331 return -TARGET_EFAULT; 1332 if (target_addr) { 1333 if (get_user_u32(addrlen, target_addrlen)) { 1334 ret = -TARGET_EFAULT; 1335 goto fail; 1336 } 1337 addr = alloca(addrlen); 1338 ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen)); 1339 } else { 1340 addr = NULL; /* To keep compiler quiet. */ 1341 ret = get_errno(recv(fd, host_msg, len, flags)); 1342 } 1343 if (!is_error(ret)) { 1344 if (target_addr) { 1345 host_to_target_sockaddr(target_addr, addr, addrlen); 1346 if (put_user_u32(addrlen, target_addrlen)) { 1347 ret = -TARGET_EFAULT; 1348 goto fail; 1349 } 1350 } 1351 unlock_user(host_msg, msg, len); 1352 } else { 1353 fail: 1354 unlock_user(host_msg, msg, 0); 1355 } 1356 return ret; 1357 } 1358 1359 #ifdef TARGET_NR_socketcall 1360 /* do_socketcall() Must return target values and target errnos. */ 1361 static abi_long do_socketcall(int num, abi_ulong vptr) 1362 { 1363 abi_long ret; 1364 const int n = sizeof(abi_ulong); 1365 1366 switch(num) { 1367 case SOCKOP_socket: 1368 { 1369 int domain, type, protocol; 1370 1371 if (get_user_s32(domain, vptr) 1372 || get_user_s32(type, vptr + n) 1373 || get_user_s32(protocol, vptr + 2 * n)) 1374 return -TARGET_EFAULT; 1375 1376 ret = do_socket(domain, type, protocol); 1377 } 1378 break; 1379 case SOCKOP_bind: 1380 { 1381 int sockfd; 1382 abi_ulong target_addr; 1383 socklen_t addrlen; 1384 1385 if (get_user_s32(sockfd, vptr) 1386 || get_user_ual(target_addr, vptr + n) 1387 || get_user_u32(addrlen, vptr + 2 * n)) 1388 return -TARGET_EFAULT; 1389 1390 ret = do_bind(sockfd, target_addr, addrlen); 1391 } 1392 break; 1393 case SOCKOP_connect: 1394 { 1395 int sockfd; 1396 abi_ulong target_addr; 1397 socklen_t addrlen; 1398 1399 if (get_user_s32(sockfd, vptr) 1400 || get_user_ual(target_addr, vptr + n) 1401 || get_user_u32(addrlen, vptr + 2 * n)) 1402 return -TARGET_EFAULT; 1403 1404 ret = do_connect(sockfd, target_addr, addrlen); 1405 } 1406 break; 1407 case SOCKOP_listen: 1408 { 1409 int sockfd, backlog; 1410 1411 if (get_user_s32(sockfd, vptr) 1412 || get_user_s32(backlog, vptr + n)) 1413 return -TARGET_EFAULT; 1414 1415 ret = get_errno(listen(sockfd, backlog)); 1416 } 1417 break; 1418 case SOCKOP_accept: 1419 { 1420 int sockfd; 1421 abi_ulong target_addr, target_addrlen; 1422 1423 if (get_user_s32(sockfd, vptr) 1424 || get_user_ual(target_addr, vptr + n) 1425 || get_user_u32(target_addrlen, vptr + 2 * n)) 1426 return -TARGET_EFAULT; 1427 1428 ret = do_accept(sockfd, target_addr, target_addrlen); 1429 } 1430 break; 1431 case SOCKOP_getsockname: 1432 { 1433 int sockfd; 1434 abi_ulong target_addr, target_addrlen; 1435 1436 if (get_user_s32(sockfd, vptr) 1437 || get_user_ual(target_addr, vptr + n) 1438 || get_user_u32(target_addrlen, vptr + 2 * n)) 1439 return -TARGET_EFAULT; 1440 1441 ret = do_getsockname(sockfd, target_addr, target_addrlen); 1442 } 1443 break; 1444 case SOCKOP_getpeername: 1445 { 1446 int sockfd; 1447 abi_ulong target_addr, target_addrlen; 1448 1449 if (get_user_s32(sockfd, vptr) 1450 || get_user_ual(target_addr, vptr + n) 1451 || get_user_u32(target_addrlen, vptr + 2 * n)) 1452 return -TARGET_EFAULT; 1453 1454 ret = do_getpeername(sockfd, target_addr, target_addrlen); 1455 } 1456 break; 1457 case SOCKOP_socketpair: 1458 { 1459 int domain, type, protocol; 1460 abi_ulong tab; 1461 1462 if (get_user_s32(domain, vptr) 1463 || get_user_s32(type, vptr + n) 1464 || get_user_s32(protocol, vptr + 2 * n) 1465 || get_user_ual(tab, vptr + 3 * n)) 1466 return -TARGET_EFAULT; 1467 1468 ret = do_socketpair(domain, type, protocol, tab); 1469 } 1470 break; 1471 case SOCKOP_send: 1472 { 1473 int sockfd; 1474 abi_ulong msg; 1475 size_t len; 1476 int flags; 1477 1478 if (get_user_s32(sockfd, vptr) 1479 || get_user_ual(msg, vptr + n) 1480 || get_user_ual(len, vptr + 2 * n) 1481 || get_user_s32(flags, vptr + 3 * n)) 1482 return -TARGET_EFAULT; 1483 1484 ret = do_sendto(sockfd, msg, len, flags, 0, 0); 1485 } 1486 break; 1487 case SOCKOP_recv: 1488 { 1489 int sockfd; 1490 abi_ulong msg; 1491 size_t len; 1492 int flags; 1493 1494 if (get_user_s32(sockfd, vptr) 1495 || get_user_ual(msg, vptr + n) 1496 || get_user_ual(len, vptr + 2 * n) 1497 || get_user_s32(flags, vptr + 3 * n)) 1498 return -TARGET_EFAULT; 1499 1500 ret = do_recvfrom(sockfd, msg, len, flags, 0, 0); 1501 } 1502 break; 1503 case SOCKOP_sendto: 1504 { 1505 int sockfd; 1506 abi_ulong msg; 1507 size_t len; 1508 int flags; 1509 abi_ulong addr; 1510 socklen_t addrlen; 1511 1512 if (get_user_s32(sockfd, vptr) 1513 || get_user_ual(msg, vptr + n) 1514 || get_user_ual(len, vptr + 2 * n) 1515 || get_user_s32(flags, vptr + 3 * n) 1516 || get_user_ual(addr, vptr + 4 * n) 1517 || get_user_u32(addrlen, vptr + 5 * n)) 1518 return -TARGET_EFAULT; 1519 1520 ret = do_sendto(sockfd, msg, len, flags, addr, addrlen); 1521 } 1522 break; 1523 case SOCKOP_recvfrom: 1524 { 1525 int sockfd; 1526 abi_ulong msg; 1527 size_t len; 1528 int flags; 1529 abi_ulong addr; 1530 socklen_t addrlen; 1531 1532 if (get_user_s32(sockfd, vptr) 1533 || get_user_ual(msg, vptr + n) 1534 || get_user_ual(len, vptr + 2 * n) 1535 || get_user_s32(flags, vptr + 3 * n) 1536 || get_user_ual(addr, vptr + 4 * n) 1537 || get_user_u32(addrlen, vptr + 5 * n)) 1538 return -TARGET_EFAULT; 1539 1540 ret = do_recvfrom(sockfd, msg, len, flags, addr, addrlen); 1541 } 1542 break; 1543 case SOCKOP_shutdown: 1544 { 1545 int sockfd, how; 1546 1547 if (get_user_s32(sockfd, vptr) 1548 || get_user_s32(how, vptr + n)) 1549 return -TARGET_EFAULT; 1550 1551 ret = get_errno(shutdown(sockfd, how)); 1552 } 1553 break; 1554 case SOCKOP_sendmsg: 1555 case SOCKOP_recvmsg: 1556 { 1557 int fd; 1558 abi_ulong target_msg; 1559 int flags; 1560 1561 if (get_user_s32(fd, vptr) 1562 || get_user_ual(target_msg, vptr + n) 1563 || get_user_s32(flags, vptr + 2 * n)) 1564 return -TARGET_EFAULT; 1565 1566 ret = do_sendrecvmsg(fd, target_msg, flags, 1567 (num == SOCKOP_sendmsg)); 1568 } 1569 break; 1570 case SOCKOP_setsockopt: 1571 { 1572 int sockfd; 1573 int level; 1574 int optname; 1575 abi_ulong optval; 1576 socklen_t optlen; 1577 1578 if (get_user_s32(sockfd, vptr) 1579 || get_user_s32(level, vptr + n) 1580 || get_user_s32(optname, vptr + 2 * n) 1581 || get_user_ual(optval, vptr + 3 * n) 1582 || get_user_u32(optlen, vptr + 4 * n)) 1583 return -TARGET_EFAULT; 1584 1585 ret = do_setsockopt(sockfd, level, optname, optval, optlen); 1586 } 1587 break; 1588 case SOCKOP_getsockopt: 1589 { 1590 int sockfd; 1591 int level; 1592 int optname; 1593 abi_ulong optval; 1594 socklen_t optlen; 1595 1596 if (get_user_s32(sockfd, vptr) 1597 || get_user_s32(level, vptr + n) 1598 || get_user_s32(optname, vptr + 2 * n) 1599 || get_user_ual(optval, vptr + 3 * n) 1600 || get_user_u32(optlen, vptr + 4 * n)) 1601 return -TARGET_EFAULT; 1602 1603 ret = do_getsockopt(sockfd, level, optname, optval, optlen); 1604 } 1605 break; 1606 default: 1607 gemu_log("Unsupported socketcall: %d\n", num); 1608 ret = -TARGET_ENOSYS; 1609 break; 1610 } 1611 return ret; 1612 } 1613 #endif 1614 1615 #ifdef TARGET_NR_ipc 1616 #define N_SHM_REGIONS 32 1617 1618 static struct shm_region { 1619 abi_ulong start; 1620 abi_ulong size; 1621 } shm_regions[N_SHM_REGIONS]; 1622 1623 struct target_ipc_perm 1624 { 1625 abi_long __key; 1626 abi_ulong uid; 1627 abi_ulong gid; 1628 abi_ulong cuid; 1629 abi_ulong cgid; 1630 unsigned short int mode; 1631 unsigned short int __pad1; 1632 unsigned short int __seq; 1633 unsigned short int __pad2; 1634 abi_ulong __unused1; 1635 abi_ulong __unused2; 1636 }; 1637 1638 struct target_semid_ds 1639 { 1640 struct target_ipc_perm sem_perm; 1641 abi_ulong sem_otime; 1642 abi_ulong __unused1; 1643 abi_ulong sem_ctime; 1644 abi_ulong __unused2; 1645 abi_ulong sem_nsems; 1646 abi_ulong __unused3; 1647 abi_ulong __unused4; 1648 }; 1649 1650 static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip, 1651 abi_ulong target_addr) 1652 { 1653 struct target_ipc_perm *target_ip; 1654 struct target_semid_ds *target_sd; 1655 1656 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) 1657 return -TARGET_EFAULT; 1658 target_ip=&(target_sd->sem_perm); 1659 host_ip->__key = tswapl(target_ip->__key); 1660 host_ip->uid = tswapl(target_ip->uid); 1661 host_ip->gid = tswapl(target_ip->gid); 1662 host_ip->cuid = tswapl(target_ip->cuid); 1663 host_ip->cgid = tswapl(target_ip->cgid); 1664 host_ip->mode = tswapl(target_ip->mode); 1665 unlock_user_struct(target_sd, target_addr, 0); 1666 return 0; 1667 } 1668 1669 static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr, 1670 struct ipc_perm *host_ip) 1671 { 1672 struct target_ipc_perm *target_ip; 1673 struct target_semid_ds *target_sd; 1674 1675 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) 1676 return -TARGET_EFAULT; 1677 target_ip = &(target_sd->sem_perm); 1678 target_ip->__key = tswapl(host_ip->__key); 1679 target_ip->uid = tswapl(host_ip->uid); 1680 target_ip->gid = tswapl(host_ip->gid); 1681 target_ip->cuid = tswapl(host_ip->cuid); 1682 target_ip->cgid = tswapl(host_ip->cgid); 1683 target_ip->mode = tswapl(host_ip->mode); 1684 unlock_user_struct(target_sd, target_addr, 1); 1685 return 0; 1686 } 1687 1688 static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd, 1689 abi_ulong target_addr) 1690 { 1691 struct target_semid_ds *target_sd; 1692 1693 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) 1694 return -TARGET_EFAULT; 1695 target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr); 1696 host_sd->sem_nsems = tswapl(target_sd->sem_nsems); 1697 host_sd->sem_otime = tswapl(target_sd->sem_otime); 1698 host_sd->sem_ctime = tswapl(target_sd->sem_ctime); 1699 unlock_user_struct(target_sd, target_addr, 0); 1700 return 0; 1701 } 1702 1703 static inline abi_long host_to_target_semid_ds(abi_ulong target_addr, 1704 struct semid_ds *host_sd) 1705 { 1706 struct target_semid_ds *target_sd; 1707 1708 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) 1709 return -TARGET_EFAULT; 1710 host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)); 1711 target_sd->sem_nsems = tswapl(host_sd->sem_nsems); 1712 target_sd->sem_otime = tswapl(host_sd->sem_otime); 1713 target_sd->sem_ctime = tswapl(host_sd->sem_ctime); 1714 unlock_user_struct(target_sd, target_addr, 1); 1715 return 0; 1716 } 1717 1718 union semun { 1719 int val; 1720 struct semid_ds *buf; 1721 unsigned short *array; 1722 }; 1723 1724 union target_semun { 1725 int val; 1726 abi_long buf; 1727 unsigned short int *array; 1728 }; 1729 1730 static inline abi_long target_to_host_semun(int cmd, 1731 union semun *host_su, 1732 abi_ulong target_addr, 1733 struct semid_ds *ds) 1734 { 1735 union target_semun *target_su; 1736 1737 switch( cmd ) { 1738 case IPC_STAT: 1739 case IPC_SET: 1740 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1)) 1741 return -TARGET_EFAULT; 1742 target_to_host_semid_ds(ds,target_su->buf); 1743 host_su->buf = ds; 1744 unlock_user_struct(target_su, target_addr, 0); 1745 break; 1746 case GETVAL: 1747 case SETVAL: 1748 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1)) 1749 return -TARGET_EFAULT; 1750 host_su->val = tswapl(target_su->val); 1751 unlock_user_struct(target_su, target_addr, 0); 1752 break; 1753 case GETALL: 1754 case SETALL: 1755 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1)) 1756 return -TARGET_EFAULT; 1757 *host_su->array = tswap16(*target_su->array); 1758 unlock_user_struct(target_su, target_addr, 0); 1759 break; 1760 default: 1761 gemu_log("semun operation not fully supported: %d\n", (int)cmd); 1762 } 1763 return 0; 1764 } 1765 1766 static inline abi_long host_to_target_semun(int cmd, 1767 abi_ulong target_addr, 1768 union semun *host_su, 1769 struct semid_ds *ds) 1770 { 1771 union target_semun *target_su; 1772 1773 switch( cmd ) { 1774 case IPC_STAT: 1775 case IPC_SET: 1776 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0)) 1777 return -TARGET_EFAULT; 1778 host_to_target_semid_ds(target_su->buf,ds); 1779 unlock_user_struct(target_su, target_addr, 1); 1780 break; 1781 case GETVAL: 1782 case SETVAL: 1783 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0)) 1784 return -TARGET_EFAULT; 1785 target_su->val = tswapl(host_su->val); 1786 unlock_user_struct(target_su, target_addr, 1); 1787 break; 1788 case GETALL: 1789 case SETALL: 1790 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0)) 1791 return -TARGET_EFAULT; 1792 *target_su->array = tswap16(*host_su->array); 1793 unlock_user_struct(target_su, target_addr, 1); 1794 break; 1795 default: 1796 gemu_log("semun operation not fully supported: %d\n", (int)cmd); 1797 } 1798 return 0; 1799 } 1800 1801 static inline abi_long do_semctl(int first, int second, int third, 1802 abi_long ptr) 1803 { 1804 union semun arg; 1805 struct semid_ds dsarg; 1806 int cmd = third&0xff; 1807 abi_long ret = 0; 1808 1809 switch( cmd ) { 1810 case GETVAL: 1811 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1812 ret = get_errno(semctl(first, second, cmd, arg)); 1813 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1814 break; 1815 case SETVAL: 1816 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1817 ret = get_errno(semctl(first, second, cmd, arg)); 1818 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1819 break; 1820 case GETALL: 1821 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1822 ret = get_errno(semctl(first, second, cmd, arg)); 1823 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1824 break; 1825 case SETALL: 1826 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1827 ret = get_errno(semctl(first, second, cmd, arg)); 1828 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1829 break; 1830 case IPC_STAT: 1831 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1832 ret = get_errno(semctl(first, second, cmd, arg)); 1833 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1834 break; 1835 case IPC_SET: 1836 target_to_host_semun(cmd,&arg,ptr,&dsarg); 1837 ret = get_errno(semctl(first, second, cmd, arg)); 1838 host_to_target_semun(cmd,ptr,&arg,&dsarg); 1839 break; 1840 default: 1841 ret = get_errno(semctl(first, second, cmd, arg)); 1842 } 1843 1844 return ret; 1845 } 1846 1847 struct target_msqid_ds 1848 { 1849 struct target_ipc_perm msg_perm; 1850 abi_ulong msg_stime; 1851 abi_ulong __unused1; 1852 abi_ulong msg_rtime; 1853 abi_ulong __unused2; 1854 abi_ulong msg_ctime; 1855 abi_ulong __unused3; 1856 abi_ulong __msg_cbytes; 1857 abi_ulong msg_qnum; 1858 abi_ulong msg_qbytes; 1859 abi_ulong msg_lspid; 1860 abi_ulong msg_lrpid; 1861 abi_ulong __unused4; 1862 abi_ulong __unused5; 1863 }; 1864 1865 static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md, 1866 abi_ulong target_addr) 1867 { 1868 struct target_msqid_ds *target_md; 1869 1870 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1)) 1871 return -TARGET_EFAULT; 1872 target_to_host_ipc_perm(&(host_md->msg_perm),target_addr); 1873 host_md->msg_stime = tswapl(target_md->msg_stime); 1874 host_md->msg_rtime = tswapl(target_md->msg_rtime); 1875 host_md->msg_ctime = tswapl(target_md->msg_ctime); 1876 host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes); 1877 host_md->msg_qnum = tswapl(target_md->msg_qnum); 1878 host_md->msg_qbytes = tswapl(target_md->msg_qbytes); 1879 host_md->msg_lspid = tswapl(target_md->msg_lspid); 1880 host_md->msg_lrpid = tswapl(target_md->msg_lrpid); 1881 unlock_user_struct(target_md, target_addr, 0); 1882 return 0; 1883 } 1884 1885 static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr, 1886 struct msqid_ds *host_md) 1887 { 1888 struct target_msqid_ds *target_md; 1889 1890 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0)) 1891 return -TARGET_EFAULT; 1892 host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)); 1893 target_md->msg_stime = tswapl(host_md->msg_stime); 1894 target_md->msg_rtime = tswapl(host_md->msg_rtime); 1895 target_md->msg_ctime = tswapl(host_md->msg_ctime); 1896 target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes); 1897 target_md->msg_qnum = tswapl(host_md->msg_qnum); 1898 target_md->msg_qbytes = tswapl(host_md->msg_qbytes); 1899 target_md->msg_lspid = tswapl(host_md->msg_lspid); 1900 target_md->msg_lrpid = tswapl(host_md->msg_lrpid); 1901 unlock_user_struct(target_md, target_addr, 1); 1902 return 0; 1903 } 1904 1905 static inline abi_long do_msgctl(int first, int second, abi_long ptr) 1906 { 1907 struct msqid_ds dsarg; 1908 int cmd = second&0xff; 1909 abi_long ret = 0; 1910 switch( cmd ) { 1911 case IPC_STAT: 1912 case IPC_SET: 1913 target_to_host_msqid_ds(&dsarg,ptr); 1914 ret = get_errno(msgctl(first, cmd, &dsarg)); 1915 host_to_target_msqid_ds(ptr,&dsarg); 1916 default: 1917 ret = get_errno(msgctl(first, cmd, &dsarg)); 1918 } 1919 return ret; 1920 } 1921 1922 struct target_msgbuf { 1923 abi_ulong mtype; 1924 char mtext[1]; 1925 }; 1926 1927 static inline abi_long do_msgsnd(int msqid, abi_long msgp, 1928 unsigned int msgsz, int msgflg) 1929 { 1930 struct target_msgbuf *target_mb; 1931 struct msgbuf *host_mb; 1932 abi_long ret = 0; 1933 1934 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0)) 1935 return -TARGET_EFAULT; 1936 host_mb = malloc(msgsz+sizeof(long)); 1937 host_mb->mtype = tswapl(target_mb->mtype); 1938 memcpy(host_mb->mtext,target_mb->mtext,msgsz); 1939 ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg)); 1940 free(host_mb); 1941 unlock_user_struct(target_mb, msgp, 0); 1942 1943 return ret; 1944 } 1945 1946 static inline abi_long do_msgrcv(int msqid, abi_long msgp, 1947 unsigned int msgsz, int msgtype, 1948 int msgflg) 1949 { 1950 struct target_msgbuf *target_mb; 1951 char *target_mtext; 1952 struct msgbuf *host_mb; 1953 abi_long ret = 0; 1954 1955 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0)) 1956 return -TARGET_EFAULT; 1957 host_mb = malloc(msgsz+sizeof(long)); 1958 ret = get_errno(msgrcv(msqid, host_mb, msgsz, 1, msgflg)); 1959 if (ret > 0) { 1960 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong); 1961 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0); 1962 if (!target_mtext) { 1963 ret = -TARGET_EFAULT; 1964 goto end; 1965 } 1966 memcpy(target_mb->mtext, host_mb->mtext, ret); 1967 unlock_user(target_mtext, target_mtext_addr, ret); 1968 } 1969 target_mb->mtype = tswapl(host_mb->mtype); 1970 free(host_mb); 1971 1972 end: 1973 if (target_mb) 1974 unlock_user_struct(target_mb, msgp, 1); 1975 return ret; 1976 } 1977 1978 /* ??? This only works with linear mappings. */ 1979 /* do_ipc() must return target values and target errnos. */ 1980 static abi_long do_ipc(unsigned int call, int first, 1981 int second, int third, 1982 abi_long ptr, abi_long fifth) 1983 { 1984 int version; 1985 abi_long ret = 0; 1986 struct shmid_ds shm_info; 1987 int i; 1988 1989 version = call >> 16; 1990 call &= 0xffff; 1991 1992 switch (call) { 1993 case IPCOP_semop: 1994 ret = get_errno(semop(first,(struct sembuf *)g2h(ptr), second)); 1995 break; 1996 1997 case IPCOP_semget: 1998 ret = get_errno(semget(first, second, third)); 1999 break; 2000 2001 case IPCOP_semctl: 2002 ret = do_semctl(first, second, third, ptr); 2003 break; 2004 2005 case IPCOP_semtimedop: 2006 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version); 2007 ret = -TARGET_ENOSYS; 2008 break; 2009 2010 case IPCOP_msgget: 2011 ret = get_errno(msgget(first, second)); 2012 break; 2013 2014 case IPCOP_msgsnd: 2015 ret = do_msgsnd(first, ptr, second, third); 2016 break; 2017 2018 case IPCOP_msgctl: 2019 ret = do_msgctl(first, second, ptr); 2020 break; 2021 2022 case IPCOP_msgrcv: 2023 { 2024 /* XXX: this code is not correct */ 2025 struct ipc_kludge 2026 { 2027 void *__unbounded msgp; 2028 long int msgtyp; 2029 }; 2030 2031 struct ipc_kludge *foo = (struct ipc_kludge *)g2h(ptr); 2032 struct msgbuf *msgp = (struct msgbuf *) foo->msgp; 2033 2034 ret = do_msgrcv(first, (long)msgp, second, 0, third); 2035 2036 } 2037 break; 2038 2039 case IPCOP_shmat: 2040 { 2041 abi_ulong raddr; 2042 void *host_addr; 2043 /* SHM_* flags are the same on all linux platforms */ 2044 host_addr = shmat(first, (void *)g2h(ptr), second); 2045 if (host_addr == (void *)-1) { 2046 ret = get_errno((long)host_addr); 2047 break; 2048 } 2049 raddr = h2g((unsigned long)host_addr); 2050 /* find out the length of the shared memory segment */ 2051 2052 ret = get_errno(shmctl(first, IPC_STAT, &shm_info)); 2053 if (is_error(ret)) { 2054 /* can't get length, bail out */ 2055 shmdt(host_addr); 2056 break; 2057 } 2058 page_set_flags(raddr, raddr + shm_info.shm_segsz, 2059 PAGE_VALID | PAGE_READ | 2060 ((second & SHM_RDONLY)? 0: PAGE_WRITE)); 2061 for (i = 0; i < N_SHM_REGIONS; ++i) { 2062 if (shm_regions[i].start == 0) { 2063 shm_regions[i].start = raddr; 2064 shm_regions[i].size = shm_info.shm_segsz; 2065 break; 2066 } 2067 } 2068 if (put_user_ual(raddr, third)) 2069 return -TARGET_EFAULT; 2070 ret = 0; 2071 } 2072 break; 2073 case IPCOP_shmdt: 2074 for (i = 0; i < N_SHM_REGIONS; ++i) { 2075 if (shm_regions[i].start == ptr) { 2076 shm_regions[i].start = 0; 2077 page_set_flags(ptr, shm_regions[i].size, 0); 2078 break; 2079 } 2080 } 2081 ret = get_errno(shmdt((void *)g2h(ptr))); 2082 break; 2083 2084 case IPCOP_shmget: 2085 /* IPC_* flag values are the same on all linux platforms */ 2086 ret = get_errno(shmget(first, second, third)); 2087 break; 2088 2089 /* IPC_* and SHM_* command values are the same on all linux platforms */ 2090 case IPCOP_shmctl: 2091 switch(second) { 2092 case IPC_RMID: 2093 case SHM_LOCK: 2094 case SHM_UNLOCK: 2095 ret = get_errno(shmctl(first, second, NULL)); 2096 break; 2097 default: 2098 goto unimplemented; 2099 } 2100 break; 2101 default: 2102 unimplemented: 2103 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version); 2104 ret = -TARGET_ENOSYS; 2105 break; 2106 } 2107 return ret; 2108 } 2109 #endif 2110 2111 /* kernel structure types definitions */ 2112 #define IFNAMSIZ 16 2113 2114 #define STRUCT(name, list...) STRUCT_ ## name, 2115 #define STRUCT_SPECIAL(name) STRUCT_ ## name, 2116 enum { 2117 #include "syscall_types.h" 2118 }; 2119 #undef STRUCT 2120 #undef STRUCT_SPECIAL 2121 2122 #define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL }; 2123 #define STRUCT_SPECIAL(name) 2124 #include "syscall_types.h" 2125 #undef STRUCT 2126 #undef STRUCT_SPECIAL 2127 2128 typedef struct IOCTLEntry { 2129 unsigned int target_cmd; 2130 unsigned int host_cmd; 2131 const char *name; 2132 int access; 2133 const argtype arg_type[5]; 2134 } IOCTLEntry; 2135 2136 #define IOC_R 0x0001 2137 #define IOC_W 0x0002 2138 #define IOC_RW (IOC_R | IOC_W) 2139 2140 #define MAX_STRUCT_SIZE 4096 2141 2142 static IOCTLEntry ioctl_entries[] = { 2143 #define IOCTL(cmd, access, types...) \ 2144 { TARGET_ ## cmd, cmd, #cmd, access, { types } }, 2145 #include "ioctls.h" 2146 { 0, 0, }, 2147 }; 2148 2149 /* ??? Implement proper locking for ioctls. */ 2150 /* do_ioctl() Must return target values and target errnos. */ 2151 static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg) 2152 { 2153 const IOCTLEntry *ie; 2154 const argtype *arg_type; 2155 abi_long ret; 2156 uint8_t buf_temp[MAX_STRUCT_SIZE]; 2157 int target_size; 2158 void *argptr; 2159 2160 ie = ioctl_entries; 2161 for(;;) { 2162 if (ie->target_cmd == 0) { 2163 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd); 2164 return -TARGET_ENOSYS; 2165 } 2166 if (ie->target_cmd == cmd) 2167 break; 2168 ie++; 2169 } 2170 arg_type = ie->arg_type; 2171 #if defined(DEBUG) 2172 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name); 2173 #endif 2174 switch(arg_type[0]) { 2175 case TYPE_NULL: 2176 /* no argument */ 2177 ret = get_errno(ioctl(fd, ie->host_cmd)); 2178 break; 2179 case TYPE_PTRVOID: 2180 case TYPE_INT: 2181 /* int argment */ 2182 ret = get_errno(ioctl(fd, ie->host_cmd, arg)); 2183 break; 2184 case TYPE_PTR: 2185 arg_type++; 2186 target_size = thunk_type_size(arg_type, 0); 2187 switch(ie->access) { 2188 case IOC_R: 2189 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 2190 if (!is_error(ret)) { 2191 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 2192 if (!argptr) 2193 return -TARGET_EFAULT; 2194 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET); 2195 unlock_user(argptr, arg, target_size); 2196 } 2197 break; 2198 case IOC_W: 2199 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 2200 if (!argptr) 2201 return -TARGET_EFAULT; 2202 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 2203 unlock_user(argptr, arg, 0); 2204 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 2205 break; 2206 default: 2207 case IOC_RW: 2208 argptr = lock_user(VERIFY_READ, arg, target_size, 1); 2209 if (!argptr) 2210 return -TARGET_EFAULT; 2211 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST); 2212 unlock_user(argptr, arg, 0); 2213 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 2214 if (!is_error(ret)) { 2215 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0); 2216 if (!argptr) 2217 return -TARGET_EFAULT; 2218 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET); 2219 unlock_user(argptr, arg, target_size); 2220 } 2221 break; 2222 } 2223 break; 2224 default: 2225 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", 2226 (long)cmd, arg_type[0]); 2227 ret = -TARGET_ENOSYS; 2228 break; 2229 } 2230 return ret; 2231 } 2232 2233 static const bitmask_transtbl iflag_tbl[] = { 2234 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK }, 2235 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT }, 2236 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR }, 2237 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK }, 2238 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK }, 2239 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP }, 2240 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR }, 2241 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR }, 2242 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL }, 2243 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC }, 2244 { TARGET_IXON, TARGET_IXON, IXON, IXON }, 2245 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY }, 2246 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF }, 2247 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL }, 2248 { 0, 0, 0, 0 } 2249 }; 2250 2251 static const bitmask_transtbl oflag_tbl[] = { 2252 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST }, 2253 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC }, 2254 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR }, 2255 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL }, 2256 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR }, 2257 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET }, 2258 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL }, 2259 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL }, 2260 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 }, 2261 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 }, 2262 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 }, 2263 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 }, 2264 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 }, 2265 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 }, 2266 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 }, 2267 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 }, 2268 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 }, 2269 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 }, 2270 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 }, 2271 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 }, 2272 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 }, 2273 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 }, 2274 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 }, 2275 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 }, 2276 { 0, 0, 0, 0 } 2277 }; 2278 2279 static const bitmask_transtbl cflag_tbl[] = { 2280 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 }, 2281 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 }, 2282 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 }, 2283 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 }, 2284 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 }, 2285 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 }, 2286 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 }, 2287 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 }, 2288 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 }, 2289 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 }, 2290 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 }, 2291 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 }, 2292 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 }, 2293 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 }, 2294 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 }, 2295 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 }, 2296 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 }, 2297 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 }, 2298 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 }, 2299 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 }, 2300 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 }, 2301 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 }, 2302 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 }, 2303 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 }, 2304 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB }, 2305 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD }, 2306 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB }, 2307 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD }, 2308 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL }, 2309 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL }, 2310 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS }, 2311 { 0, 0, 0, 0 } 2312 }; 2313 2314 static const bitmask_transtbl lflag_tbl[] = { 2315 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG }, 2316 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON }, 2317 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE }, 2318 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO }, 2319 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE }, 2320 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK }, 2321 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL }, 2322 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH }, 2323 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP }, 2324 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL }, 2325 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT }, 2326 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE }, 2327 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO }, 2328 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN }, 2329 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN }, 2330 { 0, 0, 0, 0 } 2331 }; 2332 2333 static void target_to_host_termios (void *dst, const void *src) 2334 { 2335 struct host_termios *host = dst; 2336 const struct target_termios *target = src; 2337 2338 host->c_iflag = 2339 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl); 2340 host->c_oflag = 2341 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl); 2342 host->c_cflag = 2343 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl); 2344 host->c_lflag = 2345 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl); 2346 host->c_line = target->c_line; 2347 2348 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR]; 2349 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT]; 2350 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE]; 2351 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL]; 2352 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF]; 2353 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME]; 2354 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN]; 2355 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC]; 2356 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART]; 2357 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP]; 2358 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP]; 2359 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL]; 2360 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT]; 2361 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD]; 2362 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE]; 2363 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT]; 2364 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2]; 2365 } 2366 2367 static void host_to_target_termios (void *dst, const void *src) 2368 { 2369 struct target_termios *target = dst; 2370 const struct host_termios *host = src; 2371 2372 target->c_iflag = 2373 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl)); 2374 target->c_oflag = 2375 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl)); 2376 target->c_cflag = 2377 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl)); 2378 target->c_lflag = 2379 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl)); 2380 target->c_line = host->c_line; 2381 2382 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR]; 2383 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT]; 2384 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE]; 2385 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL]; 2386 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF]; 2387 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME]; 2388 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN]; 2389 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC]; 2390 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART]; 2391 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP]; 2392 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP]; 2393 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL]; 2394 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT]; 2395 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD]; 2396 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE]; 2397 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT]; 2398 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2]; 2399 } 2400 2401 static const StructEntry struct_termios_def = { 2402 .convert = { host_to_target_termios, target_to_host_termios }, 2403 .size = { sizeof(struct target_termios), sizeof(struct host_termios) }, 2404 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) }, 2405 }; 2406 2407 static bitmask_transtbl mmap_flags_tbl[] = { 2408 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED }, 2409 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE }, 2410 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED }, 2411 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS }, 2412 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN }, 2413 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE }, 2414 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE }, 2415 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED }, 2416 { 0, 0, 0, 0 } 2417 }; 2418 2419 static bitmask_transtbl fcntl_flags_tbl[] = { 2420 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, }, 2421 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, }, 2422 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, }, 2423 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, }, 2424 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, }, 2425 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, }, 2426 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, }, 2427 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, }, 2428 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, }, 2429 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, }, 2430 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, }, 2431 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, }, 2432 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, }, 2433 #if defined(O_DIRECT) 2434 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, }, 2435 #endif 2436 { 0, 0, 0, 0 } 2437 }; 2438 2439 #if defined(TARGET_I386) 2440 2441 /* NOTE: there is really one LDT for all the threads */ 2442 uint8_t *ldt_table; 2443 2444 static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount) 2445 { 2446 int size; 2447 void *p; 2448 2449 if (!ldt_table) 2450 return 0; 2451 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE; 2452 if (size > bytecount) 2453 size = bytecount; 2454 p = lock_user(VERIFY_WRITE, ptr, size, 0); 2455 if (!p) 2456 return -TARGET_EFAULT; 2457 /* ??? Should this by byteswapped? */ 2458 memcpy(p, ldt_table, size); 2459 unlock_user(p, ptr, size); 2460 return size; 2461 } 2462 2463 /* XXX: add locking support */ 2464 static abi_long write_ldt(CPUX86State *env, 2465 abi_ulong ptr, unsigned long bytecount, int oldmode) 2466 { 2467 struct target_modify_ldt_ldt_s ldt_info; 2468 struct target_modify_ldt_ldt_s *target_ldt_info; 2469 int seg_32bit, contents, read_exec_only, limit_in_pages; 2470 int seg_not_present, useable, lm; 2471 uint32_t *lp, entry_1, entry_2; 2472 2473 if (bytecount != sizeof(ldt_info)) 2474 return -TARGET_EINVAL; 2475 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1)) 2476 return -TARGET_EFAULT; 2477 ldt_info.entry_number = tswap32(target_ldt_info->entry_number); 2478 ldt_info.base_addr = tswapl(target_ldt_info->base_addr); 2479 ldt_info.limit = tswap32(target_ldt_info->limit); 2480 ldt_info.flags = tswap32(target_ldt_info->flags); 2481 unlock_user_struct(target_ldt_info, ptr, 0); 2482 2483 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES) 2484 return -TARGET_EINVAL; 2485 seg_32bit = ldt_info.flags & 1; 2486 contents = (ldt_info.flags >> 1) & 3; 2487 read_exec_only = (ldt_info.flags >> 3) & 1; 2488 limit_in_pages = (ldt_info.flags >> 4) & 1; 2489 seg_not_present = (ldt_info.flags >> 5) & 1; 2490 useable = (ldt_info.flags >> 6) & 1; 2491 #ifdef TARGET_ABI32 2492 lm = 0; 2493 #else 2494 lm = (ldt_info.flags >> 7) & 1; 2495 #endif 2496 if (contents == 3) { 2497 if (oldmode) 2498 return -TARGET_EINVAL; 2499 if (seg_not_present == 0) 2500 return -TARGET_EINVAL; 2501 } 2502 /* allocate the LDT */ 2503 if (!ldt_table) { 2504 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); 2505 if (!ldt_table) 2506 return -TARGET_ENOMEM; 2507 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); 2508 env->ldt.base = h2g((unsigned long)ldt_table); 2509 env->ldt.limit = 0xffff; 2510 } 2511 2512 /* NOTE: same code as Linux kernel */ 2513 /* Allow LDTs to be cleared by the user. */ 2514 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) { 2515 if (oldmode || 2516 (contents == 0 && 2517 read_exec_only == 1 && 2518 seg_32bit == 0 && 2519 limit_in_pages == 0 && 2520 seg_not_present == 1 && 2521 useable == 0 )) { 2522 entry_1 = 0; 2523 entry_2 = 0; 2524 goto install; 2525 } 2526 } 2527 2528 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) | 2529 (ldt_info.limit & 0x0ffff); 2530 entry_2 = (ldt_info.base_addr & 0xff000000) | 2531 ((ldt_info.base_addr & 0x00ff0000) >> 16) | 2532 (ldt_info.limit & 0xf0000) | 2533 ((read_exec_only ^ 1) << 9) | 2534 (contents << 10) | 2535 ((seg_not_present ^ 1) << 15) | 2536 (seg_32bit << 22) | 2537 (limit_in_pages << 23) | 2538 (lm << 21) | 2539 0x7000; 2540 if (!oldmode) 2541 entry_2 |= (useable << 20); 2542 2543 /* Install the new entry ... */ 2544 install: 2545 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3)); 2546 lp[0] = tswap32(entry_1); 2547 lp[1] = tswap32(entry_2); 2548 return 0; 2549 } 2550 2551 /* specific and weird i386 syscalls */ 2552 static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr, 2553 unsigned long bytecount) 2554 { 2555 abi_long ret; 2556 2557 switch (func) { 2558 case 0: 2559 ret = read_ldt(ptr, bytecount); 2560 break; 2561 case 1: 2562 ret = write_ldt(env, ptr, bytecount, 1); 2563 break; 2564 case 0x11: 2565 ret = write_ldt(env, ptr, bytecount, 0); 2566 break; 2567 default: 2568 ret = -TARGET_ENOSYS; 2569 break; 2570 } 2571 return ret; 2572 } 2573 2574 #if defined(TARGET_I386) && defined(TARGET_ABI32) 2575 static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr) 2576 { 2577 uint64_t *gdt_table = g2h(env->gdt.base); 2578 struct target_modify_ldt_ldt_s ldt_info; 2579 struct target_modify_ldt_ldt_s *target_ldt_info; 2580 int seg_32bit, contents, read_exec_only, limit_in_pages; 2581 int seg_not_present, useable, lm; 2582 uint32_t *lp, entry_1, entry_2; 2583 int i; 2584 2585 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1); 2586 if (!target_ldt_info) 2587 return -TARGET_EFAULT; 2588 ldt_info.entry_number = tswap32(target_ldt_info->entry_number); 2589 ldt_info.base_addr = tswapl(target_ldt_info->base_addr); 2590 ldt_info.limit = tswap32(target_ldt_info->limit); 2591 ldt_info.flags = tswap32(target_ldt_info->flags); 2592 if (ldt_info.entry_number == -1) { 2593 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) { 2594 if (gdt_table[i] == 0) { 2595 ldt_info.entry_number = i; 2596 target_ldt_info->entry_number = tswap32(i); 2597 break; 2598 } 2599 } 2600 } 2601 unlock_user_struct(target_ldt_info, ptr, 1); 2602 2603 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN || 2604 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX) 2605 return -TARGET_EINVAL; 2606 seg_32bit = ldt_info.flags & 1; 2607 contents = (ldt_info.flags >> 1) & 3; 2608 read_exec_only = (ldt_info.flags >> 3) & 1; 2609 limit_in_pages = (ldt_info.flags >> 4) & 1; 2610 seg_not_present = (ldt_info.flags >> 5) & 1; 2611 useable = (ldt_info.flags >> 6) & 1; 2612 #ifdef TARGET_ABI32 2613 lm = 0; 2614 #else 2615 lm = (ldt_info.flags >> 7) & 1; 2616 #endif 2617 2618 if (contents == 3) { 2619 if (seg_not_present == 0) 2620 return -TARGET_EINVAL; 2621 } 2622 2623 /* NOTE: same code as Linux kernel */ 2624 /* Allow LDTs to be cleared by the user. */ 2625 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) { 2626 if ((contents == 0 && 2627 read_exec_only == 1 && 2628 seg_32bit == 0 && 2629 limit_in_pages == 0 && 2630 seg_not_present == 1 && 2631 useable == 0 )) { 2632 entry_1 = 0; 2633 entry_2 = 0; 2634 goto install; 2635 } 2636 } 2637 2638 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) | 2639 (ldt_info.limit & 0x0ffff); 2640 entry_2 = (ldt_info.base_addr & 0xff000000) | 2641 ((ldt_info.base_addr & 0x00ff0000) >> 16) | 2642 (ldt_info.limit & 0xf0000) | 2643 ((read_exec_only ^ 1) << 9) | 2644 (contents << 10) | 2645 ((seg_not_present ^ 1) << 15) | 2646 (seg_32bit << 22) | 2647 (limit_in_pages << 23) | 2648 (useable << 20) | 2649 (lm << 21) | 2650 0x7000; 2651 2652 /* Install the new entry ... */ 2653 install: 2654 lp = (uint32_t *)(gdt_table + ldt_info.entry_number); 2655 lp[0] = tswap32(entry_1); 2656 lp[1] = tswap32(entry_2); 2657 return 0; 2658 } 2659 2660 static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr) 2661 { 2662 struct target_modify_ldt_ldt_s *target_ldt_info; 2663 uint64_t *gdt_table = g2h(env->gdt.base); 2664 uint32_t base_addr, limit, flags; 2665 int seg_32bit, contents, read_exec_only, limit_in_pages, idx; 2666 int seg_not_present, useable, lm; 2667 uint32_t *lp, entry_1, entry_2; 2668 2669 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1); 2670 if (!target_ldt_info) 2671 return -TARGET_EFAULT; 2672 idx = tswap32(target_ldt_info->entry_number); 2673 if (idx < TARGET_GDT_ENTRY_TLS_MIN || 2674 idx > TARGET_GDT_ENTRY_TLS_MAX) { 2675 unlock_user_struct(target_ldt_info, ptr, 1); 2676 return -TARGET_EINVAL; 2677 } 2678 lp = (uint32_t *)(gdt_table + idx); 2679 entry_1 = tswap32(lp[0]); 2680 entry_2 = tswap32(lp[1]); 2681 2682 read_exec_only = ((entry_2 >> 9) & 1) ^ 1; 2683 contents = (entry_2 >> 10) & 3; 2684 seg_not_present = ((entry_2 >> 15) & 1) ^ 1; 2685 seg_32bit = (entry_2 >> 22) & 1; 2686 limit_in_pages = (entry_2 >> 23) & 1; 2687 useable = (entry_2 >> 20) & 1; 2688 #ifdef TARGET_ABI32 2689 lm = 0; 2690 #else 2691 lm = (entry_2 >> 21) & 1; 2692 #endif 2693 flags = (seg_32bit << 0) | (contents << 1) | 2694 (read_exec_only << 3) | (limit_in_pages << 4) | 2695 (seg_not_present << 5) | (useable << 6) | (lm << 7); 2696 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000); 2697 base_addr = (entry_1 >> 16) | 2698 (entry_2 & 0xff000000) | 2699 ((entry_2 & 0xff) << 16); 2700 target_ldt_info->base_addr = tswapl(base_addr); 2701 target_ldt_info->limit = tswap32(limit); 2702 target_ldt_info->flags = tswap32(flags); 2703 unlock_user_struct(target_ldt_info, ptr, 1); 2704 return 0; 2705 } 2706 #endif /* TARGET_I386 && TARGET_ABI32 */ 2707 2708 #ifndef TARGET_ABI32 2709 static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr) 2710 { 2711 abi_long ret; 2712 abi_ulong val; 2713 int idx; 2714 2715 switch(code) { 2716 case TARGET_ARCH_SET_GS: 2717 case TARGET_ARCH_SET_FS: 2718 if (code == TARGET_ARCH_SET_GS) 2719 idx = R_GS; 2720 else 2721 idx = R_FS; 2722 cpu_x86_load_seg(env, idx, 0); 2723 env->segs[idx].base = addr; 2724 break; 2725 case TARGET_ARCH_GET_GS: 2726 case TARGET_ARCH_GET_FS: 2727 if (code == TARGET_ARCH_GET_GS) 2728 idx = R_GS; 2729 else 2730 idx = R_FS; 2731 val = env->segs[idx].base; 2732 if (put_user(val, addr, abi_ulong)) 2733 return -TARGET_EFAULT; 2734 break; 2735 default: 2736 ret = -TARGET_EINVAL; 2737 break; 2738 } 2739 return 0; 2740 } 2741 #endif 2742 2743 #endif /* defined(TARGET_I386) */ 2744 2745 #if defined(USE_NPTL) 2746 2747 #define NEW_STACK_SIZE PTHREAD_STACK_MIN 2748 2749 static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER; 2750 typedef struct { 2751 CPUState *env; 2752 pthread_mutex_t mutex; 2753 pthread_cond_t cond; 2754 pthread_t thread; 2755 uint32_t tid; 2756 abi_ulong child_tidptr; 2757 abi_ulong parent_tidptr; 2758 sigset_t sigmask; 2759 } new_thread_info; 2760 2761 static void *clone_func(void *arg) 2762 { 2763 new_thread_info *info = arg; 2764 CPUState *env; 2765 2766 env = info->env; 2767 thread_env = env; 2768 info->tid = gettid(); 2769 if (info->child_tidptr) 2770 put_user_u32(info->tid, info->child_tidptr); 2771 if (info->parent_tidptr) 2772 put_user_u32(info->tid, info->parent_tidptr); 2773 /* Enable signals. */ 2774 sigprocmask(SIG_SETMASK, &info->sigmask, NULL); 2775 /* Signal to the parent that we're ready. */ 2776 pthread_mutex_lock(&info->mutex); 2777 pthread_cond_broadcast(&info->cond); 2778 pthread_mutex_unlock(&info->mutex); 2779 /* Wait until the parent has finshed initializing the tls state. */ 2780 pthread_mutex_lock(&clone_lock); 2781 pthread_mutex_unlock(&clone_lock); 2782 cpu_loop(env); 2783 /* never exits */ 2784 return NULL; 2785 } 2786 #else 2787 /* this stack is the equivalent of the kernel stack associated with a 2788 thread/process */ 2789 #define NEW_STACK_SIZE 8192 2790 2791 static int clone_func(void *arg) 2792 { 2793 CPUState *env = arg; 2794 cpu_loop(env); 2795 /* never exits */ 2796 return 0; 2797 } 2798 #endif 2799 2800 /* do_fork() Must return host values and target errnos (unlike most 2801 do_*() functions). */ 2802 static int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp, 2803 abi_ulong parent_tidptr, target_ulong newtls, 2804 abi_ulong child_tidptr) 2805 { 2806 int ret; 2807 TaskState *ts; 2808 uint8_t *new_stack; 2809 CPUState *new_env; 2810 #if defined(USE_NPTL) 2811 unsigned int nptl_flags; 2812 sigset_t sigmask; 2813 #endif 2814 2815 /* Emulate vfork() with fork() */ 2816 if (flags & CLONE_VFORK) 2817 flags &= ~(CLONE_VFORK | CLONE_VM); 2818 2819 if (flags & CLONE_VM) { 2820 #if defined(USE_NPTL) 2821 new_thread_info info; 2822 pthread_attr_t attr; 2823 #endif 2824 ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE); 2825 init_task_state(ts); 2826 new_stack = ts->stack; 2827 /* we create a new CPU instance. */ 2828 new_env = cpu_copy(env); 2829 /* Init regs that differ from the parent. */ 2830 cpu_clone_regs(new_env, newsp); 2831 new_env->opaque = ts; 2832 #if defined(USE_NPTL) 2833 nptl_flags = flags; 2834 flags &= ~CLONE_NPTL_FLAGS2; 2835 2836 /* TODO: Implement CLONE_CHILD_CLEARTID. */ 2837 if (nptl_flags & CLONE_SETTLS) 2838 cpu_set_tls (new_env, newtls); 2839 2840 /* Grab a mutex so that thread setup appears atomic. */ 2841 pthread_mutex_lock(&clone_lock); 2842 2843 memset(&info, 0, sizeof(info)); 2844 pthread_mutex_init(&info.mutex, NULL); 2845 pthread_mutex_lock(&info.mutex); 2846 pthread_cond_init(&info.cond, NULL); 2847 info.env = new_env; 2848 if (nptl_flags & CLONE_CHILD_SETTID) 2849 info.child_tidptr = child_tidptr; 2850 if (nptl_flags & CLONE_PARENT_SETTID) 2851 info.parent_tidptr = parent_tidptr; 2852 2853 ret = pthread_attr_init(&attr); 2854 ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE); 2855 /* It is not safe to deliver signals until the child has finished 2856 initializing, so temporarily block all signals. */ 2857 sigfillset(&sigmask); 2858 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask); 2859 2860 ret = pthread_create(&info.thread, &attr, clone_func, &info); 2861 2862 sigprocmask(SIG_SETMASK, &info.sigmask, NULL); 2863 pthread_attr_destroy(&attr); 2864 if (ret == 0) { 2865 /* Wait for the child to initialize. */ 2866 pthread_cond_wait(&info.cond, &info.mutex); 2867 ret = info.tid; 2868 if (flags & CLONE_PARENT_SETTID) 2869 put_user_u32(ret, parent_tidptr); 2870 } else { 2871 ret = -1; 2872 } 2873 pthread_mutex_unlock(&info.mutex); 2874 pthread_cond_destroy(&info.cond); 2875 pthread_mutex_destroy(&info.mutex); 2876 pthread_mutex_unlock(&clone_lock); 2877 #else 2878 if (flags & CLONE_NPTL_FLAGS2) 2879 return -EINVAL; 2880 /* This is probably going to die very quickly, but do it anyway. */ 2881 #ifdef __ia64__ 2882 ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env); 2883 #else 2884 ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env); 2885 #endif 2886 #endif 2887 } else { 2888 /* if no CLONE_VM, we consider it is a fork */ 2889 if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0) 2890 return -EINVAL; 2891 fork_start(); 2892 ret = fork(); 2893 #if defined(USE_NPTL) 2894 /* There is a race condition here. The parent process could 2895 theoretically read the TID in the child process before the child 2896 tid is set. This would require using either ptrace 2897 (not implemented) or having *_tidptr to point at a shared memory 2898 mapping. We can't repeat the spinlock hack used above because 2899 the child process gets its own copy of the lock. */ 2900 if (ret == 0) { 2901 cpu_clone_regs(env, newsp); 2902 fork_end(1); 2903 /* Child Process. */ 2904 if (flags & CLONE_CHILD_SETTID) 2905 put_user_u32(gettid(), child_tidptr); 2906 if (flags & CLONE_PARENT_SETTID) 2907 put_user_u32(gettid(), parent_tidptr); 2908 ts = (TaskState *)env->opaque; 2909 if (flags & CLONE_SETTLS) 2910 cpu_set_tls (env, newtls); 2911 /* TODO: Implement CLONE_CHILD_CLEARTID. */ 2912 } else { 2913 fork_end(0); 2914 } 2915 #else 2916 if (ret == 0) { 2917 cpu_clone_regs(env, newsp); 2918 } 2919 #endif 2920 } 2921 return ret; 2922 } 2923 2924 static abi_long do_fcntl(int fd, int cmd, abi_ulong arg) 2925 { 2926 struct flock fl; 2927 struct target_flock *target_fl; 2928 struct flock64 fl64; 2929 struct target_flock64 *target_fl64; 2930 abi_long ret; 2931 2932 switch(cmd) { 2933 case TARGET_F_GETLK: 2934 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1)) 2935 return -TARGET_EFAULT; 2936 fl.l_type = tswap16(target_fl->l_type); 2937 fl.l_whence = tswap16(target_fl->l_whence); 2938 fl.l_start = tswapl(target_fl->l_start); 2939 fl.l_len = tswapl(target_fl->l_len); 2940 fl.l_pid = tswapl(target_fl->l_pid); 2941 unlock_user_struct(target_fl, arg, 0); 2942 ret = get_errno(fcntl(fd, cmd, &fl)); 2943 if (ret == 0) { 2944 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0)) 2945 return -TARGET_EFAULT; 2946 target_fl->l_type = tswap16(fl.l_type); 2947 target_fl->l_whence = tswap16(fl.l_whence); 2948 target_fl->l_start = tswapl(fl.l_start); 2949 target_fl->l_len = tswapl(fl.l_len); 2950 target_fl->l_pid = tswapl(fl.l_pid); 2951 unlock_user_struct(target_fl, arg, 1); 2952 } 2953 break; 2954 2955 case TARGET_F_SETLK: 2956 case TARGET_F_SETLKW: 2957 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1)) 2958 return -TARGET_EFAULT; 2959 fl.l_type = tswap16(target_fl->l_type); 2960 fl.l_whence = tswap16(target_fl->l_whence); 2961 fl.l_start = tswapl(target_fl->l_start); 2962 fl.l_len = tswapl(target_fl->l_len); 2963 fl.l_pid = tswapl(target_fl->l_pid); 2964 unlock_user_struct(target_fl, arg, 0); 2965 ret = get_errno(fcntl(fd, cmd, &fl)); 2966 break; 2967 2968 case TARGET_F_GETLK64: 2969 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1)) 2970 return -TARGET_EFAULT; 2971 fl64.l_type = tswap16(target_fl64->l_type) >> 1; 2972 fl64.l_whence = tswap16(target_fl64->l_whence); 2973 fl64.l_start = tswapl(target_fl64->l_start); 2974 fl64.l_len = tswapl(target_fl64->l_len); 2975 fl64.l_pid = tswap16(target_fl64->l_pid); 2976 unlock_user_struct(target_fl64, arg, 0); 2977 ret = get_errno(fcntl(fd, cmd >> 1, &fl64)); 2978 if (ret == 0) { 2979 if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0)) 2980 return -TARGET_EFAULT; 2981 target_fl64->l_type = tswap16(fl64.l_type) >> 1; 2982 target_fl64->l_whence = tswap16(fl64.l_whence); 2983 target_fl64->l_start = tswapl(fl64.l_start); 2984 target_fl64->l_len = tswapl(fl64.l_len); 2985 target_fl64->l_pid = tswapl(fl64.l_pid); 2986 unlock_user_struct(target_fl64, arg, 1); 2987 } 2988 break; 2989 case TARGET_F_SETLK64: 2990 case TARGET_F_SETLKW64: 2991 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1)) 2992 return -TARGET_EFAULT; 2993 fl64.l_type = tswap16(target_fl64->l_type) >> 1; 2994 fl64.l_whence = tswap16(target_fl64->l_whence); 2995 fl64.l_start = tswapl(target_fl64->l_start); 2996 fl64.l_len = tswapl(target_fl64->l_len); 2997 fl64.l_pid = tswap16(target_fl64->l_pid); 2998 unlock_user_struct(target_fl64, arg, 0); 2999 ret = get_errno(fcntl(fd, cmd >> 1, &fl64)); 3000 break; 3001 3002 case F_GETFL: 3003 ret = get_errno(fcntl(fd, cmd, arg)); 3004 if (ret >= 0) { 3005 ret = host_to_target_bitmask(ret, fcntl_flags_tbl); 3006 } 3007 break; 3008 3009 case F_SETFL: 3010 ret = get_errno(fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl))); 3011 break; 3012 3013 default: 3014 ret = get_errno(fcntl(fd, cmd, arg)); 3015 break; 3016 } 3017 return ret; 3018 } 3019 3020 #ifdef USE_UID16 3021 3022 static inline int high2lowuid(int uid) 3023 { 3024 if (uid > 65535) 3025 return 65534; 3026 else 3027 return uid; 3028 } 3029 3030 static inline int high2lowgid(int gid) 3031 { 3032 if (gid > 65535) 3033 return 65534; 3034 else 3035 return gid; 3036 } 3037 3038 static inline int low2highuid(int uid) 3039 { 3040 if ((int16_t)uid == -1) 3041 return -1; 3042 else 3043 return uid; 3044 } 3045 3046 static inline int low2highgid(int gid) 3047 { 3048 if ((int16_t)gid == -1) 3049 return -1; 3050 else 3051 return gid; 3052 } 3053 3054 #endif /* USE_UID16 */ 3055 3056 void syscall_init(void) 3057 { 3058 IOCTLEntry *ie; 3059 const argtype *arg_type; 3060 int size; 3061 int i; 3062 3063 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def); 3064 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def); 3065 #include "syscall_types.h" 3066 #undef STRUCT 3067 #undef STRUCT_SPECIAL 3068 3069 /* we patch the ioctl size if necessary. We rely on the fact that 3070 no ioctl has all the bits at '1' in the size field */ 3071 ie = ioctl_entries; 3072 while (ie->target_cmd != 0) { 3073 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) == 3074 TARGET_IOC_SIZEMASK) { 3075 arg_type = ie->arg_type; 3076 if (arg_type[0] != TYPE_PTR) { 3077 fprintf(stderr, "cannot patch size for ioctl 0x%x\n", 3078 ie->target_cmd); 3079 exit(1); 3080 } 3081 arg_type++; 3082 size = thunk_type_size(arg_type, 0); 3083 ie->target_cmd = (ie->target_cmd & 3084 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) | 3085 (size << TARGET_IOC_SIZESHIFT); 3086 } 3087 3088 /* Build target_to_host_errno_table[] table from 3089 * host_to_target_errno_table[]. */ 3090 for (i=0; i < ERRNO_TABLE_SIZE; i++) 3091 target_to_host_errno_table[host_to_target_errno_table[i]] = i; 3092 3093 /* automatic consistency check if same arch */ 3094 #if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \ 3095 (defined(__x86_64__) && defined(TARGET_X86_64)) 3096 if (unlikely(ie->target_cmd != ie->host_cmd)) { 3097 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n", 3098 ie->name, ie->target_cmd, ie->host_cmd); 3099 } 3100 #endif 3101 ie++; 3102 } 3103 } 3104 3105 #if TARGET_ABI_BITS == 32 3106 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1) 3107 { 3108 #ifdef TARGET_WORDS_BIGENDIAN 3109 return ((uint64_t)word0 << 32) | word1; 3110 #else 3111 return ((uint64_t)word1 << 32) | word0; 3112 #endif 3113 } 3114 #else /* TARGET_ABI_BITS == 32 */ 3115 static inline uint64_t target_offset64(uint64_t word0, uint64_t word1) 3116 { 3117 return word0; 3118 } 3119 #endif /* TARGET_ABI_BITS != 32 */ 3120 3121 #ifdef TARGET_NR_truncate64 3122 static inline abi_long target_truncate64(void *cpu_env, const char *arg1, 3123 abi_long arg2, 3124 abi_long arg3, 3125 abi_long arg4) 3126 { 3127 #ifdef TARGET_ARM 3128 if (((CPUARMState *)cpu_env)->eabi) 3129 { 3130 arg2 = arg3; 3131 arg3 = arg4; 3132 } 3133 #endif 3134 return get_errno(truncate64(arg1, target_offset64(arg2, arg3))); 3135 } 3136 #endif 3137 3138 #ifdef TARGET_NR_ftruncate64 3139 static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1, 3140 abi_long arg2, 3141 abi_long arg3, 3142 abi_long arg4) 3143 { 3144 #ifdef TARGET_ARM 3145 if (((CPUARMState *)cpu_env)->eabi) 3146 { 3147 arg2 = arg3; 3148 arg3 = arg4; 3149 } 3150 #endif 3151 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3))); 3152 } 3153 #endif 3154 3155 static inline abi_long target_to_host_timespec(struct timespec *host_ts, 3156 abi_ulong target_addr) 3157 { 3158 struct target_timespec *target_ts; 3159 3160 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1)) 3161 return -TARGET_EFAULT; 3162 host_ts->tv_sec = tswapl(target_ts->tv_sec); 3163 host_ts->tv_nsec = tswapl(target_ts->tv_nsec); 3164 unlock_user_struct(target_ts, target_addr, 0); 3165 return 0; 3166 } 3167 3168 static inline abi_long host_to_target_timespec(abi_ulong target_addr, 3169 struct timespec *host_ts) 3170 { 3171 struct target_timespec *target_ts; 3172 3173 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0)) 3174 return -TARGET_EFAULT; 3175 target_ts->tv_sec = tswapl(host_ts->tv_sec); 3176 target_ts->tv_nsec = tswapl(host_ts->tv_nsec); 3177 unlock_user_struct(target_ts, target_addr, 1); 3178 return 0; 3179 } 3180 3181 #ifdef TARGET_NR_stat64 3182 static inline abi_long host_to_target_stat64(void *cpu_env, 3183 abi_ulong target_addr, 3184 struct stat *host_st) 3185 { 3186 #ifdef TARGET_ARM 3187 if (((CPUARMState *)cpu_env)->eabi) { 3188 struct target_eabi_stat64 *target_st; 3189 3190 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0)) 3191 return -TARGET_EFAULT; 3192 memset(target_st, 0, sizeof(struct target_eabi_stat64)); 3193 __put_user(host_st->st_dev, &target_st->st_dev); 3194 __put_user(host_st->st_ino, &target_st->st_ino); 3195 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO 3196 __put_user(host_st->st_ino, &target_st->__st_ino); 3197 #endif 3198 __put_user(host_st->st_mode, &target_st->st_mode); 3199 __put_user(host_st->st_nlink, &target_st->st_nlink); 3200 __put_user(host_st->st_uid, &target_st->st_uid); 3201 __put_user(host_st->st_gid, &target_st->st_gid); 3202 __put_user(host_st->st_rdev, &target_st->st_rdev); 3203 __put_user(host_st->st_size, &target_st->st_size); 3204 __put_user(host_st->st_blksize, &target_st->st_blksize); 3205 __put_user(host_st->st_blocks, &target_st->st_blocks); 3206 __put_user(host_st->st_atime, &target_st->target_st_atime); 3207 __put_user(host_st->st_mtime, &target_st->target_st_mtime); 3208 __put_user(host_st->st_ctime, &target_st->target_st_ctime); 3209 unlock_user_struct(target_st, target_addr, 1); 3210 } else 3211 #endif 3212 { 3213 struct target_stat64 *target_st; 3214 3215 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0)) 3216 return -TARGET_EFAULT; 3217 memset(target_st, 0, sizeof(struct target_stat64)); 3218 __put_user(host_st->st_dev, &target_st->st_dev); 3219 __put_user(host_st->st_ino, &target_st->st_ino); 3220 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO 3221 __put_user(host_st->st_ino, &target_st->__st_ino); 3222 #endif 3223 __put_user(host_st->st_mode, &target_st->st_mode); 3224 __put_user(host_st->st_nlink, &target_st->st_nlink); 3225 __put_user(host_st->st_uid, &target_st->st_uid); 3226 __put_user(host_st->st_gid, &target_st->st_gid); 3227 __put_user(host_st->st_rdev, &target_st->st_rdev); 3228 /* XXX: better use of kernel struct */ 3229 __put_user(host_st->st_size, &target_st->st_size); 3230 __put_user(host_st->st_blksize, &target_st->st_blksize); 3231 __put_user(host_st->st_blocks, &target_st->st_blocks); 3232 __put_user(host_st->st_atime, &target_st->target_st_atime); 3233 __put_user(host_st->st_mtime, &target_st->target_st_mtime); 3234 __put_user(host_st->st_ctime, &target_st->target_st_ctime); 3235 unlock_user_struct(target_st, target_addr, 1); 3236 } 3237 3238 return 0; 3239 } 3240 #endif 3241 3242 #if defined(USE_NPTL) 3243 /* ??? Using host futex calls even when target atomic operations 3244 are not really atomic probably breaks things. However implementing 3245 futexes locally would make futexes shared between multiple processes 3246 tricky. However they're probably useless because guest atomic 3247 operations won't work either. */ 3248 static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout, 3249 target_ulong uaddr2, int val3) 3250 { 3251 struct timespec ts, *pts; 3252 3253 /* ??? We assume FUTEX_* constants are the same on both host 3254 and target. */ 3255 switch (op) { 3256 case FUTEX_WAIT: 3257 if (timeout) { 3258 pts = &ts; 3259 target_to_host_timespec(pts, timeout); 3260 } else { 3261 pts = NULL; 3262 } 3263 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAIT, tswap32(val), 3264 pts, NULL, 0)); 3265 case FUTEX_WAKE: 3266 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAKE, val, NULL, NULL, 0)); 3267 case FUTEX_FD: 3268 return get_errno(sys_futex(g2h(uaddr), FUTEX_FD, val, NULL, NULL, 0)); 3269 case FUTEX_REQUEUE: 3270 return get_errno(sys_futex(g2h(uaddr), FUTEX_REQUEUE, val, 3271 NULL, g2h(uaddr2), 0)); 3272 case FUTEX_CMP_REQUEUE: 3273 return get_errno(sys_futex(g2h(uaddr), FUTEX_CMP_REQUEUE, val, 3274 NULL, g2h(uaddr2), tswap32(val3))); 3275 default: 3276 return -TARGET_ENOSYS; 3277 } 3278 } 3279 #endif 3280 3281 int get_osversion(void) 3282 { 3283 static int osversion; 3284 struct new_utsname buf; 3285 const char *s; 3286 int i, n, tmp; 3287 if (osversion) 3288 return osversion; 3289 if (qemu_uname_release && *qemu_uname_release) { 3290 s = qemu_uname_release; 3291 } else { 3292 if (sys_uname(&buf)) 3293 return 0; 3294 s = buf.release; 3295 } 3296 tmp = 0; 3297 for (i = 0; i < 3; i++) { 3298 n = 0; 3299 while (*s >= '0' && *s <= '9') { 3300 n *= 10; 3301 n += *s - '0'; 3302 s++; 3303 } 3304 tmp = (tmp << 8) + n; 3305 if (*s == '.') 3306 s++; 3307 } 3308 osversion = tmp; 3309 return osversion; 3310 } 3311 3312 /* do_syscall() should always have a single exit point at the end so 3313 that actions, such as logging of syscall results, can be performed. 3314 All errnos that do_syscall() returns must be -TARGET_<errcode>. */ 3315 abi_long do_syscall(void *cpu_env, int num, abi_long arg1, 3316 abi_long arg2, abi_long arg3, abi_long arg4, 3317 abi_long arg5, abi_long arg6) 3318 { 3319 abi_long ret; 3320 struct stat st; 3321 struct statfs stfs; 3322 void *p; 3323 3324 #ifdef DEBUG 3325 gemu_log("syscall %d", num); 3326 #endif 3327 if(do_strace) 3328 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6); 3329 3330 switch(num) { 3331 case TARGET_NR_exit: 3332 #ifdef HAVE_GPROF 3333 _mcleanup(); 3334 #endif 3335 gdb_exit(cpu_env, arg1); 3336 /* XXX: should free thread stack and CPU env */ 3337 _exit(arg1); 3338 ret = 0; /* avoid warning */ 3339 break; 3340 case TARGET_NR_read: 3341 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0))) 3342 goto efault; 3343 ret = get_errno(read(arg1, p, arg3)); 3344 unlock_user(p, arg2, ret); 3345 break; 3346 case TARGET_NR_write: 3347 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1))) 3348 goto efault; 3349 ret = get_errno(write(arg1, p, arg3)); 3350 unlock_user(p, arg2, 0); 3351 break; 3352 case TARGET_NR_open: 3353 if (!(p = lock_user_string(arg1))) 3354 goto efault; 3355 ret = get_errno(open(path(p), 3356 target_to_host_bitmask(arg2, fcntl_flags_tbl), 3357 arg3)); 3358 unlock_user(p, arg1, 0); 3359 break; 3360 #if defined(TARGET_NR_openat) && defined(__NR_openat) 3361 case TARGET_NR_openat: 3362 if (!(p = lock_user_string(arg2))) 3363 goto efault; 3364 ret = get_errno(sys_openat(arg1, 3365 path(p), 3366 target_to_host_bitmask(arg3, fcntl_flags_tbl), 3367 arg4)); 3368 unlock_user(p, arg2, 0); 3369 break; 3370 #endif 3371 case TARGET_NR_close: 3372 ret = get_errno(close(arg1)); 3373 break; 3374 case TARGET_NR_brk: 3375 ret = do_brk(arg1); 3376 break; 3377 case TARGET_NR_fork: 3378 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0)); 3379 break; 3380 #ifdef TARGET_NR_waitpid 3381 case TARGET_NR_waitpid: 3382 { 3383 int status; 3384 ret = get_errno(waitpid(arg1, &status, arg3)); 3385 if (!is_error(ret) && arg2 3386 && put_user_s32(status, arg2)) 3387 goto efault; 3388 } 3389 break; 3390 #endif 3391 #ifdef TARGET_NR_waitid 3392 case TARGET_NR_waitid: 3393 { 3394 siginfo_t info; 3395 info.si_pid = 0; 3396 ret = get_errno(waitid(arg1, arg2, &info, arg4)); 3397 if (!is_error(ret) && arg3 && info.si_pid != 0) { 3398 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0))) 3399 goto efault; 3400 host_to_target_siginfo(p, &info); 3401 unlock_user(p, arg3, sizeof(target_siginfo_t)); 3402 } 3403 } 3404 break; 3405 #endif 3406 #ifdef TARGET_NR_creat /* not on alpha */ 3407 case TARGET_NR_creat: 3408 if (!(p = lock_user_string(arg1))) 3409 goto efault; 3410 ret = get_errno(creat(p, arg2)); 3411 unlock_user(p, arg1, 0); 3412 break; 3413 #endif 3414 case TARGET_NR_link: 3415 { 3416 void * p2; 3417 p = lock_user_string(arg1); 3418 p2 = lock_user_string(arg2); 3419 if (!p || !p2) 3420 ret = -TARGET_EFAULT; 3421 else 3422 ret = get_errno(link(p, p2)); 3423 unlock_user(p2, arg2, 0); 3424 unlock_user(p, arg1, 0); 3425 } 3426 break; 3427 #if defined(TARGET_NR_linkat) && defined(__NR_linkat) 3428 case TARGET_NR_linkat: 3429 { 3430 void * p2 = NULL; 3431 if (!arg2 || !arg4) 3432 goto efault; 3433 p = lock_user_string(arg2); 3434 p2 = lock_user_string(arg4); 3435 if (!p || !p2) 3436 ret = -TARGET_EFAULT; 3437 else 3438 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5)); 3439 unlock_user(p, arg2, 0); 3440 unlock_user(p2, arg4, 0); 3441 } 3442 break; 3443 #endif 3444 case TARGET_NR_unlink: 3445 if (!(p = lock_user_string(arg1))) 3446 goto efault; 3447 ret = get_errno(unlink(p)); 3448 unlock_user(p, arg1, 0); 3449 break; 3450 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat) 3451 case TARGET_NR_unlinkat: 3452 if (!(p = lock_user_string(arg2))) 3453 goto efault; 3454 ret = get_errno(sys_unlinkat(arg1, p, arg3)); 3455 unlock_user(p, arg2, 0); 3456 break; 3457 #endif 3458 case TARGET_NR_execve: 3459 { 3460 char **argp, **envp; 3461 int argc, envc; 3462 abi_ulong gp; 3463 abi_ulong guest_argp; 3464 abi_ulong guest_envp; 3465 abi_ulong addr; 3466 char **q; 3467 3468 argc = 0; 3469 guest_argp = arg2; 3470 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) { 3471 if (get_user_ual(addr, gp)) 3472 goto efault; 3473 if (!addr) 3474 break; 3475 argc++; 3476 } 3477 envc = 0; 3478 guest_envp = arg3; 3479 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) { 3480 if (get_user_ual(addr, gp)) 3481 goto efault; 3482 if (!addr) 3483 break; 3484 envc++; 3485 } 3486 3487 argp = alloca((argc + 1) * sizeof(void *)); 3488 envp = alloca((envc + 1) * sizeof(void *)); 3489 3490 for (gp = guest_argp, q = argp; gp; 3491 gp += sizeof(abi_ulong), q++) { 3492 if (get_user_ual(addr, gp)) 3493 goto execve_efault; 3494 if (!addr) 3495 break; 3496 if (!(*q = lock_user_string(addr))) 3497 goto execve_efault; 3498 } 3499 *q = NULL; 3500 3501 for (gp = guest_envp, q = envp; gp; 3502 gp += sizeof(abi_ulong), q++) { 3503 if (get_user_ual(addr, gp)) 3504 goto execve_efault; 3505 if (!addr) 3506 break; 3507 if (!(*q = lock_user_string(addr))) 3508 goto execve_efault; 3509 } 3510 *q = NULL; 3511 3512 if (!(p = lock_user_string(arg1))) 3513 goto execve_efault; 3514 ret = get_errno(execve(p, argp, envp)); 3515 unlock_user(p, arg1, 0); 3516 3517 goto execve_end; 3518 3519 execve_efault: 3520 ret = -TARGET_EFAULT; 3521 3522 execve_end: 3523 for (gp = guest_argp, q = argp; *q; 3524 gp += sizeof(abi_ulong), q++) { 3525 if (get_user_ual(addr, gp) 3526 || !addr) 3527 break; 3528 unlock_user(*q, addr, 0); 3529 } 3530 for (gp = guest_envp, q = envp; *q; 3531 gp += sizeof(abi_ulong), q++) { 3532 if (get_user_ual(addr, gp) 3533 || !addr) 3534 break; 3535 unlock_user(*q, addr, 0); 3536 } 3537 } 3538 break; 3539 case TARGET_NR_chdir: 3540 if (!(p = lock_user_string(arg1))) 3541 goto efault; 3542 ret = get_errno(chdir(p)); 3543 unlock_user(p, arg1, 0); 3544 break; 3545 #ifdef TARGET_NR_time 3546 case TARGET_NR_time: 3547 { 3548 time_t host_time; 3549 ret = get_errno(time(&host_time)); 3550 if (!is_error(ret) 3551 && arg1 3552 && put_user_sal(host_time, arg1)) 3553 goto efault; 3554 } 3555 break; 3556 #endif 3557 case TARGET_NR_mknod: 3558 if (!(p = lock_user_string(arg1))) 3559 goto efault; 3560 ret = get_errno(mknod(p, arg2, arg3)); 3561 unlock_user(p, arg1, 0); 3562 break; 3563 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat) 3564 case TARGET_NR_mknodat: 3565 if (!(p = lock_user_string(arg2))) 3566 goto efault; 3567 ret = get_errno(sys_mknodat(arg1, p, arg3, arg4)); 3568 unlock_user(p, arg2, 0); 3569 break; 3570 #endif 3571 case TARGET_NR_chmod: 3572 if (!(p = lock_user_string(arg1))) 3573 goto efault; 3574 ret = get_errno(chmod(p, arg2)); 3575 unlock_user(p, arg1, 0); 3576 break; 3577 #ifdef TARGET_NR_break 3578 case TARGET_NR_break: 3579 goto unimplemented; 3580 #endif 3581 #ifdef TARGET_NR_oldstat 3582 case TARGET_NR_oldstat: 3583 goto unimplemented; 3584 #endif 3585 case TARGET_NR_lseek: 3586 ret = get_errno(lseek(arg1, arg2, arg3)); 3587 break; 3588 #ifdef TARGET_NR_getxpid 3589 case TARGET_NR_getxpid: 3590 #else 3591 case TARGET_NR_getpid: 3592 #endif 3593 ret = get_errno(getpid()); 3594 break; 3595 case TARGET_NR_mount: 3596 { 3597 /* need to look at the data field */ 3598 void *p2, *p3; 3599 p = lock_user_string(arg1); 3600 p2 = lock_user_string(arg2); 3601 p3 = lock_user_string(arg3); 3602 if (!p || !p2 || !p3) 3603 ret = -TARGET_EFAULT; 3604 else 3605 /* FIXME - arg5 should be locked, but it isn't clear how to 3606 * do that since it's not guaranteed to be a NULL-terminated 3607 * string. 3608 */ 3609 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5))); 3610 unlock_user(p, arg1, 0); 3611 unlock_user(p2, arg2, 0); 3612 unlock_user(p3, arg3, 0); 3613 break; 3614 } 3615 #ifdef TARGET_NR_umount 3616 case TARGET_NR_umount: 3617 if (!(p = lock_user_string(arg1))) 3618 goto efault; 3619 ret = get_errno(umount(p)); 3620 unlock_user(p, arg1, 0); 3621 break; 3622 #endif 3623 #ifdef TARGET_NR_stime /* not on alpha */ 3624 case TARGET_NR_stime: 3625 { 3626 time_t host_time; 3627 if (get_user_sal(host_time, arg1)) 3628 goto efault; 3629 ret = get_errno(stime(&host_time)); 3630 } 3631 break; 3632 #endif 3633 case TARGET_NR_ptrace: 3634 goto unimplemented; 3635 #ifdef TARGET_NR_alarm /* not on alpha */ 3636 case TARGET_NR_alarm: 3637 ret = alarm(arg1); 3638 break; 3639 #endif 3640 #ifdef TARGET_NR_oldfstat 3641 case TARGET_NR_oldfstat: 3642 goto unimplemented; 3643 #endif 3644 #ifdef TARGET_NR_pause /* not on alpha */ 3645 case TARGET_NR_pause: 3646 ret = get_errno(pause()); 3647 break; 3648 #endif 3649 #ifdef TARGET_NR_utime 3650 case TARGET_NR_utime: 3651 { 3652 struct utimbuf tbuf, *host_tbuf; 3653 struct target_utimbuf *target_tbuf; 3654 if (arg2) { 3655 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1)) 3656 goto efault; 3657 tbuf.actime = tswapl(target_tbuf->actime); 3658 tbuf.modtime = tswapl(target_tbuf->modtime); 3659 unlock_user_struct(target_tbuf, arg2, 0); 3660 host_tbuf = &tbuf; 3661 } else { 3662 host_tbuf = NULL; 3663 } 3664 if (!(p = lock_user_string(arg1))) 3665 goto efault; 3666 ret = get_errno(utime(p, host_tbuf)); 3667 unlock_user(p, arg1, 0); 3668 } 3669 break; 3670 #endif 3671 case TARGET_NR_utimes: 3672 { 3673 struct timeval *tvp, tv[2]; 3674 if (arg2) { 3675 if (copy_from_user_timeval(&tv[0], arg2) 3676 || copy_from_user_timeval(&tv[1], 3677 arg2 + sizeof(struct target_timeval))) 3678 goto efault; 3679 tvp = tv; 3680 } else { 3681 tvp = NULL; 3682 } 3683 if (!(p = lock_user_string(arg1))) 3684 goto efault; 3685 ret = get_errno(utimes(p, tvp)); 3686 unlock_user(p, arg1, 0); 3687 } 3688 break; 3689 #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat) 3690 case TARGET_NR_futimesat: 3691 { 3692 struct timeval *tvp, tv[2]; 3693 if (arg3) { 3694 if (copy_from_user_timeval(&tv[0], arg3) 3695 || copy_from_user_timeval(&tv[1], 3696 arg3 + sizeof(struct target_timeval))) 3697 goto efault; 3698 tvp = tv; 3699 } else { 3700 tvp = NULL; 3701 } 3702 if (!(p = lock_user_string(arg2))) 3703 goto efault; 3704 ret = get_errno(sys_futimesat(arg1, path(p), tvp)); 3705 unlock_user(p, arg2, 0); 3706 } 3707 break; 3708 #endif 3709 #ifdef TARGET_NR_stty 3710 case TARGET_NR_stty: 3711 goto unimplemented; 3712 #endif 3713 #ifdef TARGET_NR_gtty 3714 case TARGET_NR_gtty: 3715 goto unimplemented; 3716 #endif 3717 case TARGET_NR_access: 3718 if (!(p = lock_user_string(arg1))) 3719 goto efault; 3720 ret = get_errno(access(p, arg2)); 3721 unlock_user(p, arg1, 0); 3722 break; 3723 #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat) 3724 case TARGET_NR_faccessat: 3725 if (!(p = lock_user_string(arg2))) 3726 goto efault; 3727 ret = get_errno(sys_faccessat(arg1, p, arg3, arg4)); 3728 unlock_user(p, arg2, 0); 3729 break; 3730 #endif 3731 #ifdef TARGET_NR_nice /* not on alpha */ 3732 case TARGET_NR_nice: 3733 ret = get_errno(nice(arg1)); 3734 break; 3735 #endif 3736 #ifdef TARGET_NR_ftime 3737 case TARGET_NR_ftime: 3738 goto unimplemented; 3739 #endif 3740 case TARGET_NR_sync: 3741 sync(); 3742 ret = 0; 3743 break; 3744 case TARGET_NR_kill: 3745 ret = get_errno(kill(arg1, target_to_host_signal(arg2))); 3746 break; 3747 case TARGET_NR_rename: 3748 { 3749 void *p2; 3750 p = lock_user_string(arg1); 3751 p2 = lock_user_string(arg2); 3752 if (!p || !p2) 3753 ret = -TARGET_EFAULT; 3754 else 3755 ret = get_errno(rename(p, p2)); 3756 unlock_user(p2, arg2, 0); 3757 unlock_user(p, arg1, 0); 3758 } 3759 break; 3760 #if defined(TARGET_NR_renameat) && defined(__NR_renameat) 3761 case TARGET_NR_renameat: 3762 { 3763 void *p2; 3764 p = lock_user_string(arg2); 3765 p2 = lock_user_string(arg4); 3766 if (!p || !p2) 3767 ret = -TARGET_EFAULT; 3768 else 3769 ret = get_errno(sys_renameat(arg1, p, arg3, p2)); 3770 unlock_user(p2, arg4, 0); 3771 unlock_user(p, arg2, 0); 3772 } 3773 break; 3774 #endif 3775 case TARGET_NR_mkdir: 3776 if (!(p = lock_user_string(arg1))) 3777 goto efault; 3778 ret = get_errno(mkdir(p, arg2)); 3779 unlock_user(p, arg1, 0); 3780 break; 3781 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat) 3782 case TARGET_NR_mkdirat: 3783 if (!(p = lock_user_string(arg2))) 3784 goto efault; 3785 ret = get_errno(sys_mkdirat(arg1, p, arg3)); 3786 unlock_user(p, arg2, 0); 3787 break; 3788 #endif 3789 case TARGET_NR_rmdir: 3790 if (!(p = lock_user_string(arg1))) 3791 goto efault; 3792 ret = get_errno(rmdir(p)); 3793 unlock_user(p, arg1, 0); 3794 break; 3795 case TARGET_NR_dup: 3796 ret = get_errno(dup(arg1)); 3797 break; 3798 case TARGET_NR_pipe: 3799 { 3800 int host_pipe[2]; 3801 ret = get_errno(pipe(host_pipe)); 3802 if (!is_error(ret)) { 3803 #if defined(TARGET_MIPS) 3804 CPUMIPSState *env = (CPUMIPSState*)cpu_env; 3805 env->active_tc.gpr[3] = host_pipe[1]; 3806 ret = host_pipe[0]; 3807 #elif defined(TARGET_SH4) 3808 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1]; 3809 ret = host_pipe[0]; 3810 #else 3811 if (put_user_s32(host_pipe[0], arg1) 3812 || put_user_s32(host_pipe[1], arg1 + sizeof(host_pipe[0]))) 3813 goto efault; 3814 #endif 3815 } 3816 } 3817 break; 3818 case TARGET_NR_times: 3819 { 3820 struct target_tms *tmsp; 3821 struct tms tms; 3822 ret = get_errno(times(&tms)); 3823 if (arg1) { 3824 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0); 3825 if (!tmsp) 3826 goto efault; 3827 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime)); 3828 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime)); 3829 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime)); 3830 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime)); 3831 } 3832 if (!is_error(ret)) 3833 ret = host_to_target_clock_t(ret); 3834 } 3835 break; 3836 #ifdef TARGET_NR_prof 3837 case TARGET_NR_prof: 3838 goto unimplemented; 3839 #endif 3840 #ifdef TARGET_NR_signal 3841 case TARGET_NR_signal: 3842 goto unimplemented; 3843 #endif 3844 case TARGET_NR_acct: 3845 if (!(p = lock_user_string(arg1))) 3846 goto efault; 3847 ret = get_errno(acct(path(p))); 3848 unlock_user(p, arg1, 0); 3849 break; 3850 #ifdef TARGET_NR_umount2 /* not on alpha */ 3851 case TARGET_NR_umount2: 3852 if (!(p = lock_user_string(arg1))) 3853 goto efault; 3854 ret = get_errno(umount2(p, arg2)); 3855 unlock_user(p, arg1, 0); 3856 break; 3857 #endif 3858 #ifdef TARGET_NR_lock 3859 case TARGET_NR_lock: 3860 goto unimplemented; 3861 #endif 3862 case TARGET_NR_ioctl: 3863 ret = do_ioctl(arg1, arg2, arg3); 3864 break; 3865 case TARGET_NR_fcntl: 3866 ret = do_fcntl(arg1, arg2, arg3); 3867 break; 3868 #ifdef TARGET_NR_mpx 3869 case TARGET_NR_mpx: 3870 goto unimplemented; 3871 #endif 3872 case TARGET_NR_setpgid: 3873 ret = get_errno(setpgid(arg1, arg2)); 3874 break; 3875 #ifdef TARGET_NR_ulimit 3876 case TARGET_NR_ulimit: 3877 goto unimplemented; 3878 #endif 3879 #ifdef TARGET_NR_oldolduname 3880 case TARGET_NR_oldolduname: 3881 goto unimplemented; 3882 #endif 3883 case TARGET_NR_umask: 3884 ret = get_errno(umask(arg1)); 3885 break; 3886 case TARGET_NR_chroot: 3887 if (!(p = lock_user_string(arg1))) 3888 goto efault; 3889 ret = get_errno(chroot(p)); 3890 unlock_user(p, arg1, 0); 3891 break; 3892 case TARGET_NR_ustat: 3893 goto unimplemented; 3894 case TARGET_NR_dup2: 3895 ret = get_errno(dup2(arg1, arg2)); 3896 break; 3897 #ifdef TARGET_NR_getppid /* not on alpha */ 3898 case TARGET_NR_getppid: 3899 ret = get_errno(getppid()); 3900 break; 3901 #endif 3902 case TARGET_NR_getpgrp: 3903 ret = get_errno(getpgrp()); 3904 break; 3905 case TARGET_NR_setsid: 3906 ret = get_errno(setsid()); 3907 break; 3908 #ifdef TARGET_NR_sigaction 3909 case TARGET_NR_sigaction: 3910 { 3911 #if !defined(TARGET_MIPS) 3912 struct target_old_sigaction *old_act; 3913 struct target_sigaction act, oact, *pact; 3914 if (arg2) { 3915 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1)) 3916 goto efault; 3917 act._sa_handler = old_act->_sa_handler; 3918 target_siginitset(&act.sa_mask, old_act->sa_mask); 3919 act.sa_flags = old_act->sa_flags; 3920 act.sa_restorer = old_act->sa_restorer; 3921 unlock_user_struct(old_act, arg2, 0); 3922 pact = &act; 3923 } else { 3924 pact = NULL; 3925 } 3926 ret = get_errno(do_sigaction(arg1, pact, &oact)); 3927 if (!is_error(ret) && arg3) { 3928 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0)) 3929 goto efault; 3930 old_act->_sa_handler = oact._sa_handler; 3931 old_act->sa_mask = oact.sa_mask.sig[0]; 3932 old_act->sa_flags = oact.sa_flags; 3933 old_act->sa_restorer = oact.sa_restorer; 3934 unlock_user_struct(old_act, arg3, 1); 3935 } 3936 #else 3937 struct target_sigaction act, oact, *pact, *old_act; 3938 3939 if (arg2) { 3940 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1)) 3941 goto efault; 3942 act._sa_handler = old_act->_sa_handler; 3943 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]); 3944 act.sa_flags = old_act->sa_flags; 3945 unlock_user_struct(old_act, arg2, 0); 3946 pact = &act; 3947 } else { 3948 pact = NULL; 3949 } 3950 3951 ret = get_errno(do_sigaction(arg1, pact, &oact)); 3952 3953 if (!is_error(ret) && arg3) { 3954 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0)) 3955 goto efault; 3956 old_act->_sa_handler = oact._sa_handler; 3957 old_act->sa_flags = oact.sa_flags; 3958 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0]; 3959 old_act->sa_mask.sig[1] = 0; 3960 old_act->sa_mask.sig[2] = 0; 3961 old_act->sa_mask.sig[3] = 0; 3962 unlock_user_struct(old_act, arg3, 1); 3963 } 3964 #endif 3965 } 3966 break; 3967 #endif 3968 case TARGET_NR_rt_sigaction: 3969 { 3970 struct target_sigaction *act; 3971 struct target_sigaction *oact; 3972 3973 if (arg2) { 3974 if (!lock_user_struct(VERIFY_READ, act, arg2, 1)) 3975 goto efault; 3976 } else 3977 act = NULL; 3978 if (arg3) { 3979 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) { 3980 ret = -TARGET_EFAULT; 3981 goto rt_sigaction_fail; 3982 } 3983 } else 3984 oact = NULL; 3985 ret = get_errno(do_sigaction(arg1, act, oact)); 3986 rt_sigaction_fail: 3987 if (act) 3988 unlock_user_struct(act, arg2, 0); 3989 if (oact) 3990 unlock_user_struct(oact, arg3, 1); 3991 } 3992 break; 3993 #ifdef TARGET_NR_sgetmask /* not on alpha */ 3994 case TARGET_NR_sgetmask: 3995 { 3996 sigset_t cur_set; 3997 abi_ulong target_set; 3998 sigprocmask(0, NULL, &cur_set); 3999 host_to_target_old_sigset(&target_set, &cur_set); 4000 ret = target_set; 4001 } 4002 break; 4003 #endif 4004 #ifdef TARGET_NR_ssetmask /* not on alpha */ 4005 case TARGET_NR_ssetmask: 4006 { 4007 sigset_t set, oset, cur_set; 4008 abi_ulong target_set = arg1; 4009 sigprocmask(0, NULL, &cur_set); 4010 target_to_host_old_sigset(&set, &target_set); 4011 sigorset(&set, &set, &cur_set); 4012 sigprocmask(SIG_SETMASK, &set, &oset); 4013 host_to_target_old_sigset(&target_set, &oset); 4014 ret = target_set; 4015 } 4016 break; 4017 #endif 4018 #ifdef TARGET_NR_sigprocmask 4019 case TARGET_NR_sigprocmask: 4020 { 4021 int how = arg1; 4022 sigset_t set, oldset, *set_ptr; 4023 4024 if (arg2) { 4025 switch(how) { 4026 case TARGET_SIG_BLOCK: 4027 how = SIG_BLOCK; 4028 break; 4029 case TARGET_SIG_UNBLOCK: 4030 how = SIG_UNBLOCK; 4031 break; 4032 case TARGET_SIG_SETMASK: 4033 how = SIG_SETMASK; 4034 break; 4035 default: 4036 ret = -TARGET_EINVAL; 4037 goto fail; 4038 } 4039 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1))) 4040 goto efault; 4041 target_to_host_old_sigset(&set, p); 4042 unlock_user(p, arg2, 0); 4043 set_ptr = &set; 4044 } else { 4045 how = 0; 4046 set_ptr = NULL; 4047 } 4048 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset)); 4049 if (!is_error(ret) && arg3) { 4050 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 4051 goto efault; 4052 host_to_target_old_sigset(p, &oldset); 4053 unlock_user(p, arg3, sizeof(target_sigset_t)); 4054 } 4055 } 4056 break; 4057 #endif 4058 case TARGET_NR_rt_sigprocmask: 4059 { 4060 int how = arg1; 4061 sigset_t set, oldset, *set_ptr; 4062 4063 if (arg2) { 4064 switch(how) { 4065 case TARGET_SIG_BLOCK: 4066 how = SIG_BLOCK; 4067 break; 4068 case TARGET_SIG_UNBLOCK: 4069 how = SIG_UNBLOCK; 4070 break; 4071 case TARGET_SIG_SETMASK: 4072 how = SIG_SETMASK; 4073 break; 4074 default: 4075 ret = -TARGET_EINVAL; 4076 goto fail; 4077 } 4078 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1))) 4079 goto efault; 4080 target_to_host_sigset(&set, p); 4081 unlock_user(p, arg2, 0); 4082 set_ptr = &set; 4083 } else { 4084 how = 0; 4085 set_ptr = NULL; 4086 } 4087 ret = get_errno(sigprocmask(how, set_ptr, &oldset)); 4088 if (!is_error(ret) && arg3) { 4089 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0))) 4090 goto efault; 4091 host_to_target_sigset(p, &oldset); 4092 unlock_user(p, arg3, sizeof(target_sigset_t)); 4093 } 4094 } 4095 break; 4096 #ifdef TARGET_NR_sigpending 4097 case TARGET_NR_sigpending: 4098 { 4099 sigset_t set; 4100 ret = get_errno(sigpending(&set)); 4101 if (!is_error(ret)) { 4102 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 4103 goto efault; 4104 host_to_target_old_sigset(p, &set); 4105 unlock_user(p, arg1, sizeof(target_sigset_t)); 4106 } 4107 } 4108 break; 4109 #endif 4110 case TARGET_NR_rt_sigpending: 4111 { 4112 sigset_t set; 4113 ret = get_errno(sigpending(&set)); 4114 if (!is_error(ret)) { 4115 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0))) 4116 goto efault; 4117 host_to_target_sigset(p, &set); 4118 unlock_user(p, arg1, sizeof(target_sigset_t)); 4119 } 4120 } 4121 break; 4122 #ifdef TARGET_NR_sigsuspend 4123 case TARGET_NR_sigsuspend: 4124 { 4125 sigset_t set; 4126 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 4127 goto efault; 4128 target_to_host_old_sigset(&set, p); 4129 unlock_user(p, arg1, 0); 4130 ret = get_errno(sigsuspend(&set)); 4131 } 4132 break; 4133 #endif 4134 case TARGET_NR_rt_sigsuspend: 4135 { 4136 sigset_t set; 4137 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 4138 goto efault; 4139 target_to_host_sigset(&set, p); 4140 unlock_user(p, arg1, 0); 4141 ret = get_errno(sigsuspend(&set)); 4142 } 4143 break; 4144 case TARGET_NR_rt_sigtimedwait: 4145 { 4146 sigset_t set; 4147 struct timespec uts, *puts; 4148 siginfo_t uinfo; 4149 4150 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1))) 4151 goto efault; 4152 target_to_host_sigset(&set, p); 4153 unlock_user(p, arg1, 0); 4154 if (arg3) { 4155 puts = &uts; 4156 target_to_host_timespec(puts, arg3); 4157 } else { 4158 puts = NULL; 4159 } 4160 ret = get_errno(sigtimedwait(&set, &uinfo, puts)); 4161 if (!is_error(ret) && arg2) { 4162 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0))) 4163 goto efault; 4164 host_to_target_siginfo(p, &uinfo); 4165 unlock_user(p, arg2, sizeof(target_siginfo_t)); 4166 } 4167 } 4168 break; 4169 case TARGET_NR_rt_sigqueueinfo: 4170 { 4171 siginfo_t uinfo; 4172 if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1))) 4173 goto efault; 4174 target_to_host_siginfo(&uinfo, p); 4175 unlock_user(p, arg1, 0); 4176 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo)); 4177 } 4178 break; 4179 #ifdef TARGET_NR_sigreturn 4180 case TARGET_NR_sigreturn: 4181 /* NOTE: ret is eax, so not transcoding must be done */ 4182 ret = do_sigreturn(cpu_env); 4183 break; 4184 #endif 4185 case TARGET_NR_rt_sigreturn: 4186 /* NOTE: ret is eax, so not transcoding must be done */ 4187 ret = do_rt_sigreturn(cpu_env); 4188 break; 4189 case TARGET_NR_sethostname: 4190 if (!(p = lock_user_string(arg1))) 4191 goto efault; 4192 ret = get_errno(sethostname(p, arg2)); 4193 unlock_user(p, arg1, 0); 4194 break; 4195 case TARGET_NR_setrlimit: 4196 { 4197 /* XXX: convert resource ? */ 4198 int resource = arg1; 4199 struct target_rlimit *target_rlim; 4200 struct rlimit rlim; 4201 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) 4202 goto efault; 4203 rlim.rlim_cur = tswapl(target_rlim->rlim_cur); 4204 rlim.rlim_max = tswapl(target_rlim->rlim_max); 4205 unlock_user_struct(target_rlim, arg2, 0); 4206 ret = get_errno(setrlimit(resource, &rlim)); 4207 } 4208 break; 4209 case TARGET_NR_getrlimit: 4210 { 4211 /* XXX: convert resource ? */ 4212 int resource = arg1; 4213 struct target_rlimit *target_rlim; 4214 struct rlimit rlim; 4215 4216 ret = get_errno(getrlimit(resource, &rlim)); 4217 if (!is_error(ret)) { 4218 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 4219 goto efault; 4220 rlim.rlim_cur = tswapl(target_rlim->rlim_cur); 4221 rlim.rlim_max = tswapl(target_rlim->rlim_max); 4222 unlock_user_struct(target_rlim, arg2, 1); 4223 } 4224 } 4225 break; 4226 case TARGET_NR_getrusage: 4227 { 4228 struct rusage rusage; 4229 ret = get_errno(getrusage(arg1, &rusage)); 4230 if (!is_error(ret)) { 4231 host_to_target_rusage(arg2, &rusage); 4232 } 4233 } 4234 break; 4235 case TARGET_NR_gettimeofday: 4236 { 4237 struct timeval tv; 4238 ret = get_errno(gettimeofday(&tv, NULL)); 4239 if (!is_error(ret)) { 4240 if (copy_to_user_timeval(arg1, &tv)) 4241 goto efault; 4242 } 4243 } 4244 break; 4245 case TARGET_NR_settimeofday: 4246 { 4247 struct timeval tv; 4248 if (copy_from_user_timeval(&tv, arg1)) 4249 goto efault; 4250 ret = get_errno(settimeofday(&tv, NULL)); 4251 } 4252 break; 4253 #ifdef TARGET_NR_select 4254 case TARGET_NR_select: 4255 { 4256 struct target_sel_arg_struct *sel; 4257 abi_ulong inp, outp, exp, tvp; 4258 long nsel; 4259 4260 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1)) 4261 goto efault; 4262 nsel = tswapl(sel->n); 4263 inp = tswapl(sel->inp); 4264 outp = tswapl(sel->outp); 4265 exp = tswapl(sel->exp); 4266 tvp = tswapl(sel->tvp); 4267 unlock_user_struct(sel, arg1, 0); 4268 ret = do_select(nsel, inp, outp, exp, tvp); 4269 } 4270 break; 4271 #endif 4272 case TARGET_NR_symlink: 4273 { 4274 void *p2; 4275 p = lock_user_string(arg1); 4276 p2 = lock_user_string(arg2); 4277 if (!p || !p2) 4278 ret = -TARGET_EFAULT; 4279 else 4280 ret = get_errno(symlink(p, p2)); 4281 unlock_user(p2, arg2, 0); 4282 unlock_user(p, arg1, 0); 4283 } 4284 break; 4285 #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat) 4286 case TARGET_NR_symlinkat: 4287 { 4288 void *p2; 4289 p = lock_user_string(arg1); 4290 p2 = lock_user_string(arg3); 4291 if (!p || !p2) 4292 ret = -TARGET_EFAULT; 4293 else 4294 ret = get_errno(sys_symlinkat(p, arg2, p2)); 4295 unlock_user(p2, arg3, 0); 4296 unlock_user(p, arg1, 0); 4297 } 4298 break; 4299 #endif 4300 #ifdef TARGET_NR_oldlstat 4301 case TARGET_NR_oldlstat: 4302 goto unimplemented; 4303 #endif 4304 case TARGET_NR_readlink: 4305 { 4306 void *p2; 4307 p = lock_user_string(arg1); 4308 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0); 4309 if (!p || !p2) 4310 ret = -TARGET_EFAULT; 4311 else 4312 ret = get_errno(readlink(path(p), p2, arg3)); 4313 unlock_user(p2, arg2, ret); 4314 unlock_user(p, arg1, 0); 4315 } 4316 break; 4317 #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat) 4318 case TARGET_NR_readlinkat: 4319 { 4320 void *p2; 4321 p = lock_user_string(arg2); 4322 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0); 4323 if (!p || !p2) 4324 ret = -TARGET_EFAULT; 4325 else 4326 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4)); 4327 unlock_user(p2, arg3, ret); 4328 unlock_user(p, arg2, 0); 4329 } 4330 break; 4331 #endif 4332 #ifdef TARGET_NR_uselib 4333 case TARGET_NR_uselib: 4334 goto unimplemented; 4335 #endif 4336 #ifdef TARGET_NR_swapon 4337 case TARGET_NR_swapon: 4338 if (!(p = lock_user_string(arg1))) 4339 goto efault; 4340 ret = get_errno(swapon(p, arg2)); 4341 unlock_user(p, arg1, 0); 4342 break; 4343 #endif 4344 case TARGET_NR_reboot: 4345 goto unimplemented; 4346 #ifdef TARGET_NR_readdir 4347 case TARGET_NR_readdir: 4348 goto unimplemented; 4349 #endif 4350 #ifdef TARGET_NR_mmap 4351 case TARGET_NR_mmap: 4352 #if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS) 4353 { 4354 abi_ulong *v; 4355 abi_ulong v1, v2, v3, v4, v5, v6; 4356 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1))) 4357 goto efault; 4358 v1 = tswapl(v[0]); 4359 v2 = tswapl(v[1]); 4360 v3 = tswapl(v[2]); 4361 v4 = tswapl(v[3]); 4362 v5 = tswapl(v[4]); 4363 v6 = tswapl(v[5]); 4364 unlock_user(v, arg1, 0); 4365 ret = get_errno(target_mmap(v1, v2, v3, 4366 target_to_host_bitmask(v4, mmap_flags_tbl), 4367 v5, v6)); 4368 } 4369 #else 4370 ret = get_errno(target_mmap(arg1, arg2, arg3, 4371 target_to_host_bitmask(arg4, mmap_flags_tbl), 4372 arg5, 4373 arg6)); 4374 #endif 4375 break; 4376 #endif 4377 #ifdef TARGET_NR_mmap2 4378 case TARGET_NR_mmap2: 4379 #ifndef MMAP_SHIFT 4380 #define MMAP_SHIFT 12 4381 #endif 4382 ret = get_errno(target_mmap(arg1, arg2, arg3, 4383 target_to_host_bitmask(arg4, mmap_flags_tbl), 4384 arg5, 4385 arg6 << MMAP_SHIFT)); 4386 break; 4387 #endif 4388 case TARGET_NR_munmap: 4389 ret = get_errno(target_munmap(arg1, arg2)); 4390 break; 4391 case TARGET_NR_mprotect: 4392 ret = get_errno(target_mprotect(arg1, arg2, arg3)); 4393 break; 4394 #ifdef TARGET_NR_mremap 4395 case TARGET_NR_mremap: 4396 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5)); 4397 break; 4398 #endif 4399 /* ??? msync/mlock/munlock are broken for softmmu. */ 4400 #ifdef TARGET_NR_msync 4401 case TARGET_NR_msync: 4402 ret = get_errno(msync(g2h(arg1), arg2, arg3)); 4403 break; 4404 #endif 4405 #ifdef TARGET_NR_mlock 4406 case TARGET_NR_mlock: 4407 ret = get_errno(mlock(g2h(arg1), arg2)); 4408 break; 4409 #endif 4410 #ifdef TARGET_NR_munlock 4411 case TARGET_NR_munlock: 4412 ret = get_errno(munlock(g2h(arg1), arg2)); 4413 break; 4414 #endif 4415 #ifdef TARGET_NR_mlockall 4416 case TARGET_NR_mlockall: 4417 ret = get_errno(mlockall(arg1)); 4418 break; 4419 #endif 4420 #ifdef TARGET_NR_munlockall 4421 case TARGET_NR_munlockall: 4422 ret = get_errno(munlockall()); 4423 break; 4424 #endif 4425 case TARGET_NR_truncate: 4426 if (!(p = lock_user_string(arg1))) 4427 goto efault; 4428 ret = get_errno(truncate(p, arg2)); 4429 unlock_user(p, arg1, 0); 4430 break; 4431 case TARGET_NR_ftruncate: 4432 ret = get_errno(ftruncate(arg1, arg2)); 4433 break; 4434 case TARGET_NR_fchmod: 4435 ret = get_errno(fchmod(arg1, arg2)); 4436 break; 4437 #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat) 4438 case TARGET_NR_fchmodat: 4439 if (!(p = lock_user_string(arg2))) 4440 goto efault; 4441 ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4)); 4442 unlock_user(p, arg2, 0); 4443 break; 4444 #endif 4445 case TARGET_NR_getpriority: 4446 /* libc does special remapping of the return value of 4447 * sys_getpriority() so it's just easiest to call 4448 * sys_getpriority() directly rather than through libc. */ 4449 ret = sys_getpriority(arg1, arg2); 4450 break; 4451 case TARGET_NR_setpriority: 4452 ret = get_errno(setpriority(arg1, arg2, arg3)); 4453 break; 4454 #ifdef TARGET_NR_profil 4455 case TARGET_NR_profil: 4456 goto unimplemented; 4457 #endif 4458 case TARGET_NR_statfs: 4459 if (!(p = lock_user_string(arg1))) 4460 goto efault; 4461 ret = get_errno(statfs(path(p), &stfs)); 4462 unlock_user(p, arg1, 0); 4463 convert_statfs: 4464 if (!is_error(ret)) { 4465 struct target_statfs *target_stfs; 4466 4467 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0)) 4468 goto efault; 4469 __put_user(stfs.f_type, &target_stfs->f_type); 4470 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 4471 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 4472 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 4473 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 4474 __put_user(stfs.f_files, &target_stfs->f_files); 4475 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 4476 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 4477 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 4478 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 4479 unlock_user_struct(target_stfs, arg2, 1); 4480 } 4481 break; 4482 case TARGET_NR_fstatfs: 4483 ret = get_errno(fstatfs(arg1, &stfs)); 4484 goto convert_statfs; 4485 #ifdef TARGET_NR_statfs64 4486 case TARGET_NR_statfs64: 4487 if (!(p = lock_user_string(arg1))) 4488 goto efault; 4489 ret = get_errno(statfs(path(p), &stfs)); 4490 unlock_user(p, arg1, 0); 4491 convert_statfs64: 4492 if (!is_error(ret)) { 4493 struct target_statfs64 *target_stfs; 4494 4495 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0)) 4496 goto efault; 4497 __put_user(stfs.f_type, &target_stfs->f_type); 4498 __put_user(stfs.f_bsize, &target_stfs->f_bsize); 4499 __put_user(stfs.f_blocks, &target_stfs->f_blocks); 4500 __put_user(stfs.f_bfree, &target_stfs->f_bfree); 4501 __put_user(stfs.f_bavail, &target_stfs->f_bavail); 4502 __put_user(stfs.f_files, &target_stfs->f_files); 4503 __put_user(stfs.f_ffree, &target_stfs->f_ffree); 4504 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]); 4505 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]); 4506 __put_user(stfs.f_namelen, &target_stfs->f_namelen); 4507 unlock_user_struct(target_stfs, arg3, 1); 4508 } 4509 break; 4510 case TARGET_NR_fstatfs64: 4511 ret = get_errno(fstatfs(arg1, &stfs)); 4512 goto convert_statfs64; 4513 #endif 4514 #ifdef TARGET_NR_ioperm 4515 case TARGET_NR_ioperm: 4516 goto unimplemented; 4517 #endif 4518 #ifdef TARGET_NR_socketcall 4519 case TARGET_NR_socketcall: 4520 ret = do_socketcall(arg1, arg2); 4521 break; 4522 #endif 4523 #ifdef TARGET_NR_accept 4524 case TARGET_NR_accept: 4525 ret = do_accept(arg1, arg2, arg3); 4526 break; 4527 #endif 4528 #ifdef TARGET_NR_bind 4529 case TARGET_NR_bind: 4530 ret = do_bind(arg1, arg2, arg3); 4531 break; 4532 #endif 4533 #ifdef TARGET_NR_connect 4534 case TARGET_NR_connect: 4535 ret = do_connect(arg1, arg2, arg3); 4536 break; 4537 #endif 4538 #ifdef TARGET_NR_getpeername 4539 case TARGET_NR_getpeername: 4540 ret = do_getpeername(arg1, arg2, arg3); 4541 break; 4542 #endif 4543 #ifdef TARGET_NR_getsockname 4544 case TARGET_NR_getsockname: 4545 ret = do_getsockname(arg1, arg2, arg3); 4546 break; 4547 #endif 4548 #ifdef TARGET_NR_getsockopt 4549 case TARGET_NR_getsockopt: 4550 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5); 4551 break; 4552 #endif 4553 #ifdef TARGET_NR_listen 4554 case TARGET_NR_listen: 4555 ret = get_errno(listen(arg1, arg2)); 4556 break; 4557 #endif 4558 #ifdef TARGET_NR_recv 4559 case TARGET_NR_recv: 4560 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0); 4561 break; 4562 #endif 4563 #ifdef TARGET_NR_recvfrom 4564 case TARGET_NR_recvfrom: 4565 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); 4566 break; 4567 #endif 4568 #ifdef TARGET_NR_recvmsg 4569 case TARGET_NR_recvmsg: 4570 ret = do_sendrecvmsg(arg1, arg2, arg3, 0); 4571 break; 4572 #endif 4573 #ifdef TARGET_NR_send 4574 case TARGET_NR_send: 4575 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0); 4576 break; 4577 #endif 4578 #ifdef TARGET_NR_sendmsg 4579 case TARGET_NR_sendmsg: 4580 ret = do_sendrecvmsg(arg1, arg2, arg3, 1); 4581 break; 4582 #endif 4583 #ifdef TARGET_NR_sendto 4584 case TARGET_NR_sendto: 4585 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6); 4586 break; 4587 #endif 4588 #ifdef TARGET_NR_shutdown 4589 case TARGET_NR_shutdown: 4590 ret = get_errno(shutdown(arg1, arg2)); 4591 break; 4592 #endif 4593 #ifdef TARGET_NR_socket 4594 case TARGET_NR_socket: 4595 ret = do_socket(arg1, arg2, arg3); 4596 break; 4597 #endif 4598 #ifdef TARGET_NR_socketpair 4599 case TARGET_NR_socketpair: 4600 ret = do_socketpair(arg1, arg2, arg3, arg4); 4601 break; 4602 #endif 4603 #ifdef TARGET_NR_setsockopt 4604 case TARGET_NR_setsockopt: 4605 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5); 4606 break; 4607 #endif 4608 4609 case TARGET_NR_syslog: 4610 if (!(p = lock_user_string(arg2))) 4611 goto efault; 4612 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3)); 4613 unlock_user(p, arg2, 0); 4614 break; 4615 4616 case TARGET_NR_setitimer: 4617 { 4618 struct itimerval value, ovalue, *pvalue; 4619 4620 if (arg2) { 4621 pvalue = &value; 4622 if (copy_from_user_timeval(&pvalue->it_interval, arg2) 4623 || copy_from_user_timeval(&pvalue->it_value, 4624 arg2 + sizeof(struct target_timeval))) 4625 goto efault; 4626 } else { 4627 pvalue = NULL; 4628 } 4629 ret = get_errno(setitimer(arg1, pvalue, &ovalue)); 4630 if (!is_error(ret) && arg3) { 4631 if (copy_to_user_timeval(arg3, 4632 &ovalue.it_interval) 4633 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval), 4634 &ovalue.it_value)) 4635 goto efault; 4636 } 4637 } 4638 break; 4639 case TARGET_NR_getitimer: 4640 { 4641 struct itimerval value; 4642 4643 ret = get_errno(getitimer(arg1, &value)); 4644 if (!is_error(ret) && arg2) { 4645 if (copy_to_user_timeval(arg2, 4646 &value.it_interval) 4647 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval), 4648 &value.it_value)) 4649 goto efault; 4650 } 4651 } 4652 break; 4653 case TARGET_NR_stat: 4654 if (!(p = lock_user_string(arg1))) 4655 goto efault; 4656 ret = get_errno(stat(path(p), &st)); 4657 unlock_user(p, arg1, 0); 4658 goto do_stat; 4659 case TARGET_NR_lstat: 4660 if (!(p = lock_user_string(arg1))) 4661 goto efault; 4662 ret = get_errno(lstat(path(p), &st)); 4663 unlock_user(p, arg1, 0); 4664 goto do_stat; 4665 case TARGET_NR_fstat: 4666 { 4667 ret = get_errno(fstat(arg1, &st)); 4668 do_stat: 4669 if (!is_error(ret)) { 4670 struct target_stat *target_st; 4671 4672 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0)) 4673 goto efault; 4674 __put_user(st.st_dev, &target_st->st_dev); 4675 __put_user(st.st_ino, &target_st->st_ino); 4676 __put_user(st.st_mode, &target_st->st_mode); 4677 __put_user(st.st_uid, &target_st->st_uid); 4678 __put_user(st.st_gid, &target_st->st_gid); 4679 __put_user(st.st_nlink, &target_st->st_nlink); 4680 __put_user(st.st_rdev, &target_st->st_rdev); 4681 __put_user(st.st_size, &target_st->st_size); 4682 __put_user(st.st_blksize, &target_st->st_blksize); 4683 __put_user(st.st_blocks, &target_st->st_blocks); 4684 __put_user(st.st_atime, &target_st->target_st_atime); 4685 __put_user(st.st_mtime, &target_st->target_st_mtime); 4686 __put_user(st.st_ctime, &target_st->target_st_ctime); 4687 unlock_user_struct(target_st, arg2, 1); 4688 } 4689 } 4690 break; 4691 #ifdef TARGET_NR_olduname 4692 case TARGET_NR_olduname: 4693 goto unimplemented; 4694 #endif 4695 #ifdef TARGET_NR_iopl 4696 case TARGET_NR_iopl: 4697 goto unimplemented; 4698 #endif 4699 case TARGET_NR_vhangup: 4700 ret = get_errno(vhangup()); 4701 break; 4702 #ifdef TARGET_NR_idle 4703 case TARGET_NR_idle: 4704 goto unimplemented; 4705 #endif 4706 #ifdef TARGET_NR_syscall 4707 case TARGET_NR_syscall: 4708 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0); 4709 break; 4710 #endif 4711 case TARGET_NR_wait4: 4712 { 4713 int status; 4714 abi_long status_ptr = arg2; 4715 struct rusage rusage, *rusage_ptr; 4716 abi_ulong target_rusage = arg4; 4717 if (target_rusage) 4718 rusage_ptr = &rusage; 4719 else 4720 rusage_ptr = NULL; 4721 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr)); 4722 if (!is_error(ret)) { 4723 if (status_ptr) { 4724 if (put_user_s32(status, status_ptr)) 4725 goto efault; 4726 } 4727 if (target_rusage) 4728 host_to_target_rusage(target_rusage, &rusage); 4729 } 4730 } 4731 break; 4732 #ifdef TARGET_NR_swapoff 4733 case TARGET_NR_swapoff: 4734 if (!(p = lock_user_string(arg1))) 4735 goto efault; 4736 ret = get_errno(swapoff(p)); 4737 unlock_user(p, arg1, 0); 4738 break; 4739 #endif 4740 case TARGET_NR_sysinfo: 4741 { 4742 struct target_sysinfo *target_value; 4743 struct sysinfo value; 4744 ret = get_errno(sysinfo(&value)); 4745 if (!is_error(ret) && arg1) 4746 { 4747 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0)) 4748 goto efault; 4749 __put_user(value.uptime, &target_value->uptime); 4750 __put_user(value.loads[0], &target_value->loads[0]); 4751 __put_user(value.loads[1], &target_value->loads[1]); 4752 __put_user(value.loads[2], &target_value->loads[2]); 4753 __put_user(value.totalram, &target_value->totalram); 4754 __put_user(value.freeram, &target_value->freeram); 4755 __put_user(value.sharedram, &target_value->sharedram); 4756 __put_user(value.bufferram, &target_value->bufferram); 4757 __put_user(value.totalswap, &target_value->totalswap); 4758 __put_user(value.freeswap, &target_value->freeswap); 4759 __put_user(value.procs, &target_value->procs); 4760 __put_user(value.totalhigh, &target_value->totalhigh); 4761 __put_user(value.freehigh, &target_value->freehigh); 4762 __put_user(value.mem_unit, &target_value->mem_unit); 4763 unlock_user_struct(target_value, arg1, 1); 4764 } 4765 } 4766 break; 4767 #ifdef TARGET_NR_ipc 4768 case TARGET_NR_ipc: 4769 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6); 4770 break; 4771 #endif 4772 case TARGET_NR_fsync: 4773 ret = get_errno(fsync(arg1)); 4774 break; 4775 case TARGET_NR_clone: 4776 #if defined(TARGET_SH4) 4777 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4)); 4778 #else 4779 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5)); 4780 #endif 4781 break; 4782 #ifdef __NR_exit_group 4783 /* new thread calls */ 4784 case TARGET_NR_exit_group: 4785 gdb_exit(cpu_env, arg1); 4786 ret = get_errno(exit_group(arg1)); 4787 break; 4788 #endif 4789 case TARGET_NR_setdomainname: 4790 if (!(p = lock_user_string(arg1))) 4791 goto efault; 4792 ret = get_errno(setdomainname(p, arg2)); 4793 unlock_user(p, arg1, 0); 4794 break; 4795 case TARGET_NR_uname: 4796 /* no need to transcode because we use the linux syscall */ 4797 { 4798 struct new_utsname * buf; 4799 4800 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0)) 4801 goto efault; 4802 ret = get_errno(sys_uname(buf)); 4803 if (!is_error(ret)) { 4804 /* Overrite the native machine name with whatever is being 4805 emulated. */ 4806 strcpy (buf->machine, UNAME_MACHINE); 4807 /* Allow the user to override the reported release. */ 4808 if (qemu_uname_release && *qemu_uname_release) 4809 strcpy (buf->release, qemu_uname_release); 4810 } 4811 unlock_user_struct(buf, arg1, 1); 4812 } 4813 break; 4814 #ifdef TARGET_I386 4815 case TARGET_NR_modify_ldt: 4816 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3); 4817 break; 4818 #if !defined(TARGET_X86_64) 4819 case TARGET_NR_vm86old: 4820 goto unimplemented; 4821 case TARGET_NR_vm86: 4822 ret = do_vm86(cpu_env, arg1, arg2); 4823 break; 4824 #endif 4825 #endif 4826 case TARGET_NR_adjtimex: 4827 goto unimplemented; 4828 #ifdef TARGET_NR_create_module 4829 case TARGET_NR_create_module: 4830 #endif 4831 case TARGET_NR_init_module: 4832 case TARGET_NR_delete_module: 4833 #ifdef TARGET_NR_get_kernel_syms 4834 case TARGET_NR_get_kernel_syms: 4835 #endif 4836 goto unimplemented; 4837 case TARGET_NR_quotactl: 4838 goto unimplemented; 4839 case TARGET_NR_getpgid: 4840 ret = get_errno(getpgid(arg1)); 4841 break; 4842 case TARGET_NR_fchdir: 4843 ret = get_errno(fchdir(arg1)); 4844 break; 4845 #ifdef TARGET_NR_bdflush /* not on x86_64 */ 4846 case TARGET_NR_bdflush: 4847 goto unimplemented; 4848 #endif 4849 #ifdef TARGET_NR_sysfs 4850 case TARGET_NR_sysfs: 4851 goto unimplemented; 4852 #endif 4853 case TARGET_NR_personality: 4854 ret = get_errno(personality(arg1)); 4855 break; 4856 #ifdef TARGET_NR_afs_syscall 4857 case TARGET_NR_afs_syscall: 4858 goto unimplemented; 4859 #endif 4860 #ifdef TARGET_NR__llseek /* Not on alpha */ 4861 case TARGET_NR__llseek: 4862 { 4863 #if defined (__x86_64__) 4864 ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5)); 4865 if (put_user_s64(ret, arg4)) 4866 goto efault; 4867 #else 4868 int64_t res; 4869 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); 4870 if (put_user_s64(res, arg4)) 4871 goto efault; 4872 #endif 4873 } 4874 break; 4875 #endif 4876 case TARGET_NR_getdents: 4877 #if TARGET_ABI_BITS != 32 4878 goto unimplemented; 4879 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 4880 { 4881 struct target_dirent *target_dirp; 4882 struct dirent *dirp; 4883 abi_long count = arg3; 4884 4885 dirp = malloc(count); 4886 if (!dirp) { 4887 ret = -TARGET_ENOMEM; 4888 goto fail; 4889 } 4890 4891 ret = get_errno(sys_getdents(arg1, dirp, count)); 4892 if (!is_error(ret)) { 4893 struct dirent *de; 4894 struct target_dirent *tde; 4895 int len = ret; 4896 int reclen, treclen; 4897 int count1, tnamelen; 4898 4899 count1 = 0; 4900 de = dirp; 4901 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 4902 goto efault; 4903 tde = target_dirp; 4904 while (len > 0) { 4905 reclen = de->d_reclen; 4906 treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long))); 4907 tde->d_reclen = tswap16(treclen); 4908 tde->d_ino = tswapl(de->d_ino); 4909 tde->d_off = tswapl(de->d_off); 4910 tnamelen = treclen - (2 * sizeof(abi_long) + 2); 4911 if (tnamelen > 256) 4912 tnamelen = 256; 4913 /* XXX: may not be correct */ 4914 strncpy(tde->d_name, de->d_name, tnamelen); 4915 de = (struct dirent *)((char *)de + reclen); 4916 len -= reclen; 4917 tde = (struct target_dirent *)((char *)tde + treclen); 4918 count1 += treclen; 4919 } 4920 ret = count1; 4921 unlock_user(target_dirp, arg2, ret); 4922 } 4923 free(dirp); 4924 } 4925 #else 4926 { 4927 struct dirent *dirp; 4928 abi_long count = arg3; 4929 4930 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 4931 goto efault; 4932 ret = get_errno(sys_getdents(arg1, dirp, count)); 4933 if (!is_error(ret)) { 4934 struct dirent *de; 4935 int len = ret; 4936 int reclen; 4937 de = dirp; 4938 while (len > 0) { 4939 reclen = de->d_reclen; 4940 if (reclen > len) 4941 break; 4942 de->d_reclen = tswap16(reclen); 4943 tswapls(&de->d_ino); 4944 tswapls(&de->d_off); 4945 de = (struct dirent *)((char *)de + reclen); 4946 len -= reclen; 4947 } 4948 } 4949 unlock_user(dirp, arg2, ret); 4950 } 4951 #endif 4952 break; 4953 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) 4954 case TARGET_NR_getdents64: 4955 { 4956 struct dirent64 *dirp; 4957 abi_long count = arg3; 4958 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0))) 4959 goto efault; 4960 ret = get_errno(sys_getdents64(arg1, dirp, count)); 4961 if (!is_error(ret)) { 4962 struct dirent64 *de; 4963 int len = ret; 4964 int reclen; 4965 de = dirp; 4966 while (len > 0) { 4967 reclen = de->d_reclen; 4968 if (reclen > len) 4969 break; 4970 de->d_reclen = tswap16(reclen); 4971 tswap64s((uint64_t *)&de->d_ino); 4972 tswap64s((uint64_t *)&de->d_off); 4973 de = (struct dirent64 *)((char *)de + reclen); 4974 len -= reclen; 4975 } 4976 } 4977 unlock_user(dirp, arg2, ret); 4978 } 4979 break; 4980 #endif /* TARGET_NR_getdents64 */ 4981 #ifdef TARGET_NR__newselect 4982 case TARGET_NR__newselect: 4983 ret = do_select(arg1, arg2, arg3, arg4, arg5); 4984 break; 4985 #endif 4986 #ifdef TARGET_NR_poll 4987 case TARGET_NR_poll: 4988 { 4989 struct target_pollfd *target_pfd; 4990 unsigned int nfds = arg2; 4991 int timeout = arg3; 4992 struct pollfd *pfd; 4993 unsigned int i; 4994 4995 target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1); 4996 if (!target_pfd) 4997 goto efault; 4998 pfd = alloca(sizeof(struct pollfd) * nfds); 4999 for(i = 0; i < nfds; i++) { 5000 pfd[i].fd = tswap32(target_pfd[i].fd); 5001 pfd[i].events = tswap16(target_pfd[i].events); 5002 } 5003 ret = get_errno(poll(pfd, nfds, timeout)); 5004 if (!is_error(ret)) { 5005 for(i = 0; i < nfds; i++) { 5006 target_pfd[i].revents = tswap16(pfd[i].revents); 5007 } 5008 ret += nfds * (sizeof(struct target_pollfd) 5009 - sizeof(struct pollfd)); 5010 } 5011 unlock_user(target_pfd, arg1, ret); 5012 } 5013 break; 5014 #endif 5015 case TARGET_NR_flock: 5016 /* NOTE: the flock constant seems to be the same for every 5017 Linux platform */ 5018 ret = get_errno(flock(arg1, arg2)); 5019 break; 5020 case TARGET_NR_readv: 5021 { 5022 int count = arg3; 5023 struct iovec *vec; 5024 5025 vec = alloca(count * sizeof(struct iovec)); 5026 if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0) 5027 goto efault; 5028 ret = get_errno(readv(arg1, vec, count)); 5029 unlock_iovec(vec, arg2, count, 1); 5030 } 5031 break; 5032 case TARGET_NR_writev: 5033 { 5034 int count = arg3; 5035 struct iovec *vec; 5036 5037 vec = alloca(count * sizeof(struct iovec)); 5038 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0) 5039 goto efault; 5040 ret = get_errno(writev(arg1, vec, count)); 5041 unlock_iovec(vec, arg2, count, 0); 5042 } 5043 break; 5044 case TARGET_NR_getsid: 5045 ret = get_errno(getsid(arg1)); 5046 break; 5047 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */ 5048 case TARGET_NR_fdatasync: 5049 ret = get_errno(fdatasync(arg1)); 5050 break; 5051 #endif 5052 case TARGET_NR__sysctl: 5053 /* We don't implement this, but ENOTDIR is always a safe 5054 return value. */ 5055 ret = -TARGET_ENOTDIR; 5056 break; 5057 case TARGET_NR_sched_setparam: 5058 { 5059 struct sched_param *target_schp; 5060 struct sched_param schp; 5061 5062 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) 5063 goto efault; 5064 schp.sched_priority = tswap32(target_schp->sched_priority); 5065 unlock_user_struct(target_schp, arg2, 0); 5066 ret = get_errno(sched_setparam(arg1, &schp)); 5067 } 5068 break; 5069 case TARGET_NR_sched_getparam: 5070 { 5071 struct sched_param *target_schp; 5072 struct sched_param schp; 5073 ret = get_errno(sched_getparam(arg1, &schp)); 5074 if (!is_error(ret)) { 5075 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) 5076 goto efault; 5077 target_schp->sched_priority = tswap32(schp.sched_priority); 5078 unlock_user_struct(target_schp, arg2, 1); 5079 } 5080 } 5081 break; 5082 case TARGET_NR_sched_setscheduler: 5083 { 5084 struct sched_param *target_schp; 5085 struct sched_param schp; 5086 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) 5087 goto efault; 5088 schp.sched_priority = tswap32(target_schp->sched_priority); 5089 unlock_user_struct(target_schp, arg3, 0); 5090 ret = get_errno(sched_setscheduler(arg1, arg2, &schp)); 5091 } 5092 break; 5093 case TARGET_NR_sched_getscheduler: 5094 ret = get_errno(sched_getscheduler(arg1)); 5095 break; 5096 case TARGET_NR_sched_yield: 5097 ret = get_errno(sched_yield()); 5098 break; 5099 case TARGET_NR_sched_get_priority_max: 5100 ret = get_errno(sched_get_priority_max(arg1)); 5101 break; 5102 case TARGET_NR_sched_get_priority_min: 5103 ret = get_errno(sched_get_priority_min(arg1)); 5104 break; 5105 case TARGET_NR_sched_rr_get_interval: 5106 { 5107 struct timespec ts; 5108 ret = get_errno(sched_rr_get_interval(arg1, &ts)); 5109 if (!is_error(ret)) { 5110 host_to_target_timespec(arg2, &ts); 5111 } 5112 } 5113 break; 5114 case TARGET_NR_nanosleep: 5115 { 5116 struct timespec req, rem; 5117 target_to_host_timespec(&req, arg1); 5118 ret = get_errno(nanosleep(&req, &rem)); 5119 if (is_error(ret) && arg2) { 5120 host_to_target_timespec(arg2, &rem); 5121 } 5122 } 5123 break; 5124 #ifdef TARGET_NR_query_module 5125 case TARGET_NR_query_module: 5126 goto unimplemented; 5127 #endif 5128 #ifdef TARGET_NR_nfsservctl 5129 case TARGET_NR_nfsservctl: 5130 goto unimplemented; 5131 #endif 5132 case TARGET_NR_prctl: 5133 switch (arg1) 5134 { 5135 case PR_GET_PDEATHSIG: 5136 { 5137 int deathsig; 5138 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5)); 5139 if (!is_error(ret) && arg2 5140 && put_user_ual(deathsig, arg2)) 5141 goto efault; 5142 } 5143 break; 5144 default: 5145 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5)); 5146 break; 5147 } 5148 break; 5149 #ifdef TARGET_NR_arch_prctl 5150 case TARGET_NR_arch_prctl: 5151 #if defined(TARGET_I386) && !defined(TARGET_ABI32) 5152 ret = do_arch_prctl(cpu_env, arg1, arg2); 5153 break; 5154 #else 5155 goto unimplemented; 5156 #endif 5157 #endif 5158 #ifdef TARGET_NR_pread 5159 case TARGET_NR_pread: 5160 #ifdef TARGET_ARM 5161 if (((CPUARMState *)cpu_env)->eabi) 5162 arg4 = arg5; 5163 #endif 5164 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0))) 5165 goto efault; 5166 ret = get_errno(pread(arg1, p, arg3, arg4)); 5167 unlock_user(p, arg2, ret); 5168 break; 5169 case TARGET_NR_pwrite: 5170 #ifdef TARGET_ARM 5171 if (((CPUARMState *)cpu_env)->eabi) 5172 arg4 = arg5; 5173 #endif 5174 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1))) 5175 goto efault; 5176 ret = get_errno(pwrite(arg1, p, arg3, arg4)); 5177 unlock_user(p, arg2, 0); 5178 break; 5179 #endif 5180 #ifdef TARGET_NR_pread64 5181 case TARGET_NR_pread64: 5182 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0))) 5183 goto efault; 5184 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5))); 5185 unlock_user(p, arg2, ret); 5186 break; 5187 case TARGET_NR_pwrite64: 5188 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1))) 5189 goto efault; 5190 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5))); 5191 unlock_user(p, arg2, 0); 5192 break; 5193 #endif 5194 case TARGET_NR_getcwd: 5195 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0))) 5196 goto efault; 5197 ret = get_errno(sys_getcwd1(p, arg2)); 5198 unlock_user(p, arg1, ret); 5199 break; 5200 case TARGET_NR_capget: 5201 goto unimplemented; 5202 case TARGET_NR_capset: 5203 goto unimplemented; 5204 case TARGET_NR_sigaltstack: 5205 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \ 5206 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) 5207 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env)); 5208 break; 5209 #else 5210 goto unimplemented; 5211 #endif 5212 case TARGET_NR_sendfile: 5213 goto unimplemented; 5214 #ifdef TARGET_NR_getpmsg 5215 case TARGET_NR_getpmsg: 5216 goto unimplemented; 5217 #endif 5218 #ifdef TARGET_NR_putpmsg 5219 case TARGET_NR_putpmsg: 5220 goto unimplemented; 5221 #endif 5222 #ifdef TARGET_NR_vfork 5223 case TARGET_NR_vfork: 5224 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 5225 0, 0, 0, 0)); 5226 break; 5227 #endif 5228 #ifdef TARGET_NR_ugetrlimit 5229 case TARGET_NR_ugetrlimit: 5230 { 5231 struct rlimit rlim; 5232 ret = get_errno(getrlimit(arg1, &rlim)); 5233 if (!is_error(ret)) { 5234 struct target_rlimit *target_rlim; 5235 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) 5236 goto efault; 5237 target_rlim->rlim_cur = tswapl(rlim.rlim_cur); 5238 target_rlim->rlim_max = tswapl(rlim.rlim_max); 5239 unlock_user_struct(target_rlim, arg2, 1); 5240 } 5241 break; 5242 } 5243 #endif 5244 #ifdef TARGET_NR_truncate64 5245 case TARGET_NR_truncate64: 5246 if (!(p = lock_user_string(arg1))) 5247 goto efault; 5248 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4); 5249 unlock_user(p, arg1, 0); 5250 break; 5251 #endif 5252 #ifdef TARGET_NR_ftruncate64 5253 case TARGET_NR_ftruncate64: 5254 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4); 5255 break; 5256 #endif 5257 #ifdef TARGET_NR_stat64 5258 case TARGET_NR_stat64: 5259 if (!(p = lock_user_string(arg1))) 5260 goto efault; 5261 ret = get_errno(stat(path(p), &st)); 5262 unlock_user(p, arg1, 0); 5263 if (!is_error(ret)) 5264 ret = host_to_target_stat64(cpu_env, arg2, &st); 5265 break; 5266 #endif 5267 #ifdef TARGET_NR_lstat64 5268 case TARGET_NR_lstat64: 5269 if (!(p = lock_user_string(arg1))) 5270 goto efault; 5271 ret = get_errno(lstat(path(p), &st)); 5272 unlock_user(p, arg1, 0); 5273 if (!is_error(ret)) 5274 ret = host_to_target_stat64(cpu_env, arg2, &st); 5275 break; 5276 #endif 5277 #ifdef TARGET_NR_fstat64 5278 case TARGET_NR_fstat64: 5279 ret = get_errno(fstat(arg1, &st)); 5280 if (!is_error(ret)) 5281 ret = host_to_target_stat64(cpu_env, arg2, &st); 5282 break; 5283 #endif 5284 #if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64) 5285 case TARGET_NR_fstatat64: 5286 if (!(p = lock_user_string(arg2))) 5287 goto efault; 5288 ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4)); 5289 if (!is_error(ret)) 5290 ret = host_to_target_stat64(cpu_env, arg3, &st); 5291 break; 5292 #endif 5293 #ifdef USE_UID16 5294 case TARGET_NR_lchown: 5295 if (!(p = lock_user_string(arg1))) 5296 goto efault; 5297 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3))); 5298 unlock_user(p, arg1, 0); 5299 break; 5300 case TARGET_NR_getuid: 5301 ret = get_errno(high2lowuid(getuid())); 5302 break; 5303 case TARGET_NR_getgid: 5304 ret = get_errno(high2lowgid(getgid())); 5305 break; 5306 case TARGET_NR_geteuid: 5307 ret = get_errno(high2lowuid(geteuid())); 5308 break; 5309 case TARGET_NR_getegid: 5310 ret = get_errno(high2lowgid(getegid())); 5311 break; 5312 case TARGET_NR_setreuid: 5313 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2))); 5314 break; 5315 case TARGET_NR_setregid: 5316 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2))); 5317 break; 5318 case TARGET_NR_getgroups: 5319 { 5320 int gidsetsize = arg1; 5321 uint16_t *target_grouplist; 5322 gid_t *grouplist; 5323 int i; 5324 5325 grouplist = alloca(gidsetsize * sizeof(gid_t)); 5326 ret = get_errno(getgroups(gidsetsize, grouplist)); 5327 if (gidsetsize == 0) 5328 break; 5329 if (!is_error(ret)) { 5330 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0); 5331 if (!target_grouplist) 5332 goto efault; 5333 for(i = 0;i < ret; i++) 5334 target_grouplist[i] = tswap16(grouplist[i]); 5335 unlock_user(target_grouplist, arg2, gidsetsize * 2); 5336 } 5337 } 5338 break; 5339 case TARGET_NR_setgroups: 5340 { 5341 int gidsetsize = arg1; 5342 uint16_t *target_grouplist; 5343 gid_t *grouplist; 5344 int i; 5345 5346 grouplist = alloca(gidsetsize * sizeof(gid_t)); 5347 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1); 5348 if (!target_grouplist) { 5349 ret = -TARGET_EFAULT; 5350 goto fail; 5351 } 5352 for(i = 0;i < gidsetsize; i++) 5353 grouplist[i] = tswap16(target_grouplist[i]); 5354 unlock_user(target_grouplist, arg2, 0); 5355 ret = get_errno(setgroups(gidsetsize, grouplist)); 5356 } 5357 break; 5358 case TARGET_NR_fchown: 5359 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3))); 5360 break; 5361 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) 5362 case TARGET_NR_fchownat: 5363 if (!(p = lock_user_string(arg2))) 5364 goto efault; 5365 ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5)); 5366 unlock_user(p, arg2, 0); 5367 break; 5368 #endif 5369 #ifdef TARGET_NR_setresuid 5370 case TARGET_NR_setresuid: 5371 ret = get_errno(setresuid(low2highuid(arg1), 5372 low2highuid(arg2), 5373 low2highuid(arg3))); 5374 break; 5375 #endif 5376 #ifdef TARGET_NR_getresuid 5377 case TARGET_NR_getresuid: 5378 { 5379 uid_t ruid, euid, suid; 5380 ret = get_errno(getresuid(&ruid, &euid, &suid)); 5381 if (!is_error(ret)) { 5382 if (put_user_u16(high2lowuid(ruid), arg1) 5383 || put_user_u16(high2lowuid(euid), arg2) 5384 || put_user_u16(high2lowuid(suid), arg3)) 5385 goto efault; 5386 } 5387 } 5388 break; 5389 #endif 5390 #ifdef TARGET_NR_getresgid 5391 case TARGET_NR_setresgid: 5392 ret = get_errno(setresgid(low2highgid(arg1), 5393 low2highgid(arg2), 5394 low2highgid(arg3))); 5395 break; 5396 #endif 5397 #ifdef TARGET_NR_getresgid 5398 case TARGET_NR_getresgid: 5399 { 5400 gid_t rgid, egid, sgid; 5401 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 5402 if (!is_error(ret)) { 5403 if (put_user_u16(high2lowgid(rgid), arg1) 5404 || put_user_u16(high2lowgid(egid), arg2) 5405 || put_user_u16(high2lowgid(sgid), arg3)) 5406 goto efault; 5407 } 5408 } 5409 break; 5410 #endif 5411 case TARGET_NR_chown: 5412 if (!(p = lock_user_string(arg1))) 5413 goto efault; 5414 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3))); 5415 unlock_user(p, arg1, 0); 5416 break; 5417 case TARGET_NR_setuid: 5418 ret = get_errno(setuid(low2highuid(arg1))); 5419 break; 5420 case TARGET_NR_setgid: 5421 ret = get_errno(setgid(low2highgid(arg1))); 5422 break; 5423 case TARGET_NR_setfsuid: 5424 ret = get_errno(setfsuid(arg1)); 5425 break; 5426 case TARGET_NR_setfsgid: 5427 ret = get_errno(setfsgid(arg1)); 5428 break; 5429 #endif /* USE_UID16 */ 5430 5431 #ifdef TARGET_NR_lchown32 5432 case TARGET_NR_lchown32: 5433 if (!(p = lock_user_string(arg1))) 5434 goto efault; 5435 ret = get_errno(lchown(p, arg2, arg3)); 5436 unlock_user(p, arg1, 0); 5437 break; 5438 #endif 5439 #ifdef TARGET_NR_getuid32 5440 case TARGET_NR_getuid32: 5441 ret = get_errno(getuid()); 5442 break; 5443 #endif 5444 #ifdef TARGET_NR_getgid32 5445 case TARGET_NR_getgid32: 5446 ret = get_errno(getgid()); 5447 break; 5448 #endif 5449 #ifdef TARGET_NR_geteuid32 5450 case TARGET_NR_geteuid32: 5451 ret = get_errno(geteuid()); 5452 break; 5453 #endif 5454 #ifdef TARGET_NR_getegid32 5455 case TARGET_NR_getegid32: 5456 ret = get_errno(getegid()); 5457 break; 5458 #endif 5459 #ifdef TARGET_NR_setreuid32 5460 case TARGET_NR_setreuid32: 5461 ret = get_errno(setreuid(arg1, arg2)); 5462 break; 5463 #endif 5464 #ifdef TARGET_NR_setregid32 5465 case TARGET_NR_setregid32: 5466 ret = get_errno(setregid(arg1, arg2)); 5467 break; 5468 #endif 5469 #ifdef TARGET_NR_getgroups32 5470 case TARGET_NR_getgroups32: 5471 { 5472 int gidsetsize = arg1; 5473 uint32_t *target_grouplist; 5474 gid_t *grouplist; 5475 int i; 5476 5477 grouplist = alloca(gidsetsize * sizeof(gid_t)); 5478 ret = get_errno(getgroups(gidsetsize, grouplist)); 5479 if (gidsetsize == 0) 5480 break; 5481 if (!is_error(ret)) { 5482 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0); 5483 if (!target_grouplist) { 5484 ret = -TARGET_EFAULT; 5485 goto fail; 5486 } 5487 for(i = 0;i < ret; i++) 5488 target_grouplist[i] = tswap32(grouplist[i]); 5489 unlock_user(target_grouplist, arg2, gidsetsize * 4); 5490 } 5491 } 5492 break; 5493 #endif 5494 #ifdef TARGET_NR_setgroups32 5495 case TARGET_NR_setgroups32: 5496 { 5497 int gidsetsize = arg1; 5498 uint32_t *target_grouplist; 5499 gid_t *grouplist; 5500 int i; 5501 5502 grouplist = alloca(gidsetsize * sizeof(gid_t)); 5503 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1); 5504 if (!target_grouplist) { 5505 ret = -TARGET_EFAULT; 5506 goto fail; 5507 } 5508 for(i = 0;i < gidsetsize; i++) 5509 grouplist[i] = tswap32(target_grouplist[i]); 5510 unlock_user(target_grouplist, arg2, 0); 5511 ret = get_errno(setgroups(gidsetsize, grouplist)); 5512 } 5513 break; 5514 #endif 5515 #ifdef TARGET_NR_fchown32 5516 case TARGET_NR_fchown32: 5517 ret = get_errno(fchown(arg1, arg2, arg3)); 5518 break; 5519 #endif 5520 #ifdef TARGET_NR_setresuid32 5521 case TARGET_NR_setresuid32: 5522 ret = get_errno(setresuid(arg1, arg2, arg3)); 5523 break; 5524 #endif 5525 #ifdef TARGET_NR_getresuid32 5526 case TARGET_NR_getresuid32: 5527 { 5528 uid_t ruid, euid, suid; 5529 ret = get_errno(getresuid(&ruid, &euid, &suid)); 5530 if (!is_error(ret)) { 5531 if (put_user_u32(ruid, arg1) 5532 || put_user_u32(euid, arg2) 5533 || put_user_u32(suid, arg3)) 5534 goto efault; 5535 } 5536 } 5537 break; 5538 #endif 5539 #ifdef TARGET_NR_setresgid32 5540 case TARGET_NR_setresgid32: 5541 ret = get_errno(setresgid(arg1, arg2, arg3)); 5542 break; 5543 #endif 5544 #ifdef TARGET_NR_getresgid32 5545 case TARGET_NR_getresgid32: 5546 { 5547 gid_t rgid, egid, sgid; 5548 ret = get_errno(getresgid(&rgid, &egid, &sgid)); 5549 if (!is_error(ret)) { 5550 if (put_user_u32(rgid, arg1) 5551 || put_user_u32(egid, arg2) 5552 || put_user_u32(sgid, arg3)) 5553 goto efault; 5554 } 5555 } 5556 break; 5557 #endif 5558 #ifdef TARGET_NR_chown32 5559 case TARGET_NR_chown32: 5560 if (!(p = lock_user_string(arg1))) 5561 goto efault; 5562 ret = get_errno(chown(p, arg2, arg3)); 5563 unlock_user(p, arg1, 0); 5564 break; 5565 #endif 5566 #ifdef TARGET_NR_setuid32 5567 case TARGET_NR_setuid32: 5568 ret = get_errno(setuid(arg1)); 5569 break; 5570 #endif 5571 #ifdef TARGET_NR_setgid32 5572 case TARGET_NR_setgid32: 5573 ret = get_errno(setgid(arg1)); 5574 break; 5575 #endif 5576 #ifdef TARGET_NR_setfsuid32 5577 case TARGET_NR_setfsuid32: 5578 ret = get_errno(setfsuid(arg1)); 5579 break; 5580 #endif 5581 #ifdef TARGET_NR_setfsgid32 5582 case TARGET_NR_setfsgid32: 5583 ret = get_errno(setfsgid(arg1)); 5584 break; 5585 #endif 5586 5587 case TARGET_NR_pivot_root: 5588 goto unimplemented; 5589 #ifdef TARGET_NR_mincore 5590 case TARGET_NR_mincore: 5591 { 5592 void *a; 5593 ret = -TARGET_EFAULT; 5594 if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0))) 5595 goto efault; 5596 if (!(p = lock_user_string(arg3))) 5597 goto mincore_fail; 5598 ret = get_errno(mincore(a, arg2, p)); 5599 unlock_user(p, arg3, ret); 5600 mincore_fail: 5601 unlock_user(a, arg1, 0); 5602 } 5603 break; 5604 #endif 5605 #ifdef TARGET_NR_arm_fadvise64_64 5606 case TARGET_NR_arm_fadvise64_64: 5607 { 5608 /* 5609 * arm_fadvise64_64 looks like fadvise64_64 but 5610 * with different argument order 5611 */ 5612 abi_long temp; 5613 temp = arg3; 5614 arg3 = arg4; 5615 arg4 = temp; 5616 } 5617 #endif 5618 #if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) 5619 #ifdef TARGET_NR_fadvise64_64 5620 case TARGET_NR_fadvise64_64: 5621 #endif 5622 /* This is a hint, so ignoring and returning success is ok. */ 5623 ret = get_errno(0); 5624 break; 5625 #endif 5626 #ifdef TARGET_NR_madvise 5627 case TARGET_NR_madvise: 5628 /* A straight passthrough may not be safe because qemu sometimes 5629 turns private flie-backed mappings into anonymous mappings. 5630 This will break MADV_DONTNEED. 5631 This is a hint, so ignoring and returning success is ok. */ 5632 ret = get_errno(0); 5633 break; 5634 #endif 5635 #if TARGET_ABI_BITS == 32 5636 case TARGET_NR_fcntl64: 5637 { 5638 int cmd; 5639 struct flock64 fl; 5640 struct target_flock64 *target_fl; 5641 #ifdef TARGET_ARM 5642 struct target_eabi_flock64 *target_efl; 5643 #endif 5644 5645 switch(arg2){ 5646 case TARGET_F_GETLK64: 5647 cmd = F_GETLK64; 5648 break; 5649 case TARGET_F_SETLK64: 5650 cmd = F_SETLK64; 5651 break; 5652 case TARGET_F_SETLKW64: 5653 cmd = F_SETLK64; 5654 break; 5655 default: 5656 cmd = arg2; 5657 break; 5658 } 5659 5660 switch(arg2) { 5661 case TARGET_F_GETLK64: 5662 #ifdef TARGET_ARM 5663 if (((CPUARMState *)cpu_env)->eabi) { 5664 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 5665 goto efault; 5666 fl.l_type = tswap16(target_efl->l_type); 5667 fl.l_whence = tswap16(target_efl->l_whence); 5668 fl.l_start = tswap64(target_efl->l_start); 5669 fl.l_len = tswap64(target_efl->l_len); 5670 fl.l_pid = tswapl(target_efl->l_pid); 5671 unlock_user_struct(target_efl, arg3, 0); 5672 } else 5673 #endif 5674 { 5675 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 5676 goto efault; 5677 fl.l_type = tswap16(target_fl->l_type); 5678 fl.l_whence = tswap16(target_fl->l_whence); 5679 fl.l_start = tswap64(target_fl->l_start); 5680 fl.l_len = tswap64(target_fl->l_len); 5681 fl.l_pid = tswapl(target_fl->l_pid); 5682 unlock_user_struct(target_fl, arg3, 0); 5683 } 5684 ret = get_errno(fcntl(arg1, cmd, &fl)); 5685 if (ret == 0) { 5686 #ifdef TARGET_ARM 5687 if (((CPUARMState *)cpu_env)->eabi) { 5688 if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0)) 5689 goto efault; 5690 target_efl->l_type = tswap16(fl.l_type); 5691 target_efl->l_whence = tswap16(fl.l_whence); 5692 target_efl->l_start = tswap64(fl.l_start); 5693 target_efl->l_len = tswap64(fl.l_len); 5694 target_efl->l_pid = tswapl(fl.l_pid); 5695 unlock_user_struct(target_efl, arg3, 1); 5696 } else 5697 #endif 5698 { 5699 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) 5700 goto efault; 5701 target_fl->l_type = tswap16(fl.l_type); 5702 target_fl->l_whence = tswap16(fl.l_whence); 5703 target_fl->l_start = tswap64(fl.l_start); 5704 target_fl->l_len = tswap64(fl.l_len); 5705 target_fl->l_pid = tswapl(fl.l_pid); 5706 unlock_user_struct(target_fl, arg3, 1); 5707 } 5708 } 5709 break; 5710 5711 case TARGET_F_SETLK64: 5712 case TARGET_F_SETLKW64: 5713 #ifdef TARGET_ARM 5714 if (((CPUARMState *)cpu_env)->eabi) { 5715 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 5716 goto efault; 5717 fl.l_type = tswap16(target_efl->l_type); 5718 fl.l_whence = tswap16(target_efl->l_whence); 5719 fl.l_start = tswap64(target_efl->l_start); 5720 fl.l_len = tswap64(target_efl->l_len); 5721 fl.l_pid = tswapl(target_efl->l_pid); 5722 unlock_user_struct(target_efl, arg3, 0); 5723 } else 5724 #endif 5725 { 5726 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 5727 goto efault; 5728 fl.l_type = tswap16(target_fl->l_type); 5729 fl.l_whence = tswap16(target_fl->l_whence); 5730 fl.l_start = tswap64(target_fl->l_start); 5731 fl.l_len = tswap64(target_fl->l_len); 5732 fl.l_pid = tswapl(target_fl->l_pid); 5733 unlock_user_struct(target_fl, arg3, 0); 5734 } 5735 ret = get_errno(fcntl(arg1, cmd, &fl)); 5736 break; 5737 default: 5738 ret = do_fcntl(arg1, cmd, arg3); 5739 break; 5740 } 5741 break; 5742 } 5743 #endif 5744 #ifdef TARGET_NR_cacheflush 5745 case TARGET_NR_cacheflush: 5746 /* self-modifying code is handled automatically, so nothing needed */ 5747 ret = 0; 5748 break; 5749 #endif 5750 #ifdef TARGET_NR_security 5751 case TARGET_NR_security: 5752 goto unimplemented; 5753 #endif 5754 #ifdef TARGET_NR_getpagesize 5755 case TARGET_NR_getpagesize: 5756 ret = TARGET_PAGE_SIZE; 5757 break; 5758 #endif 5759 case TARGET_NR_gettid: 5760 ret = get_errno(gettid()); 5761 break; 5762 #ifdef TARGET_NR_readahead 5763 case TARGET_NR_readahead: 5764 goto unimplemented; 5765 #endif 5766 #ifdef TARGET_NR_setxattr 5767 case TARGET_NR_setxattr: 5768 case TARGET_NR_lsetxattr: 5769 case TARGET_NR_fsetxattr: 5770 case TARGET_NR_getxattr: 5771 case TARGET_NR_lgetxattr: 5772 case TARGET_NR_fgetxattr: 5773 case TARGET_NR_listxattr: 5774 case TARGET_NR_llistxattr: 5775 case TARGET_NR_flistxattr: 5776 case TARGET_NR_removexattr: 5777 case TARGET_NR_lremovexattr: 5778 case TARGET_NR_fremovexattr: 5779 goto unimplemented_nowarn; 5780 #endif 5781 #ifdef TARGET_NR_set_thread_area 5782 case TARGET_NR_set_thread_area: 5783 #if defined(TARGET_MIPS) 5784 ((CPUMIPSState *) cpu_env)->tls_value = arg1; 5785 ret = 0; 5786 break; 5787 #elif defined(TARGET_I386) && defined(TARGET_ABI32) 5788 ret = do_set_thread_area(cpu_env, arg1); 5789 break; 5790 #else 5791 goto unimplemented_nowarn; 5792 #endif 5793 #endif 5794 #ifdef TARGET_NR_get_thread_area 5795 case TARGET_NR_get_thread_area: 5796 #if defined(TARGET_I386) && defined(TARGET_ABI32) 5797 ret = do_get_thread_area(cpu_env, arg1); 5798 #else 5799 goto unimplemented_nowarn; 5800 #endif 5801 #endif 5802 #ifdef TARGET_NR_getdomainname 5803 case TARGET_NR_getdomainname: 5804 goto unimplemented_nowarn; 5805 #endif 5806 5807 #ifdef TARGET_NR_clock_gettime 5808 case TARGET_NR_clock_gettime: 5809 { 5810 struct timespec ts; 5811 ret = get_errno(clock_gettime(arg1, &ts)); 5812 if (!is_error(ret)) { 5813 host_to_target_timespec(arg2, &ts); 5814 } 5815 break; 5816 } 5817 #endif 5818 #ifdef TARGET_NR_clock_getres 5819 case TARGET_NR_clock_getres: 5820 { 5821 struct timespec ts; 5822 ret = get_errno(clock_getres(arg1, &ts)); 5823 if (!is_error(ret)) { 5824 host_to_target_timespec(arg2, &ts); 5825 } 5826 break; 5827 } 5828 #endif 5829 #ifdef TARGET_NR_clock_nanosleep 5830 case TARGET_NR_clock_nanosleep: 5831 { 5832 struct timespec ts; 5833 target_to_host_timespec(&ts, arg3); 5834 ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL)); 5835 if (arg4) 5836 host_to_target_timespec(arg4, &ts); 5837 break; 5838 } 5839 #endif 5840 5841 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) 5842 case TARGET_NR_set_tid_address: 5843 ret = get_errno(set_tid_address((int *)g2h(arg1))); 5844 break; 5845 #endif 5846 5847 #if defined(TARGET_NR_tkill) && defined(__NR_tkill) 5848 case TARGET_NR_tkill: 5849 ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2))); 5850 break; 5851 #endif 5852 5853 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill) 5854 case TARGET_NR_tgkill: 5855 ret = get_errno(sys_tgkill((int)arg1, (int)arg2, 5856 target_to_host_signal(arg3))); 5857 break; 5858 #endif 5859 5860 #ifdef TARGET_NR_set_robust_list 5861 case TARGET_NR_set_robust_list: 5862 goto unimplemented_nowarn; 5863 #endif 5864 5865 #if defined(TARGET_NR_utimensat) && defined(__NR_utimensat) 5866 case TARGET_NR_utimensat: 5867 { 5868 struct timespec ts[2]; 5869 target_to_host_timespec(ts, arg3); 5870 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec)); 5871 if (!arg2) 5872 ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4)); 5873 else { 5874 if (!(p = lock_user_string(arg2))) { 5875 ret = -TARGET_EFAULT; 5876 goto fail; 5877 } 5878 ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4)); 5879 unlock_user(p, arg2, 0); 5880 } 5881 } 5882 break; 5883 #endif 5884 #if defined(USE_NPTL) 5885 case TARGET_NR_futex: 5886 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6); 5887 break; 5888 #endif 5889 #ifdef TARGET_NR_inotify_init 5890 case TARGET_NR_inotify_init: 5891 ret = get_errno(sys_inotify_init()); 5892 break; 5893 #endif 5894 #ifdef TARGET_NR_inotify_add_watch 5895 case TARGET_NR_inotify_add_watch: 5896 p = lock_user_string(arg2); 5897 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3)); 5898 unlock_user(p, arg2, 0); 5899 break; 5900 #endif 5901 #ifdef TARGET_NR_inotify_rm_watch 5902 case TARGET_NR_inotify_rm_watch: 5903 ret = get_errno(sys_inotify_rm_watch(arg1, arg2)); 5904 break; 5905 #endif 5906 5907 default: 5908 unimplemented: 5909 gemu_log("qemu: Unsupported syscall: %d\n", num); 5910 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list) 5911 unimplemented_nowarn: 5912 #endif 5913 ret = -TARGET_ENOSYS; 5914 break; 5915 } 5916 fail: 5917 #ifdef DEBUG 5918 gemu_log(" = %ld\n", ret); 5919 #endif 5920 if(do_strace) 5921 print_syscall_ret(num, ret); 5922 return ret; 5923 efault: 5924 ret = -TARGET_EFAULT; 5925 goto fail; 5926 } 5927