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