1 /* 2 * qemu user main 3 * 4 * Copyright (c) 2003-2008 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, see <http://www.gnu.org/licenses/>. 18 */ 19 #include <stdlib.h> 20 #include <stdio.h> 21 #include <stdarg.h> 22 #include <string.h> 23 #include <errno.h> 24 #include <unistd.h> 25 #include <sys/mman.h> 26 #include <sys/syscall.h> 27 #include <sys/resource.h> 28 29 #include "qemu.h" 30 #include "qemu-common.h" 31 #include "cache-utils.h" 32 #include "cpu.h" 33 #include "tcg.h" 34 #include "qemu-timer.h" 35 #include "envlist.h" 36 37 #define DEBUG_LOGFILE "/tmp/qemu.log" 38 39 char *exec_path; 40 41 int singlestep; 42 const char *filename; 43 const char *argv0; 44 int gdbstub_port; 45 envlist_t *envlist; 46 const char *cpu_model; 47 unsigned long mmap_min_addr; 48 #if defined(CONFIG_USE_GUEST_BASE) 49 unsigned long guest_base; 50 int have_guest_base; 51 unsigned long reserved_va; 52 #endif 53 54 static void usage(void); 55 56 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX; 57 const char *qemu_uname_release = CONFIG_UNAME_RELEASE; 58 59 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so 60 we allocate a bigger stack. Need a better solution, for example 61 by remapping the process stack directly at the right place */ 62 unsigned long guest_stack_size = 8 * 1024 * 1024UL; 63 64 void gemu_log(const char *fmt, ...) 65 { 66 va_list ap; 67 68 va_start(ap, fmt); 69 vfprintf(stderr, fmt, ap); 70 va_end(ap); 71 } 72 73 #if defined(TARGET_I386) 74 int cpu_get_pic_interrupt(CPUState *env) 75 { 76 return -1; 77 } 78 #endif 79 80 /* timers for rdtsc */ 81 82 #if 0 83 84 static uint64_t emu_time; 85 86 int64_t cpu_get_real_ticks(void) 87 { 88 return emu_time++; 89 } 90 91 #endif 92 93 #if defined(CONFIG_USE_NPTL) 94 /***********************************************************/ 95 /* Helper routines for implementing atomic operations. */ 96 97 /* To implement exclusive operations we force all cpus to syncronise. 98 We don't require a full sync, only that no cpus are executing guest code. 99 The alternative is to map target atomic ops onto host equivalents, 100 which requires quite a lot of per host/target work. */ 101 static pthread_mutex_t cpu_list_mutex = PTHREAD_MUTEX_INITIALIZER; 102 static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER; 103 static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER; 104 static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER; 105 static int pending_cpus; 106 107 /* Make sure everything is in a consistent state for calling fork(). */ 108 void fork_start(void) 109 { 110 pthread_mutex_lock(&tb_lock); 111 pthread_mutex_lock(&exclusive_lock); 112 mmap_fork_start(); 113 } 114 115 void fork_end(int child) 116 { 117 mmap_fork_end(child); 118 if (child) { 119 /* Child processes created by fork() only have a single thread. 120 Discard information about the parent threads. */ 121 first_cpu = thread_env; 122 thread_env->next_cpu = NULL; 123 pending_cpus = 0; 124 pthread_mutex_init(&exclusive_lock, NULL); 125 pthread_mutex_init(&cpu_list_mutex, NULL); 126 pthread_cond_init(&exclusive_cond, NULL); 127 pthread_cond_init(&exclusive_resume, NULL); 128 pthread_mutex_init(&tb_lock, NULL); 129 gdbserver_fork(thread_env); 130 } else { 131 pthread_mutex_unlock(&exclusive_lock); 132 pthread_mutex_unlock(&tb_lock); 133 } 134 } 135 136 /* Wait for pending exclusive operations to complete. The exclusive lock 137 must be held. */ 138 static inline void exclusive_idle(void) 139 { 140 while (pending_cpus) { 141 pthread_cond_wait(&exclusive_resume, &exclusive_lock); 142 } 143 } 144 145 /* Start an exclusive operation. 146 Must only be called from outside cpu_arm_exec. */ 147 static inline void start_exclusive(void) 148 { 149 CPUState *other; 150 pthread_mutex_lock(&exclusive_lock); 151 exclusive_idle(); 152 153 pending_cpus = 1; 154 /* Make all other cpus stop executing. */ 155 for (other = first_cpu; other; other = other->next_cpu) { 156 if (other->running) { 157 pending_cpus++; 158 cpu_exit(other); 159 } 160 } 161 if (pending_cpus > 1) { 162 pthread_cond_wait(&exclusive_cond, &exclusive_lock); 163 } 164 } 165 166 /* Finish an exclusive operation. */ 167 static inline void end_exclusive(void) 168 { 169 pending_cpus = 0; 170 pthread_cond_broadcast(&exclusive_resume); 171 pthread_mutex_unlock(&exclusive_lock); 172 } 173 174 /* Wait for exclusive ops to finish, and begin cpu execution. */ 175 static inline void cpu_exec_start(CPUState *env) 176 { 177 pthread_mutex_lock(&exclusive_lock); 178 exclusive_idle(); 179 env->running = 1; 180 pthread_mutex_unlock(&exclusive_lock); 181 } 182 183 /* Mark cpu as not executing, and release pending exclusive ops. */ 184 static inline void cpu_exec_end(CPUState *env) 185 { 186 pthread_mutex_lock(&exclusive_lock); 187 env->running = 0; 188 if (pending_cpus > 1) { 189 pending_cpus--; 190 if (pending_cpus == 1) { 191 pthread_cond_signal(&exclusive_cond); 192 } 193 } 194 exclusive_idle(); 195 pthread_mutex_unlock(&exclusive_lock); 196 } 197 198 void cpu_list_lock(void) 199 { 200 pthread_mutex_lock(&cpu_list_mutex); 201 } 202 203 void cpu_list_unlock(void) 204 { 205 pthread_mutex_unlock(&cpu_list_mutex); 206 } 207 #else /* if !CONFIG_USE_NPTL */ 208 /* These are no-ops because we are not threadsafe. */ 209 static inline void cpu_exec_start(CPUState *env) 210 { 211 } 212 213 static inline void cpu_exec_end(CPUState *env) 214 { 215 } 216 217 static inline void start_exclusive(void) 218 { 219 } 220 221 static inline void end_exclusive(void) 222 { 223 } 224 225 void fork_start(void) 226 { 227 } 228 229 void fork_end(int child) 230 { 231 if (child) { 232 gdbserver_fork(thread_env); 233 } 234 } 235 236 void cpu_list_lock(void) 237 { 238 } 239 240 void cpu_list_unlock(void) 241 { 242 } 243 #endif 244 245 246 #ifdef TARGET_I386 247 /***********************************************************/ 248 /* CPUX86 core interface */ 249 250 void cpu_smm_update(CPUState *env) 251 { 252 } 253 254 uint64_t cpu_get_tsc(CPUX86State *env) 255 { 256 return cpu_get_real_ticks(); 257 } 258 259 static void write_dt(void *ptr, unsigned long addr, unsigned long limit, 260 int flags) 261 { 262 unsigned int e1, e2; 263 uint32_t *p; 264 e1 = (addr << 16) | (limit & 0xffff); 265 e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); 266 e2 |= flags; 267 p = ptr; 268 p[0] = tswap32(e1); 269 p[1] = tswap32(e2); 270 } 271 272 static uint64_t *idt_table; 273 #ifdef TARGET_X86_64 274 static void set_gate64(void *ptr, unsigned int type, unsigned int dpl, 275 uint64_t addr, unsigned int sel) 276 { 277 uint32_t *p, e1, e2; 278 e1 = (addr & 0xffff) | (sel << 16); 279 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); 280 p = ptr; 281 p[0] = tswap32(e1); 282 p[1] = tswap32(e2); 283 p[2] = tswap32(addr >> 32); 284 p[3] = 0; 285 } 286 /* only dpl matters as we do only user space emulation */ 287 static void set_idt(int n, unsigned int dpl) 288 { 289 set_gate64(idt_table + n * 2, 0, dpl, 0, 0); 290 } 291 #else 292 static void set_gate(void *ptr, unsigned int type, unsigned int dpl, 293 uint32_t addr, unsigned int sel) 294 { 295 uint32_t *p, e1, e2; 296 e1 = (addr & 0xffff) | (sel << 16); 297 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); 298 p = ptr; 299 p[0] = tswap32(e1); 300 p[1] = tswap32(e2); 301 } 302 303 /* only dpl matters as we do only user space emulation */ 304 static void set_idt(int n, unsigned int dpl) 305 { 306 set_gate(idt_table + n, 0, dpl, 0, 0); 307 } 308 #endif 309 310 void cpu_loop(CPUX86State *env) 311 { 312 int trapnr; 313 abi_ulong pc; 314 target_siginfo_t info; 315 316 for(;;) { 317 trapnr = cpu_x86_exec(env); 318 switch(trapnr) { 319 case 0x80: 320 /* linux syscall from int $0x80 */ 321 env->regs[R_EAX] = do_syscall(env, 322 env->regs[R_EAX], 323 env->regs[R_EBX], 324 env->regs[R_ECX], 325 env->regs[R_EDX], 326 env->regs[R_ESI], 327 env->regs[R_EDI], 328 env->regs[R_EBP], 329 0, 0); 330 break; 331 #ifndef TARGET_ABI32 332 case EXCP_SYSCALL: 333 /* linux syscall from syscall instruction */ 334 env->regs[R_EAX] = do_syscall(env, 335 env->regs[R_EAX], 336 env->regs[R_EDI], 337 env->regs[R_ESI], 338 env->regs[R_EDX], 339 env->regs[10], 340 env->regs[8], 341 env->regs[9], 342 0, 0); 343 env->eip = env->exception_next_eip; 344 break; 345 #endif 346 case EXCP0B_NOSEG: 347 case EXCP0C_STACK: 348 info.si_signo = SIGBUS; 349 info.si_errno = 0; 350 info.si_code = TARGET_SI_KERNEL; 351 info._sifields._sigfault._addr = 0; 352 queue_signal(env, info.si_signo, &info); 353 break; 354 case EXCP0D_GPF: 355 /* XXX: potential problem if ABI32 */ 356 #ifndef TARGET_X86_64 357 if (env->eflags & VM_MASK) { 358 handle_vm86_fault(env); 359 } else 360 #endif 361 { 362 info.si_signo = SIGSEGV; 363 info.si_errno = 0; 364 info.si_code = TARGET_SI_KERNEL; 365 info._sifields._sigfault._addr = 0; 366 queue_signal(env, info.si_signo, &info); 367 } 368 break; 369 case EXCP0E_PAGE: 370 info.si_signo = SIGSEGV; 371 info.si_errno = 0; 372 if (!(env->error_code & 1)) 373 info.si_code = TARGET_SEGV_MAPERR; 374 else 375 info.si_code = TARGET_SEGV_ACCERR; 376 info._sifields._sigfault._addr = env->cr[2]; 377 queue_signal(env, info.si_signo, &info); 378 break; 379 case EXCP00_DIVZ: 380 #ifndef TARGET_X86_64 381 if (env->eflags & VM_MASK) { 382 handle_vm86_trap(env, trapnr); 383 } else 384 #endif 385 { 386 /* division by zero */ 387 info.si_signo = SIGFPE; 388 info.si_errno = 0; 389 info.si_code = TARGET_FPE_INTDIV; 390 info._sifields._sigfault._addr = env->eip; 391 queue_signal(env, info.si_signo, &info); 392 } 393 break; 394 case EXCP01_DB: 395 case EXCP03_INT3: 396 #ifndef TARGET_X86_64 397 if (env->eflags & VM_MASK) { 398 handle_vm86_trap(env, trapnr); 399 } else 400 #endif 401 { 402 info.si_signo = SIGTRAP; 403 info.si_errno = 0; 404 if (trapnr == EXCP01_DB) { 405 info.si_code = TARGET_TRAP_BRKPT; 406 info._sifields._sigfault._addr = env->eip; 407 } else { 408 info.si_code = TARGET_SI_KERNEL; 409 info._sifields._sigfault._addr = 0; 410 } 411 queue_signal(env, info.si_signo, &info); 412 } 413 break; 414 case EXCP04_INTO: 415 case EXCP05_BOUND: 416 #ifndef TARGET_X86_64 417 if (env->eflags & VM_MASK) { 418 handle_vm86_trap(env, trapnr); 419 } else 420 #endif 421 { 422 info.si_signo = SIGSEGV; 423 info.si_errno = 0; 424 info.si_code = TARGET_SI_KERNEL; 425 info._sifields._sigfault._addr = 0; 426 queue_signal(env, info.si_signo, &info); 427 } 428 break; 429 case EXCP06_ILLOP: 430 info.si_signo = SIGILL; 431 info.si_errno = 0; 432 info.si_code = TARGET_ILL_ILLOPN; 433 info._sifields._sigfault._addr = env->eip; 434 queue_signal(env, info.si_signo, &info); 435 break; 436 case EXCP_INTERRUPT: 437 /* just indicate that signals should be handled asap */ 438 break; 439 case EXCP_DEBUG: 440 { 441 int sig; 442 443 sig = gdb_handlesig (env, TARGET_SIGTRAP); 444 if (sig) 445 { 446 info.si_signo = sig; 447 info.si_errno = 0; 448 info.si_code = TARGET_TRAP_BRKPT; 449 queue_signal(env, info.si_signo, &info); 450 } 451 } 452 break; 453 default: 454 pc = env->segs[R_CS].base + env->eip; 455 fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", 456 (long)pc, trapnr); 457 abort(); 458 } 459 process_pending_signals(env); 460 } 461 } 462 #endif 463 464 #ifdef TARGET_ARM 465 466 /* 467 * See the Linux kernel's Documentation/arm/kernel_user_helpers.txt 468 * Input: 469 * r0 = pointer to oldval 470 * r1 = pointer to newval 471 * r2 = pointer to target value 472 * 473 * Output: 474 * r0 = 0 if *ptr was changed, non-0 if no exchange happened 475 * C set if *ptr was changed, clear if no exchange happened 476 * 477 * Note segv's in kernel helpers are a bit tricky, we can set the 478 * data address sensibly but the PC address is just the entry point. 479 */ 480 static void arm_kernel_cmpxchg64_helper(CPUARMState *env) 481 { 482 uint64_t oldval, newval, val; 483 uint32_t addr, cpsr; 484 target_siginfo_t info; 485 486 /* Based on the 32 bit code in do_kernel_trap */ 487 488 /* XXX: This only works between threads, not between processes. 489 It's probably possible to implement this with native host 490 operations. However things like ldrex/strex are much harder so 491 there's not much point trying. */ 492 start_exclusive(); 493 cpsr = cpsr_read(env); 494 addr = env->regs[2]; 495 496 if (get_user_u64(oldval, env->regs[0])) { 497 env->cp15.c6_data = env->regs[0]; 498 goto segv; 499 }; 500 501 if (get_user_u64(newval, env->regs[1])) { 502 env->cp15.c6_data = env->regs[1]; 503 goto segv; 504 }; 505 506 if (get_user_u64(val, addr)) { 507 env->cp15.c6_data = addr; 508 goto segv; 509 } 510 511 if (val == oldval) { 512 val = newval; 513 514 if (put_user_u64(val, addr)) { 515 env->cp15.c6_data = addr; 516 goto segv; 517 }; 518 519 env->regs[0] = 0; 520 cpsr |= CPSR_C; 521 } else { 522 env->regs[0] = -1; 523 cpsr &= ~CPSR_C; 524 } 525 cpsr_write(env, cpsr, CPSR_C); 526 end_exclusive(); 527 return; 528 529 segv: 530 end_exclusive(); 531 /* We get the PC of the entry address - which is as good as anything, 532 on a real kernel what you get depends on which mode it uses. */ 533 info.si_signo = SIGSEGV; 534 info.si_errno = 0; 535 /* XXX: check env->error_code */ 536 info.si_code = TARGET_SEGV_MAPERR; 537 info._sifields._sigfault._addr = env->cp15.c6_data; 538 queue_signal(env, info.si_signo, &info); 539 540 end_exclusive(); 541 } 542 543 /* Handle a jump to the kernel code page. */ 544 static int 545 do_kernel_trap(CPUARMState *env) 546 { 547 uint32_t addr; 548 uint32_t cpsr; 549 uint32_t val; 550 551 switch (env->regs[15]) { 552 case 0xffff0fa0: /* __kernel_memory_barrier */ 553 /* ??? No-op. Will need to do better for SMP. */ 554 break; 555 case 0xffff0fc0: /* __kernel_cmpxchg */ 556 /* XXX: This only works between threads, not between processes. 557 It's probably possible to implement this with native host 558 operations. However things like ldrex/strex are much harder so 559 there's not much point trying. */ 560 start_exclusive(); 561 cpsr = cpsr_read(env); 562 addr = env->regs[2]; 563 /* FIXME: This should SEGV if the access fails. */ 564 if (get_user_u32(val, addr)) 565 val = ~env->regs[0]; 566 if (val == env->regs[0]) { 567 val = env->regs[1]; 568 /* FIXME: Check for segfaults. */ 569 put_user_u32(val, addr); 570 env->regs[0] = 0; 571 cpsr |= CPSR_C; 572 } else { 573 env->regs[0] = -1; 574 cpsr &= ~CPSR_C; 575 } 576 cpsr_write(env, cpsr, CPSR_C); 577 end_exclusive(); 578 break; 579 case 0xffff0fe0: /* __kernel_get_tls */ 580 env->regs[0] = env->cp15.c13_tls2; 581 break; 582 case 0xffff0f60: /* __kernel_cmpxchg64 */ 583 arm_kernel_cmpxchg64_helper(env); 584 break; 585 586 default: 587 return 1; 588 } 589 /* Jump back to the caller. */ 590 addr = env->regs[14]; 591 if (addr & 1) { 592 env->thumb = 1; 593 addr &= ~1; 594 } 595 env->regs[15] = addr; 596 597 return 0; 598 } 599 600 static int do_strex(CPUARMState *env) 601 { 602 uint32_t val; 603 int size; 604 int rc = 1; 605 int segv = 0; 606 uint32_t addr; 607 start_exclusive(); 608 addr = env->exclusive_addr; 609 if (addr != env->exclusive_test) { 610 goto fail; 611 } 612 size = env->exclusive_info & 0xf; 613 switch (size) { 614 case 0: 615 segv = get_user_u8(val, addr); 616 break; 617 case 1: 618 segv = get_user_u16(val, addr); 619 break; 620 case 2: 621 case 3: 622 segv = get_user_u32(val, addr); 623 break; 624 default: 625 abort(); 626 } 627 if (segv) { 628 env->cp15.c6_data = addr; 629 goto done; 630 } 631 if (val != env->exclusive_val) { 632 goto fail; 633 } 634 if (size == 3) { 635 segv = get_user_u32(val, addr + 4); 636 if (segv) { 637 env->cp15.c6_data = addr + 4; 638 goto done; 639 } 640 if (val != env->exclusive_high) { 641 goto fail; 642 } 643 } 644 val = env->regs[(env->exclusive_info >> 8) & 0xf]; 645 switch (size) { 646 case 0: 647 segv = put_user_u8(val, addr); 648 break; 649 case 1: 650 segv = put_user_u16(val, addr); 651 break; 652 case 2: 653 case 3: 654 segv = put_user_u32(val, addr); 655 break; 656 } 657 if (segv) { 658 env->cp15.c6_data = addr; 659 goto done; 660 } 661 if (size == 3) { 662 val = env->regs[(env->exclusive_info >> 12) & 0xf]; 663 segv = put_user_u32(val, addr + 4); 664 if (segv) { 665 env->cp15.c6_data = addr + 4; 666 goto done; 667 } 668 } 669 rc = 0; 670 fail: 671 env->regs[15] += 4; 672 env->regs[(env->exclusive_info >> 4) & 0xf] = rc; 673 done: 674 end_exclusive(); 675 return segv; 676 } 677 678 void cpu_loop(CPUARMState *env) 679 { 680 int trapnr; 681 unsigned int n, insn; 682 target_siginfo_t info; 683 uint32_t addr; 684 685 for(;;) { 686 cpu_exec_start(env); 687 trapnr = cpu_arm_exec(env); 688 cpu_exec_end(env); 689 switch(trapnr) { 690 case EXCP_UDEF: 691 { 692 TaskState *ts = env->opaque; 693 uint32_t opcode; 694 int rc; 695 696 /* we handle the FPU emulation here, as Linux */ 697 /* we get the opcode */ 698 /* FIXME - what to do if get_user() fails? */ 699 get_user_u32(opcode, env->regs[15]); 700 701 rc = EmulateAll(opcode, &ts->fpa, env); 702 if (rc == 0) { /* illegal instruction */ 703 info.si_signo = SIGILL; 704 info.si_errno = 0; 705 info.si_code = TARGET_ILL_ILLOPN; 706 info._sifields._sigfault._addr = env->regs[15]; 707 queue_signal(env, info.si_signo, &info); 708 } else if (rc < 0) { /* FP exception */ 709 int arm_fpe=0; 710 711 /* translate softfloat flags to FPSR flags */ 712 if (-rc & float_flag_invalid) 713 arm_fpe |= BIT_IOC; 714 if (-rc & float_flag_divbyzero) 715 arm_fpe |= BIT_DZC; 716 if (-rc & float_flag_overflow) 717 arm_fpe |= BIT_OFC; 718 if (-rc & float_flag_underflow) 719 arm_fpe |= BIT_UFC; 720 if (-rc & float_flag_inexact) 721 arm_fpe |= BIT_IXC; 722 723 FPSR fpsr = ts->fpa.fpsr; 724 //printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe); 725 726 if (fpsr & (arm_fpe << 16)) { /* exception enabled? */ 727 info.si_signo = SIGFPE; 728 info.si_errno = 0; 729 730 /* ordered by priority, least first */ 731 if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES; 732 if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND; 733 if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF; 734 if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV; 735 if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV; 736 737 info._sifields._sigfault._addr = env->regs[15]; 738 queue_signal(env, info.si_signo, &info); 739 } else { 740 env->regs[15] += 4; 741 } 742 743 /* accumulate unenabled exceptions */ 744 if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC)) 745 fpsr |= BIT_IXC; 746 if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC)) 747 fpsr |= BIT_UFC; 748 if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC)) 749 fpsr |= BIT_OFC; 750 if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC)) 751 fpsr |= BIT_DZC; 752 if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC)) 753 fpsr |= BIT_IOC; 754 ts->fpa.fpsr=fpsr; 755 } else { /* everything OK */ 756 /* increment PC */ 757 env->regs[15] += 4; 758 } 759 } 760 break; 761 case EXCP_SWI: 762 case EXCP_BKPT: 763 { 764 env->eabi = 1; 765 /* system call */ 766 if (trapnr == EXCP_BKPT) { 767 if (env->thumb) { 768 /* FIXME - what to do if get_user() fails? */ 769 get_user_u16(insn, env->regs[15]); 770 n = insn & 0xff; 771 env->regs[15] += 2; 772 } else { 773 /* FIXME - what to do if get_user() fails? */ 774 get_user_u32(insn, env->regs[15]); 775 n = (insn & 0xf) | ((insn >> 4) & 0xff0); 776 env->regs[15] += 4; 777 } 778 } else { 779 if (env->thumb) { 780 /* FIXME - what to do if get_user() fails? */ 781 get_user_u16(insn, env->regs[15] - 2); 782 n = insn & 0xff; 783 } else { 784 /* FIXME - what to do if get_user() fails? */ 785 get_user_u32(insn, env->regs[15] - 4); 786 n = insn & 0xffffff; 787 } 788 } 789 790 if (n == ARM_NR_cacheflush) { 791 /* nop */ 792 } else if (n == ARM_NR_semihosting 793 || n == ARM_NR_thumb_semihosting) { 794 env->regs[0] = do_arm_semihosting (env); 795 } else if (n == 0 || n >= ARM_SYSCALL_BASE 796 || (env->thumb && n == ARM_THUMB_SYSCALL)) { 797 /* linux syscall */ 798 if (env->thumb || n == 0) { 799 n = env->regs[7]; 800 } else { 801 n -= ARM_SYSCALL_BASE; 802 env->eabi = 0; 803 } 804 if ( n > ARM_NR_BASE) { 805 switch (n) { 806 case ARM_NR_cacheflush: 807 /* nop */ 808 break; 809 case ARM_NR_set_tls: 810 cpu_set_tls(env, env->regs[0]); 811 env->regs[0] = 0; 812 break; 813 default: 814 gemu_log("qemu: Unsupported ARM syscall: 0x%x\n", 815 n); 816 env->regs[0] = -TARGET_ENOSYS; 817 break; 818 } 819 } else { 820 env->regs[0] = do_syscall(env, 821 n, 822 env->regs[0], 823 env->regs[1], 824 env->regs[2], 825 env->regs[3], 826 env->regs[4], 827 env->regs[5], 828 0, 0); 829 } 830 } else { 831 goto error; 832 } 833 } 834 break; 835 case EXCP_INTERRUPT: 836 /* just indicate that signals should be handled asap */ 837 break; 838 case EXCP_PREFETCH_ABORT: 839 addr = env->cp15.c6_insn; 840 goto do_segv; 841 case EXCP_DATA_ABORT: 842 addr = env->cp15.c6_data; 843 do_segv: 844 { 845 info.si_signo = SIGSEGV; 846 info.si_errno = 0; 847 /* XXX: check env->error_code */ 848 info.si_code = TARGET_SEGV_MAPERR; 849 info._sifields._sigfault._addr = addr; 850 queue_signal(env, info.si_signo, &info); 851 } 852 break; 853 case EXCP_DEBUG: 854 { 855 int sig; 856 857 sig = gdb_handlesig (env, TARGET_SIGTRAP); 858 if (sig) 859 { 860 info.si_signo = sig; 861 info.si_errno = 0; 862 info.si_code = TARGET_TRAP_BRKPT; 863 queue_signal(env, info.si_signo, &info); 864 } 865 } 866 break; 867 case EXCP_KERNEL_TRAP: 868 if (do_kernel_trap(env)) 869 goto error; 870 break; 871 case EXCP_STREX: 872 if (do_strex(env)) { 873 addr = env->cp15.c6_data; 874 goto do_segv; 875 } 876 break; 877 default: 878 error: 879 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 880 trapnr); 881 cpu_dump_state(env, stderr, fprintf, 0); 882 abort(); 883 } 884 process_pending_signals(env); 885 } 886 } 887 888 #endif 889 890 #ifdef TARGET_UNICORE32 891 892 void cpu_loop(CPUState *env) 893 { 894 int trapnr; 895 unsigned int n, insn; 896 target_siginfo_t info; 897 898 for (;;) { 899 cpu_exec_start(env); 900 trapnr = uc32_cpu_exec(env); 901 cpu_exec_end(env); 902 switch (trapnr) { 903 case UC32_EXCP_PRIV: 904 { 905 /* system call */ 906 get_user_u32(insn, env->regs[31] - 4); 907 n = insn & 0xffffff; 908 909 if (n >= UC32_SYSCALL_BASE) { 910 /* linux syscall */ 911 n -= UC32_SYSCALL_BASE; 912 if (n == UC32_SYSCALL_NR_set_tls) { 913 cpu_set_tls(env, env->regs[0]); 914 env->regs[0] = 0; 915 } else { 916 env->regs[0] = do_syscall(env, 917 n, 918 env->regs[0], 919 env->regs[1], 920 env->regs[2], 921 env->regs[3], 922 env->regs[4], 923 env->regs[5], 924 0, 0); 925 } 926 } else { 927 goto error; 928 } 929 } 930 break; 931 case UC32_EXCP_TRAP: 932 info.si_signo = SIGSEGV; 933 info.si_errno = 0; 934 /* XXX: check env->error_code */ 935 info.si_code = TARGET_SEGV_MAPERR; 936 info._sifields._sigfault._addr = env->cp0.c4_faultaddr; 937 queue_signal(env, info.si_signo, &info); 938 break; 939 case EXCP_INTERRUPT: 940 /* just indicate that signals should be handled asap */ 941 break; 942 case EXCP_DEBUG: 943 { 944 int sig; 945 946 sig = gdb_handlesig(env, TARGET_SIGTRAP); 947 if (sig) { 948 info.si_signo = sig; 949 info.si_errno = 0; 950 info.si_code = TARGET_TRAP_BRKPT; 951 queue_signal(env, info.si_signo, &info); 952 } 953 } 954 break; 955 default: 956 goto error; 957 } 958 process_pending_signals(env); 959 } 960 961 error: 962 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 963 cpu_dump_state(env, stderr, fprintf, 0); 964 abort(); 965 } 966 #endif 967 968 #ifdef TARGET_SPARC 969 #define SPARC64_STACK_BIAS 2047 970 971 //#define DEBUG_WIN 972 973 /* WARNING: dealing with register windows _is_ complicated. More info 974 can be found at http://www.sics.se/~psm/sparcstack.html */ 975 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) 976 { 977 index = (index + cwp * 16) % (16 * env->nwindows); 978 /* wrap handling : if cwp is on the last window, then we use the 979 registers 'after' the end */ 980 if (index < 8 && env->cwp == env->nwindows - 1) 981 index += 16 * env->nwindows; 982 return index; 983 } 984 985 /* save the register window 'cwp1' */ 986 static inline void save_window_offset(CPUSPARCState *env, int cwp1) 987 { 988 unsigned int i; 989 abi_ulong sp_ptr; 990 991 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 992 #ifdef TARGET_SPARC64 993 if (sp_ptr & 3) 994 sp_ptr += SPARC64_STACK_BIAS; 995 #endif 996 #if defined(DEBUG_WIN) 997 printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n", 998 sp_ptr, cwp1); 999 #endif 1000 for(i = 0; i < 16; i++) { 1001 /* FIXME - what to do if put_user() fails? */ 1002 put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 1003 sp_ptr += sizeof(abi_ulong); 1004 } 1005 } 1006 1007 static void save_window(CPUSPARCState *env) 1008 { 1009 #ifndef TARGET_SPARC64 1010 unsigned int new_wim; 1011 new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) & 1012 ((1LL << env->nwindows) - 1); 1013 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 1014 env->wim = new_wim; 1015 #else 1016 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 1017 env->cansave++; 1018 env->canrestore--; 1019 #endif 1020 } 1021 1022 static void restore_window(CPUSPARCState *env) 1023 { 1024 #ifndef TARGET_SPARC64 1025 unsigned int new_wim; 1026 #endif 1027 unsigned int i, cwp1; 1028 abi_ulong sp_ptr; 1029 1030 #ifndef TARGET_SPARC64 1031 new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) & 1032 ((1LL << env->nwindows) - 1); 1033 #endif 1034 1035 /* restore the invalid window */ 1036 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 1037 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 1038 #ifdef TARGET_SPARC64 1039 if (sp_ptr & 3) 1040 sp_ptr += SPARC64_STACK_BIAS; 1041 #endif 1042 #if defined(DEBUG_WIN) 1043 printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n", 1044 sp_ptr, cwp1); 1045 #endif 1046 for(i = 0; i < 16; i++) { 1047 /* FIXME - what to do if get_user() fails? */ 1048 get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 1049 sp_ptr += sizeof(abi_ulong); 1050 } 1051 #ifdef TARGET_SPARC64 1052 env->canrestore++; 1053 if (env->cleanwin < env->nwindows - 1) 1054 env->cleanwin++; 1055 env->cansave--; 1056 #else 1057 env->wim = new_wim; 1058 #endif 1059 } 1060 1061 static void flush_windows(CPUSPARCState *env) 1062 { 1063 int offset, cwp1; 1064 1065 offset = 1; 1066 for(;;) { 1067 /* if restore would invoke restore_window(), then we can stop */ 1068 cwp1 = cpu_cwp_inc(env, env->cwp + offset); 1069 #ifndef TARGET_SPARC64 1070 if (env->wim & (1 << cwp1)) 1071 break; 1072 #else 1073 if (env->canrestore == 0) 1074 break; 1075 env->cansave++; 1076 env->canrestore--; 1077 #endif 1078 save_window_offset(env, cwp1); 1079 offset++; 1080 } 1081 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 1082 #ifndef TARGET_SPARC64 1083 /* set wim so that restore will reload the registers */ 1084 env->wim = 1 << cwp1; 1085 #endif 1086 #if defined(DEBUG_WIN) 1087 printf("flush_windows: nb=%d\n", offset - 1); 1088 #endif 1089 } 1090 1091 void cpu_loop (CPUSPARCState *env) 1092 { 1093 int trapnr; 1094 abi_long ret; 1095 target_siginfo_t info; 1096 1097 while (1) { 1098 trapnr = cpu_sparc_exec (env); 1099 1100 switch (trapnr) { 1101 #ifndef TARGET_SPARC64 1102 case 0x88: 1103 case 0x90: 1104 #else 1105 case 0x110: 1106 case 0x16d: 1107 #endif 1108 ret = do_syscall (env, env->gregs[1], 1109 env->regwptr[0], env->regwptr[1], 1110 env->regwptr[2], env->regwptr[3], 1111 env->regwptr[4], env->regwptr[5], 1112 0, 0); 1113 if ((abi_ulong)ret >= (abi_ulong)(-515)) { 1114 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 1115 env->xcc |= PSR_CARRY; 1116 #else 1117 env->psr |= PSR_CARRY; 1118 #endif 1119 ret = -ret; 1120 } else { 1121 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 1122 env->xcc &= ~PSR_CARRY; 1123 #else 1124 env->psr &= ~PSR_CARRY; 1125 #endif 1126 } 1127 env->regwptr[0] = ret; 1128 /* next instruction */ 1129 env->pc = env->npc; 1130 env->npc = env->npc + 4; 1131 break; 1132 case 0x83: /* flush windows */ 1133 #ifdef TARGET_ABI32 1134 case 0x103: 1135 #endif 1136 flush_windows(env); 1137 /* next instruction */ 1138 env->pc = env->npc; 1139 env->npc = env->npc + 4; 1140 break; 1141 #ifndef TARGET_SPARC64 1142 case TT_WIN_OVF: /* window overflow */ 1143 save_window(env); 1144 break; 1145 case TT_WIN_UNF: /* window underflow */ 1146 restore_window(env); 1147 break; 1148 case TT_TFAULT: 1149 case TT_DFAULT: 1150 { 1151 info.si_signo = SIGSEGV; 1152 info.si_errno = 0; 1153 /* XXX: check env->error_code */ 1154 info.si_code = TARGET_SEGV_MAPERR; 1155 info._sifields._sigfault._addr = env->mmuregs[4]; 1156 queue_signal(env, info.si_signo, &info); 1157 } 1158 break; 1159 #else 1160 case TT_SPILL: /* window overflow */ 1161 save_window(env); 1162 break; 1163 case TT_FILL: /* window underflow */ 1164 restore_window(env); 1165 break; 1166 case TT_TFAULT: 1167 case TT_DFAULT: 1168 { 1169 info.si_signo = SIGSEGV; 1170 info.si_errno = 0; 1171 /* XXX: check env->error_code */ 1172 info.si_code = TARGET_SEGV_MAPERR; 1173 if (trapnr == TT_DFAULT) 1174 info._sifields._sigfault._addr = env->dmmuregs[4]; 1175 else 1176 info._sifields._sigfault._addr = cpu_tsptr(env)->tpc; 1177 queue_signal(env, info.si_signo, &info); 1178 } 1179 break; 1180 #ifndef TARGET_ABI32 1181 case 0x16e: 1182 flush_windows(env); 1183 sparc64_get_context(env); 1184 break; 1185 case 0x16f: 1186 flush_windows(env); 1187 sparc64_set_context(env); 1188 break; 1189 #endif 1190 #endif 1191 case EXCP_INTERRUPT: 1192 /* just indicate that signals should be handled asap */ 1193 break; 1194 case EXCP_DEBUG: 1195 { 1196 int sig; 1197 1198 sig = gdb_handlesig (env, TARGET_SIGTRAP); 1199 if (sig) 1200 { 1201 info.si_signo = sig; 1202 info.si_errno = 0; 1203 info.si_code = TARGET_TRAP_BRKPT; 1204 queue_signal(env, info.si_signo, &info); 1205 } 1206 } 1207 break; 1208 default: 1209 printf ("Unhandled trap: 0x%x\n", trapnr); 1210 cpu_dump_state(env, stderr, fprintf, 0); 1211 exit (1); 1212 } 1213 process_pending_signals (env); 1214 } 1215 } 1216 1217 #endif 1218 1219 #ifdef TARGET_PPC 1220 static inline uint64_t cpu_ppc_get_tb (CPUState *env) 1221 { 1222 /* TO FIX */ 1223 return 0; 1224 } 1225 1226 uint64_t cpu_ppc_load_tbl (CPUState *env) 1227 { 1228 return cpu_ppc_get_tb(env); 1229 } 1230 1231 uint32_t cpu_ppc_load_tbu (CPUState *env) 1232 { 1233 return cpu_ppc_get_tb(env) >> 32; 1234 } 1235 1236 uint64_t cpu_ppc_load_atbl (CPUState *env) 1237 { 1238 return cpu_ppc_get_tb(env); 1239 } 1240 1241 uint32_t cpu_ppc_load_atbu (CPUState *env) 1242 { 1243 return cpu_ppc_get_tb(env) >> 32; 1244 } 1245 1246 uint32_t cpu_ppc601_load_rtcu (CPUState *env) 1247 __attribute__ (( alias ("cpu_ppc_load_tbu") )); 1248 1249 uint32_t cpu_ppc601_load_rtcl (CPUState *env) 1250 { 1251 return cpu_ppc_load_tbl(env) & 0x3FFFFF80; 1252 } 1253 1254 /* XXX: to be fixed */ 1255 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp) 1256 { 1257 return -1; 1258 } 1259 1260 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val) 1261 { 1262 return -1; 1263 } 1264 1265 #define EXCP_DUMP(env, fmt, ...) \ 1266 do { \ 1267 fprintf(stderr, fmt , ## __VA_ARGS__); \ 1268 cpu_dump_state(env, stderr, fprintf, 0); \ 1269 qemu_log(fmt, ## __VA_ARGS__); \ 1270 if (logfile) \ 1271 log_cpu_state(env, 0); \ 1272 } while (0) 1273 1274 static int do_store_exclusive(CPUPPCState *env) 1275 { 1276 target_ulong addr; 1277 target_ulong page_addr; 1278 target_ulong val; 1279 int flags; 1280 int segv = 0; 1281 1282 addr = env->reserve_ea; 1283 page_addr = addr & TARGET_PAGE_MASK; 1284 start_exclusive(); 1285 mmap_lock(); 1286 flags = page_get_flags(page_addr); 1287 if ((flags & PAGE_READ) == 0) { 1288 segv = 1; 1289 } else { 1290 int reg = env->reserve_info & 0x1f; 1291 int size = (env->reserve_info >> 5) & 0xf; 1292 int stored = 0; 1293 1294 if (addr == env->reserve_addr) { 1295 switch (size) { 1296 case 1: segv = get_user_u8(val, addr); break; 1297 case 2: segv = get_user_u16(val, addr); break; 1298 case 4: segv = get_user_u32(val, addr); break; 1299 #if defined(TARGET_PPC64) 1300 case 8: segv = get_user_u64(val, addr); break; 1301 #endif 1302 default: abort(); 1303 } 1304 if (!segv && val == env->reserve_val) { 1305 val = env->gpr[reg]; 1306 switch (size) { 1307 case 1: segv = put_user_u8(val, addr); break; 1308 case 2: segv = put_user_u16(val, addr); break; 1309 case 4: segv = put_user_u32(val, addr); break; 1310 #if defined(TARGET_PPC64) 1311 case 8: segv = put_user_u64(val, addr); break; 1312 #endif 1313 default: abort(); 1314 } 1315 if (!segv) { 1316 stored = 1; 1317 } 1318 } 1319 } 1320 env->crf[0] = (stored << 1) | xer_so; 1321 env->reserve_addr = (target_ulong)-1; 1322 } 1323 if (!segv) { 1324 env->nip += 4; 1325 } 1326 mmap_unlock(); 1327 end_exclusive(); 1328 return segv; 1329 } 1330 1331 void cpu_loop(CPUPPCState *env) 1332 { 1333 target_siginfo_t info; 1334 int trapnr; 1335 uint32_t ret; 1336 1337 for(;;) { 1338 cpu_exec_start(env); 1339 trapnr = cpu_ppc_exec(env); 1340 cpu_exec_end(env); 1341 switch(trapnr) { 1342 case POWERPC_EXCP_NONE: 1343 /* Just go on */ 1344 break; 1345 case POWERPC_EXCP_CRITICAL: /* Critical input */ 1346 cpu_abort(env, "Critical interrupt while in user mode. " 1347 "Aborting\n"); 1348 break; 1349 case POWERPC_EXCP_MCHECK: /* Machine check exception */ 1350 cpu_abort(env, "Machine check exception while in user mode. " 1351 "Aborting\n"); 1352 break; 1353 case POWERPC_EXCP_DSI: /* Data storage exception */ 1354 EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n", 1355 env->spr[SPR_DAR]); 1356 /* XXX: check this. Seems bugged */ 1357 switch (env->error_code & 0xFF000000) { 1358 case 0x40000000: 1359 info.si_signo = TARGET_SIGSEGV; 1360 info.si_errno = 0; 1361 info.si_code = TARGET_SEGV_MAPERR; 1362 break; 1363 case 0x04000000: 1364 info.si_signo = TARGET_SIGILL; 1365 info.si_errno = 0; 1366 info.si_code = TARGET_ILL_ILLADR; 1367 break; 1368 case 0x08000000: 1369 info.si_signo = TARGET_SIGSEGV; 1370 info.si_errno = 0; 1371 info.si_code = TARGET_SEGV_ACCERR; 1372 break; 1373 default: 1374 /* Let's send a regular segfault... */ 1375 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n", 1376 env->error_code); 1377 info.si_signo = TARGET_SIGSEGV; 1378 info.si_errno = 0; 1379 info.si_code = TARGET_SEGV_MAPERR; 1380 break; 1381 } 1382 info._sifields._sigfault._addr = env->nip; 1383 queue_signal(env, info.si_signo, &info); 1384 break; 1385 case POWERPC_EXCP_ISI: /* Instruction storage exception */ 1386 EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx 1387 "\n", env->spr[SPR_SRR0]); 1388 /* XXX: check this */ 1389 switch (env->error_code & 0xFF000000) { 1390 case 0x40000000: 1391 info.si_signo = TARGET_SIGSEGV; 1392 info.si_errno = 0; 1393 info.si_code = TARGET_SEGV_MAPERR; 1394 break; 1395 case 0x10000000: 1396 case 0x08000000: 1397 info.si_signo = TARGET_SIGSEGV; 1398 info.si_errno = 0; 1399 info.si_code = TARGET_SEGV_ACCERR; 1400 break; 1401 default: 1402 /* Let's send a regular segfault... */ 1403 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n", 1404 env->error_code); 1405 info.si_signo = TARGET_SIGSEGV; 1406 info.si_errno = 0; 1407 info.si_code = TARGET_SEGV_MAPERR; 1408 break; 1409 } 1410 info._sifields._sigfault._addr = env->nip - 4; 1411 queue_signal(env, info.si_signo, &info); 1412 break; 1413 case POWERPC_EXCP_EXTERNAL: /* External input */ 1414 cpu_abort(env, "External interrupt while in user mode. " 1415 "Aborting\n"); 1416 break; 1417 case POWERPC_EXCP_ALIGN: /* Alignment exception */ 1418 EXCP_DUMP(env, "Unaligned memory access\n"); 1419 /* XXX: check this */ 1420 info.si_signo = TARGET_SIGBUS; 1421 info.si_errno = 0; 1422 info.si_code = TARGET_BUS_ADRALN; 1423 info._sifields._sigfault._addr = env->nip - 4; 1424 queue_signal(env, info.si_signo, &info); 1425 break; 1426 case POWERPC_EXCP_PROGRAM: /* Program exception */ 1427 /* XXX: check this */ 1428 switch (env->error_code & ~0xF) { 1429 case POWERPC_EXCP_FP: 1430 EXCP_DUMP(env, "Floating point program exception\n"); 1431 info.si_signo = TARGET_SIGFPE; 1432 info.si_errno = 0; 1433 switch (env->error_code & 0xF) { 1434 case POWERPC_EXCP_FP_OX: 1435 info.si_code = TARGET_FPE_FLTOVF; 1436 break; 1437 case POWERPC_EXCP_FP_UX: 1438 info.si_code = TARGET_FPE_FLTUND; 1439 break; 1440 case POWERPC_EXCP_FP_ZX: 1441 case POWERPC_EXCP_FP_VXZDZ: 1442 info.si_code = TARGET_FPE_FLTDIV; 1443 break; 1444 case POWERPC_EXCP_FP_XX: 1445 info.si_code = TARGET_FPE_FLTRES; 1446 break; 1447 case POWERPC_EXCP_FP_VXSOFT: 1448 info.si_code = TARGET_FPE_FLTINV; 1449 break; 1450 case POWERPC_EXCP_FP_VXSNAN: 1451 case POWERPC_EXCP_FP_VXISI: 1452 case POWERPC_EXCP_FP_VXIDI: 1453 case POWERPC_EXCP_FP_VXIMZ: 1454 case POWERPC_EXCP_FP_VXVC: 1455 case POWERPC_EXCP_FP_VXSQRT: 1456 case POWERPC_EXCP_FP_VXCVI: 1457 info.si_code = TARGET_FPE_FLTSUB; 1458 break; 1459 default: 1460 EXCP_DUMP(env, "Unknown floating point exception (%02x)\n", 1461 env->error_code); 1462 break; 1463 } 1464 break; 1465 case POWERPC_EXCP_INVAL: 1466 EXCP_DUMP(env, "Invalid instruction\n"); 1467 info.si_signo = TARGET_SIGILL; 1468 info.si_errno = 0; 1469 switch (env->error_code & 0xF) { 1470 case POWERPC_EXCP_INVAL_INVAL: 1471 info.si_code = TARGET_ILL_ILLOPC; 1472 break; 1473 case POWERPC_EXCP_INVAL_LSWX: 1474 info.si_code = TARGET_ILL_ILLOPN; 1475 break; 1476 case POWERPC_EXCP_INVAL_SPR: 1477 info.si_code = TARGET_ILL_PRVREG; 1478 break; 1479 case POWERPC_EXCP_INVAL_FP: 1480 info.si_code = TARGET_ILL_COPROC; 1481 break; 1482 default: 1483 EXCP_DUMP(env, "Unknown invalid operation (%02x)\n", 1484 env->error_code & 0xF); 1485 info.si_code = TARGET_ILL_ILLADR; 1486 break; 1487 } 1488 break; 1489 case POWERPC_EXCP_PRIV: 1490 EXCP_DUMP(env, "Privilege violation\n"); 1491 info.si_signo = TARGET_SIGILL; 1492 info.si_errno = 0; 1493 switch (env->error_code & 0xF) { 1494 case POWERPC_EXCP_PRIV_OPC: 1495 info.si_code = TARGET_ILL_PRVOPC; 1496 break; 1497 case POWERPC_EXCP_PRIV_REG: 1498 info.si_code = TARGET_ILL_PRVREG; 1499 break; 1500 default: 1501 EXCP_DUMP(env, "Unknown privilege violation (%02x)\n", 1502 env->error_code & 0xF); 1503 info.si_code = TARGET_ILL_PRVOPC; 1504 break; 1505 } 1506 break; 1507 case POWERPC_EXCP_TRAP: 1508 cpu_abort(env, "Tried to call a TRAP\n"); 1509 break; 1510 default: 1511 /* Should not happen ! */ 1512 cpu_abort(env, "Unknown program exception (%02x)\n", 1513 env->error_code); 1514 break; 1515 } 1516 info._sifields._sigfault._addr = env->nip - 4; 1517 queue_signal(env, info.si_signo, &info); 1518 break; 1519 case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */ 1520 EXCP_DUMP(env, "No floating point allowed\n"); 1521 info.si_signo = TARGET_SIGILL; 1522 info.si_errno = 0; 1523 info.si_code = TARGET_ILL_COPROC; 1524 info._sifields._sigfault._addr = env->nip - 4; 1525 queue_signal(env, info.si_signo, &info); 1526 break; 1527 case POWERPC_EXCP_SYSCALL: /* System call exception */ 1528 cpu_abort(env, "Syscall exception while in user mode. " 1529 "Aborting\n"); 1530 break; 1531 case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */ 1532 EXCP_DUMP(env, "No APU instruction allowed\n"); 1533 info.si_signo = TARGET_SIGILL; 1534 info.si_errno = 0; 1535 info.si_code = TARGET_ILL_COPROC; 1536 info._sifields._sigfault._addr = env->nip - 4; 1537 queue_signal(env, info.si_signo, &info); 1538 break; 1539 case POWERPC_EXCP_DECR: /* Decrementer exception */ 1540 cpu_abort(env, "Decrementer interrupt while in user mode. " 1541 "Aborting\n"); 1542 break; 1543 case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */ 1544 cpu_abort(env, "Fix interval timer interrupt while in user mode. " 1545 "Aborting\n"); 1546 break; 1547 case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */ 1548 cpu_abort(env, "Watchdog timer interrupt while in user mode. " 1549 "Aborting\n"); 1550 break; 1551 case POWERPC_EXCP_DTLB: /* Data TLB error */ 1552 cpu_abort(env, "Data TLB exception while in user mode. " 1553 "Aborting\n"); 1554 break; 1555 case POWERPC_EXCP_ITLB: /* Instruction TLB error */ 1556 cpu_abort(env, "Instruction TLB exception while in user mode. " 1557 "Aborting\n"); 1558 break; 1559 case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */ 1560 EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n"); 1561 info.si_signo = TARGET_SIGILL; 1562 info.si_errno = 0; 1563 info.si_code = TARGET_ILL_COPROC; 1564 info._sifields._sigfault._addr = env->nip - 4; 1565 queue_signal(env, info.si_signo, &info); 1566 break; 1567 case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */ 1568 cpu_abort(env, "Embedded floating-point data IRQ not handled\n"); 1569 break; 1570 case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */ 1571 cpu_abort(env, "Embedded floating-point round IRQ not handled\n"); 1572 break; 1573 case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */ 1574 cpu_abort(env, "Performance monitor exception not handled\n"); 1575 break; 1576 case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */ 1577 cpu_abort(env, "Doorbell interrupt while in user mode. " 1578 "Aborting\n"); 1579 break; 1580 case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */ 1581 cpu_abort(env, "Doorbell critical interrupt while in user mode. " 1582 "Aborting\n"); 1583 break; 1584 case POWERPC_EXCP_RESET: /* System reset exception */ 1585 cpu_abort(env, "Reset interrupt while in user mode. " 1586 "Aborting\n"); 1587 break; 1588 case POWERPC_EXCP_DSEG: /* Data segment exception */ 1589 cpu_abort(env, "Data segment exception while in user mode. " 1590 "Aborting\n"); 1591 break; 1592 case POWERPC_EXCP_ISEG: /* Instruction segment exception */ 1593 cpu_abort(env, "Instruction segment exception " 1594 "while in user mode. Aborting\n"); 1595 break; 1596 /* PowerPC 64 with hypervisor mode support */ 1597 case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */ 1598 cpu_abort(env, "Hypervisor decrementer interrupt " 1599 "while in user mode. Aborting\n"); 1600 break; 1601 case POWERPC_EXCP_TRACE: /* Trace exception */ 1602 /* Nothing to do: 1603 * we use this exception to emulate step-by-step execution mode. 1604 */ 1605 break; 1606 /* PowerPC 64 with hypervisor mode support */ 1607 case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */ 1608 cpu_abort(env, "Hypervisor data storage exception " 1609 "while in user mode. Aborting\n"); 1610 break; 1611 case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */ 1612 cpu_abort(env, "Hypervisor instruction storage exception " 1613 "while in user mode. Aborting\n"); 1614 break; 1615 case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */ 1616 cpu_abort(env, "Hypervisor data segment exception " 1617 "while in user mode. Aborting\n"); 1618 break; 1619 case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */ 1620 cpu_abort(env, "Hypervisor instruction segment exception " 1621 "while in user mode. Aborting\n"); 1622 break; 1623 case POWERPC_EXCP_VPU: /* Vector unavailable exception */ 1624 EXCP_DUMP(env, "No Altivec instructions allowed\n"); 1625 info.si_signo = TARGET_SIGILL; 1626 info.si_errno = 0; 1627 info.si_code = TARGET_ILL_COPROC; 1628 info._sifields._sigfault._addr = env->nip - 4; 1629 queue_signal(env, info.si_signo, &info); 1630 break; 1631 case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */ 1632 cpu_abort(env, "Programable interval timer interrupt " 1633 "while in user mode. Aborting\n"); 1634 break; 1635 case POWERPC_EXCP_IO: /* IO error exception */ 1636 cpu_abort(env, "IO error exception while in user mode. " 1637 "Aborting\n"); 1638 break; 1639 case POWERPC_EXCP_RUNM: /* Run mode exception */ 1640 cpu_abort(env, "Run mode exception while in user mode. " 1641 "Aborting\n"); 1642 break; 1643 case POWERPC_EXCP_EMUL: /* Emulation trap exception */ 1644 cpu_abort(env, "Emulation trap exception not handled\n"); 1645 break; 1646 case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */ 1647 cpu_abort(env, "Instruction fetch TLB exception " 1648 "while in user-mode. Aborting"); 1649 break; 1650 case POWERPC_EXCP_DLTLB: /* Data load TLB miss */ 1651 cpu_abort(env, "Data load TLB exception while in user-mode. " 1652 "Aborting"); 1653 break; 1654 case POWERPC_EXCP_DSTLB: /* Data store TLB miss */ 1655 cpu_abort(env, "Data store TLB exception while in user-mode. " 1656 "Aborting"); 1657 break; 1658 case POWERPC_EXCP_FPA: /* Floating-point assist exception */ 1659 cpu_abort(env, "Floating-point assist exception not handled\n"); 1660 break; 1661 case POWERPC_EXCP_IABR: /* Instruction address breakpoint */ 1662 cpu_abort(env, "Instruction address breakpoint exception " 1663 "not handled\n"); 1664 break; 1665 case POWERPC_EXCP_SMI: /* System management interrupt */ 1666 cpu_abort(env, "System management interrupt while in user mode. " 1667 "Aborting\n"); 1668 break; 1669 case POWERPC_EXCP_THERM: /* Thermal interrupt */ 1670 cpu_abort(env, "Thermal interrupt interrupt while in user mode. " 1671 "Aborting\n"); 1672 break; 1673 case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */ 1674 cpu_abort(env, "Performance monitor exception not handled\n"); 1675 break; 1676 case POWERPC_EXCP_VPUA: /* Vector assist exception */ 1677 cpu_abort(env, "Vector assist exception not handled\n"); 1678 break; 1679 case POWERPC_EXCP_SOFTP: /* Soft patch exception */ 1680 cpu_abort(env, "Soft patch exception not handled\n"); 1681 break; 1682 case POWERPC_EXCP_MAINT: /* Maintenance exception */ 1683 cpu_abort(env, "Maintenance exception while in user mode. " 1684 "Aborting\n"); 1685 break; 1686 case POWERPC_EXCP_STOP: /* stop translation */ 1687 /* We did invalidate the instruction cache. Go on */ 1688 break; 1689 case POWERPC_EXCP_BRANCH: /* branch instruction: */ 1690 /* We just stopped because of a branch. Go on */ 1691 break; 1692 case POWERPC_EXCP_SYSCALL_USER: 1693 /* system call in user-mode emulation */ 1694 /* WARNING: 1695 * PPC ABI uses overflow flag in cr0 to signal an error 1696 * in syscalls. 1697 */ 1698 #if 0 1699 printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0], 1700 env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]); 1701 #endif 1702 env->crf[0] &= ~0x1; 1703 ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4], 1704 env->gpr[5], env->gpr[6], env->gpr[7], 1705 env->gpr[8], 0, 0); 1706 if (ret == (uint32_t)(-TARGET_QEMU_ESIGRETURN)) { 1707 /* Returning from a successful sigreturn syscall. 1708 Avoid corrupting register state. */ 1709 break; 1710 } 1711 if (ret > (uint32_t)(-515)) { 1712 env->crf[0] |= 0x1; 1713 ret = -ret; 1714 } 1715 env->gpr[3] = ret; 1716 #if 0 1717 printf("syscall returned 0x%08x (%d)\n", ret, ret); 1718 #endif 1719 break; 1720 case POWERPC_EXCP_STCX: 1721 if (do_store_exclusive(env)) { 1722 info.si_signo = TARGET_SIGSEGV; 1723 info.si_errno = 0; 1724 info.si_code = TARGET_SEGV_MAPERR; 1725 info._sifields._sigfault._addr = env->nip; 1726 queue_signal(env, info.si_signo, &info); 1727 } 1728 break; 1729 case EXCP_DEBUG: 1730 { 1731 int sig; 1732 1733 sig = gdb_handlesig(env, TARGET_SIGTRAP); 1734 if (sig) { 1735 info.si_signo = sig; 1736 info.si_errno = 0; 1737 info.si_code = TARGET_TRAP_BRKPT; 1738 queue_signal(env, info.si_signo, &info); 1739 } 1740 } 1741 break; 1742 case EXCP_INTERRUPT: 1743 /* just indicate that signals should be handled asap */ 1744 break; 1745 default: 1746 cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr); 1747 break; 1748 } 1749 process_pending_signals(env); 1750 } 1751 } 1752 #endif 1753 1754 #ifdef TARGET_MIPS 1755 1756 #define MIPS_SYS(name, args) args, 1757 1758 static const uint8_t mips_syscall_args[] = { 1759 MIPS_SYS(sys_syscall , 8) /* 4000 */ 1760 MIPS_SYS(sys_exit , 1) 1761 MIPS_SYS(sys_fork , 0) 1762 MIPS_SYS(sys_read , 3) 1763 MIPS_SYS(sys_write , 3) 1764 MIPS_SYS(sys_open , 3) /* 4005 */ 1765 MIPS_SYS(sys_close , 1) 1766 MIPS_SYS(sys_waitpid , 3) 1767 MIPS_SYS(sys_creat , 2) 1768 MIPS_SYS(sys_link , 2) 1769 MIPS_SYS(sys_unlink , 1) /* 4010 */ 1770 MIPS_SYS(sys_execve , 0) 1771 MIPS_SYS(sys_chdir , 1) 1772 MIPS_SYS(sys_time , 1) 1773 MIPS_SYS(sys_mknod , 3) 1774 MIPS_SYS(sys_chmod , 2) /* 4015 */ 1775 MIPS_SYS(sys_lchown , 3) 1776 MIPS_SYS(sys_ni_syscall , 0) 1777 MIPS_SYS(sys_ni_syscall , 0) /* was sys_stat */ 1778 MIPS_SYS(sys_lseek , 3) 1779 MIPS_SYS(sys_getpid , 0) /* 4020 */ 1780 MIPS_SYS(sys_mount , 5) 1781 MIPS_SYS(sys_oldumount , 1) 1782 MIPS_SYS(sys_setuid , 1) 1783 MIPS_SYS(sys_getuid , 0) 1784 MIPS_SYS(sys_stime , 1) /* 4025 */ 1785 MIPS_SYS(sys_ptrace , 4) 1786 MIPS_SYS(sys_alarm , 1) 1787 MIPS_SYS(sys_ni_syscall , 0) /* was sys_fstat */ 1788 MIPS_SYS(sys_pause , 0) 1789 MIPS_SYS(sys_utime , 2) /* 4030 */ 1790 MIPS_SYS(sys_ni_syscall , 0) 1791 MIPS_SYS(sys_ni_syscall , 0) 1792 MIPS_SYS(sys_access , 2) 1793 MIPS_SYS(sys_nice , 1) 1794 MIPS_SYS(sys_ni_syscall , 0) /* 4035 */ 1795 MIPS_SYS(sys_sync , 0) 1796 MIPS_SYS(sys_kill , 2) 1797 MIPS_SYS(sys_rename , 2) 1798 MIPS_SYS(sys_mkdir , 2) 1799 MIPS_SYS(sys_rmdir , 1) /* 4040 */ 1800 MIPS_SYS(sys_dup , 1) 1801 MIPS_SYS(sys_pipe , 0) 1802 MIPS_SYS(sys_times , 1) 1803 MIPS_SYS(sys_ni_syscall , 0) 1804 MIPS_SYS(sys_brk , 1) /* 4045 */ 1805 MIPS_SYS(sys_setgid , 1) 1806 MIPS_SYS(sys_getgid , 0) 1807 MIPS_SYS(sys_ni_syscall , 0) /* was signal(2) */ 1808 MIPS_SYS(sys_geteuid , 0) 1809 MIPS_SYS(sys_getegid , 0) /* 4050 */ 1810 MIPS_SYS(sys_acct , 0) 1811 MIPS_SYS(sys_umount , 2) 1812 MIPS_SYS(sys_ni_syscall , 0) 1813 MIPS_SYS(sys_ioctl , 3) 1814 MIPS_SYS(sys_fcntl , 3) /* 4055 */ 1815 MIPS_SYS(sys_ni_syscall , 2) 1816 MIPS_SYS(sys_setpgid , 2) 1817 MIPS_SYS(sys_ni_syscall , 0) 1818 MIPS_SYS(sys_olduname , 1) 1819 MIPS_SYS(sys_umask , 1) /* 4060 */ 1820 MIPS_SYS(sys_chroot , 1) 1821 MIPS_SYS(sys_ustat , 2) 1822 MIPS_SYS(sys_dup2 , 2) 1823 MIPS_SYS(sys_getppid , 0) 1824 MIPS_SYS(sys_getpgrp , 0) /* 4065 */ 1825 MIPS_SYS(sys_setsid , 0) 1826 MIPS_SYS(sys_sigaction , 3) 1827 MIPS_SYS(sys_sgetmask , 0) 1828 MIPS_SYS(sys_ssetmask , 1) 1829 MIPS_SYS(sys_setreuid , 2) /* 4070 */ 1830 MIPS_SYS(sys_setregid , 2) 1831 MIPS_SYS(sys_sigsuspend , 0) 1832 MIPS_SYS(sys_sigpending , 1) 1833 MIPS_SYS(sys_sethostname , 2) 1834 MIPS_SYS(sys_setrlimit , 2) /* 4075 */ 1835 MIPS_SYS(sys_getrlimit , 2) 1836 MIPS_SYS(sys_getrusage , 2) 1837 MIPS_SYS(sys_gettimeofday, 2) 1838 MIPS_SYS(sys_settimeofday, 2) 1839 MIPS_SYS(sys_getgroups , 2) /* 4080 */ 1840 MIPS_SYS(sys_setgroups , 2) 1841 MIPS_SYS(sys_ni_syscall , 0) /* old_select */ 1842 MIPS_SYS(sys_symlink , 2) 1843 MIPS_SYS(sys_ni_syscall , 0) /* was sys_lstat */ 1844 MIPS_SYS(sys_readlink , 3) /* 4085 */ 1845 MIPS_SYS(sys_uselib , 1) 1846 MIPS_SYS(sys_swapon , 2) 1847 MIPS_SYS(sys_reboot , 3) 1848 MIPS_SYS(old_readdir , 3) 1849 MIPS_SYS(old_mmap , 6) /* 4090 */ 1850 MIPS_SYS(sys_munmap , 2) 1851 MIPS_SYS(sys_truncate , 2) 1852 MIPS_SYS(sys_ftruncate , 2) 1853 MIPS_SYS(sys_fchmod , 2) 1854 MIPS_SYS(sys_fchown , 3) /* 4095 */ 1855 MIPS_SYS(sys_getpriority , 2) 1856 MIPS_SYS(sys_setpriority , 3) 1857 MIPS_SYS(sys_ni_syscall , 0) 1858 MIPS_SYS(sys_statfs , 2) 1859 MIPS_SYS(sys_fstatfs , 2) /* 4100 */ 1860 MIPS_SYS(sys_ni_syscall , 0) /* was ioperm(2) */ 1861 MIPS_SYS(sys_socketcall , 2) 1862 MIPS_SYS(sys_syslog , 3) 1863 MIPS_SYS(sys_setitimer , 3) 1864 MIPS_SYS(sys_getitimer , 2) /* 4105 */ 1865 MIPS_SYS(sys_newstat , 2) 1866 MIPS_SYS(sys_newlstat , 2) 1867 MIPS_SYS(sys_newfstat , 2) 1868 MIPS_SYS(sys_uname , 1) 1869 MIPS_SYS(sys_ni_syscall , 0) /* 4110 was iopl(2) */ 1870 MIPS_SYS(sys_vhangup , 0) 1871 MIPS_SYS(sys_ni_syscall , 0) /* was sys_idle() */ 1872 MIPS_SYS(sys_ni_syscall , 0) /* was sys_vm86 */ 1873 MIPS_SYS(sys_wait4 , 4) 1874 MIPS_SYS(sys_swapoff , 1) /* 4115 */ 1875 MIPS_SYS(sys_sysinfo , 1) 1876 MIPS_SYS(sys_ipc , 6) 1877 MIPS_SYS(sys_fsync , 1) 1878 MIPS_SYS(sys_sigreturn , 0) 1879 MIPS_SYS(sys_clone , 6) /* 4120 */ 1880 MIPS_SYS(sys_setdomainname, 2) 1881 MIPS_SYS(sys_newuname , 1) 1882 MIPS_SYS(sys_ni_syscall , 0) /* sys_modify_ldt */ 1883 MIPS_SYS(sys_adjtimex , 1) 1884 MIPS_SYS(sys_mprotect , 3) /* 4125 */ 1885 MIPS_SYS(sys_sigprocmask , 3) 1886 MIPS_SYS(sys_ni_syscall , 0) /* was create_module */ 1887 MIPS_SYS(sys_init_module , 5) 1888 MIPS_SYS(sys_delete_module, 1) 1889 MIPS_SYS(sys_ni_syscall , 0) /* 4130 was get_kernel_syms */ 1890 MIPS_SYS(sys_quotactl , 0) 1891 MIPS_SYS(sys_getpgid , 1) 1892 MIPS_SYS(sys_fchdir , 1) 1893 MIPS_SYS(sys_bdflush , 2) 1894 MIPS_SYS(sys_sysfs , 3) /* 4135 */ 1895 MIPS_SYS(sys_personality , 1) 1896 MIPS_SYS(sys_ni_syscall , 0) /* for afs_syscall */ 1897 MIPS_SYS(sys_setfsuid , 1) 1898 MIPS_SYS(sys_setfsgid , 1) 1899 MIPS_SYS(sys_llseek , 5) /* 4140 */ 1900 MIPS_SYS(sys_getdents , 3) 1901 MIPS_SYS(sys_select , 5) 1902 MIPS_SYS(sys_flock , 2) 1903 MIPS_SYS(sys_msync , 3) 1904 MIPS_SYS(sys_readv , 3) /* 4145 */ 1905 MIPS_SYS(sys_writev , 3) 1906 MIPS_SYS(sys_cacheflush , 3) 1907 MIPS_SYS(sys_cachectl , 3) 1908 MIPS_SYS(sys_sysmips , 4) 1909 MIPS_SYS(sys_ni_syscall , 0) /* 4150 */ 1910 MIPS_SYS(sys_getsid , 1) 1911 MIPS_SYS(sys_fdatasync , 0) 1912 MIPS_SYS(sys_sysctl , 1) 1913 MIPS_SYS(sys_mlock , 2) 1914 MIPS_SYS(sys_munlock , 2) /* 4155 */ 1915 MIPS_SYS(sys_mlockall , 1) 1916 MIPS_SYS(sys_munlockall , 0) 1917 MIPS_SYS(sys_sched_setparam, 2) 1918 MIPS_SYS(sys_sched_getparam, 2) 1919 MIPS_SYS(sys_sched_setscheduler, 3) /* 4160 */ 1920 MIPS_SYS(sys_sched_getscheduler, 1) 1921 MIPS_SYS(sys_sched_yield , 0) 1922 MIPS_SYS(sys_sched_get_priority_max, 1) 1923 MIPS_SYS(sys_sched_get_priority_min, 1) 1924 MIPS_SYS(sys_sched_rr_get_interval, 2) /* 4165 */ 1925 MIPS_SYS(sys_nanosleep, 2) 1926 MIPS_SYS(sys_mremap , 4) 1927 MIPS_SYS(sys_accept , 3) 1928 MIPS_SYS(sys_bind , 3) 1929 MIPS_SYS(sys_connect , 3) /* 4170 */ 1930 MIPS_SYS(sys_getpeername , 3) 1931 MIPS_SYS(sys_getsockname , 3) 1932 MIPS_SYS(sys_getsockopt , 5) 1933 MIPS_SYS(sys_listen , 2) 1934 MIPS_SYS(sys_recv , 4) /* 4175 */ 1935 MIPS_SYS(sys_recvfrom , 6) 1936 MIPS_SYS(sys_recvmsg , 3) 1937 MIPS_SYS(sys_send , 4) 1938 MIPS_SYS(sys_sendmsg , 3) 1939 MIPS_SYS(sys_sendto , 6) /* 4180 */ 1940 MIPS_SYS(sys_setsockopt , 5) 1941 MIPS_SYS(sys_shutdown , 2) 1942 MIPS_SYS(sys_socket , 3) 1943 MIPS_SYS(sys_socketpair , 4) 1944 MIPS_SYS(sys_setresuid , 3) /* 4185 */ 1945 MIPS_SYS(sys_getresuid , 3) 1946 MIPS_SYS(sys_ni_syscall , 0) /* was sys_query_module */ 1947 MIPS_SYS(sys_poll , 3) 1948 MIPS_SYS(sys_nfsservctl , 3) 1949 MIPS_SYS(sys_setresgid , 3) /* 4190 */ 1950 MIPS_SYS(sys_getresgid , 3) 1951 MIPS_SYS(sys_prctl , 5) 1952 MIPS_SYS(sys_rt_sigreturn, 0) 1953 MIPS_SYS(sys_rt_sigaction, 4) 1954 MIPS_SYS(sys_rt_sigprocmask, 4) /* 4195 */ 1955 MIPS_SYS(sys_rt_sigpending, 2) 1956 MIPS_SYS(sys_rt_sigtimedwait, 4) 1957 MIPS_SYS(sys_rt_sigqueueinfo, 3) 1958 MIPS_SYS(sys_rt_sigsuspend, 0) 1959 MIPS_SYS(sys_pread64 , 6) /* 4200 */ 1960 MIPS_SYS(sys_pwrite64 , 6) 1961 MIPS_SYS(sys_chown , 3) 1962 MIPS_SYS(sys_getcwd , 2) 1963 MIPS_SYS(sys_capget , 2) 1964 MIPS_SYS(sys_capset , 2) /* 4205 */ 1965 MIPS_SYS(sys_sigaltstack , 2) 1966 MIPS_SYS(sys_sendfile , 4) 1967 MIPS_SYS(sys_ni_syscall , 0) 1968 MIPS_SYS(sys_ni_syscall , 0) 1969 MIPS_SYS(sys_mmap2 , 6) /* 4210 */ 1970 MIPS_SYS(sys_truncate64 , 4) 1971 MIPS_SYS(sys_ftruncate64 , 4) 1972 MIPS_SYS(sys_stat64 , 2) 1973 MIPS_SYS(sys_lstat64 , 2) 1974 MIPS_SYS(sys_fstat64 , 2) /* 4215 */ 1975 MIPS_SYS(sys_pivot_root , 2) 1976 MIPS_SYS(sys_mincore , 3) 1977 MIPS_SYS(sys_madvise , 3) 1978 MIPS_SYS(sys_getdents64 , 3) 1979 MIPS_SYS(sys_fcntl64 , 3) /* 4220 */ 1980 MIPS_SYS(sys_ni_syscall , 0) 1981 MIPS_SYS(sys_gettid , 0) 1982 MIPS_SYS(sys_readahead , 5) 1983 MIPS_SYS(sys_setxattr , 5) 1984 MIPS_SYS(sys_lsetxattr , 5) /* 4225 */ 1985 MIPS_SYS(sys_fsetxattr , 5) 1986 MIPS_SYS(sys_getxattr , 4) 1987 MIPS_SYS(sys_lgetxattr , 4) 1988 MIPS_SYS(sys_fgetxattr , 4) 1989 MIPS_SYS(sys_listxattr , 3) /* 4230 */ 1990 MIPS_SYS(sys_llistxattr , 3) 1991 MIPS_SYS(sys_flistxattr , 3) 1992 MIPS_SYS(sys_removexattr , 2) 1993 MIPS_SYS(sys_lremovexattr, 2) 1994 MIPS_SYS(sys_fremovexattr, 2) /* 4235 */ 1995 MIPS_SYS(sys_tkill , 2) 1996 MIPS_SYS(sys_sendfile64 , 5) 1997 MIPS_SYS(sys_futex , 2) 1998 MIPS_SYS(sys_sched_setaffinity, 3) 1999 MIPS_SYS(sys_sched_getaffinity, 3) /* 4240 */ 2000 MIPS_SYS(sys_io_setup , 2) 2001 MIPS_SYS(sys_io_destroy , 1) 2002 MIPS_SYS(sys_io_getevents, 5) 2003 MIPS_SYS(sys_io_submit , 3) 2004 MIPS_SYS(sys_io_cancel , 3) /* 4245 */ 2005 MIPS_SYS(sys_exit_group , 1) 2006 MIPS_SYS(sys_lookup_dcookie, 3) 2007 MIPS_SYS(sys_epoll_create, 1) 2008 MIPS_SYS(sys_epoll_ctl , 4) 2009 MIPS_SYS(sys_epoll_wait , 3) /* 4250 */ 2010 MIPS_SYS(sys_remap_file_pages, 5) 2011 MIPS_SYS(sys_set_tid_address, 1) 2012 MIPS_SYS(sys_restart_syscall, 0) 2013 MIPS_SYS(sys_fadvise64_64, 7) 2014 MIPS_SYS(sys_statfs64 , 3) /* 4255 */ 2015 MIPS_SYS(sys_fstatfs64 , 2) 2016 MIPS_SYS(sys_timer_create, 3) 2017 MIPS_SYS(sys_timer_settime, 4) 2018 MIPS_SYS(sys_timer_gettime, 2) 2019 MIPS_SYS(sys_timer_getoverrun, 1) /* 4260 */ 2020 MIPS_SYS(sys_timer_delete, 1) 2021 MIPS_SYS(sys_clock_settime, 2) 2022 MIPS_SYS(sys_clock_gettime, 2) 2023 MIPS_SYS(sys_clock_getres, 2) 2024 MIPS_SYS(sys_clock_nanosleep, 4) /* 4265 */ 2025 MIPS_SYS(sys_tgkill , 3) 2026 MIPS_SYS(sys_utimes , 2) 2027 MIPS_SYS(sys_mbind , 4) 2028 MIPS_SYS(sys_ni_syscall , 0) /* sys_get_mempolicy */ 2029 MIPS_SYS(sys_ni_syscall , 0) /* 4270 sys_set_mempolicy */ 2030 MIPS_SYS(sys_mq_open , 4) 2031 MIPS_SYS(sys_mq_unlink , 1) 2032 MIPS_SYS(sys_mq_timedsend, 5) 2033 MIPS_SYS(sys_mq_timedreceive, 5) 2034 MIPS_SYS(sys_mq_notify , 2) /* 4275 */ 2035 MIPS_SYS(sys_mq_getsetattr, 3) 2036 MIPS_SYS(sys_ni_syscall , 0) /* sys_vserver */ 2037 MIPS_SYS(sys_waitid , 4) 2038 MIPS_SYS(sys_ni_syscall , 0) /* available, was setaltroot */ 2039 MIPS_SYS(sys_add_key , 5) 2040 MIPS_SYS(sys_request_key, 4) 2041 MIPS_SYS(sys_keyctl , 5) 2042 MIPS_SYS(sys_set_thread_area, 1) 2043 MIPS_SYS(sys_inotify_init, 0) 2044 MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */ 2045 MIPS_SYS(sys_inotify_rm_watch, 2) 2046 MIPS_SYS(sys_migrate_pages, 4) 2047 MIPS_SYS(sys_openat, 4) 2048 MIPS_SYS(sys_mkdirat, 3) 2049 MIPS_SYS(sys_mknodat, 4) /* 4290 */ 2050 MIPS_SYS(sys_fchownat, 5) 2051 MIPS_SYS(sys_futimesat, 3) 2052 MIPS_SYS(sys_fstatat64, 4) 2053 MIPS_SYS(sys_unlinkat, 3) 2054 MIPS_SYS(sys_renameat, 4) /* 4295 */ 2055 MIPS_SYS(sys_linkat, 5) 2056 MIPS_SYS(sys_symlinkat, 3) 2057 MIPS_SYS(sys_readlinkat, 4) 2058 MIPS_SYS(sys_fchmodat, 3) 2059 MIPS_SYS(sys_faccessat, 3) /* 4300 */ 2060 MIPS_SYS(sys_pselect6, 6) 2061 MIPS_SYS(sys_ppoll, 5) 2062 MIPS_SYS(sys_unshare, 1) 2063 MIPS_SYS(sys_splice, 4) 2064 MIPS_SYS(sys_sync_file_range, 7) /* 4305 */ 2065 MIPS_SYS(sys_tee, 4) 2066 MIPS_SYS(sys_vmsplice, 4) 2067 MIPS_SYS(sys_move_pages, 6) 2068 MIPS_SYS(sys_set_robust_list, 2) 2069 MIPS_SYS(sys_get_robust_list, 3) /* 4310 */ 2070 MIPS_SYS(sys_kexec_load, 4) 2071 MIPS_SYS(sys_getcpu, 3) 2072 MIPS_SYS(sys_epoll_pwait, 6) 2073 MIPS_SYS(sys_ioprio_set, 3) 2074 MIPS_SYS(sys_ioprio_get, 2) 2075 MIPS_SYS(sys_utimensat, 4) 2076 MIPS_SYS(sys_signalfd, 3) 2077 MIPS_SYS(sys_ni_syscall, 0) /* was timerfd */ 2078 MIPS_SYS(sys_eventfd, 1) 2079 MIPS_SYS(sys_fallocate, 6) /* 4320 */ 2080 MIPS_SYS(sys_timerfd_create, 2) 2081 MIPS_SYS(sys_timerfd_gettime, 2) 2082 MIPS_SYS(sys_timerfd_settime, 4) 2083 MIPS_SYS(sys_signalfd4, 4) 2084 MIPS_SYS(sys_eventfd2, 2) /* 4325 */ 2085 MIPS_SYS(sys_epoll_create1, 1) 2086 MIPS_SYS(sys_dup3, 3) 2087 MIPS_SYS(sys_pipe2, 2) 2088 MIPS_SYS(sys_inotify_init1, 1) 2089 MIPS_SYS(sys_preadv, 6) /* 4330 */ 2090 MIPS_SYS(sys_pwritev, 6) 2091 MIPS_SYS(sys_rt_tgsigqueueinfo, 4) 2092 MIPS_SYS(sys_perf_event_open, 5) 2093 MIPS_SYS(sys_accept4, 4) 2094 MIPS_SYS(sys_recvmmsg, 5) /* 4335 */ 2095 MIPS_SYS(sys_fanotify_init, 2) 2096 MIPS_SYS(sys_fanotify_mark, 6) 2097 MIPS_SYS(sys_prlimit64, 4) 2098 MIPS_SYS(sys_name_to_handle_at, 5) 2099 MIPS_SYS(sys_open_by_handle_at, 3) /* 4340 */ 2100 MIPS_SYS(sys_clock_adjtime, 2) 2101 MIPS_SYS(sys_syncfs, 1) 2102 }; 2103 2104 #undef MIPS_SYS 2105 2106 static int do_store_exclusive(CPUMIPSState *env) 2107 { 2108 target_ulong addr; 2109 target_ulong page_addr; 2110 target_ulong val; 2111 int flags; 2112 int segv = 0; 2113 int reg; 2114 int d; 2115 2116 addr = env->lladdr; 2117 page_addr = addr & TARGET_PAGE_MASK; 2118 start_exclusive(); 2119 mmap_lock(); 2120 flags = page_get_flags(page_addr); 2121 if ((flags & PAGE_READ) == 0) { 2122 segv = 1; 2123 } else { 2124 reg = env->llreg & 0x1f; 2125 d = (env->llreg & 0x20) != 0; 2126 if (d) { 2127 segv = get_user_s64(val, addr); 2128 } else { 2129 segv = get_user_s32(val, addr); 2130 } 2131 if (!segv) { 2132 if (val != env->llval) { 2133 env->active_tc.gpr[reg] = 0; 2134 } else { 2135 if (d) { 2136 segv = put_user_u64(env->llnewval, addr); 2137 } else { 2138 segv = put_user_u32(env->llnewval, addr); 2139 } 2140 if (!segv) { 2141 env->active_tc.gpr[reg] = 1; 2142 } 2143 } 2144 } 2145 } 2146 env->lladdr = -1; 2147 if (!segv) { 2148 env->active_tc.PC += 4; 2149 } 2150 mmap_unlock(); 2151 end_exclusive(); 2152 return segv; 2153 } 2154 2155 void cpu_loop(CPUMIPSState *env) 2156 { 2157 target_siginfo_t info; 2158 int trapnr, ret; 2159 unsigned int syscall_num; 2160 2161 for(;;) { 2162 cpu_exec_start(env); 2163 trapnr = cpu_mips_exec(env); 2164 cpu_exec_end(env); 2165 switch(trapnr) { 2166 case EXCP_SYSCALL: 2167 syscall_num = env->active_tc.gpr[2] - 4000; 2168 env->active_tc.PC += 4; 2169 if (syscall_num >= sizeof(mips_syscall_args)) { 2170 ret = -TARGET_ENOSYS; 2171 } else { 2172 int nb_args; 2173 abi_ulong sp_reg; 2174 abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0; 2175 2176 nb_args = mips_syscall_args[syscall_num]; 2177 sp_reg = env->active_tc.gpr[29]; 2178 switch (nb_args) { 2179 /* these arguments are taken from the stack */ 2180 case 8: 2181 if ((ret = get_user_ual(arg8, sp_reg + 28)) != 0) { 2182 goto done_syscall; 2183 } 2184 case 7: 2185 if ((ret = get_user_ual(arg7, sp_reg + 24)) != 0) { 2186 goto done_syscall; 2187 } 2188 case 6: 2189 if ((ret = get_user_ual(arg6, sp_reg + 20)) != 0) { 2190 goto done_syscall; 2191 } 2192 case 5: 2193 if ((ret = get_user_ual(arg5, sp_reg + 16)) != 0) { 2194 goto done_syscall; 2195 } 2196 default: 2197 break; 2198 } 2199 ret = do_syscall(env, env->active_tc.gpr[2], 2200 env->active_tc.gpr[4], 2201 env->active_tc.gpr[5], 2202 env->active_tc.gpr[6], 2203 env->active_tc.gpr[7], 2204 arg5, arg6, arg7, arg8); 2205 } 2206 done_syscall: 2207 if (ret == -TARGET_QEMU_ESIGRETURN) { 2208 /* Returning from a successful sigreturn syscall. 2209 Avoid clobbering register state. */ 2210 break; 2211 } 2212 if ((unsigned int)ret >= (unsigned int)(-1133)) { 2213 env->active_tc.gpr[7] = 1; /* error flag */ 2214 ret = -ret; 2215 } else { 2216 env->active_tc.gpr[7] = 0; /* error flag */ 2217 } 2218 env->active_tc.gpr[2] = ret; 2219 break; 2220 case EXCP_TLBL: 2221 case EXCP_TLBS: 2222 case EXCP_AdEL: 2223 case EXCP_AdES: 2224 info.si_signo = TARGET_SIGSEGV; 2225 info.si_errno = 0; 2226 /* XXX: check env->error_code */ 2227 info.si_code = TARGET_SEGV_MAPERR; 2228 info._sifields._sigfault._addr = env->CP0_BadVAddr; 2229 queue_signal(env, info.si_signo, &info); 2230 break; 2231 case EXCP_CpU: 2232 case EXCP_RI: 2233 info.si_signo = TARGET_SIGILL; 2234 info.si_errno = 0; 2235 info.si_code = 0; 2236 queue_signal(env, info.si_signo, &info); 2237 break; 2238 case EXCP_INTERRUPT: 2239 /* just indicate that signals should be handled asap */ 2240 break; 2241 case EXCP_DEBUG: 2242 { 2243 int sig; 2244 2245 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2246 if (sig) 2247 { 2248 info.si_signo = sig; 2249 info.si_errno = 0; 2250 info.si_code = TARGET_TRAP_BRKPT; 2251 queue_signal(env, info.si_signo, &info); 2252 } 2253 } 2254 break; 2255 case EXCP_SC: 2256 if (do_store_exclusive(env)) { 2257 info.si_signo = TARGET_SIGSEGV; 2258 info.si_errno = 0; 2259 info.si_code = TARGET_SEGV_MAPERR; 2260 info._sifields._sigfault._addr = env->active_tc.PC; 2261 queue_signal(env, info.si_signo, &info); 2262 } 2263 break; 2264 default: 2265 // error: 2266 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 2267 trapnr); 2268 cpu_dump_state(env, stderr, fprintf, 0); 2269 abort(); 2270 } 2271 process_pending_signals(env); 2272 } 2273 } 2274 #endif 2275 2276 #ifdef TARGET_SH4 2277 void cpu_loop (CPUState *env) 2278 { 2279 int trapnr, ret; 2280 target_siginfo_t info; 2281 2282 while (1) { 2283 trapnr = cpu_sh4_exec (env); 2284 2285 switch (trapnr) { 2286 case 0x160: 2287 env->pc += 2; 2288 ret = do_syscall(env, 2289 env->gregs[3], 2290 env->gregs[4], 2291 env->gregs[5], 2292 env->gregs[6], 2293 env->gregs[7], 2294 env->gregs[0], 2295 env->gregs[1], 2296 0, 0); 2297 env->gregs[0] = ret; 2298 break; 2299 case EXCP_INTERRUPT: 2300 /* just indicate that signals should be handled asap */ 2301 break; 2302 case EXCP_DEBUG: 2303 { 2304 int sig; 2305 2306 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2307 if (sig) 2308 { 2309 info.si_signo = sig; 2310 info.si_errno = 0; 2311 info.si_code = TARGET_TRAP_BRKPT; 2312 queue_signal(env, info.si_signo, &info); 2313 } 2314 } 2315 break; 2316 case 0xa0: 2317 case 0xc0: 2318 info.si_signo = SIGSEGV; 2319 info.si_errno = 0; 2320 info.si_code = TARGET_SEGV_MAPERR; 2321 info._sifields._sigfault._addr = env->tea; 2322 queue_signal(env, info.si_signo, &info); 2323 break; 2324 2325 default: 2326 printf ("Unhandled trap: 0x%x\n", trapnr); 2327 cpu_dump_state(env, stderr, fprintf, 0); 2328 exit (1); 2329 } 2330 process_pending_signals (env); 2331 } 2332 } 2333 #endif 2334 2335 #ifdef TARGET_CRIS 2336 void cpu_loop (CPUState *env) 2337 { 2338 int trapnr, ret; 2339 target_siginfo_t info; 2340 2341 while (1) { 2342 trapnr = cpu_cris_exec (env); 2343 switch (trapnr) { 2344 case 0xaa: 2345 { 2346 info.si_signo = SIGSEGV; 2347 info.si_errno = 0; 2348 /* XXX: check env->error_code */ 2349 info.si_code = TARGET_SEGV_MAPERR; 2350 info._sifields._sigfault._addr = env->pregs[PR_EDA]; 2351 queue_signal(env, info.si_signo, &info); 2352 } 2353 break; 2354 case EXCP_INTERRUPT: 2355 /* just indicate that signals should be handled asap */ 2356 break; 2357 case EXCP_BREAK: 2358 ret = do_syscall(env, 2359 env->regs[9], 2360 env->regs[10], 2361 env->regs[11], 2362 env->regs[12], 2363 env->regs[13], 2364 env->pregs[7], 2365 env->pregs[11], 2366 0, 0); 2367 env->regs[10] = ret; 2368 break; 2369 case EXCP_DEBUG: 2370 { 2371 int sig; 2372 2373 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2374 if (sig) 2375 { 2376 info.si_signo = sig; 2377 info.si_errno = 0; 2378 info.si_code = TARGET_TRAP_BRKPT; 2379 queue_signal(env, info.si_signo, &info); 2380 } 2381 } 2382 break; 2383 default: 2384 printf ("Unhandled trap: 0x%x\n", trapnr); 2385 cpu_dump_state(env, stderr, fprintf, 0); 2386 exit (1); 2387 } 2388 process_pending_signals (env); 2389 } 2390 } 2391 #endif 2392 2393 #ifdef TARGET_MICROBLAZE 2394 void cpu_loop (CPUState *env) 2395 { 2396 int trapnr, ret; 2397 target_siginfo_t info; 2398 2399 while (1) { 2400 trapnr = cpu_mb_exec (env); 2401 switch (trapnr) { 2402 case 0xaa: 2403 { 2404 info.si_signo = SIGSEGV; 2405 info.si_errno = 0; 2406 /* XXX: check env->error_code */ 2407 info.si_code = TARGET_SEGV_MAPERR; 2408 info._sifields._sigfault._addr = 0; 2409 queue_signal(env, info.si_signo, &info); 2410 } 2411 break; 2412 case EXCP_INTERRUPT: 2413 /* just indicate that signals should be handled asap */ 2414 break; 2415 case EXCP_BREAK: 2416 /* Return address is 4 bytes after the call. */ 2417 env->regs[14] += 4; 2418 ret = do_syscall(env, 2419 env->regs[12], 2420 env->regs[5], 2421 env->regs[6], 2422 env->regs[7], 2423 env->regs[8], 2424 env->regs[9], 2425 env->regs[10], 2426 0, 0); 2427 env->regs[3] = ret; 2428 env->sregs[SR_PC] = env->regs[14]; 2429 break; 2430 case EXCP_HW_EXCP: 2431 env->regs[17] = env->sregs[SR_PC] + 4; 2432 if (env->iflags & D_FLAG) { 2433 env->sregs[SR_ESR] |= 1 << 12; 2434 env->sregs[SR_PC] -= 4; 2435 /* FIXME: if branch was immed, replay the imm aswell. */ 2436 } 2437 2438 env->iflags &= ~(IMM_FLAG | D_FLAG); 2439 2440 switch (env->sregs[SR_ESR] & 31) { 2441 case ESR_EC_DIVZERO: 2442 info.si_signo = SIGFPE; 2443 info.si_errno = 0; 2444 info.si_code = TARGET_FPE_FLTDIV; 2445 info._sifields._sigfault._addr = 0; 2446 queue_signal(env, info.si_signo, &info); 2447 break; 2448 case ESR_EC_FPU: 2449 info.si_signo = SIGFPE; 2450 info.si_errno = 0; 2451 if (env->sregs[SR_FSR] & FSR_IO) { 2452 info.si_code = TARGET_FPE_FLTINV; 2453 } 2454 if (env->sregs[SR_FSR] & FSR_DZ) { 2455 info.si_code = TARGET_FPE_FLTDIV; 2456 } 2457 info._sifields._sigfault._addr = 0; 2458 queue_signal(env, info.si_signo, &info); 2459 break; 2460 default: 2461 printf ("Unhandled hw-exception: 0x%x\n", 2462 env->sregs[SR_ESR] & ESR_EC_MASK); 2463 cpu_dump_state(env, stderr, fprintf, 0); 2464 exit (1); 2465 break; 2466 } 2467 break; 2468 case EXCP_DEBUG: 2469 { 2470 int sig; 2471 2472 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2473 if (sig) 2474 { 2475 info.si_signo = sig; 2476 info.si_errno = 0; 2477 info.si_code = TARGET_TRAP_BRKPT; 2478 queue_signal(env, info.si_signo, &info); 2479 } 2480 } 2481 break; 2482 default: 2483 printf ("Unhandled trap: 0x%x\n", trapnr); 2484 cpu_dump_state(env, stderr, fprintf, 0); 2485 exit (1); 2486 } 2487 process_pending_signals (env); 2488 } 2489 } 2490 #endif 2491 2492 #ifdef TARGET_M68K 2493 2494 void cpu_loop(CPUM68KState *env) 2495 { 2496 int trapnr; 2497 unsigned int n; 2498 target_siginfo_t info; 2499 TaskState *ts = env->opaque; 2500 2501 for(;;) { 2502 trapnr = cpu_m68k_exec(env); 2503 switch(trapnr) { 2504 case EXCP_ILLEGAL: 2505 { 2506 if (ts->sim_syscalls) { 2507 uint16_t nr; 2508 nr = lduw(env->pc + 2); 2509 env->pc += 4; 2510 do_m68k_simcall(env, nr); 2511 } else { 2512 goto do_sigill; 2513 } 2514 } 2515 break; 2516 case EXCP_HALT_INSN: 2517 /* Semihosing syscall. */ 2518 env->pc += 4; 2519 do_m68k_semihosting(env, env->dregs[0]); 2520 break; 2521 case EXCP_LINEA: 2522 case EXCP_LINEF: 2523 case EXCP_UNSUPPORTED: 2524 do_sigill: 2525 info.si_signo = SIGILL; 2526 info.si_errno = 0; 2527 info.si_code = TARGET_ILL_ILLOPN; 2528 info._sifields._sigfault._addr = env->pc; 2529 queue_signal(env, info.si_signo, &info); 2530 break; 2531 case EXCP_TRAP0: 2532 { 2533 ts->sim_syscalls = 0; 2534 n = env->dregs[0]; 2535 env->pc += 2; 2536 env->dregs[0] = do_syscall(env, 2537 n, 2538 env->dregs[1], 2539 env->dregs[2], 2540 env->dregs[3], 2541 env->dregs[4], 2542 env->dregs[5], 2543 env->aregs[0], 2544 0, 0); 2545 } 2546 break; 2547 case EXCP_INTERRUPT: 2548 /* just indicate that signals should be handled asap */ 2549 break; 2550 case EXCP_ACCESS: 2551 { 2552 info.si_signo = SIGSEGV; 2553 info.si_errno = 0; 2554 /* XXX: check env->error_code */ 2555 info.si_code = TARGET_SEGV_MAPERR; 2556 info._sifields._sigfault._addr = env->mmu.ar; 2557 queue_signal(env, info.si_signo, &info); 2558 } 2559 break; 2560 case EXCP_DEBUG: 2561 { 2562 int sig; 2563 2564 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2565 if (sig) 2566 { 2567 info.si_signo = sig; 2568 info.si_errno = 0; 2569 info.si_code = TARGET_TRAP_BRKPT; 2570 queue_signal(env, info.si_signo, &info); 2571 } 2572 } 2573 break; 2574 default: 2575 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 2576 trapnr); 2577 cpu_dump_state(env, stderr, fprintf, 0); 2578 abort(); 2579 } 2580 process_pending_signals(env); 2581 } 2582 } 2583 #endif /* TARGET_M68K */ 2584 2585 #ifdef TARGET_ALPHA 2586 static void do_store_exclusive(CPUAlphaState *env, int reg, int quad) 2587 { 2588 target_ulong addr, val, tmp; 2589 target_siginfo_t info; 2590 int ret = 0; 2591 2592 addr = env->lock_addr; 2593 tmp = env->lock_st_addr; 2594 env->lock_addr = -1; 2595 env->lock_st_addr = 0; 2596 2597 start_exclusive(); 2598 mmap_lock(); 2599 2600 if (addr == tmp) { 2601 if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) { 2602 goto do_sigsegv; 2603 } 2604 2605 if (val == env->lock_value) { 2606 tmp = env->ir[reg]; 2607 if (quad ? put_user_u64(tmp, addr) : put_user_u32(tmp, addr)) { 2608 goto do_sigsegv; 2609 } 2610 ret = 1; 2611 } 2612 } 2613 env->ir[reg] = ret; 2614 env->pc += 4; 2615 2616 mmap_unlock(); 2617 end_exclusive(); 2618 return; 2619 2620 do_sigsegv: 2621 mmap_unlock(); 2622 end_exclusive(); 2623 2624 info.si_signo = TARGET_SIGSEGV; 2625 info.si_errno = 0; 2626 info.si_code = TARGET_SEGV_MAPERR; 2627 info._sifields._sigfault._addr = addr; 2628 queue_signal(env, TARGET_SIGSEGV, &info); 2629 } 2630 2631 void cpu_loop (CPUState *env) 2632 { 2633 int trapnr; 2634 target_siginfo_t info; 2635 abi_long sysret; 2636 2637 while (1) { 2638 trapnr = cpu_alpha_exec (env); 2639 2640 /* All of the traps imply a transition through PALcode, which 2641 implies an REI instruction has been executed. Which means 2642 that the intr_flag should be cleared. */ 2643 env->intr_flag = 0; 2644 2645 switch (trapnr) { 2646 case EXCP_RESET: 2647 fprintf(stderr, "Reset requested. Exit\n"); 2648 exit(1); 2649 break; 2650 case EXCP_MCHK: 2651 fprintf(stderr, "Machine check exception. Exit\n"); 2652 exit(1); 2653 break; 2654 case EXCP_SMP_INTERRUPT: 2655 case EXCP_CLK_INTERRUPT: 2656 case EXCP_DEV_INTERRUPT: 2657 fprintf(stderr, "External interrupt. Exit\n"); 2658 exit(1); 2659 break; 2660 case EXCP_MMFAULT: 2661 env->lock_addr = -1; 2662 info.si_signo = TARGET_SIGSEGV; 2663 info.si_errno = 0; 2664 info.si_code = (page_get_flags(env->trap_arg0) & PAGE_VALID 2665 ? TARGET_SEGV_ACCERR : TARGET_SEGV_MAPERR); 2666 info._sifields._sigfault._addr = env->trap_arg0; 2667 queue_signal(env, info.si_signo, &info); 2668 break; 2669 case EXCP_UNALIGN: 2670 env->lock_addr = -1; 2671 info.si_signo = TARGET_SIGBUS; 2672 info.si_errno = 0; 2673 info.si_code = TARGET_BUS_ADRALN; 2674 info._sifields._sigfault._addr = env->trap_arg0; 2675 queue_signal(env, info.si_signo, &info); 2676 break; 2677 case EXCP_OPCDEC: 2678 do_sigill: 2679 env->lock_addr = -1; 2680 info.si_signo = TARGET_SIGILL; 2681 info.si_errno = 0; 2682 info.si_code = TARGET_ILL_ILLOPC; 2683 info._sifields._sigfault._addr = env->pc; 2684 queue_signal(env, info.si_signo, &info); 2685 break; 2686 case EXCP_ARITH: 2687 env->lock_addr = -1; 2688 info.si_signo = TARGET_SIGFPE; 2689 info.si_errno = 0; 2690 info.si_code = TARGET_FPE_FLTINV; 2691 info._sifields._sigfault._addr = env->pc; 2692 queue_signal(env, info.si_signo, &info); 2693 break; 2694 case EXCP_FEN: 2695 /* No-op. Linux simply re-enables the FPU. */ 2696 break; 2697 case EXCP_CALL_PAL: 2698 env->lock_addr = -1; 2699 switch (env->error_code) { 2700 case 0x80: 2701 /* BPT */ 2702 info.si_signo = TARGET_SIGTRAP; 2703 info.si_errno = 0; 2704 info.si_code = TARGET_TRAP_BRKPT; 2705 info._sifields._sigfault._addr = env->pc; 2706 queue_signal(env, info.si_signo, &info); 2707 break; 2708 case 0x81: 2709 /* BUGCHK */ 2710 info.si_signo = TARGET_SIGTRAP; 2711 info.si_errno = 0; 2712 info.si_code = 0; 2713 info._sifields._sigfault._addr = env->pc; 2714 queue_signal(env, info.si_signo, &info); 2715 break; 2716 case 0x83: 2717 /* CALLSYS */ 2718 trapnr = env->ir[IR_V0]; 2719 sysret = do_syscall(env, trapnr, 2720 env->ir[IR_A0], env->ir[IR_A1], 2721 env->ir[IR_A2], env->ir[IR_A3], 2722 env->ir[IR_A4], env->ir[IR_A5], 2723 0, 0); 2724 if (trapnr == TARGET_NR_sigreturn 2725 || trapnr == TARGET_NR_rt_sigreturn) { 2726 break; 2727 } 2728 /* Syscall writes 0 to V0 to bypass error check, similar 2729 to how this is handled internal to Linux kernel. */ 2730 if (env->ir[IR_V0] == 0) { 2731 env->ir[IR_V0] = sysret; 2732 } else { 2733 env->ir[IR_V0] = (sysret < 0 ? -sysret : sysret); 2734 env->ir[IR_A3] = (sysret < 0); 2735 } 2736 break; 2737 case 0x86: 2738 /* IMB */ 2739 /* ??? We can probably elide the code using page_unprotect 2740 that is checking for self-modifying code. Instead we 2741 could simply call tb_flush here. Until we work out the 2742 changes required to turn off the extra write protection, 2743 this can be a no-op. */ 2744 break; 2745 case 0x9E: 2746 /* RDUNIQUE */ 2747 /* Handled in the translator for usermode. */ 2748 abort(); 2749 case 0x9F: 2750 /* WRUNIQUE */ 2751 /* Handled in the translator for usermode. */ 2752 abort(); 2753 case 0xAA: 2754 /* GENTRAP */ 2755 info.si_signo = TARGET_SIGFPE; 2756 switch (env->ir[IR_A0]) { 2757 case TARGET_GEN_INTOVF: 2758 info.si_code = TARGET_FPE_INTOVF; 2759 break; 2760 case TARGET_GEN_INTDIV: 2761 info.si_code = TARGET_FPE_INTDIV; 2762 break; 2763 case TARGET_GEN_FLTOVF: 2764 info.si_code = TARGET_FPE_FLTOVF; 2765 break; 2766 case TARGET_GEN_FLTUND: 2767 info.si_code = TARGET_FPE_FLTUND; 2768 break; 2769 case TARGET_GEN_FLTINV: 2770 info.si_code = TARGET_FPE_FLTINV; 2771 break; 2772 case TARGET_GEN_FLTINE: 2773 info.si_code = TARGET_FPE_FLTRES; 2774 break; 2775 case TARGET_GEN_ROPRAND: 2776 info.si_code = 0; 2777 break; 2778 default: 2779 info.si_signo = TARGET_SIGTRAP; 2780 info.si_code = 0; 2781 break; 2782 } 2783 info.si_errno = 0; 2784 info._sifields._sigfault._addr = env->pc; 2785 queue_signal(env, info.si_signo, &info); 2786 break; 2787 default: 2788 goto do_sigill; 2789 } 2790 break; 2791 case EXCP_DEBUG: 2792 info.si_signo = gdb_handlesig (env, TARGET_SIGTRAP); 2793 if (info.si_signo) { 2794 env->lock_addr = -1; 2795 info.si_errno = 0; 2796 info.si_code = TARGET_TRAP_BRKPT; 2797 queue_signal(env, info.si_signo, &info); 2798 } 2799 break; 2800 case EXCP_STL_C: 2801 case EXCP_STQ_C: 2802 do_store_exclusive(env, env->error_code, trapnr - EXCP_STL_C); 2803 break; 2804 default: 2805 printf ("Unhandled trap: 0x%x\n", trapnr); 2806 cpu_dump_state(env, stderr, fprintf, 0); 2807 exit (1); 2808 } 2809 process_pending_signals (env); 2810 } 2811 } 2812 #endif /* TARGET_ALPHA */ 2813 2814 #ifdef TARGET_S390X 2815 void cpu_loop(CPUS390XState *env) 2816 { 2817 int trapnr; 2818 target_siginfo_t info; 2819 2820 while (1) { 2821 trapnr = cpu_s390x_exec (env); 2822 2823 switch (trapnr) { 2824 case EXCP_INTERRUPT: 2825 /* just indicate that signals should be handled asap */ 2826 break; 2827 case EXCP_DEBUG: 2828 { 2829 int sig; 2830 2831 sig = gdb_handlesig (env, TARGET_SIGTRAP); 2832 if (sig) { 2833 info.si_signo = sig; 2834 info.si_errno = 0; 2835 info.si_code = TARGET_TRAP_BRKPT; 2836 queue_signal(env, info.si_signo, &info); 2837 } 2838 } 2839 break; 2840 case EXCP_SVC: 2841 { 2842 int n = env->int_svc_code; 2843 if (!n) { 2844 /* syscalls > 255 */ 2845 n = env->regs[1]; 2846 } 2847 env->psw.addr += env->int_svc_ilc; 2848 env->regs[2] = do_syscall(env, n, 2849 env->regs[2], 2850 env->regs[3], 2851 env->regs[4], 2852 env->regs[5], 2853 env->regs[6], 2854 env->regs[7], 2855 0, 0); 2856 } 2857 break; 2858 case EXCP_ADDR: 2859 { 2860 info.si_signo = SIGSEGV; 2861 info.si_errno = 0; 2862 /* XXX: check env->error_code */ 2863 info.si_code = TARGET_SEGV_MAPERR; 2864 info._sifields._sigfault._addr = env->__excp_addr; 2865 queue_signal(env, info.si_signo, &info); 2866 } 2867 break; 2868 case EXCP_SPEC: 2869 { 2870 fprintf(stderr,"specification exception insn 0x%08x%04x\n", ldl(env->psw.addr), lduw(env->psw.addr + 4)); 2871 info.si_signo = SIGILL; 2872 info.si_errno = 0; 2873 info.si_code = TARGET_ILL_ILLOPC; 2874 info._sifields._sigfault._addr = env->__excp_addr; 2875 queue_signal(env, info.si_signo, &info); 2876 } 2877 break; 2878 default: 2879 printf ("Unhandled trap: 0x%x\n", trapnr); 2880 cpu_dump_state(env, stderr, fprintf, 0); 2881 exit (1); 2882 } 2883 process_pending_signals (env); 2884 } 2885 } 2886 2887 #endif /* TARGET_S390X */ 2888 2889 THREAD CPUState *thread_env; 2890 2891 void task_settid(TaskState *ts) 2892 { 2893 if (ts->ts_tid == 0) { 2894 #ifdef CONFIG_USE_NPTL 2895 ts->ts_tid = (pid_t)syscall(SYS_gettid); 2896 #else 2897 /* when no threads are used, tid becomes pid */ 2898 ts->ts_tid = getpid(); 2899 #endif 2900 } 2901 } 2902 2903 void stop_all_tasks(void) 2904 { 2905 /* 2906 * We trust that when using NPTL, start_exclusive() 2907 * handles thread stopping correctly. 2908 */ 2909 start_exclusive(); 2910 } 2911 2912 /* Assumes contents are already zeroed. */ 2913 void init_task_state(TaskState *ts) 2914 { 2915 int i; 2916 2917 ts->used = 1; 2918 ts->first_free = ts->sigqueue_table; 2919 for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) { 2920 ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1]; 2921 } 2922 ts->sigqueue_table[i].next = NULL; 2923 } 2924 2925 static void handle_arg_help(const char *arg) 2926 { 2927 usage(); 2928 } 2929 2930 static void handle_arg_log(const char *arg) 2931 { 2932 int mask; 2933 const CPULogItem *item; 2934 2935 mask = cpu_str_to_log_mask(arg); 2936 if (!mask) { 2937 printf("Log items (comma separated):\n"); 2938 for (item = cpu_log_items; item->mask != 0; item++) { 2939 printf("%-10s %s\n", item->name, item->help); 2940 } 2941 exit(1); 2942 } 2943 cpu_set_log(mask); 2944 } 2945 2946 static void handle_arg_set_env(const char *arg) 2947 { 2948 char *r, *p, *token; 2949 r = p = strdup(arg); 2950 while ((token = strsep(&p, ",")) != NULL) { 2951 if (envlist_setenv(envlist, token) != 0) { 2952 usage(); 2953 } 2954 } 2955 free(r); 2956 } 2957 2958 static void handle_arg_unset_env(const char *arg) 2959 { 2960 char *r, *p, *token; 2961 r = p = strdup(arg); 2962 while ((token = strsep(&p, ",")) != NULL) { 2963 if (envlist_unsetenv(envlist, token) != 0) { 2964 usage(); 2965 } 2966 } 2967 free(r); 2968 } 2969 2970 static void handle_arg_argv0(const char *arg) 2971 { 2972 argv0 = strdup(arg); 2973 } 2974 2975 static void handle_arg_stack_size(const char *arg) 2976 { 2977 char *p; 2978 guest_stack_size = strtoul(arg, &p, 0); 2979 if (guest_stack_size == 0) { 2980 usage(); 2981 } 2982 2983 if (*p == 'M') { 2984 guest_stack_size *= 1024 * 1024; 2985 } else if (*p == 'k' || *p == 'K') { 2986 guest_stack_size *= 1024; 2987 } 2988 } 2989 2990 static void handle_arg_ld_prefix(const char *arg) 2991 { 2992 interp_prefix = strdup(arg); 2993 } 2994 2995 static void handle_arg_pagesize(const char *arg) 2996 { 2997 qemu_host_page_size = atoi(arg); 2998 if (qemu_host_page_size == 0 || 2999 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) { 3000 fprintf(stderr, "page size must be a power of two\n"); 3001 exit(1); 3002 } 3003 } 3004 3005 static void handle_arg_gdb(const char *arg) 3006 { 3007 gdbstub_port = atoi(arg); 3008 } 3009 3010 static void handle_arg_uname(const char *arg) 3011 { 3012 qemu_uname_release = strdup(arg); 3013 } 3014 3015 static void handle_arg_cpu(const char *arg) 3016 { 3017 cpu_model = strdup(arg); 3018 if (cpu_model == NULL || strcmp(cpu_model, "?") == 0) { 3019 /* XXX: implement xxx_cpu_list for targets that still miss it */ 3020 #if defined(cpu_list_id) 3021 cpu_list_id(stdout, &fprintf, ""); 3022 #elif defined(cpu_list) 3023 cpu_list(stdout, &fprintf); /* deprecated */ 3024 #endif 3025 exit(1); 3026 } 3027 } 3028 3029 #if defined(CONFIG_USE_GUEST_BASE) 3030 static void handle_arg_guest_base(const char *arg) 3031 { 3032 guest_base = strtol(arg, NULL, 0); 3033 have_guest_base = 1; 3034 } 3035 3036 static void handle_arg_reserved_va(const char *arg) 3037 { 3038 char *p; 3039 int shift = 0; 3040 reserved_va = strtoul(arg, &p, 0); 3041 switch (*p) { 3042 case 'k': 3043 case 'K': 3044 shift = 10; 3045 break; 3046 case 'M': 3047 shift = 20; 3048 break; 3049 case 'G': 3050 shift = 30; 3051 break; 3052 } 3053 if (shift) { 3054 unsigned long unshifted = reserved_va; 3055 p++; 3056 reserved_va <<= shift; 3057 if (((reserved_va >> shift) != unshifted) 3058 #if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS 3059 || (reserved_va > (1ul << TARGET_VIRT_ADDR_SPACE_BITS)) 3060 #endif 3061 ) { 3062 fprintf(stderr, "Reserved virtual address too big\n"); 3063 exit(1); 3064 } 3065 } 3066 if (*p) { 3067 fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p); 3068 exit(1); 3069 } 3070 } 3071 #endif 3072 3073 static void handle_arg_singlestep(const char *arg) 3074 { 3075 singlestep = 1; 3076 } 3077 3078 static void handle_arg_strace(const char *arg) 3079 { 3080 do_strace = 1; 3081 } 3082 3083 static void handle_arg_version(const char *arg) 3084 { 3085 printf("qemu-" TARGET_ARCH " version " QEMU_VERSION QEMU_PKGVERSION 3086 ", Copyright (c) 2003-2008 Fabrice Bellard\n"); 3087 } 3088 3089 struct qemu_argument { 3090 const char *argv; 3091 const char *env; 3092 bool has_arg; 3093 void (*handle_opt)(const char *arg); 3094 const char *example; 3095 const char *help; 3096 }; 3097 3098 struct qemu_argument arg_table[] = { 3099 {"h", "", false, handle_arg_help, 3100 "", "print this help"}, 3101 {"g", "QEMU_GDB", true, handle_arg_gdb, 3102 "port", "wait gdb connection to 'port'"}, 3103 {"L", "QEMU_LD_PREFIX", true, handle_arg_ld_prefix, 3104 "path", "set the elf interpreter prefix to 'path'"}, 3105 {"s", "QEMU_STACK_SIZE", true, handle_arg_stack_size, 3106 "size", "set the stack size to 'size' bytes"}, 3107 {"cpu", "QEMU_CPU", true, handle_arg_cpu, 3108 "model", "select CPU (-cpu ? for list)"}, 3109 {"E", "QEMU_SET_ENV", true, handle_arg_set_env, 3110 "var=value", "sets targets environment variable (see below)"}, 3111 {"U", "QEMU_UNSET_ENV", true, handle_arg_unset_env, 3112 "var", "unsets targets environment variable (see below)"}, 3113 {"0", "QEMU_ARGV0", true, handle_arg_argv0, 3114 "argv0", "forces target process argv[0] to be 'argv0'"}, 3115 {"r", "QEMU_UNAME", true, handle_arg_uname, 3116 "uname", "set qemu uname release string to 'uname'"}, 3117 #if defined(CONFIG_USE_GUEST_BASE) 3118 {"B", "QEMU_GUEST_BASE", true, handle_arg_guest_base, 3119 "address", "set guest_base address to 'address'"}, 3120 {"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va, 3121 "size", "reserve 'size' bytes for guest virtual address space"}, 3122 #endif 3123 {"d", "QEMU_LOG", true, handle_arg_log, 3124 "options", "activate log"}, 3125 {"p", "QEMU_PAGESIZE", true, handle_arg_pagesize, 3126 "pagesize", "set the host page size to 'pagesize'"}, 3127 {"singlestep", "QEMU_SINGLESTEP", false, handle_arg_singlestep, 3128 "", "run in singlestep mode"}, 3129 {"strace", "QEMU_STRACE", false, handle_arg_strace, 3130 "", "log system calls"}, 3131 {"version", "QEMU_VERSION", false, handle_arg_version, 3132 "", "log system calls"}, 3133 {NULL, NULL, false, NULL, NULL, NULL} 3134 }; 3135 3136 static void usage(void) 3137 { 3138 struct qemu_argument *arginfo; 3139 int maxarglen; 3140 int maxenvlen; 3141 3142 printf("usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n" 3143 "Linux CPU emulator (compiled for " TARGET_ARCH " emulation)\n" 3144 "\n" 3145 "Options and associated environment variables:\n" 3146 "\n"); 3147 3148 maxarglen = maxenvlen = 0; 3149 3150 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 3151 if (strlen(arginfo->env) > maxenvlen) { 3152 maxenvlen = strlen(arginfo->env); 3153 } 3154 if (strlen(arginfo->argv) > maxarglen) { 3155 maxarglen = strlen(arginfo->argv); 3156 } 3157 } 3158 3159 printf("%-*s%-*sDescription\n", maxarglen+3, "Argument", 3160 maxenvlen+1, "Env-variable"); 3161 3162 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 3163 if (arginfo->has_arg) { 3164 printf("-%s %-*s %-*s %s\n", arginfo->argv, 3165 (int)(maxarglen-strlen(arginfo->argv)), arginfo->example, 3166 maxenvlen, arginfo->env, arginfo->help); 3167 } else { 3168 printf("-%-*s %-*s %s\n", maxarglen+1, arginfo->argv, 3169 maxenvlen, arginfo->env, 3170 arginfo->help); 3171 } 3172 } 3173 3174 printf("\n" 3175 "Defaults:\n" 3176 "QEMU_LD_PREFIX = %s\n" 3177 "QEMU_STACK_SIZE = %ld byte\n" 3178 "QEMU_LOG = %s\n", 3179 interp_prefix, 3180 guest_stack_size, 3181 DEBUG_LOGFILE); 3182 3183 printf("\n" 3184 "You can use -E and -U options or the QEMU_SET_ENV and\n" 3185 "QEMU_UNSET_ENV environment variables to set and unset\n" 3186 "environment variables for the target process.\n" 3187 "It is possible to provide several variables by separating them\n" 3188 "by commas in getsubopt(3) style. Additionally it is possible to\n" 3189 "provide the -E and -U options multiple times.\n" 3190 "The following lines are equivalent:\n" 3191 " -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n" 3192 " -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n" 3193 " QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n" 3194 "Note that if you provide several changes to a single variable\n" 3195 "the last change will stay in effect.\n"); 3196 3197 exit(1); 3198 } 3199 3200 static int parse_args(int argc, char **argv) 3201 { 3202 const char *r; 3203 int optind; 3204 struct qemu_argument *arginfo; 3205 3206 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 3207 if (arginfo->env == NULL) { 3208 continue; 3209 } 3210 3211 r = getenv(arginfo->env); 3212 if (r != NULL) { 3213 arginfo->handle_opt(r); 3214 } 3215 } 3216 3217 optind = 1; 3218 for (;;) { 3219 if (optind >= argc) { 3220 break; 3221 } 3222 r = argv[optind]; 3223 if (r[0] != '-') { 3224 break; 3225 } 3226 optind++; 3227 r++; 3228 if (!strcmp(r, "-")) { 3229 break; 3230 } 3231 3232 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 3233 if (!strcmp(r, arginfo->argv)) { 3234 if (optind >= argc) { 3235 usage(); 3236 } 3237 3238 arginfo->handle_opt(argv[optind]); 3239 3240 if (arginfo->has_arg) { 3241 optind++; 3242 } 3243 3244 break; 3245 } 3246 } 3247 3248 /* no option matched the current argv */ 3249 if (arginfo->handle_opt == NULL) { 3250 usage(); 3251 } 3252 } 3253 3254 if (optind >= argc) { 3255 usage(); 3256 } 3257 3258 filename = argv[optind]; 3259 exec_path = argv[optind]; 3260 3261 return optind; 3262 } 3263 3264 int main(int argc, char **argv, char **envp) 3265 { 3266 const char *log_file = DEBUG_LOGFILE; 3267 struct target_pt_regs regs1, *regs = ®s1; 3268 struct image_info info1, *info = &info1; 3269 struct linux_binprm bprm; 3270 TaskState *ts; 3271 CPUState *env; 3272 int optind; 3273 char **target_environ, **wrk; 3274 char **target_argv; 3275 int target_argc; 3276 int i; 3277 int ret; 3278 3279 if (argc <= 1) 3280 usage(); 3281 3282 qemu_cache_utils_init(envp); 3283 3284 if ((envlist = envlist_create()) == NULL) { 3285 (void) fprintf(stderr, "Unable to allocate envlist\n"); 3286 exit(1); 3287 } 3288 3289 /* add current environment into the list */ 3290 for (wrk = environ; *wrk != NULL; wrk++) { 3291 (void) envlist_setenv(envlist, *wrk); 3292 } 3293 3294 /* Read the stack limit from the kernel. If it's "unlimited", 3295 then we can do little else besides use the default. */ 3296 { 3297 struct rlimit lim; 3298 if (getrlimit(RLIMIT_STACK, &lim) == 0 3299 && lim.rlim_cur != RLIM_INFINITY 3300 && lim.rlim_cur == (target_long)lim.rlim_cur) { 3301 guest_stack_size = lim.rlim_cur; 3302 } 3303 } 3304 3305 cpu_model = NULL; 3306 #if defined(cpudef_setup) 3307 cpudef_setup(); /* parse cpu definitions in target config file (TBD) */ 3308 #endif 3309 3310 /* init debug */ 3311 cpu_set_log_filename(log_file); 3312 optind = parse_args(argc, argv); 3313 3314 /* Zero out regs */ 3315 memset(regs, 0, sizeof(struct target_pt_regs)); 3316 3317 /* Zero out image_info */ 3318 memset(info, 0, sizeof(struct image_info)); 3319 3320 memset(&bprm, 0, sizeof (bprm)); 3321 3322 /* Scan interp_prefix dir for replacement files. */ 3323 init_paths(interp_prefix); 3324 3325 if (cpu_model == NULL) { 3326 #if defined(TARGET_I386) 3327 #ifdef TARGET_X86_64 3328 cpu_model = "qemu64"; 3329 #else 3330 cpu_model = "qemu32"; 3331 #endif 3332 #elif defined(TARGET_ARM) 3333 cpu_model = "any"; 3334 #elif defined(TARGET_UNICORE32) 3335 cpu_model = "any"; 3336 #elif defined(TARGET_M68K) 3337 cpu_model = "any"; 3338 #elif defined(TARGET_SPARC) 3339 #ifdef TARGET_SPARC64 3340 cpu_model = "TI UltraSparc II"; 3341 #else 3342 cpu_model = "Fujitsu MB86904"; 3343 #endif 3344 #elif defined(TARGET_MIPS) 3345 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) 3346 cpu_model = "20Kc"; 3347 #else 3348 cpu_model = "24Kf"; 3349 #endif 3350 #elif defined(TARGET_PPC) 3351 #ifdef TARGET_PPC64 3352 cpu_model = "970fx"; 3353 #else 3354 cpu_model = "750"; 3355 #endif 3356 #else 3357 cpu_model = "any"; 3358 #endif 3359 } 3360 tcg_exec_init(0); 3361 cpu_exec_init_all(); 3362 /* NOTE: we need to init the CPU at this stage to get 3363 qemu_host_page_size */ 3364 env = cpu_init(cpu_model); 3365 if (!env) { 3366 fprintf(stderr, "Unable to find CPU definition\n"); 3367 exit(1); 3368 } 3369 #if defined(TARGET_I386) || defined(TARGET_SPARC) || defined(TARGET_PPC) 3370 cpu_reset(env); 3371 #endif 3372 3373 thread_env = env; 3374 3375 if (getenv("QEMU_STRACE")) { 3376 do_strace = 1; 3377 } 3378 3379 target_environ = envlist_to_environ(envlist, NULL); 3380 envlist_free(envlist); 3381 3382 #if defined(CONFIG_USE_GUEST_BASE) 3383 /* 3384 * Now that page sizes are configured in cpu_init() we can do 3385 * proper page alignment for guest_base. 3386 */ 3387 guest_base = HOST_PAGE_ALIGN(guest_base); 3388 3389 if (reserved_va) { 3390 void *p; 3391 int flags; 3392 3393 flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE; 3394 if (have_guest_base) { 3395 flags |= MAP_FIXED; 3396 } 3397 p = mmap((void *)guest_base, reserved_va, PROT_NONE, flags, -1, 0); 3398 if (p == MAP_FAILED) { 3399 fprintf(stderr, "Unable to reserve guest address space\n"); 3400 exit(1); 3401 } 3402 guest_base = (unsigned long)p; 3403 /* Make sure the address is properly aligned. */ 3404 if (guest_base & ~qemu_host_page_mask) { 3405 munmap(p, reserved_va); 3406 p = mmap((void *)guest_base, reserved_va + qemu_host_page_size, 3407 PROT_NONE, flags, -1, 0); 3408 if (p == MAP_FAILED) { 3409 fprintf(stderr, "Unable to reserve guest address space\n"); 3410 exit(1); 3411 } 3412 guest_base = HOST_PAGE_ALIGN((unsigned long)p); 3413 } 3414 qemu_log("Reserved 0x%lx bytes of guest address space\n", reserved_va); 3415 } 3416 3417 if (reserved_va || have_guest_base) { 3418 if (!guest_validate_base(guest_base)) { 3419 fprintf(stderr, "Guest base/Reserved VA rejected by guest code\n"); 3420 exit(1); 3421 } 3422 } 3423 #endif /* CONFIG_USE_GUEST_BASE */ 3424 3425 /* 3426 * Read in mmap_min_addr kernel parameter. This value is used 3427 * When loading the ELF image to determine whether guest_base 3428 * is needed. It is also used in mmap_find_vma. 3429 */ 3430 { 3431 FILE *fp; 3432 3433 if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) { 3434 unsigned long tmp; 3435 if (fscanf(fp, "%lu", &tmp) == 1) { 3436 mmap_min_addr = tmp; 3437 qemu_log("host mmap_min_addr=0x%lx\n", mmap_min_addr); 3438 } 3439 fclose(fp); 3440 } 3441 } 3442 3443 /* 3444 * Prepare copy of argv vector for target. 3445 */ 3446 target_argc = argc - optind; 3447 target_argv = calloc(target_argc + 1, sizeof (char *)); 3448 if (target_argv == NULL) { 3449 (void) fprintf(stderr, "Unable to allocate memory for target_argv\n"); 3450 exit(1); 3451 } 3452 3453 /* 3454 * If argv0 is specified (using '-0' switch) we replace 3455 * argv[0] pointer with the given one. 3456 */ 3457 i = 0; 3458 if (argv0 != NULL) { 3459 target_argv[i++] = strdup(argv0); 3460 } 3461 for (; i < target_argc; i++) { 3462 target_argv[i] = strdup(argv[optind + i]); 3463 } 3464 target_argv[target_argc] = NULL; 3465 3466 ts = g_malloc0 (sizeof(TaskState)); 3467 init_task_state(ts); 3468 /* build Task State */ 3469 ts->info = info; 3470 ts->bprm = &bprm; 3471 env->opaque = ts; 3472 task_settid(ts); 3473 3474 ret = loader_exec(filename, target_argv, target_environ, regs, 3475 info, &bprm); 3476 if (ret != 0) { 3477 printf("Error %d while loading %s\n", ret, filename); 3478 _exit(1); 3479 } 3480 3481 for (i = 0; i < target_argc; i++) { 3482 free(target_argv[i]); 3483 } 3484 free(target_argv); 3485 3486 for (wrk = target_environ; *wrk; wrk++) { 3487 free(*wrk); 3488 } 3489 3490 free(target_environ); 3491 3492 if (qemu_log_enabled()) { 3493 #if defined(CONFIG_USE_GUEST_BASE) 3494 qemu_log("guest_base 0x%lx\n", guest_base); 3495 #endif 3496 log_page_dump(); 3497 3498 qemu_log("start_brk 0x" TARGET_ABI_FMT_lx "\n", info->start_brk); 3499 qemu_log("end_code 0x" TARGET_ABI_FMT_lx "\n", info->end_code); 3500 qemu_log("start_code 0x" TARGET_ABI_FMT_lx "\n", 3501 info->start_code); 3502 qemu_log("start_data 0x" TARGET_ABI_FMT_lx "\n", 3503 info->start_data); 3504 qemu_log("end_data 0x" TARGET_ABI_FMT_lx "\n", info->end_data); 3505 qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n", 3506 info->start_stack); 3507 qemu_log("brk 0x" TARGET_ABI_FMT_lx "\n", info->brk); 3508 qemu_log("entry 0x" TARGET_ABI_FMT_lx "\n", info->entry); 3509 } 3510 3511 target_set_brk(info->brk); 3512 syscall_init(); 3513 signal_init(); 3514 3515 #if defined(CONFIG_USE_GUEST_BASE) 3516 /* Now that we've loaded the binary, GUEST_BASE is fixed. Delay 3517 generating the prologue until now so that the prologue can take 3518 the real value of GUEST_BASE into account. */ 3519 tcg_prologue_init(&tcg_ctx); 3520 #endif 3521 3522 #if defined(TARGET_I386) 3523 cpu_x86_set_cpl(env, 3); 3524 3525 env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK; 3526 env->hflags |= HF_PE_MASK; 3527 if (env->cpuid_features & CPUID_SSE) { 3528 env->cr[4] |= CR4_OSFXSR_MASK; 3529 env->hflags |= HF_OSFXSR_MASK; 3530 } 3531 #ifndef TARGET_ABI32 3532 /* enable 64 bit mode if possible */ 3533 if (!(env->cpuid_ext2_features & CPUID_EXT2_LM)) { 3534 fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n"); 3535 exit(1); 3536 } 3537 env->cr[4] |= CR4_PAE_MASK; 3538 env->efer |= MSR_EFER_LMA | MSR_EFER_LME; 3539 env->hflags |= HF_LMA_MASK; 3540 #endif 3541 3542 /* flags setup : we activate the IRQs by default as in user mode */ 3543 env->eflags |= IF_MASK; 3544 3545 /* linux register setup */ 3546 #ifndef TARGET_ABI32 3547 env->regs[R_EAX] = regs->rax; 3548 env->regs[R_EBX] = regs->rbx; 3549 env->regs[R_ECX] = regs->rcx; 3550 env->regs[R_EDX] = regs->rdx; 3551 env->regs[R_ESI] = regs->rsi; 3552 env->regs[R_EDI] = regs->rdi; 3553 env->regs[R_EBP] = regs->rbp; 3554 env->regs[R_ESP] = regs->rsp; 3555 env->eip = regs->rip; 3556 #else 3557 env->regs[R_EAX] = regs->eax; 3558 env->regs[R_EBX] = regs->ebx; 3559 env->regs[R_ECX] = regs->ecx; 3560 env->regs[R_EDX] = regs->edx; 3561 env->regs[R_ESI] = regs->esi; 3562 env->regs[R_EDI] = regs->edi; 3563 env->regs[R_EBP] = regs->ebp; 3564 env->regs[R_ESP] = regs->esp; 3565 env->eip = regs->eip; 3566 #endif 3567 3568 /* linux interrupt setup */ 3569 #ifndef TARGET_ABI32 3570 env->idt.limit = 511; 3571 #else 3572 env->idt.limit = 255; 3573 #endif 3574 env->idt.base = target_mmap(0, sizeof(uint64_t) * (env->idt.limit + 1), 3575 PROT_READ|PROT_WRITE, 3576 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); 3577 idt_table = g2h(env->idt.base); 3578 set_idt(0, 0); 3579 set_idt(1, 0); 3580 set_idt(2, 0); 3581 set_idt(3, 3); 3582 set_idt(4, 3); 3583 set_idt(5, 0); 3584 set_idt(6, 0); 3585 set_idt(7, 0); 3586 set_idt(8, 0); 3587 set_idt(9, 0); 3588 set_idt(10, 0); 3589 set_idt(11, 0); 3590 set_idt(12, 0); 3591 set_idt(13, 0); 3592 set_idt(14, 0); 3593 set_idt(15, 0); 3594 set_idt(16, 0); 3595 set_idt(17, 0); 3596 set_idt(18, 0); 3597 set_idt(19, 0); 3598 set_idt(0x80, 3); 3599 3600 /* linux segment setup */ 3601 { 3602 uint64_t *gdt_table; 3603 env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES, 3604 PROT_READ|PROT_WRITE, 3605 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); 3606 env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1; 3607 gdt_table = g2h(env->gdt.base); 3608 #ifdef TARGET_ABI32 3609 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, 3610 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 3611 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); 3612 #else 3613 /* 64 bit code segment */ 3614 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, 3615 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 3616 DESC_L_MASK | 3617 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); 3618 #endif 3619 write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff, 3620 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 3621 (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT)); 3622 } 3623 cpu_x86_load_seg(env, R_CS, __USER_CS); 3624 cpu_x86_load_seg(env, R_SS, __USER_DS); 3625 #ifdef TARGET_ABI32 3626 cpu_x86_load_seg(env, R_DS, __USER_DS); 3627 cpu_x86_load_seg(env, R_ES, __USER_DS); 3628 cpu_x86_load_seg(env, R_FS, __USER_DS); 3629 cpu_x86_load_seg(env, R_GS, __USER_DS); 3630 /* This hack makes Wine work... */ 3631 env->segs[R_FS].selector = 0; 3632 #else 3633 cpu_x86_load_seg(env, R_DS, 0); 3634 cpu_x86_load_seg(env, R_ES, 0); 3635 cpu_x86_load_seg(env, R_FS, 0); 3636 cpu_x86_load_seg(env, R_GS, 0); 3637 #endif 3638 #elif defined(TARGET_ARM) 3639 { 3640 int i; 3641 cpsr_write(env, regs->uregs[16], 0xffffffff); 3642 for(i = 0; i < 16; i++) { 3643 env->regs[i] = regs->uregs[i]; 3644 } 3645 } 3646 #elif defined(TARGET_UNICORE32) 3647 { 3648 int i; 3649 cpu_asr_write(env, regs->uregs[32], 0xffffffff); 3650 for (i = 0; i < 32; i++) { 3651 env->regs[i] = regs->uregs[i]; 3652 } 3653 } 3654 #elif defined(TARGET_SPARC) 3655 { 3656 int i; 3657 env->pc = regs->pc; 3658 env->npc = regs->npc; 3659 env->y = regs->y; 3660 for(i = 0; i < 8; i++) 3661 env->gregs[i] = regs->u_regs[i]; 3662 for(i = 0; i < 8; i++) 3663 env->regwptr[i] = regs->u_regs[i + 8]; 3664 } 3665 #elif defined(TARGET_PPC) 3666 { 3667 int i; 3668 3669 #if defined(TARGET_PPC64) 3670 #if defined(TARGET_ABI32) 3671 env->msr &= ~((target_ulong)1 << MSR_SF); 3672 #else 3673 env->msr |= (target_ulong)1 << MSR_SF; 3674 #endif 3675 #endif 3676 env->nip = regs->nip; 3677 for(i = 0; i < 32; i++) { 3678 env->gpr[i] = regs->gpr[i]; 3679 } 3680 } 3681 #elif defined(TARGET_M68K) 3682 { 3683 env->pc = regs->pc; 3684 env->dregs[0] = regs->d0; 3685 env->dregs[1] = regs->d1; 3686 env->dregs[2] = regs->d2; 3687 env->dregs[3] = regs->d3; 3688 env->dregs[4] = regs->d4; 3689 env->dregs[5] = regs->d5; 3690 env->dregs[6] = regs->d6; 3691 env->dregs[7] = regs->d7; 3692 env->aregs[0] = regs->a0; 3693 env->aregs[1] = regs->a1; 3694 env->aregs[2] = regs->a2; 3695 env->aregs[3] = regs->a3; 3696 env->aregs[4] = regs->a4; 3697 env->aregs[5] = regs->a5; 3698 env->aregs[6] = regs->a6; 3699 env->aregs[7] = regs->usp; 3700 env->sr = regs->sr; 3701 ts->sim_syscalls = 1; 3702 } 3703 #elif defined(TARGET_MICROBLAZE) 3704 { 3705 env->regs[0] = regs->r0; 3706 env->regs[1] = regs->r1; 3707 env->regs[2] = regs->r2; 3708 env->regs[3] = regs->r3; 3709 env->regs[4] = regs->r4; 3710 env->regs[5] = regs->r5; 3711 env->regs[6] = regs->r6; 3712 env->regs[7] = regs->r7; 3713 env->regs[8] = regs->r8; 3714 env->regs[9] = regs->r9; 3715 env->regs[10] = regs->r10; 3716 env->regs[11] = regs->r11; 3717 env->regs[12] = regs->r12; 3718 env->regs[13] = regs->r13; 3719 env->regs[14] = regs->r14; 3720 env->regs[15] = regs->r15; 3721 env->regs[16] = regs->r16; 3722 env->regs[17] = regs->r17; 3723 env->regs[18] = regs->r18; 3724 env->regs[19] = regs->r19; 3725 env->regs[20] = regs->r20; 3726 env->regs[21] = regs->r21; 3727 env->regs[22] = regs->r22; 3728 env->regs[23] = regs->r23; 3729 env->regs[24] = regs->r24; 3730 env->regs[25] = regs->r25; 3731 env->regs[26] = regs->r26; 3732 env->regs[27] = regs->r27; 3733 env->regs[28] = regs->r28; 3734 env->regs[29] = regs->r29; 3735 env->regs[30] = regs->r30; 3736 env->regs[31] = regs->r31; 3737 env->sregs[SR_PC] = regs->pc; 3738 } 3739 #elif defined(TARGET_MIPS) 3740 { 3741 int i; 3742 3743 for(i = 0; i < 32; i++) { 3744 env->active_tc.gpr[i] = regs->regs[i]; 3745 } 3746 env->active_tc.PC = regs->cp0_epc & ~(target_ulong)1; 3747 if (regs->cp0_epc & 1) { 3748 env->hflags |= MIPS_HFLAG_M16; 3749 } 3750 } 3751 #elif defined(TARGET_SH4) 3752 { 3753 int i; 3754 3755 for(i = 0; i < 16; i++) { 3756 env->gregs[i] = regs->regs[i]; 3757 } 3758 env->pc = regs->pc; 3759 } 3760 #elif defined(TARGET_ALPHA) 3761 { 3762 int i; 3763 3764 for(i = 0; i < 28; i++) { 3765 env->ir[i] = ((abi_ulong *)regs)[i]; 3766 } 3767 env->ir[IR_SP] = regs->usp; 3768 env->pc = regs->pc; 3769 } 3770 #elif defined(TARGET_CRIS) 3771 { 3772 env->regs[0] = regs->r0; 3773 env->regs[1] = regs->r1; 3774 env->regs[2] = regs->r2; 3775 env->regs[3] = regs->r3; 3776 env->regs[4] = regs->r4; 3777 env->regs[5] = regs->r5; 3778 env->regs[6] = regs->r6; 3779 env->regs[7] = regs->r7; 3780 env->regs[8] = regs->r8; 3781 env->regs[9] = regs->r9; 3782 env->regs[10] = regs->r10; 3783 env->regs[11] = regs->r11; 3784 env->regs[12] = regs->r12; 3785 env->regs[13] = regs->r13; 3786 env->regs[14] = info->start_stack; 3787 env->regs[15] = regs->acr; 3788 env->pc = regs->erp; 3789 } 3790 #elif defined(TARGET_S390X) 3791 { 3792 int i; 3793 for (i = 0; i < 16; i++) { 3794 env->regs[i] = regs->gprs[i]; 3795 } 3796 env->psw.mask = regs->psw.mask; 3797 env->psw.addr = regs->psw.addr; 3798 } 3799 #else 3800 #error unsupported target CPU 3801 #endif 3802 3803 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32) 3804 ts->stack_base = info->start_stack; 3805 ts->heap_base = info->brk; 3806 /* This will be filled in on the first SYS_HEAPINFO call. */ 3807 ts->heap_limit = 0; 3808 #endif 3809 3810 if (gdbstub_port) { 3811 if (gdbserver_start(gdbstub_port) < 0) { 3812 fprintf(stderr, "qemu: could not open gdbserver on port %d\n", 3813 gdbstub_port); 3814 exit(1); 3815 } 3816 gdb_handlesig(env, 0); 3817 } 3818 cpu_loop(env); 3819 /* never exits */ 3820 return 0; 3821 } 3822