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