xenitp.c

xen虚拟机源代码安装包

}

void print_br (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;

    printf (" b0:  %016lx  ", regs->b[0]);
    printf (" b1:  %016lx  ", regs->b[1]);
    printf (" b2:  %016lx\n", regs->b[2]);
    printf (" b3:  %016lx  ", regs->b[3]);
    printf (" b4:  %016lx  ", regs->b[4]);
    printf (" b5:  %016lx\n", regs->b[5]);
    printf (" b6:  %016lx  ", regs->b[6]);
    printf (" b7:  %016lx\n", regs->b[7]);
}

void print_regs (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;

    printf (" r1:  %016lx  ", regs->r[1]);
    printf (" r2:  %016lx  ", regs->r[2]);
    printf (" r3:  %016lx\n", regs->r[3]);
    printf (" r4:  %016lx  ", regs->r[4]);
    printf (" r5:  %016lx  ", regs->r[5]);
    printf (" r6:  %016lx\n", regs->r[6]);
    printf (" r7:  %016lx  ", regs->r[7]);
    printf (" r8:  %016lx  ", regs->r[8]);
    printf (" r9:  %016lx\n", regs->r[9]);
    printf (" r10: %016lx  ", regs->r[10]);
    printf (" r11: %016lx  ", regs->r[11]);
    printf (" sp:  %016lx\n", regs->r[12]);
    printf (" tp:  %016lx  ", regs->r[13]);
    printf (" r14: %016lx  ", regs->r[14]);
    printf (" r15: %016lx\n", regs->r[15]);

    printf ("      Bank %d (current)                         Bank %d\n",
            (regs->psr & PSR_BN) ? 1 : 0, (regs->psr & PSR_BN) ? 0 : 1);
    printf ("16:%016lx ", regs->r[16]);
    printf ("17:%016lx ", regs->r[17]);
    printf ("16:%016lx ", regs->bank[0]);
    printf ("17:%016lx\n", regs->bank[1]);
    printf ("18:%016lx ", regs->r[18]);
    printf ("19:%016lx ", regs->r[19]);
    printf ("18:%016lx ", regs->bank[2]);
    printf ("19:%016lx\n", regs->bank[3]);
    printf ("20:%016lx ", regs->r[20]);
    printf ("21:%016lx ", regs->r[21]);
    printf ("20:%016lx ", regs->bank[4]);
    printf ("21:%016lx\n", regs->bank[5]);
    printf ("22:%016lx ", regs->r[22]);
    printf ("23:%016lx ", regs->r[23]);
    printf ("22:%016lx ", regs->bank[6]);
    printf ("23:%016lx\n", regs->bank[7]);
    printf ("24:%016lx ", regs->r[24]);
    printf ("25:%016lx ", regs->r[25]);
    printf ("24:%016lx ", regs->bank[8]);
    printf ("25:%016lx\n", regs->bank[9]);
    printf ("26:%016lx ", regs->r[26]);
    printf ("27:%016lx ", regs->r[27]);
    printf ("26:%016lx ", regs->bank[10]);
    printf ("27:%016lx\n", regs->bank[11]);
    printf ("28:%016lx ", regs->r[28]);
    printf ("29:%016lx ", regs->r[29]);
    printf ("28:%016lx ", regs->bank[12]);
    printf ("29:%016lx\n", regs->bank[13]);
    printf ("30:%016lx ", regs->r[30]);
    printf ("31:%016lx ", regs->r[31]);
    printf ("30:%016lx ", regs->bank[14]);
    printf ("31:%016lx\n", regs->bank[15]);
    printf ("\n");
}

