xenitp.c

xen虚拟机源代码安装包

                if (virt_to_phys (*b == 'i', vaddr, res) != 0) {
                    printf ("cannot find vaddr %016lx in tr\n", vaddr);
                    return -1;
                }
                return 0;
            }
            else {
                printf ("unknown symbol\n");
                return -1;
            }
            *buf = e;
        }
        break;
    case '(':
        (*buf)++;
        if (parse_expr (buf, res, EXPR_BASE) != 0)
            return -1;

        if (next_char (buf) != ')') {
            printf ("missing ')'\n");
            return -1;
        }
        else
            (*buf)++;
        break;
    default:
        printf ("unknown operand '%c' in expression\n", c);
        return -1;
    }

    return 0;
}

int parse_expr (char **buf, unsigned long *res, enum prio_expr prio)
{
    unsigned long val = 0;
    unsigned long val1;
    char c;

    if (parse_unary (buf, &val) != 0)
        return -1;

    while (1) {
        c = next_char (buf);
        switch (c) {
        case '+':
        case '-':
            if (prio > EXPR_SUM)
                return 0;
            (*buf)++;
            if (parse_expr (buf, &val1, EXPR_SUM) < 0)
                return -1;
            if (c == '+')
                val += val1;
            else
                val -= val1;
            break;
        case '*':
            if (prio > EXPR_PROD)
                return 0;

            (*buf)++;
            if (parse_expr (buf, &val1, EXPR_SUM) < 0)
                return -1;

            val *= val1;
            break;
        default:
            *res = val;
            return 0;
        }
    }
}

char *parse_arg (char **buf)
{
    char *res;
    char *b = *buf;

    /* Eat leading spaces.  */
    while (isspace ((unsigned char)*b))
        b++;

    res = b;
    while (*b && !isspace ((unsigned char)*b))
        b++;

    /* Set the NUL terminator.  */
    if (*b)
        *b++ = 0;

    *buf = b;
    return res;
}

vcpu_guest_context_any_t vcpu_ctx_any[MAX_VIRT_CPUS];

int vcpu_setcontext (int vcpu)
{
    int ret;

    ret = xc_vcpu_setcontext (xc_handle, domid, vcpu, &vcpu_ctx_any[vcpu]);
    if (ret < 0)
        perror ("xc_vcpu_setcontext");

    return ret;
}

enum cmd_status { CMD_ERROR, CMD_OK, CMD_REPEAT, CMD_QUIT };

struct command_desc
{
    const char *name;
    const char *help;
    enum cmd_status (*cmd)(char *line);
};

static enum cmd_status
cmd_registers (char *line)
{
    print_ctx (cur_ctx);
    return CMD_OK;
}

static enum cmd_status
cmd_sstep (char *line)
{
    /* Set psr.dd and psr.id to skip over current breakpoint.  */
    cur_ctx->regs.psr |= PSR_SS | PSR_DD | PSR_ID;
    cur_ctx->regs.psr &= ~PSR_TB;
    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;

    if (wait_domain (cur_vcpu, cur_ctx) < 0) {
        perror ("wait_domain");
        return CMD_ERROR;
    }

    print_ctx (cur_ctx);

    return CMD_REPEAT;
}

static enum cmd_status
cmd_go (char *line)
{
    unsigned long n = 1;

    if (*line != 0) {
        if (parse_expr (&line, &n, 0) < 0)
            return CMD_ERROR;
    }
    while (n > 0) {
        /* Set psr.dd and psr.id to skip over current breakpoint.  */
        if ((cur_ctx->regs.psr & (PSR_SS | PSR_TB | PSR_DB)) != 0) {
            cur_ctx->regs.psr &= ~(PSR_SS | PSR_TB);
            cur_ctx->regs.psr |= PSR_DD | PSR_ID;
            if (vcpu_setcontext (cur_vcpu) < 0)
                return CMD_ERROR;
        }

        if (wait_domain (cur_vcpu, cur_ctx) < 0) {
            perror ("wait_domain");
            return CMD_ERROR;
        }
        print_ctx (cur_ctx);
        n--;
    }

    return CMD_REPEAT;
}

static enum cmd_status
cmd_cb (char *line)
{
    if ((cur_ctx->regs.psr & (PSR_SS | PSR_TB)) != PSR_TB) {
        cur_ctx->regs.psr &= ~PSR_SS;
        cur_ctx->regs.psr |= PSR_TB;
        if (vcpu_setcontext (cur_vcpu) < 0)
            return CMD_ERROR;
    }

    if (wait_domain (cur_vcpu, cur_ctx) < 0) {
        perror ("wait_domain");
        return CMD_ERROR;
    }

    print_ctx (cur_ctx);

    return CMD_REPEAT;
}

static int quit_paused;

static enum cmd_status
cmd_quit (char *line)
{
    if (!strcmp (line, "paused"))
        quit_paused = 1;
    return CMD_QUIT;
}

static enum cmd_status
cmd_echo (char *line)
{
    printf ("%s", line);
    return CMD_OK;
}

static enum cmd_status
cmd_disassemble (char *args)
{
    static unsigned long addr;
    unsigned long end_addr = addr + 16;

    if (*args != 0) {
        if (parse_expr (&args, &addr, 0) < 0)
            return CMD_ERROR;
        if (*args != 0) {
            if (parse_expr (&args, &end_addr, 0) < 0)
                return CMD_ERROR;
        }
        else 
            end_addr = addr + 16;
    }
    target_disas (stdout, addr, end_addr - addr);
    addr = end_addr;
    return CMD_REPEAT;
}

