Archipelago » qemu

/* Structure used to record exclusive memory locations.  */

typedef struct mmon_state {

    struct mmon_state *next;

    CPUARMState *cpu_env;

    uint32_t addr;

} mmon_state;

/* Chain of current locks.  */

static mmon_state* mmon_head = NULL;

static void allocate_mmon_state(CPUState *env)

{

    env->mmon_entry = malloc(sizeof (mmon_state));

    memset (env->mmon_entry, 0, sizeof (mmon_state));

    env->mmon_entry->cpu_env = env;

    mmon_head = env->mmon_entry;

}

/* Flush any monitor locks for the specified address.  */

static void flush_mmon(uint32_t addr)

{

    mmon_state *mon;

    for (mon = mmon_head; mon; mon = mon->next)

      {

        if (mon->addr != addr)

          continue;

        mon->addr = 0;

        break;

      }

}

/* Mark an address for exclusive access.  */

void HELPER(mark_exclusive)(CPUState *env, uint32_t addr)

{

    if (!env->mmon_entry)

        allocate_mmon_state(env);

    /* Clear any previous locks.  */

    flush_mmon(addr);

    env->mmon_entry->addr = addr;

}

/* Test if an exclusive address is still exclusive.  Returns zero

   if the address is still exclusive.   */

uint32_t HELPER(test_exclusive)(CPUState *env, uint32_t addr)

{

    int res;

    if (!env->mmon_entry)

        return 1;

    if (env->mmon_entry->addr == addr)

        res = 0;

    else

        res = 1;

    flush_mmon(addr);

    return res;

}

void HELPER(clrex)(CPUState *env)

{

    if (!(env->mmon_entry && env->mmon_entry->addr))

        return;

    flush_mmon(env->mmon_entry->addr);

}

/* Not really implemented.  Need to figure out a sane way of doing this.

   Maybe add generic watchpoint support and use that.  */

void HELPER(mark_exclusive)(CPUState *env, uint32_t addr)

{

    env->mmon_addr = addr;

}

uint32_t HELPER(test_exclusive)(CPUState *env, uint32_t addr)

{

    return (env->mmon_addr != addr);

}

void HELPER(clrex)(CPUState *env)

{

    env->mmon_addr = -1;

}