compat-mode/HVM support in xenctx
PATCH 1/1 compat-mode/HVM support in xenctx
Add support to xenctx for guests that have a different word size to the tools (x86 only, but shouldn't break ia64). Again, only 32-bit HVM guests are supported until EFER.LMA is easier to get at.
tools/xentrace/xenctx.c +204 -124
@@ -24,6 +24,8 @@#include <getopt.h> #include "xenctrl.h" +#include <xen/foreign/x86_32.h> +#include <xen/foreign/x86_64.h> int xc_handle =0 ;int domid =0 ;
@@ -31,28 +33,18 @@ int stack_trace = 0;int stack_trace =0 ;int disp_all =0 ; -#if defined (__i386__) -#if defined (__OpenBSD__) -#define FMT_SIZE_T "%08lx" -#define INSTR_POINTER (regs) (unsigned long)(regs->eip) -#else -#define FMT_SIZE_T "%08x" -#define INSTR_POINTER (regs) (regs->eip) -#endif -#define STACK_POINTER (regs) (regs->esp) -#define FRAME_POINTER (regs) (regs->ebp) -#define STACK_ROWS 4 -#define STACK_COLS 8 -#elif defined (__x86_64__) -#define FMT_SIZE_T "%016lx" -#define STACK_POINTER (regs) (regs->rsp) -#define FRAME_POINTER (regs) (regs->rbp) -#define INSTR_POINTER (regs) (regs->rip) -#define STACK_ROWS 4 -#define STACK_COLS 4 +#if defined (__i386__) || defined (__x86_64__) +typedef unsigned long long guest_word_t ; +#define FMT_32B_WORD "%08llx" +#define FMT_64B_WORD "%016llx" +/* Word-length of the guest's own data structures */ +int guest_word_size =sizeof (unsigned long ); +/* Word-length of the context record we get from xen */ +int ctxt_word_size =sizeof (unsigned long );#elif defined (__ia64__)/* On ia64, we can't translate virtual address to physical address. */ #define NO_TRANSLATION +typedef size_t guest_word_t ;/* Which registers should be displayed. */ int disp_cr_regs;
@@ -63,22 +55,19 @@ int disp_tlb;#endif struct symbol { -size_t address; +guest_word_t address;char type;char *name;struct symbol *next; } *symbol_table =NULL ; -size_t kernel_stext, kernel_etext, kernel_sinittext, kernel_einittext, kernel_hypercallpage; - -static int is_kernel_text (size_t addr) -{ -#if defined (__i386__) +guest_word_t kernel_stext, kernel_etext, kernel_sinittext, kernel_einittext, kernel_hypercallpage; + +static int is_kernel_text (guest_word_t addr) +{ +#if defined (__i386__) || defined (__x86_64__)if (symbol_table ==NULL ) -return (addr >0xc000000 ); -#elif defined (__x86_64__) -if (symbol_table ==NULL ) -return (addr >0xffffffff80000000UL ); +return (addr > ((guest_word_size ==4 ) ?0xc000000 :0xffffffff80000000ULL ));#elif defined (__ia64__)if (symbol_table ==NULL )return (addr >0xa000000000000000UL );
@@ -134,7 +123,7 @@ static void insert_symbol(struct symbol prev = symbol; } -static struct symbol *lookup_symbol (size_t address) +static struct symbol *lookup_symbol (guest_word_t address) {struct symbol *s = symbol_table;
@@ -147,7 +136,7 @@ static struct symbol *lookup_symbol(sizereturn NULL ; } -static void print_symbol (size_t addr) +static void print_symbol (guest_word_t addr) {struct symbol *s;
@@ -255,21 +244,23 @@ static void print_flags(uint64_t flags)printf ("\n" ); } -static void print_special (unsigned long *regs,const char *name,unsigned int mask) +static void print_special (void *regs,const char *name,unsigned int mask,int width) {unsigned int i;printf ("\n" );for (i =0 ; mask; mask >>=1 , ++i) -if (mask &1 ) -printf ("%s%u: " FMT_SIZE_T "\n" , name, i, (size_t )regs[i]); -} -#endif - -#ifdef __i386__ -static void print_ctx (vcpu_guest_context_t *ctx1) -{ -struct cpu_user_regs *regs = &ctx1->user_regs; +if (mask &1 ) { +if (width ==4 ) +printf ("%s%u: %08" PRIx32"\n" , name, i, ((uint32_t *) regs)[i]); +else +printf ("%s%u: %08" PRIx64"\n" , name, i, ((uint64_t *) regs)[i]); + } +} + +static void print_ctx_32 (vcpu_guest_context_x86_32_t *ctx) +{ +struct cpu_user_regs_x86_32 *regs = &ctx->user_regs;printf ("cs:eip: %04x:%08x " , regs->cs, regs->eip);print_symbol (regs->eip);
@@ -291,54 +282,87 @@ static void print_ctx(vcpu_guest_contextprintf (" gs: %04x\n" , regs->gs);if (disp_all) { -print_special (ctx1->ctrlreg,"cr" ,0x1d ); -print_special (ctx1->debugreg,"dr" ,0xcf ); - } -} -#elif defined(__x86_64__) -static void print_ctx (vcpu_guest_context_t *ctx1) -{ -struct cpu_user_regs *regs = &ctx1->user_regs; - -printf ("rip: %016lx " , regs->rip); +print_special (ctx->ctrlreg,"cr" ,0x1d ,4 ); +print_special (ctx->debugreg,"dr" ,0xcf ,4 ); + } +} + +static void print_ctx_64 (vcpu_guest_context_x86_64_t *ctx) +{ +struct cpu_user_regs_x86_64 *regs = &ctx->user_regs; + +printf ("rip: %016" PRIx64" " , regs->rip);print_symbol (regs->rip);print_flags (regs->rflags); -printf ("rsp: %016lx\n" , regs->rsp); - -printf ("rax: %016lx\t" , regs->rax); -printf ("rcx: %016lx\t" , regs->rcx); -printf ("rdx: %016lx\n" , regs->rdx); - -printf ("rbx: %016lx\t" , regs->rbx); -printf ("rsi: %016lx\t" , regs->rsi); -printf ("rdi: %016lx\n" , regs->rdi); - -printf ("rbp: %016lx\t" , regs->rbp); -printf (" r8: %016lx\t" , regs->r8); -printf (" r9: %016lx\n" , regs->r9); - -printf ("r10: %016lx\t" , regs->r10); -printf ("r11: %016lx\t" , regs->r11); -printf ("r12: %016lx\n" , regs->r12); - -printf ("r13: %016lx\t" , regs->r13); -printf ("r14: %016lx\t" , regs->r14); -printf ("r15: %016lx\n" , regs->r15); +printf ("rsp: %016" PRIx64"\n" , regs->rsp); + +printf ("rax: %016" PRIx64"\t" , regs->rax); +printf ("rcx: %016" PRIx64"\t" , regs->rcx); +printf ("rdx: %016" PRIx64"\n" , regs->rdx); + +printf ("rbx: %016" PRIx64"\t" , regs->rbx); +printf ("rsi: %016" PRIx64"\t" , regs->rsi); +printf ("rdi: %016" PRIx64"\n" , regs->rdi); + +printf ("rbp: %016" PRIx64"\t" , regs->rbp); +printf (" r8: %016" PRIx64"\t" , regs->r8); +printf (" r9: %016" PRIx64"\n" , regs->r9); + +printf ("r10: %016" PRIx64"\t" , regs->r10); +printf ("r11: %016" PRIx64"\t" , regs->r11); +printf ("r12: %016" PRIx64"\n" , regs->r12); + +printf ("r13: %016" PRIx64"\t" , regs->r13); +printf ("r14: %016" PRIx64"\t" , regs->r14); +printf ("r15: %016" PRIx64"\n" , regs->r15);printf (" cs: %04x\t" , regs->cs);printf (" ss: %04x\t" , regs->ss);printf (" ds: %04x\t" , regs->ds);printf (" es: %04x\n" , regs->es); -printf (" fs: %04x @ %016lx\n" , regs->fs, ctx1->fs_base); -printf (" gs: %04x @ %016lx/%016lx\n" , regs->gs, - ctx1->gs_base_kernel, ctx1->gs_base_user); +printf (" fs: %04x @ %016" PRIx64"\n" , regs->fs, ctx->fs_base); +printf (" gs: %04x @ %016" PRIx64"/%016" PRIx64"\n" , regs->gs, + ctx->gs_base_kernel, ctx->gs_base_user);if (disp_all) { -print_special (ctx1->ctrlreg,"cr" ,0x1d ); -print_special (ctx1->debugreg,"dr" ,0xcf ); - } -} +print_special (ctx->ctrlreg,"cr" ,0x1d ,8 ); +print_special (ctx->debugreg,"dr" ,0xcf ,8 ); + } +} + +static void print_ctx (vcpu_guest_context_any_t *ctx) +{ +if (ctxt_word_size ==4 ) +print_ctx_32 (&ctx->x32); +else +print_ctx_64 (&ctx->x64); +} + +static guest_word_t instr_pointer (vcpu_guest_context_any_t *ctx) +{ +if (ctxt_word_size ==4 ) +return ctx->x32.user_regs.eip; +else +return ctx->x64.user_regs.rip; +} + +static guest_word_t stack_pointer (vcpu_guest_context_any_t *ctx) +{ +if (ctxt_word_size ==4 ) +return ctx->x32.user_regs.esp; +else +return ctx->x64.user_regs.rsp; +} + +static guest_word_t frame_pointer (vcpu_guest_context_any_t *ctx) +{ +if (ctxt_word_size ==4 ) +return ctx->x32.user_regs.ebp; +else +return ctx->x64.user_regs.rbp; +} +#elif defined(__ia64__)#define PTE_ED_SHIFT 52
@@ -401,9 +425,9 @@ static void print_tr(int i, const struct tr->itir >> ITIR_KEY_SHIFT & ITIR_KEY_MASK); } -void print_ctx (vcpu_guest_context_t *ctx) -{ -struct vcpu_guest_context_regs *regs = &ctx->regs; +void print_ctx (vcpu_guest_context_any_t *ctx) +{ +struct vcpu_guest_context_regs *regs = &ctx.c->regs;struct vcpu_tr_regs *tr = &ctx->regs.tr;int i;unsigned int rbs_size, cfm_sof;
@@ -584,7 +608,7 @@ void print_ctx(vcpu_guest_context_t *ctx#endif #ifndef NO_TRANSLATION -static void *map_page (vcpu_guest_context_t *ctx,int vcpu,size_t virt) +static void *map_page (vcpu_guest_context_any_t *ctx,int vcpu,guest_word_t virt) {static unsigned long previous_mfn =0 ;static void *mapped =NULL ;
@@ -611,33 +635,53 @@ static void *map_page(vcpu_guest_contextreturn (void *)(mapped + offset); } -static void print_stack (vcpu_guest_context_t *ctx,int vcpu) -{ -struct cpu_user_regs *regs = &ctx->user_regs; -size_t stack =STACK_POINTER (regs); -size_t stack_limit = (STACK_POINTER (regs) &XC_PAGE_MASK ) +XC_PAGE_SIZE ; -size_t frame; -size_t instr; -size_t *p; +static guest_word_t read_stack_word (guest_word_t *src,int width) +{ +guest_word_t word =0 ; +/* Little-endian only */ +memcpy (&word, src, width); +return word; +} + +static void print_stack_word (guest_word_t word,int width) +{ +if (width ==4 ) +printf (FMT_32B_WORD , word); +else +printf (FMT_64B_WORD , word); +} + +static void print_stack (vcpu_guest_context_any_t *ctx,int vcpu,int width) +{ +guest_word_t stack =stack_pointer (ctx); +guest_word_t stack_limit; +guest_word_t frame; +guest_word_t instr; +guest_word_t word; +guest_word_t *p;int i; + stack_limit = ((stack_pointer (ctx) +XC_PAGE_SIZE ) + & ~((guest_word_t )XC_PAGE_SIZE -1 ));printf ("\n" );printf ("Stack:\n" ); -for (i=1 ; i<STACK_ROWS +1 && stack < stack_limit; i++) { -while (stack < stack_limit && stack <STACK_POINTER (regs) + i*STACK_COLS *sizeof (stack)) { +for (i=1 ; i<5 && stack < stack_limit; i++) { +while (stack < stack_limit && stack <stack_pointer (ctx) + i*32 ) { p =map_page (ctx, vcpu, stack); -printf (" " FMT_SIZE_T , *p); - stack +=sizeof (stack); + word =read_stack_word (p, width); +printf (" " ); +print_stack_word (word, width); + stack += width; }printf ("\n" ); }printf ("\n" );printf ("Code:\n" ); - instr =INSTR_POINTER (regs) -21 ; + instr =instr_pointer (ctx) -21 ;for (i=0 ; i<32 ; i++) {unsigned char *c =map_page (ctx, vcpu, instr+i); -if (instr+i ==INSTR_POINTER (regs)) +if (instr+i ==instr_pointer (ctx))printf ("<%02x> " , *c);else printf ("%02x " , *c);
@@ -650,52 +694,65 @@ static void print_stack(vcpu_guest_conteprintf ("Stack Trace:\n" ); else printf("Call Trace:\n"); -printf ("%c [<" FMT_SIZE_T ">] " , - stack_trace ?'*' :' ' ,INSTR_POINTER (regs)); - -print_symbol (INSTR_POINTER (regs)); +printf ("%c [<" , stack_trace ?'*' :' ' ); +print_stack_word (instr_pointer (ctx), width); +printf (">] " ); + +print_symbol (instr_pointer (ctx));printf (" <--\n" );if (frame_ptrs) { - stack =STACK_POINTER (regs); - frame =FRAME_POINTER (regs); + stack =stack_pointer (ctx); + frame =frame_pointer (ctx);while (frame && stack < stack_limit) {if (stack_trace) {while (stack < frame) { p =map_page (ctx, vcpu, stack); -printf ("| " FMT_SIZE_T " " , *p); -printf ("\n" ); - stack +=sizeof (*p); +printf ("| " ); +print_stack_word (read_stack_word (p, width), width); +printf (" \n" ); + stack += width; } }else { stack = frame; } p =map_page (ctx, vcpu, stack); - frame = *p; -if (stack_trace) -printf ("|-- " FMT_SIZE_T "\n" , *p); - stack +=sizeof (*p); + frame =read_stack_word (p, width); +if (stack_trace) { +printf ("|-- " ); +print_stack_word (read_stack_word (p, width), width); +printf ("\n" ); + } + stack += width;if (frame) { p =map_page (ctx, vcpu, stack); -printf ("%c [<" FMT_SIZE_T ">] " , stack_trace ?'|' :' ' , *p); -print_symbol (*p); + word =read_stack_word (p, width); +printf ("%c [<" , stack_trace ?'|' :' ' ); +print_stack_word (word, width); +printf (">] " ); +print_symbol (word);printf ("\n" ); - stack +=sizeof (*p); + stack += width; } } }else { - stack =STACK_POINTER (regs); + stack =stack_pointer (ctx);while (stack < stack_limit) { p =map_page (ctx, vcpu, stack); -if (is_kernel_text (*p)) { -printf (" [<" FMT_SIZE_T ">] " , *p); -print_symbol (*p); + word =read_stack_word (p, width); +if (is_kernel_text (word)) { +printf (" [<" ); +print_stack_word (word, width); +printf (">] " ); +print_symbol (word);printf ("\n" ); }else if (stack_trace) { -printf (" " FMT_SIZE_T "\n" , *p); +printf (" " ); +print_stack_word (word, width); +printf ("\n" ); } - stack +=sizeof (*p); + stack += width; } } }
@@ -729,10 +786,33 @@ static void dump_ctx(int vcpu)exit (-1 ); } -print_ctx (&ctx.c); +#if defined(__i386__) || defined(__x86_64__) + { +struct xen_domctl domctl; +memset (&domctl,0 ,sizeof domctl); + domctl.domain = domid; + domctl.cmd = XEN_DOMCTL_get_address_size; +if (xc_domctl (xc_handle, &domctl) ==0 ) + ctxt_word_size = guest_word_size = domctl.u.address_size.size /8 ; +if (dominfo.hvm) { +xen_capabilities_info_t xen_caps ="" ; +if (xc_version (xc_handle, XENVER_capabilities, &xen_caps) !=0 ) { +perror ("xc_version" ); +exit (-1 ); + } +/* HVM guest context records are always host-sized */ + ctxt_word_size = (strstr (xen_caps,"xen-3.0-x86_64" )) ?8 :4 ; +/* XXX For now we can't tell whether a HVM guest is in long +* XXX mode; eventually fix this here and in xc_pagetab.c */ + guest_word_size =4 ; + } + } +#endif + +print_ctx (&ctx);#ifndef NO_TRANSLATION -if (is_kernel_text (INSTR_POINTER ((&ctx.c.user_regs)))) -print_stack (&ctx.c, vcpu); +if (is_kernel_text (instr_pointer (&ctx))) +print_stack (&ctx, vcpu, guest_word_size);#endif if (!dominfo.paused) {
@@ -774,9 +854,9 @@ int main(int argc, char **argv)int main (int argc,char **argv) {int ch; -static const char *sopts ="fs:h" +static const char *sopts ="fs:ha" #ifdef __ia64__ -"ar:" +"r:" #endif ;static const struct option lopts[] = {
_______________________________________________
Xen-devel mailing list
[email protected]
http://lists.xensource.com/xen-devel
Quoted 3 lines · Tim Deegan
Add support to xenctx for guests that have a different word size to the tools (x86 only, but shouldn't break ia64). Again, only 32-bit HVM guests are supported until EFER.LMA is easier to get at.
Maybe add a VGCF_ or dummy ourselves up a fake CR5 where we can stash these kinds of low-level flags.
-- Keir
Quoted 8 lines · Keir Fraser
Quoted 3 lines · Tim Deegan
Add support to xenctx for guests that have a different word size to the tools (x86 only, but shouldn't break ia64). Again, only 32-bit HVM guests are supported until EFER.LMA is easier to get at.
Maybe add a
VGCF_or dummy ourselves up a fake CR5 where we can stash these kinds of low-level flags.
I was thinking of extending the HVM save support to allow a particular type and instance to be requested. That would let us get the full register set for a HVM vcpu without walking the whole save record. But a VGCF_long_mode or similar would be quicker and easier. :)
Tim.
Signature · 3 lines
Tim Deegan <[email protected]> Principal Software Engineer, Citrix Systems (R&D) Ltd. [Company #02300071, SL9 0DZ, UK.]
Quoted 7 lines · Tim Deegan
Quoted 2 lines
Maybe add a
VGCF_or dummy ourselves up a fake CR5 where we can stash these kinds of low-level flags.I was thinking of extending the HVM save support to allow a particular type and instance to be requested. That would let us get the full register set for a HVM vcpu without walking the whole save record. But a
VGCF_long_modeor similar would be quicker and easier. :)
I'd prefer the former, of course! But I'd settle for the latter. Overall it prolongs the agony though, imo.
-- Keir