static enum cmd_status
cmd_dump (char *args)
{
    static unsigned long addr;
    unsigned long end_addr = addr + 256;
    unsigned long p;

    if (*args != 0) {
        if (parse_expr (&args, &addr, 0) < 0)
            return CMD_ERROR;
        if (*args != 0) {
            if (parse_expr (&args, &end_addr, 0) < 0)
                return CMD_ERROR;
        }
        else 
            end_addr = addr + 256;
    }
    for (p = addr; p < end_addr; p += 16) {
        int i;
        printf ("%016lx:", p);
        for (i = 0; i < 16; i++) {
            unsigned char *m = target_map_memory (p + i);
            printf ("%c%02x", i == 8 ? '-' : ' ', *m);
        }
        printf ("\n");
    }
    addr = end_addr;
    return CMD_REPEAT;
}

static enum cmd_status
cmd_break (char *args)
{
    unsigned long addr;
    int i;

    for (i = 0; i < 4; i++)
        if (cur_ctx->regs.ibr[2 * i] == 0 && cur_ctx->regs.ibr[2 * i + 1] == 0)
            break;

    if (i == 4) {
        printf ("no availabe break points\n");
        return CMD_ERROR;
    }

    if (parse_expr (&args, &addr, 0) < 0)
        return CMD_ERROR;

    cur_ctx->regs.ibr[2 * i] = addr;
    cur_ctx->regs.ibr[2 * i + 1] = 0x87fffffffffffff0UL;
    cur_ctx->regs.psr |= PSR_DB;

    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;
    else
        return CMD_OK;
}

static enum cmd_status
cmd_watch (char *args)
{
    unsigned long addr;
    unsigned long mask;
    int i;

    for (i = 0; i < 4; i++)
        if (cur_ctx->regs.dbr[2 * i] == 0 && cur_ctx->regs.dbr[2 * i + 1] == 0)
            break;

    if (i == 4) {
        printf ("no availabe watch points\n");
        return CMD_ERROR;
    }

    if (parse_expr (&args, &addr, 0) < 0)
        return CMD_ERROR;

    if (*args == 0)
        mask = 3;
    else if (parse_expr (&args, &mask, 0) < 0)
        return CMD_ERROR;

    cur_ctx->regs.dbr[2 * i] = addr;
    cur_ctx->regs.dbr[2 * i + 1] = ~((1UL << mask) - 1) | (0xc7UL << 56);
    cur_ctx->regs.psr |= PSR_DB;

    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;
    else {
        printf ("Watchpoint %d set\n", i);
        return CMD_OK;
    }
}

static enum cmd_status
cmd_delete (char *args)
{
    unsigned long num;

    if (parse_expr (&args, &num, 0) < 0)
        return CMD_ERROR;

    if (num < 4) {
        cur_ctx->regs.ibr[2 * num] = 0;
        cur_ctx->regs.ibr[2 * num + 1] = 0;
    }
    else if (num < 8) {
        num -= 4;
        cur_ctx->regs.dbr[2 * num] = 0;
        cur_ctx->regs.dbr[2 * num + 1] = 0;
    }
    else {
        printf ("breakpoint out of range\n");
        return CMD_ERROR;
    }

    cur_ctx->regs.psr |= PSR_DB;

    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;
    else
        return CMD_OK;
}

static enum cmd_status
cmd_disable (char *args)
{
    unsigned long num;

    if (parse_expr (&args, &num, 0) < 0)
        return CMD_ERROR;

    if (num >= 4) {
        printf ("breakpoint out of range\n");
        return CMD_ERROR;
    }

    cur_ctx->regs.ibr[2 * num + 1] &= ~(1UL << 63);

    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;
    else
        return CMD_OK;
}

static enum cmd_status
cmd_enable (char *args)
{
    unsigned long num;

    if (parse_expr (&args, &num, 0) < 0)
        return CMD_ERROR;

    if (num >= 4) {
        printf ("breakpoint out of range\n");
        return CMD_ERROR;
    }

    cur_ctx->regs.ibr[2 * num + 1] |= 1UL << 63;

    if (vcpu_setcontext (cur_vcpu) < 0)
        return CMD_ERROR;
    else
        return CMD_OK;
}

static enum cmd_status
cmd_print (char *args)
{
    unsigned long addr;

    if (parse_expr (&args, &addr, 0) < 0)
        return CMD_ERROR;

    printf ("res: 0x%016lx = %ld\n", addr, addr);

    return CMD_OK;
}

struct bit_xlat {
    unsigned int bit;
    const char *name;
};

static const struct bit_xlat debug_flags[] = {
    { XEN_IA64_DEBUG_ON_KERN_SSTEP, "sstep" },
    { XEN_IA64_DEBUG_ON_KERN_DEBUG, "debug" },
    { XEN_IA64_DEBUG_ON_KERN_TBRANCH, "tbranch" },
    { XEN_IA64_DEBUG_ON_EXTINT, "extint" },
    { XEN_IA64_DEBUG_ON_EXCEPT, "except" },
    { XEN_IA64_DEBUG_ON_EVENT, "event" },
    { XEN_IA64_DEBUG_ON_PRIVOP, "privop" },
    { XEN_IA64_DEBUG_ON_PAL, "pal" },
    { XEN_IA64_DEBUG_ON_SAL, "sal" },
    { XEN_IA64_DEBUG_ON_EFI, "efi" },
    { XEN_IA64_DEBUG_ON_RFI, "rfi" },
    { XEN_IA64_DEBUG_ON_MMU, "mmu" },
    { XEN_IA64_DEBUG_ON_BAD_MPA, "mpa" },
    { XEN_IA64_DEBUG_FORCE_SS, "ss" },
    { XEN_IA64_DEBUG_FORCE_DB, "db" },
    { XEN_IA64_DEBUG_ON_TR, "tr" },