void print_cr (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;

    printf (" dcr:  %016lx  ", regs->cr.dcr);
    printf (" itm:  %016lx  ", regs->cr.itm);
    printf (" iva:  %016lx\n", regs->cr.iva);
    printf (" pta:  %016lx  ", regs->cr.pta);
    printf (" ipsr: %016lx  ", regs->cr.ipsr);
    printf (" isr:  %016lx\n", regs->cr.isr);
    printf (" iip:  %016lx  ", regs->cr.iip);
    printf (" ifa:  %016lx  ", regs->cr.ifa);
    printf (" itir: %016lx\n", regs->cr.itir);
    printf (" iipa: %016lx  ", regs->cr.iipa);
    printf (" ifs:  %016lx  ", regs->cr.ifs);
    printf (" iim:  %016lx\n", regs->cr.iim);
    printf (" iha:  %016lx  ", regs->cr.iha);
    printf (" lid:  %016lx  ", regs->cr.lid);
    printf (" ivr:  %016lx\n", regs->cr.ivr);
    printf (" tpr:  %016lx  ", regs->cr.tpr);
    printf (" eoi:  %016lx  ", regs->cr.eoi);
    printf (" irr0: %016lx\n", regs->cr.irr[0]);
    printf (" irr1: %016lx  ", regs->cr.irr[1]);
    printf (" irr2: %016lx  ", regs->cr.irr[2]);
    printf (" irr3: %016lx\n", regs->cr.irr[3]);
    printf (" itv:  %016lx  ", regs->cr.itv);
    printf (" pmv:  %016lx  ", regs->cr.pmv);
    printf (" cmcv: %016lx\n", regs->cr.cmcv);
    printf (" lrr0: %016lx  ", regs->cr.lrr0);
    printf (" lrr1: %016lx  ", regs->cr.lrr1);
    printf (" ev_cb:%016lx\n", ctx->event_callback_ip);
}

void print_ar (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;

    printf (" kr0:  %016lx  ", regs->ar.kr[0]);
    printf (" kr1:  %016lx  ", regs->ar.kr[1]);
    printf (" kr2:  %016lx\n", regs->ar.kr[2]);
    printf (" kr3:  %016lx  ", regs->ar.kr[3]);
    printf (" kr4:  %016lx  ", regs->ar.kr[4]);
    printf (" kr5:  %016lx\n", regs->ar.kr[5]);
    printf (" kr6:  %016lx  ", regs->ar.kr[6]);
    printf (" kr7:  %016lx  ", regs->ar.kr[7]);
    printf (" rsc:  %016lx\n", regs->ar.rsc);
    printf (" bsp:  %016lx  ", regs->ar.bsp);
    printf (" bsps: %016lx  ", regs->ar.bspstore);
    printf (" rnat: %016lx\n", regs->ar.rnat);
    printf (" csd:  %016lx  ", regs->ar.csd);
    printf (" ccv:  %016lx  ", regs->ar.ccv);
    printf (" unat: %016lx\n", regs->ar.unat);
    printf (" fpsr: %016lx  ", regs->ar.fpsr);
    printf (" itc:  %016lx\n", regs->ar.itc);
    printf (" pfs:  %016lx  ", regs->ar.pfs);
    printf (" lc:   %016lx  ", regs->ar.lc);
    printf (" ec:   %016lx\n", regs->ar.ec);
}

void print_a_rr (int num, unsigned long rr)
{
    int ps_val = (rr >> RR_PS_SHIFT) & RR_PS_MASK;

    printf (" [%d]  %06lx %02x %s %ld\n",
            num, (rr >> RR_RID_SHIFT) & RR_RID_MASK,
            ps_val, get_ps (ps_val), rr & RR_VE_MASK);
}

void print_rr (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;
    int i;

    printf (" rr:  rid    ps      ve\n");
    for (i = 0; i < 8; i++)
        print_a_rr (i, regs->rr[i]);
}

void print_db (vcpu_guest_context_t *ctx)
{
    struct vcpu_guest_context_regs *regs = &ctx->regs;
    int i;

    for (i = 0; i < 7; i += 2)
        printf ("  ibr[%d]:  %016lx   ibr[%d]:  %016lx\n",
                i, regs->ibr[i], i + 1, regs->ibr[i + 1]);
    printf ("\n");
    for (i = 0; i < 7; i += 2)
        printf ("  dbr[%d]:  %016lx   dbr[%d]:  %016lx\n",
                i, regs->dbr[i], i + 1, regs->dbr[i + 1]);
}

