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