cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

cpu_loop.c (4909B)

      1/*
      2 *  qemu user cpu loop
      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
     20#include "qemu/osdep.h"
     21#include "qemu-common.h"
     22#include "qemu.h"
     23#include "user-internals.h"
     24#include "cpu_loop-common.h"
     25#include "signal-common.h"
     26
     27void cpu_loop(CPUM68KState *env)
     28{
     29    CPUState *cs = env_cpu(env);
     30    int trapnr;
     31    unsigned int n;
     32    target_siginfo_t info;
     33
     34    for(;;) {
     35        cpu_exec_start(cs);
     36        trapnr = cpu_exec(cs);
     37        cpu_exec_end(cs);
     38        process_queued_cpu_work(cs);
     39
     40        switch(trapnr) {
     41        case EXCP_HALT_INSN:
     42            /* Semihosing syscall.  */
     43            env->pc += 4;
     44            do_m68k_semihosting(env, env->dregs[0]);
     45            break;
     46        case EXCP_ILLEGAL:
     47        case EXCP_LINEA:
     48        case EXCP_LINEF:
     49            info.si_signo = TARGET_SIGILL;
     50            info.si_errno = 0;
     51            info.si_code = TARGET_ILL_ILLOPN;
     52            info._sifields._sigfault._addr = env->pc;
     53            queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
     54            break;
     55        case EXCP_CHK:
     56            info.si_signo = TARGET_SIGFPE;
     57            info.si_errno = 0;
     58            info.si_code = TARGET_FPE_INTOVF;
     59            info._sifields._sigfault._addr = env->pc;
     60            queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
     61            break;
     62        case EXCP_DIV0:
     63            info.si_signo = TARGET_SIGFPE;
     64            info.si_errno = 0;
     65            info.si_code = TARGET_FPE_INTDIV;
     66            info._sifields._sigfault._addr = env->pc;
     67            queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
     68            break;
     69        case EXCP_TRAP0:
     70            {
     71                abi_long ret;
     72                n = env->dregs[0];
     73                env->pc += 2;
     74                ret = do_syscall(env,
     75                                 n,
     76                                 env->dregs[1],
     77                                 env->dregs[2],
     78                                 env->dregs[3],
     79                                 env->dregs[4],
     80                                 env->dregs[5],
     81                                 env->aregs[0],
     82                                 0, 0);
     83                if (ret == -TARGET_ERESTARTSYS) {
     84                    env->pc -= 2;
     85                } else if (ret != -TARGET_QEMU_ESIGRETURN) {
     86                    env->dregs[0] = ret;
     87                }
     88            }
     89            break;
     90        case EXCP_INTERRUPT:
     91            /* just indicate that signals should be handled asap */
     92            break;
     93        case EXCP_ACCESS:
     94            {
     95                info.si_signo = TARGET_SIGSEGV;
     96                info.si_errno = 0;
     97                /* XXX: check env->error_code */
     98                info.si_code = TARGET_SEGV_MAPERR;
     99                info._sifields._sigfault._addr = env->mmu.ar;
    100                queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
    101            }
    102            break;
    103        case EXCP_DEBUG:
    104            info.si_signo = TARGET_SIGTRAP;
    105            info.si_errno = 0;
    106            info.si_code = TARGET_TRAP_BRKPT;
    107            queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
    108            break;
    109        case EXCP_ATOMIC:
    110            cpu_exec_step_atomic(cs);
    111            break;
    112        default:
    113            EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr);
    114            abort();
    115        }
    116        process_pending_signals(env);
    117    }
    118}
    119
    120void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
    121{
    122    CPUState *cpu = env_cpu(env);
    123    TaskState *ts = cpu->opaque;
    124    struct image_info *info = ts->info;
    125
    126    env->pc = regs->pc;
    127    env->dregs[0] = regs->d0;
    128    env->dregs[1] = regs->d1;
    129    env->dregs[2] = regs->d2;
    130    env->dregs[3] = regs->d3;
    131    env->dregs[4] = regs->d4;
    132    env->dregs[5] = regs->d5;
    133    env->dregs[6] = regs->d6;
    134    env->dregs[7] = regs->d7;
    135    env->aregs[0] = regs->a0;
    136    env->aregs[1] = regs->a1;
    137    env->aregs[2] = regs->a2;
    138    env->aregs[3] = regs->a3;
    139    env->aregs[4] = regs->a4;
    140    env->aregs[5] = regs->a5;
    141    env->aregs[6] = regs->a6;
    142    env->aregs[7] = regs->usp;
    143    env->sr = regs->sr;
    144
    145    ts->stack_base = info->start_stack;
    146    ts->heap_base = info->brk;
    147    /* This will be filled in on the first SYS_HEAPINFO call.  */
    148    ts->heap_limit = 0;
    149}