struct bit_descr {
    const char *name;
    unsigned char sz;
};

const struct bit_descr psr_bits[] = 
    {
        {"", 1 },    {"be", 1 },  {"up", 1 },  {"ac", 1 },
        {"mfl", 1 }, {"mfh", 1 }, {"", 7 },
        {"ic", 1 },  {"i", 1 },   {"pk", 1 },
        {"", 1 },    {"dt", 1 },  {"dfl", 1 }, {"dfh", 1 },
        {"sp", 1 },  {"pp", 1 },  {"di", 1 },  {"si", 1 },
        {"db", 1 },  {"lp", 1 },  {"tb", 1 },  {"rt", 1 },
        {"", 4 },
        {"cpl", 2 }, {"is", 1 },  {"mc", 1 },
        {"it", 1 },  {"id", 1 },  {"da", 1 },  {"dd", 1 },
        {"ss", 1 },  {"ri", 2 },  {"ed", 1 },
        {"bn", 1 },  {"ia", 1 },  {"vm", 1 },
        {NULL, 0 }
    };

void print_bits (const struct bit_descr *desc, unsigned long val)
{
    const struct bit_descr *d;
    unsigned int off;

    /* Reverse order.  */
    for (d = desc, off = 0; d->name; d++)
        off += d->sz;

    d--;

    while (1) {
        off -= d->sz;
        if (*d->name) {
            if (d->sz != 1 || ((val >> off) & 1))
                printf (" %s", d->name);
            if (d->sz != 1)
                printf ("=%lx", (val >> off) & ((1 << d->sz) - 1));
        }
        if (d == desc)
            break;
        d--;
    }
}
        
void print_tr (vcpu_guest_context_t *ctx)
{
    struct vcpu_tr_regs *tr = &ctx->regs.tr;
    int i;

    printf ("\n itr: P rid    va               pa            ps      ed pl "
            "ar a d ma    key\n");

    for (i = 0; i < sizeof (tr->itrs) / sizeof (tr->itrs[0]); i++)
        print_a_tr (i, &tr->itrs[i]);

    printf ("\n dtr: P rid    va               pa            ps      ed pl "
            "ar a d ma    key\n");

    for (i = 0; i < sizeof (tr->dtrs) / sizeof (tr->dtrs[0]); i++)
        print_a_tr (i, &tr->dtrs[i]);
}

int lock_pages (void *addr, size_t len);
void unlock_pages (void *addr, size_t len);
int do_xen_hypercall (int xc_handle, privcmd_hypercall_t *hypercall);

#ifdef HAVE_DEBUG_OP
static int do_ia64_debug_op (int xc_handle,
                            unsigned long cmd, unsigned long domain,
                            xen_ia64_debug_op_t *op)
{
    int ret = -1;
    privcmd_hypercall_t hypercall;

    hypercall.op     = __HYPERVISOR_ia64_debug_op;
    hypercall.arg[0] = cmd;
    hypercall.arg[1] = domain;
    hypercall.arg[2] = (unsigned long)op;

    if (lock_pages (op, sizeof (*op)) != 0) {
        perror ("Could not lock memory for Xen hypercall");
        goto out1;
    }

    ret = do_xen_hypercall (xc_handle, &hypercall);
    if (ret  < 0) {
        if (errno == EACCES)
            fprintf (stderr,"domctl operation failed -- need to "
                     "rebuild the user-space tool set?\n");
    }

    unlock_pages (op, sizeof (*op));

out1:
    return ret;
}
#endif

static volatile int ctrl_c_hit;

void ctrl_c_handler (int sig)
{
    ctrl_c_hit = 1;
}

