1 /* 2 * Linux syscalls 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 #include <stdlib.h> 21 #include <stdio.h> 22 #include <stdarg.h> 23 #include <elf.h> 24 #include <endian.h> 25 #include <errno.h> 26 #include <unistd.h> 27 #include <fcntl.h> 28 #include <sys/types.h> 29 #include <sys/wait.h> 30 #include <sys/time.h> 31 #include <sys/stat.h> 32 #include <sys/mount.h> 33 #include <sys/resource.h> 34 #include <sys/mman.h> 35 #include <sys/swap.h> 36 #include <signal.h> 37 #include <sched.h> 38 #include <sys/socket.h> 39 #include <sys/uio.h> 40 //#include <sys/user.h> 41 42 #define termios host_termios 43 #define winsize host_winsize 44 #define termio host_termio 45 46 #include <linux/termios.h> 47 #include <linux/unistd.h> 48 #include <linux/utsname.h> 49 #include <linux/cdrom.h> 50 #include <linux/hdreg.h> 51 #include <linux/soundcard.h> 52 53 #include "gemu.h" 54 55 //#define DEBUG 56 57 #ifndef PAGE_SIZE 58 #define PAGE_SIZE 4096 59 #define PAGE_MASK ~(PAGE_SIZE - 1) 60 #endif 61 62 struct dirent { 63 long d_ino; 64 long d_off; 65 unsigned short d_reclen; 66 char d_name[256]; /* We must not include limits.h! */ 67 }; 68 69 //#include <linux/msdos_fs.h> 70 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2]) 71 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2]) 72 73 #include "syscall_defs.h" 74 75 #ifdef TARGET_I386 76 #include "cpu-i386.h" 77 #include "syscall-i386.h" 78 #endif 79 80 #define __NR_sys_uname __NR_uname 81 #define __NR_sys_getcwd1 __NR_getcwd 82 #define __NR_sys_statfs __NR_statfs 83 #define __NR_sys_fstatfs __NR_fstatfs 84 #define __NR_sys_getdents __NR_getdents 85 86 #ifdef __NR_gettid 87 _syscall0(int, gettid) 88 #else 89 static int gettid(void) { 90 return -ENOSYS; 91 } 92 #endif 93 _syscall1(int,sys_uname,struct new_utsname *,buf) 94 _syscall2(int,sys_getcwd1,char *,buf,size_t,size) 95 _syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count); 96 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, 97 loff_t *, res, uint, wh); 98 _syscall2(int,sys_statfs,const char *,path,struct kernel_statfs *,buf) 99 _syscall2(int,sys_fstatfs,int,fd,struct kernel_statfs *,buf) 100 101 static inline long get_errno(long ret) 102 { 103 if (ret == -1) 104 return -errno; 105 else 106 return ret; 107 } 108 109 static inline int is_error(long ret) 110 { 111 return (unsigned long)ret >= (unsigned long)(-4096); 112 } 113 114 static char *target_brk; 115 static char *target_original_brk; 116 117 void target_set_brk(char *new_brk) 118 { 119 target_brk = new_brk; 120 target_original_brk = new_brk; 121 } 122 123 static long do_brk(char *new_brk) 124 { 125 char *brk_page; 126 long mapped_addr; 127 int new_alloc_size; 128 129 if (!new_brk) 130 return (long)target_brk; 131 if (new_brk < target_original_brk) 132 return -ENOMEM; 133 134 brk_page = (char *)(((unsigned long)target_brk + PAGE_SIZE - 1) & PAGE_MASK); 135 136 /* If the new brk is less than this, set it and we're done... */ 137 if (new_brk < brk_page) { 138 target_brk = new_brk; 139 return (long)target_brk; 140 } 141 142 /* We need to allocate more memory after the brk... */ 143 new_alloc_size = ((new_brk - brk_page + 1)+(PAGE_SIZE-1)) & PAGE_MASK; 144 mapped_addr = get_errno((long)mmap((caddr_t)brk_page, new_alloc_size, 145 PROT_READ|PROT_WRITE, 146 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0)); 147 148 if (is_error(mapped_addr)) { 149 return mapped_addr; 150 } else { 151 target_brk = new_brk; 152 return (long)target_brk; 153 } 154 } 155 156 static inline fd_set *target_to_host_fds(fd_set *fds, 157 target_long *target_fds, int n) 158 { 159 #if !defined(BSWP_NEEDED) && !defined(WORD_BIGENDIAN) 160 return (fd_set *)target_fds; 161 #else 162 int i, b; 163 if (target_fds) { 164 FD_ZERO(fds); 165 for(i = 0;i < n; i++) { 166 b = (tswapl(target_fds[i / TARGET_LONG_BITS]) >> 167 (i & (TARGET_LONG_BITS - 1))) & 1; 168 if (b) 169 FD_SET(i, fds); 170 } 171 return fds; 172 } else { 173 return NULL; 174 } 175 #endif 176 } 177 178 static inline void host_to_target_fds(target_long *target_fds, 179 fd_set *fds, int n) 180 { 181 #if !defined(BSWP_NEEDED) && !defined(WORD_BIGENDIAN) 182 /* nothing to do */ 183 #else 184 int i, nw, j, k; 185 target_long v; 186 187 if (target_fds) { 188 nw = n / TARGET_LONG_BITS; 189 k = 0; 190 for(i = 0;i < nw; i++) { 191 v = 0; 192 for(j = 0; j < TARGET_LONG_BITS; j++) { 193 v |= ((FD_ISSET(k, fds) != 0) << j); 194 k++; 195 } 196 target_fds[i] = tswapl(v); 197 } 198 } 199 #endif 200 } 201 202 /* XXX: incorrect for some archs */ 203 static void host_to_target_old_sigset(target_ulong *old_sigset, 204 const sigset_t *sigset) 205 { 206 *old_sigset = tswap32(*(unsigned long *)sigset & 0xffffffff); 207 } 208 209 static void target_to_host_old_sigset(sigset_t *sigset, 210 const target_ulong *old_sigset) 211 { 212 sigemptyset(sigset); 213 *(unsigned long *)sigset = tswapl(*old_sigset); 214 } 215 216 217 static long do_select(long n, 218 target_long *target_rfds, target_long *target_wfds, 219 target_long *target_efds, struct target_timeval *target_tv) 220 { 221 fd_set rfds, wfds, efds; 222 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr; 223 struct timeval tv, *tv_ptr; 224 long ret; 225 226 rfds_ptr = target_to_host_fds(&rfds, target_rfds, n); 227 wfds_ptr = target_to_host_fds(&wfds, target_wfds, n); 228 efds_ptr = target_to_host_fds(&efds, target_efds, n); 229 230 if (target_tv) { 231 tv.tv_sec = tswapl(target_tv->tv_sec); 232 tv.tv_usec = tswapl(target_tv->tv_usec); 233 tv_ptr = &tv; 234 } else { 235 tv_ptr = NULL; 236 } 237 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr)); 238 if (!is_error(ret)) { 239 host_to_target_fds(target_rfds, rfds_ptr, n); 240 host_to_target_fds(target_wfds, wfds_ptr, n); 241 host_to_target_fds(target_efds, efds_ptr, n); 242 243 if (target_tv) { 244 target_tv->tv_sec = tswapl(tv.tv_sec); 245 target_tv->tv_usec = tswapl(tv.tv_usec); 246 } 247 } 248 return ret; 249 } 250 251 static long do_socketcall(int num, long *vptr) 252 { 253 long ret; 254 255 switch(num) { 256 case SOCKOP_socket: 257 ret = get_errno(socket(vptr[0], vptr[1], vptr[2])); 258 break; 259 case SOCKOP_bind: 260 ret = get_errno(bind(vptr[0], (struct sockaddr *)vptr[1], vptr[2])); 261 break; 262 case SOCKOP_connect: 263 ret = get_errno(connect(vptr[0], (struct sockaddr *)vptr[1], vptr[2])); 264 break; 265 case SOCKOP_listen: 266 ret = get_errno(listen(vptr[0], vptr[1])); 267 break; 268 case SOCKOP_accept: 269 { 270 socklen_t size; 271 size = tswap32(*(int32_t *)vptr[2]); 272 ret = get_errno(accept(vptr[0], (struct sockaddr *)vptr[1], &size)); 273 if (!is_error(ret)) 274 *(int32_t *)vptr[2] = size; 275 } 276 break; 277 case SOCKOP_getsockname: 278 { 279 socklen_t size; 280 size = tswap32(*(int32_t *)vptr[2]); 281 ret = get_errno(getsockname(vptr[0], (struct sockaddr *)vptr[1], &size)); 282 if (!is_error(ret)) 283 *(int32_t *)vptr[2] = size; 284 } 285 break; 286 case SOCKOP_getpeername: 287 { 288 socklen_t size; 289 size = tswap32(*(int32_t *)vptr[2]); 290 ret = get_errno(getpeername(vptr[0], (struct sockaddr *)vptr[1], &size)); 291 if (!is_error(ret)) 292 *(int32_t *)vptr[2] = size; 293 } 294 break; 295 case SOCKOP_socketpair: 296 { 297 int tab[2]; 298 int32_t *target_tab = (int32_t *)vptr[3]; 299 ret = get_errno(socketpair(vptr[0], vptr[1], vptr[2], tab)); 300 if (!is_error(ret)) { 301 target_tab[0] = tswap32(tab[0]); 302 target_tab[1] = tswap32(tab[1]); 303 } 304 } 305 break; 306 case SOCKOP_send: 307 ret = get_errno(send(vptr[0], (void *)vptr[1], vptr[2], vptr[3])); 308 break; 309 case SOCKOP_recv: 310 ret = get_errno(recv(vptr[0], (void *)vptr[1], vptr[2], vptr[3])); 311 break; 312 case SOCKOP_sendto: 313 ret = get_errno(sendto(vptr[0], (void *)vptr[1], vptr[2], vptr[3], 314 (struct sockaddr *)vptr[4], vptr[5])); 315 break; 316 case SOCKOP_recvfrom: 317 { 318 socklen_t size; 319 size = tswap32(*(int32_t *)vptr[5]); 320 ret = get_errno(recvfrom(vptr[0], (void *)vptr[1], vptr[2], 321 vptr[3], (struct sockaddr *)vptr[4], &size)); 322 if (!is_error(ret)) 323 *(int32_t *)vptr[5] = size; 324 } 325 break; 326 case SOCKOP_shutdown: 327 ret = get_errno(shutdown(vptr[0], vptr[1])); 328 break; 329 case SOCKOP_sendmsg: 330 case SOCKOP_recvmsg: 331 { 332 int fd; 333 struct target_msghdr *msgp; 334 struct msghdr msg; 335 int flags, count, i; 336 struct iovec *vec; 337 struct target_iovec *target_vec; 338 339 msgp = (void *)vptr[1]; 340 msg.msg_name = (void *)tswapl(msgp->msg_name); 341 msg.msg_namelen = tswapl(msgp->msg_namelen); 342 msg.msg_control = (void *)tswapl(msgp->msg_control); 343 msg.msg_controllen = tswapl(msgp->msg_controllen); 344 msg.msg_flags = tswap32(msgp->msg_flags); 345 346 count = tswapl(msgp->msg_iovlen); 347 vec = alloca(count * sizeof(struct iovec)); 348 target_vec = (void *)tswapl(msgp->msg_iov); 349 for(i = 0;i < count; i++) { 350 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base); 351 vec[i].iov_len = tswapl(target_vec[i].iov_len); 352 } 353 msg.msg_iovlen = count; 354 msg.msg_iov = vec; 355 356 fd = vptr[0]; 357 flags = vptr[2]; 358 if (num == SOCKOP_sendmsg) 359 ret = sendmsg(fd, &msg, flags); 360 else 361 ret = recvmsg(fd, &msg, flags); 362 ret = get_errno(ret); 363 } 364 break; 365 case SOCKOP_setsockopt: 366 case SOCKOP_getsockopt: 367 default: 368 gemu_log("Unsupported socketcall: %d\n", num); 369 ret = -ENOSYS; 370 break; 371 } 372 return ret; 373 } 374 375 /* kernel structure types definitions */ 376 #define IFNAMSIZ 16 377 378 #define STRUCT(name, list...) STRUCT_ ## name, 379 #define STRUCT_SPECIAL(name) STRUCT_ ## name, 380 enum { 381 #include "syscall_types.h" 382 }; 383 #undef STRUCT 384 #undef STRUCT_SPECIAL 385 386 #define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL }; 387 #define STRUCT_SPECIAL(name) 388 #include "syscall_types.h" 389 #undef STRUCT 390 #undef STRUCT_SPECIAL 391 392 typedef struct IOCTLEntry { 393 int target_cmd; 394 int host_cmd; 395 const char *name; 396 int access; 397 const argtype arg_type[5]; 398 } IOCTLEntry; 399 400 #define IOC_R 0x0001 401 #define IOC_W 0x0002 402 #define IOC_RW (IOC_R | IOC_W) 403 404 #define MAX_STRUCT_SIZE 4096 405 406 const IOCTLEntry ioctl_entries[] = { 407 #define IOCTL(cmd, access, types...) \ 408 { TARGET_ ## cmd, cmd, #cmd, access, { types } }, 409 #include "ioctls.h" 410 { 0, 0, }, 411 }; 412 413 static long do_ioctl(long fd, long cmd, long arg) 414 { 415 const IOCTLEntry *ie; 416 const argtype *arg_type; 417 long ret; 418 uint8_t buf_temp[MAX_STRUCT_SIZE]; 419 420 ie = ioctl_entries; 421 for(;;) { 422 if (ie->target_cmd == 0) { 423 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", cmd); 424 return -ENOSYS; 425 } 426 if (ie->target_cmd == cmd) 427 break; 428 ie++; 429 } 430 arg_type = ie->arg_type; 431 #ifdef DEBUG 432 gemu_log("ioctl: cmd=0x%04lx (%s)\n", cmd, ie->name); 433 #endif 434 switch(arg_type[0]) { 435 case TYPE_NULL: 436 /* no argument */ 437 ret = get_errno(ioctl(fd, ie->host_cmd)); 438 break; 439 case TYPE_PTRVOID: 440 case TYPE_INT: 441 /* int argment */ 442 ret = get_errno(ioctl(fd, ie->host_cmd, arg)); 443 break; 444 case TYPE_PTR: 445 arg_type++; 446 switch(ie->access) { 447 case IOC_R: 448 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 449 if (!is_error(ret)) { 450 thunk_convert((void *)arg, buf_temp, arg_type, THUNK_TARGET); 451 } 452 break; 453 case IOC_W: 454 thunk_convert(buf_temp, (void *)arg, arg_type, THUNK_HOST); 455 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 456 break; 457 default: 458 case IOC_RW: 459 thunk_convert(buf_temp, (void *)arg, arg_type, THUNK_HOST); 460 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp)); 461 if (!is_error(ret)) { 462 thunk_convert((void *)arg, buf_temp, arg_type, THUNK_TARGET); 463 } 464 break; 465 } 466 break; 467 default: 468 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", cmd, arg_type[0]); 469 ret = -ENOSYS; 470 break; 471 } 472 return ret; 473 } 474 475 bitmask_transtbl iflag_tbl[] = { 476 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK }, 477 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT }, 478 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR }, 479 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK }, 480 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK }, 481 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP }, 482 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR }, 483 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR }, 484 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL }, 485 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC }, 486 { TARGET_IXON, TARGET_IXON, IXON, IXON }, 487 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY }, 488 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF }, 489 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL }, 490 { 0, 0, 0, 0 } 491 }; 492 493 bitmask_transtbl oflag_tbl[] = { 494 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST }, 495 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC }, 496 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR }, 497 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL }, 498 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR }, 499 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET }, 500 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL }, 501 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL }, 502 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 }, 503 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 }, 504 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 }, 505 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 }, 506 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 }, 507 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 }, 508 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 }, 509 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 }, 510 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 }, 511 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 }, 512 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 }, 513 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 }, 514 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 }, 515 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 }, 516 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 }, 517 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 }, 518 { 0, 0, 0, 0 } 519 }; 520 521 bitmask_transtbl cflag_tbl[] = { 522 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 }, 523 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 }, 524 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 }, 525 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 }, 526 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 }, 527 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 }, 528 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 }, 529 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 }, 530 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 }, 531 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 }, 532 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 }, 533 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 }, 534 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 }, 535 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 }, 536 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 }, 537 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 }, 538 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 }, 539 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 }, 540 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 }, 541 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 }, 542 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 }, 543 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 }, 544 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 }, 545 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 }, 546 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB }, 547 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD }, 548 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB }, 549 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD }, 550 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL }, 551 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL }, 552 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS }, 553 { 0, 0, 0, 0 } 554 }; 555 556 bitmask_transtbl lflag_tbl[] = { 557 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG }, 558 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON }, 559 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE }, 560 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO }, 561 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE }, 562 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK }, 563 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL }, 564 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH }, 565 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP }, 566 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL }, 567 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT }, 568 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE }, 569 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO }, 570 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN }, 571 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN }, 572 { 0, 0, 0, 0 } 573 }; 574 575 static void target_to_host_termios (void *dst, const void *src) 576 { 577 struct host_termios *host = dst; 578 const struct target_termios *target = src; 579 580 host->c_iflag = 581 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl); 582 host->c_oflag = 583 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl); 584 host->c_cflag = 585 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl); 586 host->c_lflag = 587 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl); 588 host->c_line = target->c_line; 589 590 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR]; 591 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT]; 592 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE]; 593 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL]; 594 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF]; 595 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME]; 596 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN]; 597 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC]; 598 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART]; 599 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP]; 600 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP]; 601 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL]; 602 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT]; 603 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD]; 604 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE]; 605 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT]; 606 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2]; 607 } 608 609 static void host_to_target_termios (void *dst, const void *src) 610 { 611 struct target_termios *target = dst; 612 const struct host_termios *host = src; 613 614 target->c_iflag = 615 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl)); 616 target->c_oflag = 617 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl)); 618 target->c_cflag = 619 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl)); 620 target->c_lflag = 621 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl)); 622 target->c_line = host->c_line; 623 624 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR]; 625 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT]; 626 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE]; 627 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL]; 628 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF]; 629 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME]; 630 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN]; 631 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC]; 632 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART]; 633 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP]; 634 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP]; 635 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL]; 636 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT]; 637 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD]; 638 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE]; 639 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT]; 640 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2]; 641 } 642 643 StructEntry struct_termios_def = { 644 .convert = { host_to_target_termios, target_to_host_termios }, 645 .size = { sizeof(struct target_termios), sizeof(struct host_termios) }, 646 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) }, 647 }; 648 649 #ifdef TARGET_I386 650 651 /* NOTE: there is really one LDT for all the threads */ 652 uint8_t *ldt_table; 653 654 static int read_ldt(void *ptr, unsigned long bytecount) 655 { 656 int size; 657 658 if (!ldt_table) 659 return 0; 660 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE; 661 if (size > bytecount) 662 size = bytecount; 663 memcpy(ptr, ldt_table, size); 664 return size; 665 } 666 667 /* XXX: add locking support */ 668 static int write_ldt(CPUX86State *env, 669 void *ptr, unsigned long bytecount, int oldmode) 670 { 671 struct target_modify_ldt_ldt_s ldt_info; 672 int seg_32bit, contents, read_exec_only, limit_in_pages; 673 int seg_not_present, useable; 674 uint32_t *lp, entry_1, entry_2; 675 676 if (bytecount != sizeof(ldt_info)) 677 return -EINVAL; 678 memcpy(&ldt_info, ptr, sizeof(ldt_info)); 679 tswap32s(&ldt_info.entry_number); 680 tswapls((long *)&ldt_info.base_addr); 681 tswap32s(&ldt_info.limit); 682 tswap32s(&ldt_info.flags); 683 684 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES) 685 return -EINVAL; 686 seg_32bit = ldt_info.flags & 1; 687 contents = (ldt_info.flags >> 1) & 3; 688 read_exec_only = (ldt_info.flags >> 3) & 1; 689 limit_in_pages = (ldt_info.flags >> 4) & 1; 690 seg_not_present = (ldt_info.flags >> 5) & 1; 691 useable = (ldt_info.flags >> 6) & 1; 692 693 if (contents == 3) { 694 if (oldmode) 695 return -EINVAL; 696 if (seg_not_present == 0) 697 return -EINVAL; 698 } 699 /* allocate the LDT */ 700 if (!ldt_table) { 701 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); 702 if (!ldt_table) 703 return -ENOMEM; 704 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); 705 env->ldt.base = ldt_table; 706 env->ldt.limit = 0xffff; 707 } 708 709 /* NOTE: same code as Linux kernel */ 710 /* Allow LDTs to be cleared by the user. */ 711 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) { 712 if (oldmode || 713 (contents == 0 && 714 read_exec_only == 1 && 715 seg_32bit == 0 && 716 limit_in_pages == 0 && 717 seg_not_present == 1 && 718 useable == 0 )) { 719 entry_1 = 0; 720 entry_2 = 0; 721 goto install; 722 } 723 } 724 725 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) | 726 (ldt_info.limit & 0x0ffff); 727 entry_2 = (ldt_info.base_addr & 0xff000000) | 728 ((ldt_info.base_addr & 0x00ff0000) >> 16) | 729 (ldt_info.limit & 0xf0000) | 730 ((read_exec_only ^ 1) << 9) | 731 (contents << 10) | 732 ((seg_not_present ^ 1) << 15) | 733 (seg_32bit << 22) | 734 (limit_in_pages << 23) | 735 0x7000; 736 if (!oldmode) 737 entry_2 |= (useable << 20); 738 739 /* Install the new entry ... */ 740 install: 741 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3)); 742 lp[0] = tswap32(entry_1); 743 lp[1] = tswap32(entry_2); 744 return 0; 745 } 746 747 /* specific and weird i386 syscalls */ 748 int gemu_modify_ldt(CPUX86State *env, int func, void *ptr, unsigned long bytecount) 749 { 750 int ret = -ENOSYS; 751 752 switch (func) { 753 case 0: 754 ret = read_ldt(ptr, bytecount); 755 break; 756 case 1: 757 ret = write_ldt(env, ptr, bytecount, 1); 758 break; 759 case 0x11: 760 ret = write_ldt(env, ptr, bytecount, 0); 761 break; 762 } 763 return ret; 764 } 765 #endif 766 767 void syscall_init(void) 768 { 769 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def); 770 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def); 771 #include "syscall_types.h" 772 #undef STRUCT 773 #undef STRUCT_SPECIAL 774 } 775 776 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, 777 long arg4, long arg5, long arg6) 778 { 779 long ret; 780 struct stat st; 781 struct kernel_statfs *stfs; 782 783 #ifdef DEBUG 784 gemu_log("syscall %d\n", num); 785 #endif 786 switch(num) { 787 case TARGET_NR_exit: 788 #ifdef HAVE_GPROF 789 _mcleanup(); 790 #endif 791 _exit(arg1); 792 ret = 0; /* avoid warning */ 793 break; 794 case TARGET_NR_read: 795 ret = get_errno(read(arg1, (void *)arg2, arg3)); 796 break; 797 case TARGET_NR_write: 798 ret = get_errno(write(arg1, (void *)arg2, arg3)); 799 break; 800 case TARGET_NR_open: 801 ret = get_errno(open((const char *)arg1, arg2, arg3)); 802 break; 803 case TARGET_NR_close: 804 ret = get_errno(close(arg1)); 805 break; 806 case TARGET_NR_brk: 807 ret = do_brk((char *)arg1); 808 break; 809 case TARGET_NR_fork: 810 ret = get_errno(fork()); 811 break; 812 case TARGET_NR_waitpid: 813 { 814 int *status = (int *)arg2; 815 ret = get_errno(waitpid(arg1, status, arg3)); 816 if (!is_error(ret) && status) 817 tswapls((long *)&status); 818 } 819 break; 820 case TARGET_NR_creat: 821 ret = get_errno(creat((const char *)arg1, arg2)); 822 break; 823 case TARGET_NR_link: 824 ret = get_errno(link((const char *)arg1, (const char *)arg2)); 825 break; 826 case TARGET_NR_unlink: 827 ret = get_errno(unlink((const char *)arg1)); 828 break; 829 case TARGET_NR_execve: 830 ret = get_errno(execve((const char *)arg1, (void *)arg2, (void *)arg3)); 831 break; 832 case TARGET_NR_chdir: 833 ret = get_errno(chdir((const char *)arg1)); 834 break; 835 case TARGET_NR_time: 836 { 837 int *time_ptr = (int *)arg1; 838 ret = get_errno(time((time_t *)time_ptr)); 839 if (!is_error(ret) && time_ptr) 840 tswap32s(time_ptr); 841 } 842 break; 843 case TARGET_NR_mknod: 844 ret = get_errno(mknod((const char *)arg1, arg2, arg3)); 845 break; 846 case TARGET_NR_chmod: 847 ret = get_errno(chmod((const char *)arg1, arg2)); 848 break; 849 case TARGET_NR_lchown: 850 ret = get_errno(chown((const char *)arg1, arg2, arg3)); 851 break; 852 case TARGET_NR_break: 853 goto unimplemented; 854 case TARGET_NR_oldstat: 855 goto unimplemented; 856 case TARGET_NR_lseek: 857 ret = get_errno(lseek(arg1, arg2, arg3)); 858 break; 859 case TARGET_NR_getpid: 860 ret = get_errno(getpid()); 861 break; 862 case TARGET_NR_mount: 863 /* need to look at the data field */ 864 goto unimplemented; 865 case TARGET_NR_umount: 866 ret = get_errno(umount((const char *)arg1)); 867 break; 868 case TARGET_NR_setuid: 869 ret = get_errno(setuid(arg1)); 870 break; 871 case TARGET_NR_getuid: 872 ret = get_errno(getuid()); 873 break; 874 case TARGET_NR_stime: 875 { 876 int *time_ptr = (int *)arg1; 877 if (time_ptr) 878 tswap32s(time_ptr); 879 ret = get_errno(stime((time_t *)time_ptr)); 880 } 881 break; 882 case TARGET_NR_ptrace: 883 goto unimplemented; 884 case TARGET_NR_alarm: 885 ret = alarm(arg1); 886 break; 887 case TARGET_NR_oldfstat: 888 goto unimplemented; 889 case TARGET_NR_pause: 890 ret = get_errno(pause()); 891 break; 892 case TARGET_NR_utime: 893 goto unimplemented; 894 case TARGET_NR_stty: 895 goto unimplemented; 896 case TARGET_NR_gtty: 897 goto unimplemented; 898 case TARGET_NR_access: 899 ret = get_errno(access((const char *)arg1, arg2)); 900 break; 901 case TARGET_NR_nice: 902 ret = get_errno(nice(arg1)); 903 break; 904 case TARGET_NR_ftime: 905 goto unimplemented; 906 case TARGET_NR_sync: 907 ret = get_errno(sync()); 908 break; 909 case TARGET_NR_kill: 910 ret = get_errno(kill(arg1, arg2)); 911 break; 912 case TARGET_NR_rename: 913 ret = get_errno(rename((const char *)arg1, (const char *)arg2)); 914 break; 915 case TARGET_NR_mkdir: 916 ret = get_errno(mkdir((const char *)arg1, arg2)); 917 break; 918 case TARGET_NR_rmdir: 919 ret = get_errno(rmdir((const char *)arg1)); 920 break; 921 case TARGET_NR_dup: 922 ret = get_errno(dup(arg1)); 923 break; 924 case TARGET_NR_pipe: 925 { 926 int *pipe_ptr = (int *)arg1; 927 ret = get_errno(pipe(pipe_ptr)); 928 if (!is_error(ret)) { 929 tswap32s(&pipe_ptr[0]); 930 tswap32s(&pipe_ptr[1]); 931 } 932 } 933 break; 934 case TARGET_NR_times: 935 goto unimplemented; 936 case TARGET_NR_prof: 937 goto unimplemented; 938 case TARGET_NR_setgid: 939 ret = get_errno(setgid(arg1)); 940 break; 941 case TARGET_NR_getgid: 942 ret = get_errno(getgid()); 943 break; 944 case TARGET_NR_signal: 945 goto unimplemented; 946 case TARGET_NR_geteuid: 947 ret = get_errno(geteuid()); 948 break; 949 case TARGET_NR_getegid: 950 ret = get_errno(getegid()); 951 break; 952 case TARGET_NR_acct: 953 goto unimplemented; 954 case TARGET_NR_umount2: 955 ret = get_errno(umount2((const char *)arg1, arg2)); 956 break; 957 case TARGET_NR_lock: 958 goto unimplemented; 959 case TARGET_NR_ioctl: 960 ret = do_ioctl(arg1, arg2, arg3); 961 break; 962 case TARGET_NR_fcntl: 963 switch(arg2) { 964 case F_GETLK: 965 case F_SETLK: 966 case F_SETLKW: 967 goto unimplemented; 968 default: 969 ret = get_errno(fcntl(arg1, arg2, arg3)); 970 break; 971 } 972 break; 973 case TARGET_NR_mpx: 974 goto unimplemented; 975 case TARGET_NR_setpgid: 976 ret = get_errno(setpgid(arg1, arg2)); 977 break; 978 case TARGET_NR_ulimit: 979 goto unimplemented; 980 case TARGET_NR_oldolduname: 981 goto unimplemented; 982 case TARGET_NR_umask: 983 ret = get_errno(umask(arg1)); 984 break; 985 case TARGET_NR_chroot: 986 ret = get_errno(chroot((const char *)arg1)); 987 break; 988 case TARGET_NR_ustat: 989 goto unimplemented; 990 case TARGET_NR_dup2: 991 ret = get_errno(dup2(arg1, arg2)); 992 break; 993 case TARGET_NR_getppid: 994 ret = get_errno(getppid()); 995 break; 996 case TARGET_NR_getpgrp: 997 ret = get_errno(getpgrp()); 998 break; 999 case TARGET_NR_setsid: 1000 ret = get_errno(setsid()); 1001 break; 1002 case TARGET_NR_sigaction: 1003 #if 1 1004 { 1005 int signum = arg1; 1006 struct target_old_sigaction *tact = arg2, *toldact = arg3; 1007 ret = 0; 1008 1009 } 1010 break; 1011 #else 1012 goto unimplemented; 1013 #endif 1014 case TARGET_NR_sgetmask: 1015 goto unimplemented; 1016 case TARGET_NR_ssetmask: 1017 goto unimplemented; 1018 case TARGET_NR_setreuid: 1019 ret = get_errno(setreuid(arg1, arg2)); 1020 break; 1021 case TARGET_NR_setregid: 1022 ret = get_errno(setregid(arg1, arg2)); 1023 break; 1024 case TARGET_NR_sigsuspend: 1025 goto unimplemented; 1026 case TARGET_NR_sigpending: 1027 goto unimplemented; 1028 case TARGET_NR_sethostname: 1029 ret = get_errno(sethostname((const char *)arg1, arg2)); 1030 break; 1031 case TARGET_NR_setrlimit: 1032 goto unimplemented; 1033 case TARGET_NR_getrlimit: 1034 goto unimplemented; 1035 case TARGET_NR_getrusage: 1036 goto unimplemented; 1037 case TARGET_NR_gettimeofday: 1038 { 1039 struct target_timeval *target_tv = (void *)arg1; 1040 struct timeval tv; 1041 ret = get_errno(gettimeofday(&tv, NULL)); 1042 if (!is_error(ret)) { 1043 target_tv->tv_sec = tswapl(tv.tv_sec); 1044 target_tv->tv_usec = tswapl(tv.tv_usec); 1045 } 1046 } 1047 break; 1048 case TARGET_NR_settimeofday: 1049 { 1050 struct target_timeval *target_tv = (void *)arg1; 1051 struct timeval tv; 1052 tv.tv_sec = tswapl(target_tv->tv_sec); 1053 tv.tv_usec = tswapl(target_tv->tv_usec); 1054 ret = get_errno(settimeofday(&tv, NULL)); 1055 } 1056 break; 1057 case TARGET_NR_getgroups: 1058 goto unimplemented; 1059 case TARGET_NR_setgroups: 1060 goto unimplemented; 1061 case TARGET_NR_select: 1062 goto unimplemented; 1063 case TARGET_NR_symlink: 1064 ret = get_errno(symlink((const char *)arg1, (const char *)arg2)); 1065 break; 1066 case TARGET_NR_oldlstat: 1067 goto unimplemented; 1068 case TARGET_NR_readlink: 1069 ret = get_errno(readlink((const char *)arg1, (char *)arg2, arg3)); 1070 break; 1071 case TARGET_NR_uselib: 1072 goto unimplemented; 1073 case TARGET_NR_swapon: 1074 ret = get_errno(swapon((const char *)arg1, arg2)); 1075 break; 1076 case TARGET_NR_reboot: 1077 goto unimplemented; 1078 case TARGET_NR_readdir: 1079 goto unimplemented; 1080 #ifdef TARGET_I386 1081 case TARGET_NR_mmap: 1082 { 1083 uint32_t v1, v2, v3, v4, v5, v6, *vptr; 1084 vptr = (uint32_t *)arg1; 1085 v1 = tswap32(vptr[0]); 1086 v2 = tswap32(vptr[1]); 1087 v3 = tswap32(vptr[2]); 1088 v4 = tswap32(vptr[3]); 1089 v5 = tswap32(vptr[4]); 1090 v6 = tswap32(vptr[5]); 1091 ret = get_errno((long)mmap((void *)v1, v2, v3, v4, v5, v6)); 1092 } 1093 break; 1094 #endif 1095 #ifdef TARGET_I386 1096 case TARGET_NR_mmap2: 1097 #else 1098 case TARGET_NR_mmap: 1099 #endif 1100 ret = get_errno((long)mmap((void *)arg1, arg2, arg3, arg4, arg5, arg6)); 1101 break; 1102 case TARGET_NR_munmap: 1103 ret = get_errno(munmap((void *)arg1, arg2)); 1104 break; 1105 case TARGET_NR_truncate: 1106 ret = get_errno(truncate((const char *)arg1, arg2)); 1107 break; 1108 case TARGET_NR_ftruncate: 1109 ret = get_errno(ftruncate(arg1, arg2)); 1110 break; 1111 case TARGET_NR_fchmod: 1112 ret = get_errno(fchmod(arg1, arg2)); 1113 break; 1114 case TARGET_NR_fchown: 1115 ret = get_errno(fchown(arg1, arg2, arg3)); 1116 break; 1117 case TARGET_NR_getpriority: 1118 ret = get_errno(getpriority(arg1, arg2)); 1119 break; 1120 case TARGET_NR_setpriority: 1121 ret = get_errno(setpriority(arg1, arg2, arg3)); 1122 break; 1123 case TARGET_NR_profil: 1124 goto unimplemented; 1125 case TARGET_NR_statfs: 1126 stfs = (void *)arg2; 1127 ret = get_errno(sys_statfs((const char *)arg1, stfs)); 1128 convert_statfs: 1129 if (!is_error(ret)) { 1130 tswap32s(&stfs->f_type); 1131 tswap32s(&stfs->f_bsize); 1132 tswap32s(&stfs->f_blocks); 1133 tswap32s(&stfs->f_bfree); 1134 tswap32s(&stfs->f_bavail); 1135 tswap32s(&stfs->f_files); 1136 tswap32s(&stfs->f_ffree); 1137 tswap32s(&stfs->f_fsid.val[0]); 1138 tswap32s(&stfs->f_fsid.val[1]); 1139 tswap32s(&stfs->f_namelen); 1140 } 1141 break; 1142 case TARGET_NR_fstatfs: 1143 stfs = (void *)arg2; 1144 ret = get_errno(sys_fstatfs(arg1, stfs)); 1145 goto convert_statfs; 1146 case TARGET_NR_ioperm: 1147 goto unimplemented; 1148 case TARGET_NR_socketcall: 1149 ret = do_socketcall(arg1, (long *)arg2); 1150 break; 1151 case TARGET_NR_syslog: 1152 goto unimplemented; 1153 case TARGET_NR_setitimer: 1154 goto unimplemented; 1155 case TARGET_NR_getitimer: 1156 goto unimplemented; 1157 case TARGET_NR_stat: 1158 ret = get_errno(stat((const char *)arg1, &st)); 1159 goto do_stat; 1160 case TARGET_NR_lstat: 1161 ret = get_errno(lstat((const char *)arg1, &st)); 1162 goto do_stat; 1163 case TARGET_NR_fstat: 1164 { 1165 ret = get_errno(fstat(arg1, &st)); 1166 do_stat: 1167 if (!is_error(ret)) { 1168 struct target_stat *target_st = (void *)arg2; 1169 target_st->st_dev = tswap16(st.st_dev); 1170 target_st->st_ino = tswapl(st.st_ino); 1171 target_st->st_mode = tswap16(st.st_mode); 1172 target_st->st_nlink = tswap16(st.st_nlink); 1173 target_st->st_uid = tswap16(st.st_uid); 1174 target_st->st_gid = tswap16(st.st_gid); 1175 target_st->st_rdev = tswap16(st.st_rdev); 1176 target_st->st_size = tswapl(st.st_size); 1177 target_st->st_blksize = tswapl(st.st_blksize); 1178 target_st->st_blocks = tswapl(st.st_blocks); 1179 target_st->st_atime = tswapl(st.st_atime); 1180 target_st->st_mtime = tswapl(st.st_mtime); 1181 target_st->st_ctime = tswapl(st.st_ctime); 1182 } 1183 } 1184 break; 1185 case TARGET_NR_olduname: 1186 goto unimplemented; 1187 case TARGET_NR_iopl: 1188 goto unimplemented; 1189 case TARGET_NR_vhangup: 1190 ret = get_errno(vhangup()); 1191 break; 1192 case TARGET_NR_idle: 1193 goto unimplemented; 1194 case TARGET_NR_vm86old: 1195 goto unimplemented; 1196 case TARGET_NR_wait4: 1197 { 1198 int status; 1199 target_long *status_ptr = (void *)arg2; 1200 struct rusage rusage, *rusage_ptr; 1201 struct target_rusage *target_rusage = (void *)arg4; 1202 if (target_rusage) 1203 rusage_ptr = &rusage; 1204 else 1205 rusage_ptr = NULL; 1206 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr)); 1207 if (!is_error(ret)) { 1208 if (status_ptr) 1209 *status_ptr = tswap32(status); 1210 if (target_rusage) { 1211 target_rusage->ru_utime.tv_sec = tswapl(rusage.ru_utime.tv_sec); 1212 target_rusage->ru_utime.tv_usec = tswapl(rusage.ru_utime.tv_usec); 1213 target_rusage->ru_stime.tv_sec = tswapl(rusage.ru_stime.tv_sec); 1214 target_rusage->ru_stime.tv_usec = tswapl(rusage.ru_stime.tv_usec); 1215 target_rusage->ru_maxrss = tswapl(rusage.ru_maxrss); 1216 target_rusage->ru_ixrss = tswapl(rusage.ru_ixrss); 1217 target_rusage->ru_idrss = tswapl(rusage.ru_idrss); 1218 target_rusage->ru_isrss = tswapl(rusage.ru_isrss); 1219 target_rusage->ru_minflt = tswapl(rusage.ru_minflt); 1220 target_rusage->ru_majflt = tswapl(rusage.ru_majflt); 1221 target_rusage->ru_nswap = tswapl(rusage.ru_nswap); 1222 target_rusage->ru_inblock = tswapl(rusage.ru_inblock); 1223 target_rusage->ru_oublock = tswapl(rusage.ru_oublock); 1224 target_rusage->ru_msgsnd = tswapl(rusage.ru_msgsnd); 1225 target_rusage->ru_msgrcv = tswapl(rusage.ru_msgrcv); 1226 target_rusage->ru_nsignals = tswapl(rusage.ru_nsignals); 1227 target_rusage->ru_nvcsw = tswapl(rusage.ru_nvcsw); 1228 target_rusage->ru_nivcsw = tswapl(rusage.ru_nivcsw); 1229 } 1230 } 1231 } 1232 break; 1233 case TARGET_NR_swapoff: 1234 ret = get_errno(swapoff((const char *)arg1)); 1235 break; 1236 case TARGET_NR_sysinfo: 1237 goto unimplemented; 1238 case TARGET_NR_ipc: 1239 goto unimplemented; 1240 case TARGET_NR_fsync: 1241 ret = get_errno(fsync(arg1)); 1242 break; 1243 case TARGET_NR_sigreturn: 1244 goto unimplemented; 1245 case TARGET_NR_clone: 1246 goto unimplemented; 1247 case TARGET_NR_setdomainname: 1248 ret = get_errno(setdomainname((const char *)arg1, arg2)); 1249 break; 1250 case TARGET_NR_uname: 1251 /* no need to transcode because we use the linux syscall */ 1252 ret = get_errno(sys_uname((struct new_utsname *)arg1)); 1253 break; 1254 #ifdef TARGET_I386 1255 case TARGET_NR_modify_ldt: 1256 ret = get_errno(gemu_modify_ldt(cpu_env, arg1, (void *)arg2, arg3)); 1257 break; 1258 #endif 1259 case TARGET_NR_adjtimex: 1260 goto unimplemented; 1261 case TARGET_NR_mprotect: 1262 ret = get_errno(mprotect((void *)arg1, arg2, arg3)); 1263 break; 1264 case TARGET_NR_sigprocmask: 1265 { 1266 int how = arg1; 1267 sigset_t set, oldset, *set_ptr; 1268 target_ulong *pset = (void *)arg2, *poldset = (void *)arg3; 1269 1270 switch(how) { 1271 case TARGET_SIG_BLOCK: 1272 how = SIG_BLOCK; 1273 break; 1274 case TARGET_SIG_UNBLOCK: 1275 how = SIG_UNBLOCK; 1276 break; 1277 case TARGET_SIG_SETMASK: 1278 how = SIG_SETMASK; 1279 break; 1280 default: 1281 ret = -EINVAL; 1282 goto fail; 1283 } 1284 1285 if (pset) { 1286 target_to_host_old_sigset(&set, pset); 1287 set_ptr = &set; 1288 } else { 1289 set_ptr = NULL; 1290 } 1291 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset)); 1292 if (!is_error(ret) && poldset) { 1293 host_to_target_old_sigset(poldset, &oldset); 1294 } 1295 } 1296 break; 1297 case TARGET_NR_create_module: 1298 case TARGET_NR_init_module: 1299 case TARGET_NR_delete_module: 1300 case TARGET_NR_get_kernel_syms: 1301 goto unimplemented; 1302 case TARGET_NR_quotactl: 1303 goto unimplemented; 1304 case TARGET_NR_getpgid: 1305 ret = get_errno(getpgid(arg1)); 1306 break; 1307 case TARGET_NR_fchdir: 1308 ret = get_errno(fchdir(arg1)); 1309 break; 1310 case TARGET_NR_bdflush: 1311 goto unimplemented; 1312 case TARGET_NR_sysfs: 1313 goto unimplemented; 1314 case TARGET_NR_personality: 1315 ret = get_errno(mprotect((void *)arg1, arg2, arg3)); 1316 break; 1317 case TARGET_NR_afs_syscall: 1318 goto unimplemented; 1319 case TARGET_NR_setfsuid: 1320 goto unimplemented; 1321 case TARGET_NR_setfsgid: 1322 goto unimplemented; 1323 case TARGET_NR__llseek: 1324 { 1325 int64_t res; 1326 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); 1327 *(int64_t *)arg4 = tswap64(res); 1328 } 1329 break; 1330 case TARGET_NR_getdents: 1331 #if TARGET_LONG_SIZE != 4 1332 #error not supported 1333 #endif 1334 { 1335 struct dirent *dirp = (void *)arg2; 1336 long count = arg3; 1337 ret = get_errno(sys_getdents(arg1, dirp, count)); 1338 if (!is_error(ret)) { 1339 struct dirent *de; 1340 int len = ret; 1341 int reclen; 1342 de = dirp; 1343 while (len > 0) { 1344 reclen = tswap16(de->d_reclen); 1345 if (reclen > len) 1346 break; 1347 de->d_reclen = reclen; 1348 tswapls(&de->d_ino); 1349 tswapls(&de->d_off); 1350 de = (struct dirent *)((char *)de + reclen); 1351 len -= reclen; 1352 } 1353 } 1354 } 1355 break; 1356 case TARGET_NR__newselect: 1357 ret = do_select(arg1, (void *)arg2, (void *)arg3, (void *)arg4, 1358 (void *)arg5); 1359 break; 1360 case TARGET_NR_flock: 1361 goto unimplemented; 1362 case TARGET_NR_msync: 1363 ret = get_errno(msync((void *)arg1, arg2, arg3)); 1364 break; 1365 case TARGET_NR_readv: 1366 { 1367 int count = arg3; 1368 int i; 1369 struct iovec *vec; 1370 struct target_iovec *target_vec = (void *)arg2; 1371 1372 vec = alloca(count * sizeof(struct iovec)); 1373 for(i = 0;i < count; i++) { 1374 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base); 1375 vec[i].iov_len = tswapl(target_vec[i].iov_len); 1376 } 1377 ret = get_errno(readv(arg1, vec, count)); 1378 } 1379 break; 1380 case TARGET_NR_writev: 1381 { 1382 int count = arg3; 1383 int i; 1384 struct iovec *vec; 1385 struct target_iovec *target_vec = (void *)arg2; 1386 1387 vec = alloca(count * sizeof(struct iovec)); 1388 for(i = 0;i < count; i++) { 1389 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base); 1390 vec[i].iov_len = tswapl(target_vec[i].iov_len); 1391 } 1392 ret = get_errno(writev(arg1, vec, count)); 1393 } 1394 break; 1395 case TARGET_NR_getsid: 1396 ret = get_errno(getsid(arg1)); 1397 break; 1398 case TARGET_NR_fdatasync: 1399 goto unimplemented; 1400 case TARGET_NR__sysctl: 1401 goto unimplemented; 1402 case TARGET_NR_mlock: 1403 ret = get_errno(mlock((void *)arg1, arg2)); 1404 break; 1405 case TARGET_NR_munlock: 1406 ret = get_errno(munlock((void *)arg1, arg2)); 1407 break; 1408 case TARGET_NR_mlockall: 1409 ret = get_errno(mlockall(arg1)); 1410 break; 1411 case TARGET_NR_munlockall: 1412 ret = get_errno(munlockall()); 1413 break; 1414 case TARGET_NR_sched_setparam: 1415 goto unimplemented; 1416 case TARGET_NR_sched_getparam: 1417 goto unimplemented; 1418 case TARGET_NR_sched_setscheduler: 1419 goto unimplemented; 1420 case TARGET_NR_sched_getscheduler: 1421 goto unimplemented; 1422 case TARGET_NR_sched_yield: 1423 ret = get_errno(sched_yield()); 1424 break; 1425 case TARGET_NR_sched_get_priority_max: 1426 case TARGET_NR_sched_get_priority_min: 1427 case TARGET_NR_sched_rr_get_interval: 1428 case TARGET_NR_nanosleep: 1429 case TARGET_NR_mremap: 1430 case TARGET_NR_setresuid: 1431 case TARGET_NR_getresuid: 1432 case TARGET_NR_vm86: 1433 case TARGET_NR_query_module: 1434 case TARGET_NR_poll: 1435 case TARGET_NR_nfsservctl: 1436 case TARGET_NR_setresgid: 1437 case TARGET_NR_getresgid: 1438 case TARGET_NR_prctl: 1439 case TARGET_NR_rt_sigreturn: 1440 case TARGET_NR_rt_sigaction: 1441 case TARGET_NR_rt_sigprocmask: 1442 case TARGET_NR_rt_sigpending: 1443 case TARGET_NR_rt_sigtimedwait: 1444 case TARGET_NR_rt_sigqueueinfo: 1445 case TARGET_NR_rt_sigsuspend: 1446 case TARGET_NR_pread: 1447 case TARGET_NR_pwrite: 1448 goto unimplemented; 1449 case TARGET_NR_chown: 1450 ret = get_errno(chown((const char *)arg1, arg2, arg3)); 1451 break; 1452 case TARGET_NR_getcwd: 1453 ret = get_errno(sys_getcwd1((char *)arg1, arg2)); 1454 break; 1455 case TARGET_NR_capget: 1456 case TARGET_NR_capset: 1457 case TARGET_NR_sigaltstack: 1458 case TARGET_NR_sendfile: 1459 case TARGET_NR_getpmsg: 1460 case TARGET_NR_putpmsg: 1461 case TARGET_NR_vfork: 1462 ret = get_errno(vfork()); 1463 break; 1464 case TARGET_NR_ugetrlimit: 1465 case TARGET_NR_truncate64: 1466 case TARGET_NR_ftruncate64: 1467 case TARGET_NR_stat64: 1468 case TARGET_NR_lstat64: 1469 case TARGET_NR_fstat64: 1470 case TARGET_NR_lchown32: 1471 case TARGET_NR_getuid32: 1472 case TARGET_NR_getgid32: 1473 case TARGET_NR_geteuid32: 1474 case TARGET_NR_getegid32: 1475 case TARGET_NR_setreuid32: 1476 case TARGET_NR_setregid32: 1477 case TARGET_NR_getgroups32: 1478 case TARGET_NR_setgroups32: 1479 case TARGET_NR_fchown32: 1480 case TARGET_NR_setresuid32: 1481 case TARGET_NR_getresuid32: 1482 case TARGET_NR_setresgid32: 1483 case TARGET_NR_getresgid32: 1484 case TARGET_NR_chown32: 1485 case TARGET_NR_setuid32: 1486 case TARGET_NR_setgid32: 1487 case TARGET_NR_setfsuid32: 1488 case TARGET_NR_setfsgid32: 1489 case TARGET_NR_pivot_root: 1490 case TARGET_NR_mincore: 1491 case TARGET_NR_madvise: 1492 case TARGET_NR_getdents64: 1493 case TARGET_NR_fcntl64: 1494 case TARGET_NR_security: 1495 goto unimplemented; 1496 case TARGET_NR_gettid: 1497 ret = get_errno(gettid()); 1498 break; 1499 case TARGET_NR_readahead: 1500 case TARGET_NR_setxattr: 1501 case TARGET_NR_lsetxattr: 1502 case TARGET_NR_fsetxattr: 1503 case TARGET_NR_getxattr: 1504 case TARGET_NR_lgetxattr: 1505 case TARGET_NR_fgetxattr: 1506 case TARGET_NR_listxattr: 1507 case TARGET_NR_llistxattr: 1508 case TARGET_NR_flistxattr: 1509 case TARGET_NR_removexattr: 1510 case TARGET_NR_lremovexattr: 1511 case TARGET_NR_fremovexattr: 1512 goto unimplemented; 1513 default: 1514 unimplemented: 1515 gemu_log("Unsupported syscall: %d\n", num); 1516 ret = -ENOSYS; 1517 break; 1518 } 1519 fail: 1520 return ret; 1521 } 1522 1523