1 /* 2 * Linux syscalls 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 #include <stdlib.h> 21 #include <stdio.h> 22 #include <stdarg.h> 23 #include <string.h> 24 #include <elf.h> 25 #include <endian.h> 26 #include <errno.h> 27 #include <unistd.h> 28 #include <fcntl.h> 29 #include <sys/types.h> 30 #include <sys/wait.h> 31 #include <sys/time.h> 32 #include <sys/stat.h> 33 #include <sys/mount.h> 34 #include <sys/resource.h> 35 #include <sys/mman.h> 36 #include <sys/swap.h> 37 #include <signal.h> 38 #include <sched.h> 39 #include <sys/socket.h> 40 #include <sys/uio.h> 41 //#include <sys/user.h> 42 43 #define termios host_termios 44 #define winsize host_winsize 45 #define termio host_termio 46 #define sgttyb host_sgttyb /* same as target */ 47 #define tchars host_tchars /* same as target */ 48 #define ltchars host_ltchars /* same as target */ 49 50 #include <linux/termios.h> 51 #include <linux/unistd.h> 52 #include <linux/utsname.h> 53 #include <linux/cdrom.h> 54 #include <linux/hdreg.h> 55 #include <linux/soundcard.h> 56 #include <linux/dirent.h> 57 58 #include "gemu.h" 59 60 //#define DEBUG 61 62 #ifndef PAGE_SIZE 63 #define PAGE_SIZE 4096 64 #define PAGE_MASK ~(PAGE_SIZE - 1) 65 #endif 66 67 //#include <linux/msdos_fs.h> 68 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2]) 69 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2]) 70 71 #include "syscall_defs.h" 72 73 #ifdef TARGET_I386 74 #include "cpu-i386.h" 75 #include "syscall-i386.h" 76 #endif 77 78 #define __NR_sys_uname __NR_uname 79 #define __NR_sys_getcwd1 __NR_getcwd 80 #define __NR_sys_statfs __NR_statfs 81 #define __NR_sys_fstatfs __NR_fstatfs 82 #define __NR_sys_getdents __NR_getdents 83 #define __NR_sys_getdents64 __NR_getdents64 84 85 #ifdef __NR_gettid 86 _syscall0(int, gettid) 87 #else 88 static int gettid(void) { 89 return -ENOSYS; 90 } 91 #endif 92 _syscall1(int,sys_uname,struct new_utsname *,buf) 93 _syscall2(int,sys_getcwd1,char *,buf,size_t,size) 94 _syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count); 95 _syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, 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 sync(); 908 ret = 0; 909 break; 910 case TARGET_NR_kill: 911 ret = get_errno(kill(arg1, arg2)); 912 break; 913 case TARGET_NR_rename: 914 ret = get_errno(rename((const char *)arg1, (const char *)arg2)); 915 break; 916 case TARGET_NR_mkdir: 917 ret = get_errno(mkdir((const char *)arg1, arg2)); 918 break; 919 case TARGET_NR_rmdir: 920 ret = get_errno(rmdir((const char *)arg1)); 921 break; 922 case TARGET_NR_dup: 923 ret = get_errno(dup(arg1)); 924 break; 925 case TARGET_NR_pipe: 926 { 927 int *pipe_ptr = (int *)arg1; 928 ret = get_errno(pipe(pipe_ptr)); 929 if (!is_error(ret)) { 930 tswap32s(&pipe_ptr[0]); 931 tswap32s(&pipe_ptr[1]); 932 } 933 } 934 break; 935 case TARGET_NR_times: 936 goto unimplemented; 937 case TARGET_NR_prof: 938 goto unimplemented; 939 case TARGET_NR_setgid: 940 ret = get_errno(setgid(arg1)); 941 break; 942 case TARGET_NR_getgid: 943 ret = get_errno(getgid()); 944 break; 945 case TARGET_NR_signal: 946 goto unimplemented; 947 case TARGET_NR_geteuid: 948 ret = get_errno(geteuid()); 949 break; 950 case TARGET_NR_getegid: 951 ret = get_errno(getegid()); 952 break; 953 case TARGET_NR_acct: 954 goto unimplemented; 955 case TARGET_NR_umount2: 956 ret = get_errno(umount2((const char *)arg1, arg2)); 957 break; 958 case TARGET_NR_lock: 959 goto unimplemented; 960 case TARGET_NR_ioctl: 961 ret = do_ioctl(arg1, arg2, arg3); 962 break; 963 case TARGET_NR_fcntl: 964 switch(arg2) { 965 case F_GETLK: 966 case F_SETLK: 967 case F_SETLKW: 968 goto unimplemented; 969 default: 970 ret = get_errno(fcntl(arg1, arg2, arg3)); 971 break; 972 } 973 break; 974 case TARGET_NR_mpx: 975 goto unimplemented; 976 case TARGET_NR_setpgid: 977 ret = get_errno(setpgid(arg1, arg2)); 978 break; 979 case TARGET_NR_ulimit: 980 goto unimplemented; 981 case TARGET_NR_oldolduname: 982 goto unimplemented; 983 case TARGET_NR_umask: 984 ret = get_errno(umask(arg1)); 985 break; 986 case TARGET_NR_chroot: 987 ret = get_errno(chroot((const char *)arg1)); 988 break; 989 case TARGET_NR_ustat: 990 goto unimplemented; 991 case TARGET_NR_dup2: 992 ret = get_errno(dup2(arg1, arg2)); 993 break; 994 case TARGET_NR_getppid: 995 ret = get_errno(getppid()); 996 break; 997 case TARGET_NR_getpgrp: 998 ret = get_errno(getpgrp()); 999 break; 1000 case TARGET_NR_setsid: 1001 ret = get_errno(setsid()); 1002 break; 1003 case TARGET_NR_sigaction: 1004 #if 1 1005 { 1006 ret = 0; 1007 } 1008 break; 1009 #else 1010 goto unimplemented; 1011 #endif 1012 case TARGET_NR_sgetmask: 1013 goto unimplemented; 1014 case TARGET_NR_ssetmask: 1015 goto unimplemented; 1016 case TARGET_NR_setreuid: 1017 ret = get_errno(setreuid(arg1, arg2)); 1018 break; 1019 case TARGET_NR_setregid: 1020 ret = get_errno(setregid(arg1, arg2)); 1021 break; 1022 case TARGET_NR_sigsuspend: 1023 goto unimplemented; 1024 case TARGET_NR_sigpending: 1025 goto unimplemented; 1026 case TARGET_NR_sethostname: 1027 ret = get_errno(sethostname((const char *)arg1, arg2)); 1028 break; 1029 case TARGET_NR_setrlimit: 1030 goto unimplemented; 1031 case TARGET_NR_getrlimit: 1032 goto unimplemented; 1033 case TARGET_NR_getrusage: 1034 goto unimplemented; 1035 case TARGET_NR_gettimeofday: 1036 { 1037 struct target_timeval *target_tv = (void *)arg1; 1038 struct timeval tv; 1039 ret = get_errno(gettimeofday(&tv, NULL)); 1040 if (!is_error(ret)) { 1041 target_tv->tv_sec = tswapl(tv.tv_sec); 1042 target_tv->tv_usec = tswapl(tv.tv_usec); 1043 } 1044 } 1045 break; 1046 case TARGET_NR_settimeofday: 1047 { 1048 struct target_timeval *target_tv = (void *)arg1; 1049 struct timeval tv; 1050 tv.tv_sec = tswapl(target_tv->tv_sec); 1051 tv.tv_usec = tswapl(target_tv->tv_usec); 1052 ret = get_errno(settimeofday(&tv, NULL)); 1053 } 1054 break; 1055 case TARGET_NR_getgroups: 1056 goto unimplemented; 1057 case TARGET_NR_setgroups: 1058 goto unimplemented; 1059 case TARGET_NR_select: 1060 goto unimplemented; 1061 case TARGET_NR_symlink: 1062 ret = get_errno(symlink((const char *)arg1, (const char *)arg2)); 1063 break; 1064 case TARGET_NR_oldlstat: 1065 goto unimplemented; 1066 case TARGET_NR_readlink: 1067 ret = get_errno(readlink((const char *)arg1, (char *)arg2, arg3)); 1068 break; 1069 case TARGET_NR_uselib: 1070 goto unimplemented; 1071 case TARGET_NR_swapon: 1072 ret = get_errno(swapon((const char *)arg1, arg2)); 1073 break; 1074 case TARGET_NR_reboot: 1075 goto unimplemented; 1076 case TARGET_NR_readdir: 1077 goto unimplemented; 1078 #ifdef TARGET_I386 1079 case TARGET_NR_mmap: 1080 { 1081 uint32_t v1, v2, v3, v4, v5, v6, *vptr; 1082 vptr = (uint32_t *)arg1; 1083 v1 = tswap32(vptr[0]); 1084 v2 = tswap32(vptr[1]); 1085 v3 = tswap32(vptr[2]); 1086 v4 = tswap32(vptr[3]); 1087 v5 = tswap32(vptr[4]); 1088 v6 = tswap32(vptr[5]); 1089 ret = get_errno((long)mmap((void *)v1, v2, v3, v4, v5, v6)); 1090 } 1091 break; 1092 #endif 1093 #ifdef TARGET_I386 1094 case TARGET_NR_mmap2: 1095 #else 1096 case TARGET_NR_mmap: 1097 #endif 1098 ret = get_errno((long)mmap((void *)arg1, arg2, arg3, arg4, arg5, arg6)); 1099 break; 1100 case TARGET_NR_munmap: 1101 ret = get_errno(munmap((void *)arg1, arg2)); 1102 break; 1103 case TARGET_NR_truncate: 1104 ret = get_errno(truncate((const char *)arg1, arg2)); 1105 break; 1106 case TARGET_NR_ftruncate: 1107 ret = get_errno(ftruncate(arg1, arg2)); 1108 break; 1109 case TARGET_NR_fchmod: 1110 ret = get_errno(fchmod(arg1, arg2)); 1111 break; 1112 case TARGET_NR_fchown: 1113 ret = get_errno(fchown(arg1, arg2, arg3)); 1114 break; 1115 case TARGET_NR_getpriority: 1116 ret = get_errno(getpriority(arg1, arg2)); 1117 break; 1118 case TARGET_NR_setpriority: 1119 ret = get_errno(setpriority(arg1, arg2, arg3)); 1120 break; 1121 case TARGET_NR_profil: 1122 goto unimplemented; 1123 case TARGET_NR_statfs: 1124 stfs = (void *)arg2; 1125 ret = get_errno(sys_statfs((const char *)arg1, stfs)); 1126 convert_statfs: 1127 if (!is_error(ret)) { 1128 tswap32s(&stfs->f_type); 1129 tswap32s(&stfs->f_bsize); 1130 tswap32s(&stfs->f_blocks); 1131 tswap32s(&stfs->f_bfree); 1132 tswap32s(&stfs->f_bavail); 1133 tswap32s(&stfs->f_files); 1134 tswap32s(&stfs->f_ffree); 1135 tswap32s(&stfs->f_fsid.val[0]); 1136 tswap32s(&stfs->f_fsid.val[1]); 1137 tswap32s(&stfs->f_namelen); 1138 } 1139 break; 1140 case TARGET_NR_fstatfs: 1141 stfs = (void *)arg2; 1142 ret = get_errno(sys_fstatfs(arg1, stfs)); 1143 goto convert_statfs; 1144 case TARGET_NR_ioperm: 1145 goto unimplemented; 1146 case TARGET_NR_socketcall: 1147 ret = do_socketcall(arg1, (long *)arg2); 1148 break; 1149 case TARGET_NR_syslog: 1150 goto unimplemented; 1151 case TARGET_NR_setitimer: 1152 goto unimplemented; 1153 case TARGET_NR_getitimer: 1154 goto unimplemented; 1155 case TARGET_NR_stat: 1156 ret = get_errno(stat((const char *)arg1, &st)); 1157 goto do_stat; 1158 case TARGET_NR_lstat: 1159 ret = get_errno(lstat((const char *)arg1, &st)); 1160 goto do_stat; 1161 case TARGET_NR_fstat: 1162 { 1163 ret = get_errno(fstat(arg1, &st)); 1164 do_stat: 1165 if (!is_error(ret)) { 1166 struct target_stat *target_st = (void *)arg2; 1167 target_st->st_dev = tswap16(st.st_dev); 1168 target_st->st_ino = tswapl(st.st_ino); 1169 target_st->st_mode = tswap16(st.st_mode); 1170 target_st->st_nlink = tswap16(st.st_nlink); 1171 target_st->st_uid = tswap16(st.st_uid); 1172 target_st->st_gid = tswap16(st.st_gid); 1173 target_st->st_rdev = tswap16(st.st_rdev); 1174 target_st->st_size = tswapl(st.st_size); 1175 target_st->st_blksize = tswapl(st.st_blksize); 1176 target_st->st_blocks = tswapl(st.st_blocks); 1177 target_st->st_atime = tswapl(st.st_atime); 1178 target_st->st_mtime = tswapl(st.st_mtime); 1179 target_st->st_ctime = tswapl(st.st_ctime); 1180 } 1181 } 1182 break; 1183 case TARGET_NR_olduname: 1184 goto unimplemented; 1185 case TARGET_NR_iopl: 1186 goto unimplemented; 1187 case TARGET_NR_vhangup: 1188 ret = get_errno(vhangup()); 1189 break; 1190 case TARGET_NR_idle: 1191 goto unimplemented; 1192 case TARGET_NR_vm86old: 1193 goto unimplemented; 1194 case TARGET_NR_wait4: 1195 { 1196 int status; 1197 target_long *status_ptr = (void *)arg2; 1198 struct rusage rusage, *rusage_ptr; 1199 struct target_rusage *target_rusage = (void *)arg4; 1200 if (target_rusage) 1201 rusage_ptr = &rusage; 1202 else 1203 rusage_ptr = NULL; 1204 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr)); 1205 if (!is_error(ret)) { 1206 if (status_ptr) 1207 *status_ptr = tswap32(status); 1208 if (target_rusage) { 1209 target_rusage->ru_utime.tv_sec = tswapl(rusage.ru_utime.tv_sec); 1210 target_rusage->ru_utime.tv_usec = tswapl(rusage.ru_utime.tv_usec); 1211 target_rusage->ru_stime.tv_sec = tswapl(rusage.ru_stime.tv_sec); 1212 target_rusage->ru_stime.tv_usec = tswapl(rusage.ru_stime.tv_usec); 1213 target_rusage->ru_maxrss = tswapl(rusage.ru_maxrss); 1214 target_rusage->ru_ixrss = tswapl(rusage.ru_ixrss); 1215 target_rusage->ru_idrss = tswapl(rusage.ru_idrss); 1216 target_rusage->ru_isrss = tswapl(rusage.ru_isrss); 1217 target_rusage->ru_minflt = tswapl(rusage.ru_minflt); 1218 target_rusage->ru_majflt = tswapl(rusage.ru_majflt); 1219 target_rusage->ru_nswap = tswapl(rusage.ru_nswap); 1220 target_rusage->ru_inblock = tswapl(rusage.ru_inblock); 1221 target_rusage->ru_oublock = tswapl(rusage.ru_oublock); 1222 target_rusage->ru_msgsnd = tswapl(rusage.ru_msgsnd); 1223 target_rusage->ru_msgrcv = tswapl(rusage.ru_msgrcv); 1224 target_rusage->ru_nsignals = tswapl(rusage.ru_nsignals); 1225 target_rusage->ru_nvcsw = tswapl(rusage.ru_nvcsw); 1226 target_rusage->ru_nivcsw = tswapl(rusage.ru_nivcsw); 1227 } 1228 } 1229 } 1230 break; 1231 case TARGET_NR_swapoff: 1232 ret = get_errno(swapoff((const char *)arg1)); 1233 break; 1234 case TARGET_NR_sysinfo: 1235 goto unimplemented; 1236 case TARGET_NR_ipc: 1237 goto unimplemented; 1238 case TARGET_NR_fsync: 1239 ret = get_errno(fsync(arg1)); 1240 break; 1241 case TARGET_NR_sigreturn: 1242 goto unimplemented; 1243 case TARGET_NR_clone: 1244 goto unimplemented; 1245 case TARGET_NR_setdomainname: 1246 ret = get_errno(setdomainname((const char *)arg1, arg2)); 1247 break; 1248 case TARGET_NR_uname: 1249 /* no need to transcode because we use the linux syscall */ 1250 ret = get_errno(sys_uname((struct new_utsname *)arg1)); 1251 break; 1252 #ifdef TARGET_I386 1253 case TARGET_NR_modify_ldt: 1254 ret = get_errno(gemu_modify_ldt(cpu_env, arg1, (void *)arg2, arg3)); 1255 break; 1256 #endif 1257 case TARGET_NR_adjtimex: 1258 goto unimplemented; 1259 case TARGET_NR_mprotect: 1260 ret = get_errno(mprotect((void *)arg1, arg2, arg3)); 1261 break; 1262 case TARGET_NR_sigprocmask: 1263 { 1264 int how = arg1; 1265 sigset_t set, oldset, *set_ptr; 1266 target_ulong *pset = (void *)arg2, *poldset = (void *)arg3; 1267 1268 switch(how) { 1269 case TARGET_SIG_BLOCK: 1270 how = SIG_BLOCK; 1271 break; 1272 case TARGET_SIG_UNBLOCK: 1273 how = SIG_UNBLOCK; 1274 break; 1275 case TARGET_SIG_SETMASK: 1276 how = SIG_SETMASK; 1277 break; 1278 default: 1279 ret = -EINVAL; 1280 goto fail; 1281 } 1282 1283 if (pset) { 1284 target_to_host_old_sigset(&set, pset); 1285 set_ptr = &set; 1286 } else { 1287 set_ptr = NULL; 1288 } 1289 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset)); 1290 if (!is_error(ret) && poldset) { 1291 host_to_target_old_sigset(poldset, &oldset); 1292 } 1293 } 1294 break; 1295 case TARGET_NR_create_module: 1296 case TARGET_NR_init_module: 1297 case TARGET_NR_delete_module: 1298 case TARGET_NR_get_kernel_syms: 1299 goto unimplemented; 1300 case TARGET_NR_quotactl: 1301 goto unimplemented; 1302 case TARGET_NR_getpgid: 1303 ret = get_errno(getpgid(arg1)); 1304 break; 1305 case TARGET_NR_fchdir: 1306 ret = get_errno(fchdir(arg1)); 1307 break; 1308 case TARGET_NR_bdflush: 1309 goto unimplemented; 1310 case TARGET_NR_sysfs: 1311 goto unimplemented; 1312 case TARGET_NR_personality: 1313 ret = get_errno(mprotect((void *)arg1, arg2, arg3)); 1314 break; 1315 case TARGET_NR_afs_syscall: 1316 goto unimplemented; 1317 case TARGET_NR_setfsuid: 1318 goto unimplemented; 1319 case TARGET_NR_setfsgid: 1320 goto unimplemented; 1321 case TARGET_NR__llseek: 1322 { 1323 int64_t res; 1324 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); 1325 *(int64_t *)arg4 = tswap64(res); 1326 } 1327 break; 1328 case TARGET_NR_getdents: 1329 #if TARGET_LONG_SIZE != 4 1330 #error not supported 1331 #endif 1332 { 1333 struct dirent *dirp = (void *)arg2; 1334 long count = arg3; 1335 1336 ret = get_errno(sys_getdents(arg1, dirp, count)); 1337 if (!is_error(ret)) { 1338 struct dirent *de; 1339 int len = ret; 1340 int reclen; 1341 de = dirp; 1342 while (len > 0) { 1343 reclen = tswap16(de->d_reclen); 1344 if (reclen > len) 1345 break; 1346 de->d_reclen = reclen; 1347 tswapls(&de->d_ino); 1348 tswapls(&de->d_off); 1349 de = (struct dirent *)((char *)de + reclen); 1350 len -= reclen; 1351 } 1352 } 1353 } 1354 break; 1355 case TARGET_NR_getdents64: 1356 { 1357 struct dirent64 *dirp = (void *)arg2; 1358 long count = arg3; 1359 ret = get_errno(sys_getdents64(arg1, dirp, count)); 1360 if (!is_error(ret)) { 1361 struct dirent64 *de; 1362 int len = ret; 1363 int reclen; 1364 de = dirp; 1365 while (len > 0) { 1366 reclen = tswap16(de->d_reclen); 1367 if (reclen > len) 1368 break; 1369 de->d_reclen = reclen; 1370 tswap64s(&de->d_ino); 1371 tswap64s(&de->d_off); 1372 de = (struct dirent64 *)((char *)de + reclen); 1373 len -= reclen; 1374 } 1375 } 1376 } 1377 break; 1378 case TARGET_NR__newselect: 1379 ret = do_select(arg1, (void *)arg2, (void *)arg3, (void *)arg4, 1380 (void *)arg5); 1381 break; 1382 case TARGET_NR_flock: 1383 goto unimplemented; 1384 case TARGET_NR_msync: 1385 ret = get_errno(msync((void *)arg1, arg2, arg3)); 1386 break; 1387 case TARGET_NR_readv: 1388 { 1389 int count = arg3; 1390 int i; 1391 struct iovec *vec; 1392 struct target_iovec *target_vec = (void *)arg2; 1393 1394 vec = alloca(count * sizeof(struct iovec)); 1395 for(i = 0;i < count; i++) { 1396 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base); 1397 vec[i].iov_len = tswapl(target_vec[i].iov_len); 1398 } 1399 ret = get_errno(readv(arg1, vec, count)); 1400 } 1401 break; 1402 case TARGET_NR_writev: 1403 { 1404 int count = arg3; 1405 int i; 1406 struct iovec *vec; 1407 struct target_iovec *target_vec = (void *)arg2; 1408 1409 vec = alloca(count * sizeof(struct iovec)); 1410 for(i = 0;i < count; i++) { 1411 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base); 1412 vec[i].iov_len = tswapl(target_vec[i].iov_len); 1413 } 1414 ret = get_errno(writev(arg1, vec, count)); 1415 } 1416 break; 1417 case TARGET_NR_getsid: 1418 ret = get_errno(getsid(arg1)); 1419 break; 1420 case TARGET_NR_fdatasync: 1421 goto unimplemented; 1422 case TARGET_NR__sysctl: 1423 goto unimplemented; 1424 case TARGET_NR_mlock: 1425 ret = get_errno(mlock((void *)arg1, arg2)); 1426 break; 1427 case TARGET_NR_munlock: 1428 ret = get_errno(munlock((void *)arg1, arg2)); 1429 break; 1430 case TARGET_NR_mlockall: 1431 ret = get_errno(mlockall(arg1)); 1432 break; 1433 case TARGET_NR_munlockall: 1434 ret = get_errno(munlockall()); 1435 break; 1436 case TARGET_NR_sched_setparam: 1437 goto unimplemented; 1438 case TARGET_NR_sched_getparam: 1439 goto unimplemented; 1440 case TARGET_NR_sched_setscheduler: 1441 goto unimplemented; 1442 case TARGET_NR_sched_getscheduler: 1443 goto unimplemented; 1444 case TARGET_NR_sched_yield: 1445 ret = get_errno(sched_yield()); 1446 break; 1447 case TARGET_NR_sched_get_priority_max: 1448 case TARGET_NR_sched_get_priority_min: 1449 case TARGET_NR_sched_rr_get_interval: 1450 case TARGET_NR_nanosleep: 1451 case TARGET_NR_mremap: 1452 case TARGET_NR_setresuid: 1453 case TARGET_NR_getresuid: 1454 case TARGET_NR_vm86: 1455 case TARGET_NR_query_module: 1456 case TARGET_NR_poll: 1457 case TARGET_NR_nfsservctl: 1458 case TARGET_NR_setresgid: 1459 case TARGET_NR_getresgid: 1460 case TARGET_NR_prctl: 1461 case TARGET_NR_rt_sigreturn: 1462 case TARGET_NR_rt_sigaction: 1463 case TARGET_NR_rt_sigprocmask: 1464 case TARGET_NR_rt_sigpending: 1465 case TARGET_NR_rt_sigtimedwait: 1466 case TARGET_NR_rt_sigqueueinfo: 1467 case TARGET_NR_rt_sigsuspend: 1468 case TARGET_NR_pread: 1469 case TARGET_NR_pwrite: 1470 goto unimplemented; 1471 case TARGET_NR_chown: 1472 ret = get_errno(chown((const char *)arg1, arg2, arg3)); 1473 break; 1474 case TARGET_NR_getcwd: 1475 ret = get_errno(sys_getcwd1((char *)arg1, arg2)); 1476 break; 1477 case TARGET_NR_capget: 1478 case TARGET_NR_capset: 1479 case TARGET_NR_sigaltstack: 1480 case TARGET_NR_sendfile: 1481 case TARGET_NR_getpmsg: 1482 case TARGET_NR_putpmsg: 1483 case TARGET_NR_vfork: 1484 ret = get_errno(vfork()); 1485 break; 1486 case TARGET_NR_ugetrlimit: 1487 case TARGET_NR_truncate64: 1488 case TARGET_NR_ftruncate64: 1489 goto unimplemented; 1490 case TARGET_NR_stat64: 1491 ret = get_errno(stat((const char *)arg1, &st)); 1492 goto do_stat64; 1493 case TARGET_NR_lstat64: 1494 ret = get_errno(lstat((const char *)arg1, &st)); 1495 goto do_stat64; 1496 case TARGET_NR_fstat64: 1497 { 1498 ret = get_errno(fstat(arg1, &st)); 1499 do_stat64: 1500 if (!is_error(ret)) { 1501 struct target_stat64 *target_st = (void *)arg2; 1502 target_st->st_dev = tswap16(st.st_dev); 1503 target_st->st_ino = tswapl(st.st_ino); 1504 target_st->st_mode = tswap16(st.st_mode); 1505 target_st->st_nlink = tswap16(st.st_nlink); 1506 target_st->st_uid = tswap16(st.st_uid); 1507 target_st->st_gid = tswap16(st.st_gid); 1508 target_st->st_rdev = tswap16(st.st_rdev); 1509 /* XXX: better use of kernel struct */ 1510 target_st->st_size = tswapl(st.st_size); 1511 target_st->st_blksize = tswapl(st.st_blksize); 1512 target_st->st_blocks = tswapl(st.st_blocks); 1513 target_st->st_atime = tswapl(st.st_atime); 1514 target_st->st_mtime = tswapl(st.st_mtime); 1515 target_st->st_ctime = tswapl(st.st_ctime); 1516 } 1517 } 1518 break; 1519 1520 case TARGET_NR_lchown32: 1521 case TARGET_NR_getuid32: 1522 case TARGET_NR_getgid32: 1523 case TARGET_NR_geteuid32: 1524 case TARGET_NR_getegid32: 1525 case TARGET_NR_setreuid32: 1526 case TARGET_NR_setregid32: 1527 case TARGET_NR_getgroups32: 1528 case TARGET_NR_setgroups32: 1529 case TARGET_NR_fchown32: 1530 case TARGET_NR_setresuid32: 1531 case TARGET_NR_getresuid32: 1532 case TARGET_NR_setresgid32: 1533 case TARGET_NR_getresgid32: 1534 case TARGET_NR_chown32: 1535 case TARGET_NR_setuid32: 1536 case TARGET_NR_setgid32: 1537 case TARGET_NR_setfsuid32: 1538 case TARGET_NR_setfsgid32: 1539 case TARGET_NR_pivot_root: 1540 case TARGET_NR_mincore: 1541 case TARGET_NR_madvise: 1542 goto unimplemented; 1543 #if TARGET_LONG_BITS == 32 1544 case TARGET_NR_fcntl64: 1545 switch(arg2) { 1546 case F_GETLK64: 1547 case F_SETLK64: 1548 case F_SETLKW64: 1549 goto unimplemented; 1550 default: 1551 ret = get_errno(fcntl(arg1, arg2, arg3)); 1552 break; 1553 } 1554 break; 1555 #endif 1556 case TARGET_NR_security: 1557 goto unimplemented; 1558 case TARGET_NR_gettid: 1559 ret = get_errno(gettid()); 1560 break; 1561 case TARGET_NR_readahead: 1562 case TARGET_NR_setxattr: 1563 case TARGET_NR_lsetxattr: 1564 case TARGET_NR_fsetxattr: 1565 case TARGET_NR_getxattr: 1566 case TARGET_NR_lgetxattr: 1567 case TARGET_NR_fgetxattr: 1568 case TARGET_NR_listxattr: 1569 case TARGET_NR_llistxattr: 1570 case TARGET_NR_flistxattr: 1571 case TARGET_NR_removexattr: 1572 case TARGET_NR_lremovexattr: 1573 case TARGET_NR_fremovexattr: 1574 goto unimplemented; 1575 default: 1576 unimplemented: 1577 gemu_log("Unsupported syscall: %d\n", num); 1578 ret = -ENOSYS; 1579 break; 1580 } 1581 fail: 1582 return ret; 1583 } 1584 1585