int wait_domain (int vcpu, vcpu_guest_context_t *ctx)
{
    struct timespec ts;
    xc_dominfo_t dominfo;
    int ret;
    int cnt = 0;

    ts.tv_sec = 0;
    ts.tv_nsec = 10*1000*1000;

    ret = xc_domain_unpause (xc_handle, domid);
    if (ret < 0)
        perror ("xc_domain_unpause");

    ctrl_c_hit = 0;

    while (1) {
        ret = xc_domain_getinfo (xc_handle, domid, 1, &dominfo);
        if (ret < 0)
            perror ("xc_domain_getinfo");

        if (dominfo.paused)
            break;

        if (ctrl_c_hit) {
            fflush (stdout);
            /* Force pause.  */
            ret = xc_domain_pause (xc_handle, domid);
            if (ret < 0)
                perror ("xc_domain_pause");

            break;
        }
                
        printf ("%c\b", "/-\\|"[(cnt++) % 4]);
        fflush (stdout);
        nanosleep (&ts, NULL);
    }
    return xc_ia64_vcpu_getcontext (xc_handle, domid, vcpu, ctx);
}

int virt_to_phys (int is_inst, unsigned long vaddr, unsigned long *paddr)
{
    struct vcpu_tr_regs *trs = &cur_ctx->regs.tr;
    struct ia64_tr_entry *tr;
    int i;
    int num;

    /* Search in tr.  */
    if (is_inst) {
        tr = trs->itrs;
        num = sizeof (trs->itrs) / sizeof (trs->itrs[0]);
    }
    else {
        tr = trs->dtrs;
        num = sizeof (trs->dtrs) / sizeof (trs->dtrs[0]);
    }
    for (i = 0; i < num; i++, tr++) {
        int ps_val = (tr->itir >> ITIR_PS_SHIFT) & ITIR_PS_MASK;
        unsigned long ps_mask = (-1L) << ps_val;

        if ((tr->vadr & ps_mask) == (vaddr & ps_mask)) {
            *paddr = ((tr->pte & (PTE_PPN_MASK << PTE_PPN_SHIFT)) & ps_mask) |
                     (vaddr & ~ps_mask);
            return 0;
        }
    }
    return -1;
}

unsigned long *
get_reg_addr (const char *name)
{
    if (strcmp (name, "ip") == 0)
        return &cur_ctx->regs.ip;
    else if (strcmp (name, "psr") == 0)
        return &cur_ctx->regs.psr;
    else if (strcmp (name, "iip") == 0)
        return &cur_ctx->regs.cr.iip;
    else if (strcmp (name, "b0") == 0)
        return &cur_ctx->regs.b[0];
    else
        return 0;
}

enum prio_expr {EXPR_BASE, EXPR_SUM, EXPR_LOGIC, EXPR_PROD};

int parse_expr (char **buf, unsigned long *res, enum prio_expr prio);

int next_char (char **buf)
{
    char *b;

    b = *buf;
    while (isspace ((unsigned char)*b))
        b++;
    *buf = b;
    return *b;
}

int parse_unary (char **buf, unsigned long *res)
{
    char c;

    c = next_char (buf);
    switch (c) {
    case '0' ... '9':
        {
            char *e;
            *res = strtoul (*buf, &e, 0);
            if (e == *buf) {
                printf ("bad literal\n");
                return -1;
            }
            *buf = e;
        }
        break;
    case '+':
        (*buf)++;
        return parse_unary (buf, res);
    case '$':
        {
            char *b;
            char *e;
            char c;
            unsigned long *reg;
            int len;

            b = *buf;
            e = b + 1;

            while ((*e >= 'a' && *e <= 'z') ||
                   (*e >= 'A' && *e <= 'Z') ||
                   (*e >= '0' && *e <= '9') ||
                   (*e == '_' || *e == '.'))
                e++;

            if (b == e) {
                printf ("identifier missing after '$'\n");
                return -1;
            }

            b++;
            len = e - b;

            c = b[len];
            b[len] = 0;
            reg = get_reg_addr (b);
            b[len] = c;

            if (reg != NULL)
                *res = *reg;
            else if (strncmp (b, "d2p", len) == 0 ||
                     strncmp (b, "i2p", len) == 0) {
                unsigned long vaddr;

                *buf = e;
                if (parse_unary (buf, &vaddr) != 0)
                    return -1;