* [PATCH v5 0/8] add xenalyze to staging
@ 2015-06-09 11:23 Olaf Hering
2015-06-09 11:23 ` [PATCH v5 1/8] xenalyze: add to tools/xentrace/ Olaf Hering
` (7 more replies)
0 siblings, 8 replies; 20+ messages in thread
From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw)
To: xen-devel, George Dunlap; +Cc: Olaf Hering
Having xenalyze in the source tree makes it much easier to keep private
debug code in hypervisor and xenalyze in sync. It helped alot while
debugging the root cause for commit 607e8494c42397fb249191904066cace6ac9a880.
changes between v4 and v5:
- fix typo in commit msg (traling)
- use xen/trace.h instead of public/trace.h
- remove extra CFLAGS for xenalyze.o
- build xenalyze only on X86
- remove extra printf from sched_process for unhandled events
changes between v3 and v4:
- install existing binaries in sbindir
- install xenalyze in bindir
changes between v2 and v3:
- move to tools/xentrace
changes between v1 and v2:
- move to tools/xentrace/xenalyze
- drop patch which touches sched_switch_process
- add patch to remove argp_program_version
- add patch to bump NR_CPUS
Olaf Hering (8):
xenalyze: add to tools/xentrace/
xenalyze: increase NR_CPUS to 256
xenalyze: print newline after unknown hvm events
xenalyze: include odd mmio states in default output
xenalyze: handle TRC_TRACE_WRAP_BUFFER
xenalyze: handle more events in sched_process
xenalyze: remove trailing whitespaces
xenalyze: remove argp_program_version
.gitignore | 1 +
tools/xentrace/Makefile | 6 +
tools/xentrace/analyze.h | 107 +
tools/xentrace/mread.c | 160 +
tools/xentrace/mread.h | 18 +
tools/xentrace/pv.h | 41 +
tools/xentrace/xenalyze.c | 10467 ++++++++++++++++++++++++++++++++++++++++++++
7 files changed, 10800 insertions(+)
create mode 100644 tools/xentrace/analyze.h
create mode 100644 tools/xentrace/mread.c
create mode 100644 tools/xentrace/mread.h
create mode 100644 tools/xentrace/pv.h
create mode 100644 tools/xentrace/xenalyze.c
^ permalink raw reply [flat|nested] 20+ messages in thread* [PATCH v5 1/8] xenalyze: add to tools/xentrace/ 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-11 15:23 ` George Dunlap 2015-06-09 11:23 ` [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 Olaf Hering ` (6 subsequent siblings) 7 siblings, 1 reply; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini This merges xenalyze.hg, changeset 150:24308507be1d, into tools/xentrace/xenalyze.c to have the tool and public/trace.h in one place. Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: Wei Liu <wei.liu2@citrix.com> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- .gitignore | 1 + tools/xentrace/Makefile | 6 + tools/xentrace/analyze.h | 107 + tools/xentrace/mread.c | 160 + tools/xentrace/mread.h | 18 + tools/xentrace/pv.h | 41 + tools/xentrace/xenalyze.c | 10407 ++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 10740 insertions(+) diff --git a/.gitignore b/.gitignore index 3bc9cd9..3f42ded 100644 --- a/.gitignore +++ b/.gitignore @@ -173,6 +173,7 @@ tools/misc/gtracestat tools/misc/xenlockprof tools/misc/lowmemd tools/misc/xencov +tools/xentrace/xenalyze tools/pygrub/build/* tools/python/build/* tools/security/secpol_tool diff --git a/tools/xentrace/Makefile b/tools/xentrace/Makefile index 5360960..8932b73 100644 --- a/tools/xentrace/Makefile +++ b/tools/xentrace/Makefile @@ -7,6 +7,8 @@ CFLAGS += $(CFLAGS_libxenctrl) LDLIBS += $(LDLIBS_libxenctrl) BIN = +BIN-$(CONFIG_X86) = xenalyze +BIN += $(BIN-y) SBIN = xentrace xentrace_setsize LIBBIN = xenctx SCRIPTS = xentrace_format @@ -26,6 +28,7 @@ install: build [ -z "$(LIBBIN)" ] || $(INSTALL_DIR) $(DESTDIR)$(LIBEXEC_BIN) $(INSTALL_DIR) $(DESTDIR)$(MAN1DIR) $(INSTALL_DIR) $(DESTDIR)$(MAN8DIR) + $(INSTALL_PROG) $(BIN) $(DESTDIR)$(bindir) $(INSTALL_PROG) $(SBIN) $(DESTDIR)$(sbindir) $(INSTALL_PYTHON_PROG) $(SCRIPTS) $(DESTDIR)$(bindir) [ -z "$(LIBBIN)" ] || $(INSTALL_PROG) $(LIBBIN) $(DESTDIR)$(LIBEXEC_BIN) @@ -48,5 +51,8 @@ xenctx: xenctx.o xentrace_setsize: setsize.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS) $(APPEND_LDFLAGS) +xenalyze: xenalyze.o mread.o + $(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(APPEND_LDFLAGS) + -include $(DEPS) diff --git a/tools/xentrace/analyze.h b/tools/xentrace/analyze.h new file mode 100644 index 0000000..40ee551 --- /dev/null +++ b/tools/xentrace/analyze.h @@ -0,0 +1,107 @@ +#ifndef __ANALYZE_H +# define __ANALYZE_H + +#include <stdint.h> + +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) + +#define TRC_GEN_MAIN 0 +#define TRC_SCHED_MAIN 1 +#define TRC_DOM0OP_MAIN 2 +#define TRC_HVM_MAIN 3 +#define TRC_MEM_MAIN 4 +#define TRC_PV_MAIN 5 +#define TRC_SHADOW_MAIN 6 +#define TRC_HW_MAIN 7 + +#define TRC_LOST_RECORDS_END (TRC_GEN + 50) + +#define NR_CPUS 128 +#if __x86_64__ +# define BITS_PER_LONG 64 +#else +# define BITS_PER_LONG 32 +#endif + +#define BITS_TO_LONGS(bits) \ + (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG) +#define DECLARE_BITMAP(name,bits) \ + unsigned long name[BITS_TO_LONGS(bits)] +typedef struct cpumask{ DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t; + +enum { + TRCE_SFLAG_SET_AD, + TRCE_SFLAG_SET_A, + TRCE_SFLAG_SHADOW_L1_GET_REF, + TRCE_SFLAG_SHADOW_L1_PUT_REF, + TRCE_SFLAG_L2_PROPAGATE, + TRCE_SFLAG_SET_CHANGED, + TRCE_SFLAG_SET_FLUSH, + TRCE_SFLAG_SET_ERROR, + TRCE_SFLAG_DEMOTE, + TRCE_SFLAG_PROMOTE, + TRCE_SFLAG_WRMAP, + TRCE_SFLAG_WRMAP_GUESS_FOUND, + TRCE_SFLAG_WRMAP_BRUTE_FORCE, + TRCE_SFLAG_EARLY_UNSHADOW, + TRCE_SFLAG_EMULATION_2ND_PT_WRITTEN, + TRCE_SFLAG_EMULATION_LAST_FAILED, + TRCE_SFLAG_EMULATE_FULL_PT, + TRCE_SFLAG_PREALLOC_UNPIN, + TRCE_SFLAG_PREALLOC_UNHOOK +}; + +#define TRC_HVM_OP_DESTROY_PROC (TRC_HVM_HANDLER + 0x100) + +typedef unsigned long long tsc_t; + +/* -- on-disk trace buffer definitions -- */ +struct trace_record { + union { + struct { + unsigned event:28, + extra_words:3, + cycle_flag:1; + union { + struct { + uint32_t tsc_lo, tsc_hi; + uint32_t data[7]; + } tsc; + struct { + uint32_t data[7]; + } notsc; + } u; + }; + uint32_t raw[8]; + }; +}; + +/* -- General info about a current record -- */ +struct time_struct { + unsigned long long time; + unsigned int s, ns; +}; + +#define DUMP_HEADER_MAX 256 + +struct record_info { + int cpu; + tsc_t tsc; + union { + unsigned event; + struct { + unsigned minor:12, + sub:4, + main:12, + unused:4; + } evt; + }; + int extra_words; + int size; + uint32_t *d; + char dump_header[DUMP_HEADER_MAX]; + struct time_struct t; + struct trace_record rec; +}; + +#endif diff --git a/tools/xentrace/mread.c b/tools/xentrace/mread.c new file mode 100644 index 0000000..a63d16c --- /dev/null +++ b/tools/xentrace/mread.c @@ -0,0 +1,160 @@ +#include <stdio.h> +#include <stdlib.h> +#include <strings.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <errno.h> +#include "mread.h" + +mread_handle_t mread_init(int fd) +{ + struct stat64 s; + mread_handle_t h; + + h=malloc(sizeof(struct mread_ctrl)); + + if (!h) + { + perror("malloc"); + exit(1); + } + + bzero(h, sizeof(struct mread_ctrl)); + + h->fd = fd; + + fstat64(fd, &s); + h->file_size = s.st_size; + + return h; +} + +ssize_t mread64(mread_handle_t h, void *rec, ssize_t len, loff_t offset) +{ + /* Idea: have a "cache" of N mmaped regions. If the offset is + * in one of the regions, just copy it. If not, evict one of the + * regions and map the appropriate range. + * + * Basic algorithm: + * - See if the offset is in one of the regions + * - If not, map it + * - evict an old region + * - map the new region + * - Copy + */ + char * b=NULL; + int bind=-1; + loff_t boffset=0; + ssize_t bsize; + +#define dprintf(x...) +//#define dprintf fprintf + + dprintf(warn, "%s: offset %llx len %d\n", __func__, + offset, len); + if ( offset > h->file_size ) + { + dprintf(warn, " offset > file size %llx, returning 0\n", + h->file_size); + return 0; + } + if ( offset + len > h->file_size ) + { + dprintf(warn, " offset+len > file size %llx, truncating\n", + h->file_size); + len = h->file_size - offset; + } + + /* Try to find the offset in our range */ + dprintf(warn, " Trying last, %d\n", last); + if ( h->map[h->last].buffer + && (offset & MREAD_BUF_MASK) == h->map[h->last].start_offset ) + { + bind=h->last; + goto copy; + } + + /* Scan to see if it's anywhere else */ + dprintf(warn, " Scanning\n"); + for(bind=0; bind<MREAD_MAPS; bind++) + if ( h->map[bind].buffer + && (offset & MREAD_BUF_MASK) == h->map[bind].start_offset ) + { + dprintf(warn, " Found, index %d\n", bind); + break; + } + + /* If we didn't find it, evict someone and map it */ + if ( bind == MREAD_MAPS ) + { + dprintf(warn, " Clock\n"); + while(1) + { + h->clock++; + if(h->clock >= MREAD_MAPS) + h->clock=0; + dprintf(warn, " %d\n", h->clock); + if(h->map[h->clock].buffer == NULL) + { + dprintf(warn, " Buffer null, using\n"); + break; + } + if(!h->map[h->clock].accessed) + { + dprintf(warn, " Not accessed, using\n"); + break; + } + h->map[h->clock].accessed=0; + } + if(h->map[h->clock].buffer) + { + dprintf(warn, " Unmapping\n"); + munmap(h->map[h->clock].buffer, MREAD_BUF_SIZE); + } + /* FIXME: Try MAP_HUGETLB? */ + /* FIXME: Make sure this works on large files... */ + h->map[h->clock].start_offset = offset & MREAD_BUF_MASK; + dprintf(warn, " Mapping %llx from offset %llx\n", + MREAD_BUF_SIZE, h->map[h->clock].start_offset); + h->map[h->clock].buffer = mmap(NULL, MREAD_BUF_SIZE, PROT_READ, + MAP_SHARED, + h->fd, + h->map[h->clock].start_offset); + dprintf(warn, " mmap returned %p\n", h->map[h->clock].buffer); + if ( h->map[h->clock].buffer == MAP_FAILED ) + { + h->map[h->clock].buffer = NULL; + perror("mmap"); + exit(1); + } + bind = h->clock; + } + + h->last=bind; +copy: + h->map[bind].accessed=1; + b=h->map[bind].buffer; + boffset=offset - h->map[bind].start_offset; + if ( boffset + len > MREAD_BUF_SIZE ) + bsize = MREAD_BUF_SIZE - boffset; + else + bsize = len; + dprintf(warn, " Using index %d, buffer at %p, buffer offset %llx len %d\n", + bind, b, boffset, bsize); + + bcopy(b+boffset, rec, bsize); + + /* Handle the boundary case; make sure this is after doing anything + * with the static variables*/ + if ( len > bsize ) + { + dprintf(warn, " Finishing up by reading l %d o %llx\n", + len-bsize, offset+bsize); + mread64(h, rec+bsize, len-bsize, offset+bsize); + } + + /* FIXME: ?? */ + return len; +#undef dprintf +} diff --git a/tools/xentrace/mread.h b/tools/xentrace/mread.h new file mode 100644 index 0000000..8df41a8 --- /dev/null +++ b/tools/xentrace/mread.h @@ -0,0 +1,18 @@ +#define MREAD_MAPS 8 +#define MREAD_BUF_SHIFT 9 +#define PAGE_SHIFT 12 +#define MREAD_BUF_SIZE (1ULL<<(PAGE_SHIFT+MREAD_BUF_SHIFT)) +#define MREAD_BUF_MASK (~(MREAD_BUF_SIZE-1)) +typedef struct mread_ctrl { + int fd; + loff_t file_size; + struct mread_buffer { + char * buffer; + loff_t start_offset; + int accessed; + } map[MREAD_MAPS]; + int clock, last; +} *mread_handle_t; + +mread_handle_t mread_init(int fd); +ssize_t mread64(mread_handle_t h, void *dst, ssize_t len, loff_t offset); diff --git a/tools/xentrace/pv.h b/tools/xentrace/pv.h new file mode 100644 index 0000000..3e6ad77 --- /dev/null +++ b/tools/xentrace/pv.h @@ -0,0 +1,41 @@ +/* + * PV event decoding. + * + * Copyright (C) 2012 Citrix Systems R&D Ltd. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + */ +#ifndef __PV_H + +#include "analyze.h" +#include <xen/trace.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define ARG_MISSING 0x0 +#define ARG_32BIT 0x1 +#define ARG_64BIT 0x2 + +#define MMU_UPDATE_PREEMPTED (~(~0U>>1)) + +static inline uint32_t pv_hypercall_op(const struct record_info *ri) +{ + return ri->d[0] & ~TRC_PV_HYPERCALL_V2_ARG_MASK; +} + +static inline int pv_hypercall_arg_present(const struct record_info *ri, int arg) +{ + return (ri->d[0] >> (20 + 2*arg)) & 0x3; +} + +void pv_hypercall_gather_args(const struct record_info *ri, uint64_t *args); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c new file mode 100644 index 0000000..a0a3ac1 --- /dev/null +++ b/tools/xentrace/xenalyze.c @@ -0,0 +1,10407 @@ +/* + * xenalyze.c: Analyzing xentrace output + * + * Written by George Dunlap. + * + * Copyright (c) 2006-2007, XenSource Inc. + * Copyright (c) 2007-2008, Citrix Systems R&D Ltd, UK + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple + * Place - Suite 330, Boston, MA 02111-1307 USA. + */ +#define _XOPEN_SOURCE 600 +#include <stdio.h> +#include <stdlib.h> +#include <argp.h> +#include <inttypes.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <xen/trace.h> +#include "analyze.h" +#include "mread.h" +#include "pv.h" +#include <errno.h> +#include <strings.h> +#include <string.h> +#include <assert.h> + +struct mread_ctrl; + + +#define DEFAULT_CPU_HZ 2400000000LL +#define QHZ_FROM_HZ(_hz) (((_hz) << 10)/ 1000000000) + +#define ADDR_SPACE_BITS 48 +#define DEFAULT_SAMPLE_SIZE 10240 +#define DEFAULT_INTERVAL_LENGTH 1000 + +struct array_struct { + unsigned long long *values; + int count; +}; + +#define warn_once(_x...) \ + do { \ + static int _w=1; \ + if ( _w ) { \ + _w=0; \ + fprintf(warn, ##_x); \ + } \ + } while(0) \ + +/* -- Global variables -- */ +struct { + int fd; + struct mread_ctrl *mh; + struct symbol_struct * symbols; + char * symbol_file; + char * trace_file; + int output_defined; + loff_t file_size; + struct { + loff_t update_offset; + int pipe[2]; + FILE* out; + int pid; + } progress; +} G = { + .fd=-1, + .symbols = NULL, + .symbol_file = NULL, + .trace_file = NULL, + .output_defined = 0, + .file_size = 0, + .progress = { .update_offset = 0 }, +}; + +/* + Kinds of errors: + Unexpected values + - RIP with information in high bits (not all 0 or 1) + - exit reason too high + Unexpected record layout + - x64 bit set in PIO,PV_PTWR_EMULATION_PAE, + - Unknown minor type (PV_PTWR_EMULATION, RUNSTATE_CHANGE + - Wrong record size + - More than one bit set in evt.main field + Unexpected sequences + - wake tsc tracking + - TSC dependency loop + - Mismatch between non-running old event states + - Runstate continue while running on another pcpu + - lost_record_end seen in non-lost pcpu + - Unexpected non-CPU_CHANGE record during new_pcpu scan + - record tsc < interval start tsc + - lost_record tsc !> order tsc + Limited resources + - interrupt interval slots + - record cpu > MAX_CPUS + Algorithm asserts + - Duplicate CR3/domain values + - Logic holes + - domain runstates + - runstate / tsc skew + - vcpu_{prev,next}_update p->current{==,!=}null + - vcpu start conditions + - lost_cpu count higher than # of seen cpus / < 0 + - lost cpu has non-null p->current + Symbol file + -file doesn't open + -file not ordered + System + - short read + - malloc failed + Args + - Invalid cpu_hz value / suffix + - No trace file + - Can't open trace file +*/ +enum error_level { + ERR_NONE=0, + ERR_STRICT, /* Be unreasonably picky */ + ERR_WARN, /* Something midly unexpected */ + ERR_SANITY, /* Sanity checks: RIP with info in high bits */ + ERR_RECORD, /* Something that keeps you from processing the record */ + ERR_FILE, /* Probably caused by a corrupt file */ + ERR_LIMIT, /* Exceeded limits; data will be lost */ + ERR_MAX_TOLERABLE=ERR_LIMIT, + /* -- Unrecoverable past this point -- */ + ERR_ASSERT, /* Algoritm assert */ + ERR_SYSTEM, /* System error: cannot allocate memory, short read, &c */ +}; + +int verbosity = 5; + +struct { + unsigned + scatterplot_interrupt_eip:1, + scatterplot_cpi:1, + scatterplot_unpin_promote:1, + scatterplot_cr3_switch:1, + scatterplot_wake_to_halt:1, + scatterplot_io:1, + scatterplot_vmexit_eip:1, + scatterplot_runstate:1, + scatterplot_runstate_time:1, + scatterplot_pcpu:1, + scatterplot_extint_cycles:1, + scatterplot_rdtsc:1, + scatterplot_irq:1, + histogram_interrupt_eip:1, + interval_mode:1, + dump_all:1, + dump_raw_process:1, + dump_raw_reads:1, + dump_no_processing:1, + dump_ipi_latency:1, + dump_trace_volume_on_lost_record:1, + dump_show_power_states:1, + with_cr3_enumeration:1, + with_pio_enumeration:1, + with_mmio_enumeration:1, + with_interrupt_eip_enumeration:1, + show_default_domain_summary:1, + mmio_enumeration_skip_vga:1, + progress:1, + svm_mode:1, + summary:1, + report_pcpu:1, + tsc_loop_fatal:1, + summary_info; + long long cpu_qhz, cpu_hz; + int scatterplot_interrupt_vector; + int scatterplot_extint_cycles_vector; + int scatterplot_io_port; + int histogram_interrupt_vector; + unsigned long long histogram_interrupt_increment; + int interrupt_eip_enumeration_vector; + int default_guest_paging_levels; + int sample_size; + enum error_level tolerance; /* Tolerate up to this level of error */ + struct { + tsc_t cycles; + /* Used if interval is specified in seconds to delay calculating + * time_interval until all arguments have been processed (specifically, + * cpu_hz). */ + unsigned msec; + enum { + INTERVAL_CR3_SCHEDULE_TIME, + INTERVAL_CR3_SCHEDULE_ORDERED, + INTERVAL_CR3_SHORT_SUMMARY, + INTERVAL_DOMAIN_TOTAL_TIME, + INTERVAL_DOMAIN_SHORT_SUMMARY, + INTERVAL_DOMAIN_GUEST_INTERRUPT, + INTERVAL_DOMAIN_GRANT_MAPS + } output; + enum { + INTERVAL_MODE_CUSTOM, + INTERVAL_MODE_ARRAY, + INTERVAL_MODE_LIST + } mode; + enum { + INTERVAL_CHECK_NONE, + INTERVAL_CHECK_CR3, + INTERVAL_CHECK_DOMAIN + } check; + /* Options for specific interval output types */ + union { + struct array_struct array; + }; + int count; + } interval; +} opt = { + .scatterplot_interrupt_eip=0, + .scatterplot_cpi=0, + .scatterplot_unpin_promote=0, + .scatterplot_cr3_switch=0, + .scatterplot_wake_to_halt=0, + .scatterplot_vmexit_eip=0, + .scatterplot_runstate=0, + .scatterplot_runstate_time=0, + .scatterplot_pcpu=0, + .scatterplot_extint_cycles=0, + .scatterplot_rdtsc=0, + .scatterplot_irq=0, + .histogram_interrupt_eip=0, + .dump_all = 0, + .dump_raw_process = 0, + .dump_raw_reads = 0, + .dump_no_processing = 0, + .dump_ipi_latency = 0, + .dump_trace_volume_on_lost_record = 0, + .dump_show_power_states = 0, + .with_cr3_enumeration = 0, + .with_pio_enumeration = 1, + .with_mmio_enumeration = 0, + .with_interrupt_eip_enumeration = 0, + .show_default_domain_summary = 0, + .mmio_enumeration_skip_vga = 1, + .progress = 0, + .svm_mode = 0, + .summary = 0, + .report_pcpu = 0, + .tsc_loop_fatal = 0, + .cpu_hz = DEFAULT_CPU_HZ, + /* Pre-calculate a multiplier that makes the rest of the + * calculations easier */ + .cpu_qhz = QHZ_FROM_HZ(DEFAULT_CPU_HZ), + .default_guest_paging_levels = 2, + .sample_size = DEFAULT_SAMPLE_SIZE, + .tolerance = ERR_SANITY, + .interval = { .msec = DEFAULT_INTERVAL_LENGTH }, +}; + +FILE *warn = NULL; + +/* -- Summary data -- */ +struct cycle_framework { + tsc_t first_tsc, last_tsc, total_cycles; +}; + +struct interval_element { + int count; + long long cycles; + long long instructions; +}; + +struct event_cycle_summary { + int count, cycles_count; + long long cycles; + long long *cycles_sample; + struct interval_element interval; +}; + +struct cycle_summary { + int count; + unsigned long long cycles; + long long *sample; + struct interval_element interval; +}; + +struct weighted_cpi_summary { + int count; + unsigned long long instructions; + unsigned long long cycles; + float *cpi; + unsigned long long *cpi_weight; + struct interval_element interval; +}; + +/* -- Symbol list information -- */ +#define SYMBOL_ENTRIES_PER_STRUCT 1023 +#define SYMBOL_NAME_SIZE 124 +struct symbol_struct { + int count; + struct { + unsigned long long addr; + char name[SYMBOL_NAME_SIZE]; + } symbols[SYMBOL_ENTRIES_PER_STRUCT]; + struct symbol_struct *next; +}; + +void error(enum error_level l, struct record_info *ri); + +void parse_symbol_file(char *fn) { + unsigned long long last_addr = 0; + FILE * symbol_file; + struct symbol_struct ** p=&G.symbols; + + if((symbol_file=fopen(fn, "rb"))==NULL) { + fprintf(stderr, "Could not open symbol file %s\n", fn); + perror("open"); + error(ERR_SYSTEM, NULL); + } + while(!feof(symbol_file)) { + /* Allocate a new struct if we need it */ + if(!*p) { + *p = malloc(sizeof(**p)); + if(!*p) { + fprintf(stderr, "Malloc failed!\n"); + error(ERR_SYSTEM, NULL); + } + (*p)->count=0; + (*p)->next=NULL; + } + + /* FIXME -- use SYMBOL_NAME_SIZE */ + /* FIXME -- use regexp. This won't work for symbols with spaces (yes they exist) */ + (*p)->symbols[(*p)->count].addr = 0xDEADBEEF; + if ( fscanf(symbol_file, "%llx %128s", + &(*p)->symbols[(*p)->count].addr, + (*p)->symbols[(*p)->count].name) == 0 ) + break; + + + if( ((*p)->symbols[(*p)->count].addr > 0) + && ((*p)->symbols[(*p)->count].addr < last_addr) ) { + fprintf(stderr, "Symbol file not properly ordered: %llx %s < %llx!\n", + (*p)->symbols[(*p)->count].addr, + (*p)->symbols[(*p)->count].name, + last_addr); + /* Could be recovered from; just free existing strings and set symbols to NULL */ + error(ERR_ASSERT, NULL); + } else + last_addr = (*p)->symbols[(*p)->count].addr; + + (*p)->count++; + + /* If this struct is full, point to the next. It will be allocated + if needed. */ + if((*p)->count == SYMBOL_ENTRIES_PER_STRUCT) { + p=&((*p)->next); + } + } +} + +/* WARNING not thread safe */ +char * find_symbol(unsigned long long addr) { + struct symbol_struct * p=G.symbols; + int i; + char * lastname="ZERO"; + unsigned long long offset=addr; + static char name[128]; + + if(!p) { + name[0]=0; + return name; + } + + while(1) { + if(!p) + goto finish; + for(i=0; i<p->count; i++) { + if(p->symbols[i].addr > addr) + goto finish; + else { + lastname=p->symbols[i].name; + offset=addr - p->symbols[i].addr; + } + } + p=p->next; + } + finish: + snprintf(name, 128, "(%s +%llx)", + lastname, offset); + return name; +} + +/* -- Eip list data -- */ +enum { + EIP_LIST_TYPE_NONE=0, + EIP_LIST_TYPE_MAX +}; + +struct eip_list_struct { + struct eip_list_struct *next; + unsigned long long eip; + struct event_cycle_summary summary; + int type; + void * extra; +}; + +struct { + void (*update)(struct eip_list_struct *, void *); + void (*new)(struct eip_list_struct *, void *); + void (*dump)(struct eip_list_struct *); +} eip_list_type[EIP_LIST_TYPE_MAX] = { + [EIP_LIST_TYPE_NONE] = { + .update=NULL, + .new=NULL, + .dump=NULL }, +}; + + +/* --- HVM class of events --- */ + +/* + * -- Algorithms -- + * + * Interrupt Wake-to-halt detection + * + * Purpose: To correlate device interrupts to vcpu runtime. + * + * Diagram: + * ... + * blocked -> runnable <- set to waking + * ... + * runnable -> running + * inj_virq A <- Note "waking" interrupt + * vmenter <- Start tsc of "wake-to-halt" interval. + Turn off 'waking'. + * ... + * inj_virq B <- Note alternate interrupt + * vmenter <- Start tsc of "interrupt-to-halt" interval + * ... + * vmexit <- End tsc of "x-to-halt" interval + * running -> blocked <- Process + * + * The "waking" interrupts we want to sub-classify into + * "wake-only" (when interrupt was the only interrupt from wake to halt) and + * "wake-all" (whether this was the only interrupt or not). + */ + +/* VMX data */ +#define EXIT_REASON_EXCEPTION_NMI 0 +#define EXIT_REASON_EXTERNAL_INTERRUPT 1 +#define EXIT_REASON_TRIPLE_FAULT 2 +#define EXIT_REASON_INIT 3 +#define EXIT_REASON_SIPI 4 +#define EXIT_REASON_IO_SMI 5 +#define EXIT_REASON_OTHER_SMI 6 +#define EXIT_REASON_PENDING_INTERRUPT 7 +#define EXIT_REASON_PENDING_VIRT_NMI 8 +#define EXIT_REASON_TASK_SWITCH 9 +#define EXIT_REASON_CPUID 10 +#define EXIT_REASON_GETSEC 11 +#define EXIT_REASON_HLT 12 +#define EXIT_REASON_INVD 13 +#define EXIT_REASON_INVLPG 14 +#define EXIT_REASON_RDPMC 15 +#define EXIT_REASON_RDTSC 16 +#define EXIT_REASON_RSM 17 +#define EXIT_REASON_VMCALL 18 +#define EXIT_REASON_VMCLEAR 19 +#define EXIT_REASON_VMLAUNCH 20 +#define EXIT_REASON_VMPTRLD 21 +#define EXIT_REASON_VMPTRST 22 +#define EXIT_REASON_VMREAD 23 +#define EXIT_REASON_VMRESUME 24 +#define EXIT_REASON_VMWRITE 25 +#define EXIT_REASON_VMOFF 26 +#define EXIT_REASON_VMON 27 +#define EXIT_REASON_CR_ACCESS 28 +#define EXIT_REASON_DR_ACCESS 29 +#define EXIT_REASON_IO_INSTRUCTION 30 +#define EXIT_REASON_MSR_READ 31 +#define EXIT_REASON_MSR_WRITE 32 +#define EXIT_REASON_INVALID_GUEST_STATE 33 +#define EXIT_REASON_MSR_LOADING 34 +#define EXIT_REASON_MWAIT_INSTRUCTION 36 +#define EXIT_REASON_MONITOR_TRAP_FLAG 37 +#define EXIT_REASON_MONITOR_INSTRUCTION 39 +#define EXIT_REASON_PAUSE_INSTRUCTION 40 +#define EXIT_REASON_MACHINE_CHECK 41 +#define EXIT_REASON_TPR_BELOW_THRESHOLD 43 +#define EXIT_REASON_APIC_ACCESS 44 +#define EXIT_REASON_ACCESS_GDTR_OR_IDTR 46 +#define EXIT_REASON_ACCESS_LDTR_OR_TR 47 +#define EXIT_REASON_EPT_VIOLATION 48 +#define EXIT_REASON_EPT_MISCONFIG 49 +#define EXIT_REASON_INVEPT 50 +#define EXIT_REASON_RDTSCP 51 +#define EXIT_REASON_VMX_PREEMPTION_TIMER_EXPIRED 52 +#define EXIT_REASON_INVVPID 53 +#define EXIT_REASON_WBINVD 54 +#define EXIT_REASON_XSETBV 55 + +#define HVM_VMX_EXIT_REASON_MAX (EXIT_REASON_XSETBV+1) + +char * hvm_vmx_exit_reason_name[HVM_VMX_EXIT_REASON_MAX] = { + [0] = "NONE", + [EXIT_REASON_EXCEPTION_NMI]="EXCEPTION_NMI", + [EXIT_REASON_EXTERNAL_INTERRUPT]="EXTERNAL_INTERRUPT", + [EXIT_REASON_TRIPLE_FAULT]="TRIPLE_FAULT", + [EXIT_REASON_INIT]="INIT", + [EXIT_REASON_SIPI]="SIPI", + [EXIT_REASON_IO_SMI]="IO_SMI", + [EXIT_REASON_OTHER_SMI]="OTHER_SMI", + [EXIT_REASON_PENDING_INTERRUPT]="PENDING_INTERRUPT", + [EXIT_REASON_PENDING_VIRT_NMI]="PENDING_VIRT_NMI", + [EXIT_REASON_TASK_SWITCH]="TASK_SWITCH", + [EXIT_REASON_CPUID]="CPUID", + [EXIT_REASON_GETSEC]="GETSEC", + [EXIT_REASON_HLT]="HLT", + [EXIT_REASON_INVD]="INVD", + [EXIT_REASON_INVLPG]="INVLPG", + [EXIT_REASON_RDPMC]="RDPMC", + [EXIT_REASON_RDTSC]="RDTSC", + [EXIT_REASON_RSM]="RSM", + [EXIT_REASON_VMCALL]="VMCALL", + [EXIT_REASON_VMCLEAR]="VMCLEAR", + [EXIT_REASON_VMLAUNCH]="VMLAUNCH", + [EXIT_REASON_VMPTRLD]="VMPTRLD", + [EXIT_REASON_VMPTRST]="VMPTRST", + [EXIT_REASON_VMREAD]="VMREAD", + [EXIT_REASON_VMRESUME]="VMRESUME", + [EXIT_REASON_VMWRITE]="VMWRITE", + [EXIT_REASON_VMOFF]="VMOFF", + [EXIT_REASON_VMON]="VMON", + [EXIT_REASON_CR_ACCESS]="CR_ACCESS", + [EXIT_REASON_DR_ACCESS]="DR_ACCESS", + [EXIT_REASON_IO_INSTRUCTION]="IO_INSTRUCTION", + [EXIT_REASON_MSR_READ]="MSR_READ", + [EXIT_REASON_MSR_WRITE]="MSR_WRITE", + [EXIT_REASON_INVALID_GUEST_STATE]="INVALID_GUEST_STATE", + [EXIT_REASON_MSR_LOADING]="MSR_LOADING", + [EXIT_REASON_MWAIT_INSTRUCTION]="MWAIT_INSTRUCTION", + [EXIT_REASON_MONITOR_TRAP_FLAG]="MONITOR_TRAP_FLAG", + [EXIT_REASON_MONITOR_INSTRUCTION]="MONITOR_INSTRUCTION", + [EXIT_REASON_PAUSE_INSTRUCTION]="PAUSE_INSTRUCTION", + [EXIT_REASON_MACHINE_CHECK]="MACHINE_CHECK", + [EXIT_REASON_TPR_BELOW_THRESHOLD]="TPR_BELOW_THRESHOLD", + [EXIT_REASON_APIC_ACCESS]="APIC_ACCESS", + [EXIT_REASON_EPT_VIOLATION]="EPT_VIOLATION", + [EXIT_REASON_EPT_MISCONFIG]="EPT_MISCONFIG", + [EXIT_REASON_INVEPT]="INVEPT", + [EXIT_REASON_RDTSCP]="RDTSCP", + [EXIT_REASON_VMX_PREEMPTION_TIMER_EXPIRED]="VMX_PREEMPTION_TIMER_EXPIRED", + [EXIT_REASON_INVVPID]="INVVPID", + [EXIT_REASON_WBINVD]="WBINVD", + [EXIT_REASON_XSETBV]="XSETBV", +}; + +/* SVM data */ +enum VMEXIT_EXITCODE +{ + /* control register read exitcodes */ + VMEXIT_CR0_READ = 0, + VMEXIT_CR1_READ = 1, + VMEXIT_CR2_READ = 2, + VMEXIT_CR3_READ = 3, + VMEXIT_CR4_READ = 4, + VMEXIT_CR5_READ = 5, + VMEXIT_CR6_READ = 6, + VMEXIT_CR7_READ = 7, + VMEXIT_CR8_READ = 8, + VMEXIT_CR9_READ = 9, + VMEXIT_CR10_READ = 10, + VMEXIT_CR11_READ = 11, + VMEXIT_CR12_READ = 12, + VMEXIT_CR13_READ = 13, + VMEXIT_CR14_READ = 14, + VMEXIT_CR15_READ = 15, + + /* control register write exitcodes */ + VMEXIT_CR0_WRITE = 16, + VMEXIT_CR1_WRITE = 17, + VMEXIT_CR2_WRITE = 18, + VMEXIT_CR3_WRITE = 19, + VMEXIT_CR4_WRITE = 20, + VMEXIT_CR5_WRITE = 21, + VMEXIT_CR6_WRITE = 22, + VMEXIT_CR7_WRITE = 23, + VMEXIT_CR8_WRITE = 24, + VMEXIT_CR9_WRITE = 25, + VMEXIT_CR10_WRITE = 26, + VMEXIT_CR11_WRITE = 27, + VMEXIT_CR12_WRITE = 28, + VMEXIT_CR13_WRITE = 29, + VMEXIT_CR14_WRITE = 30, + VMEXIT_CR15_WRITE = 31, + + /* debug register read exitcodes */ + VMEXIT_DR0_READ = 32, + VMEXIT_DR1_READ = 33, + VMEXIT_DR2_READ = 34, + VMEXIT_DR3_READ = 35, + VMEXIT_DR4_READ = 36, + VMEXIT_DR5_READ = 37, + VMEXIT_DR6_READ = 38, + VMEXIT_DR7_READ = 39, + VMEXIT_DR8_READ = 40, + VMEXIT_DR9_READ = 41, + VMEXIT_DR10_READ = 42, + VMEXIT_DR11_READ = 43, + VMEXIT_DR12_READ = 44, + VMEXIT_DR13_READ = 45, + VMEXIT_DR14_READ = 46, + VMEXIT_DR15_READ = 47, + + /* debug register write exitcodes */ + VMEXIT_DR0_WRITE = 48, + VMEXIT_DR1_WRITE = 49, + VMEXIT_DR2_WRITE = 50, + VMEXIT_DR3_WRITE = 51, + VMEXIT_DR4_WRITE = 52, + VMEXIT_DR5_WRITE = 53, + VMEXIT_DR6_WRITE = 54, + VMEXIT_DR7_WRITE = 55, + VMEXIT_DR8_WRITE = 56, + VMEXIT_DR9_WRITE = 57, + VMEXIT_DR10_WRITE = 58, + VMEXIT_DR11_WRITE = 59, + VMEXIT_DR12_WRITE = 60, + VMEXIT_DR13_WRITE = 61, + VMEXIT_DR14_WRITE = 62, + VMEXIT_DR15_WRITE = 63, + + /* processor exception exitcodes (VMEXIT_EXCP[0-31]) */ + VMEXIT_EXCEPTION_DE = 64, /* divide-by-zero-error */ + VMEXIT_EXCEPTION_DB = 65, /* debug */ + VMEXIT_EXCEPTION_NMI = 66, /* non-maskable-interrupt */ + VMEXIT_EXCEPTION_BP = 67, /* breakpoint */ + VMEXIT_EXCEPTION_OF = 68, /* overflow */ + VMEXIT_EXCEPTION_BR = 69, /* bound-range */ + VMEXIT_EXCEPTION_UD = 70, /* invalid-opcode*/ + VMEXIT_EXCEPTION_NM = 71, /* device-not-available */ + VMEXIT_EXCEPTION_DF = 72, /* double-fault */ + VMEXIT_EXCEPTION_09 = 73, /* unsupported (reserved) */ + VMEXIT_EXCEPTION_TS = 74, /* invalid-tss */ + VMEXIT_EXCEPTION_NP = 75, /* segment-not-present */ + VMEXIT_EXCEPTION_SS = 76, /* stack */ + VMEXIT_EXCEPTION_GP = 77, /* general-protection */ + VMEXIT_EXCEPTION_PF = 78, /* page-fault */ + VMEXIT_EXCEPTION_15 = 79, /* reserved */ + VMEXIT_EXCEPTION_MF = 80, /* x87 floating-point exception-pending */ + VMEXIT_EXCEPTION_AC = 81, /* alignment-check */ + VMEXIT_EXCEPTION_MC = 82, /* machine-check */ + VMEXIT_EXCEPTION_XF = 83, /* simd floating-point */ + + /* exceptions 20-31 (exitcodes 84-95) are reserved */ + + /* ...and the rest of the #VMEXITs */ + VMEXIT_INTR = 96, + VMEXIT_NMI = 97, + VMEXIT_SMI = 98, + VMEXIT_INIT = 99, + VMEXIT_VINTR = 100, + VMEXIT_CR0_SEL_WRITE = 101, + VMEXIT_IDTR_READ = 102, + VMEXIT_GDTR_READ = 103, + VMEXIT_LDTR_READ = 104, + VMEXIT_TR_READ = 105, + VMEXIT_IDTR_WRITE = 106, + VMEXIT_GDTR_WRITE = 107, + VMEXIT_LDTR_WRITE = 108, + VMEXIT_TR_WRITE = 109, + VMEXIT_RDTSC = 110, + VMEXIT_RDPMC = 111, + VMEXIT_PUSHF = 112, + VMEXIT_POPF = 113, + VMEXIT_CPUID = 114, + VMEXIT_RSM = 115, + VMEXIT_IRET = 116, + VMEXIT_SWINT = 117, + VMEXIT_INVD = 118, + VMEXIT_PAUSE = 119, + VMEXIT_HLT = 120, + VMEXIT_INVLPG = 121, + VMEXIT_INVLPGA = 122, + VMEXIT_IOIO = 123, + VMEXIT_MSR = 124, + VMEXIT_TASK_SWITCH = 125, + VMEXIT_FERR_FREEZE = 126, + VMEXIT_SHUTDOWN = 127, + VMEXIT_VMRUN = 128, + VMEXIT_VMMCALL = 129, + VMEXIT_VMLOAD = 130, + VMEXIT_VMSAVE = 131, + VMEXIT_STGI = 132, + VMEXIT_CLGI = 133, + VMEXIT_SKINIT = 134, + VMEXIT_RDTSCP = 135, + VMEXIT_ICEBP = 136, + VMEXIT_WBINVD = 137, + VMEXIT_MONITOR = 138, + VMEXIT_MWAIT = 139, + VMEXIT_MWAIT_CONDITIONAL= 140, + VMEXIT_NPF = 1024, /* nested paging fault */ + VMEXIT_INVALID = -1 +}; + +#define HVM_SVM_EXIT_REASON_MAX 1025 +char * hvm_svm_exit_reason_name[HVM_SVM_EXIT_REASON_MAX] = { + /* 0-15 */ + "VMEXIT_CR0_READ", + "VMEXIT_CR1_READ", + "VMEXIT_CR2_READ", + "VMEXIT_CR3_READ", + "VMEXIT_CR4_READ", + "VMEXIT_CR5_READ", + "VMEXIT_CR6_READ", + "VMEXIT_CR7_READ", + "VMEXIT_CR8_READ", + "VMEXIT_CR9_READ", + "VMEXIT_CR10_READ", + "VMEXIT_CR11_READ", + "VMEXIT_CR12_READ", + "VMEXIT_CR13_READ", + "VMEXIT_CR14_READ", + "VMEXIT_CR15_READ", + /* 16-31 */ + "VMEXIT_CR0_WRITE", + "VMEXIT_CR1_WRITE", + "VMEXIT_CR2_WRITE", + "VMEXIT_CR3_WRITE", + "VMEXIT_CR4_WRITE", + "VMEXIT_CR5_WRITE", + "VMEXIT_CR6_WRITE", + "VMEXIT_CR7_WRITE", + "VMEXIT_CR8_WRITE", + "VMEXIT_CR9_WRITE", + "VMEXIT_CR10_WRITE", + "VMEXIT_CR11_WRITE", + "VMEXIT_CR12_WRITE", + "VMEXIT_CR13_WRITE", + "VMEXIT_CR14_WRITE", + "VMEXIT_CR15_WRITE", + /* 32-47 */ + "VMEXIT_DR0_READ", + "VMEXIT_DR1_READ", + "VMEXIT_DR2_READ", + "VMEXIT_DR3_READ", + "VMEXIT_DR4_READ", + "VMEXIT_DR5_READ", + "VMEXIT_DR6_READ", + "VMEXIT_DR7_READ", + "VMEXIT_DR8_READ", + "VMEXIT_DR9_READ", + "VMEXIT_DR10_READ", + "VMEXIT_DR11_READ", + "VMEXIT_DR12_READ", + "VMEXIT_DR13_READ", + "VMEXIT_DR14_READ", + "VMEXIT_DR15_READ", + /* 48-63 */ + "VMEXIT_DR0_WRITE", + "VMEXIT_DR1_WRITE", + "VMEXIT_DR2_WRITE", + "VMEXIT_DR3_WRITE", + "VMEXIT_DR4_WRITE", + "VMEXIT_DR5_WRITE", + "VMEXIT_DR6_WRITE", + "VMEXIT_DR7_WRITE", + "VMEXIT_DR8_WRITE", + "VMEXIT_DR9_WRITE", + "VMEXIT_DR10_WRITE", + "VMEXIT_DR11_WRITE", + "VMEXIT_DR12_WRITE", + "VMEXIT_DR13_WRITE", + "VMEXIT_DR14_WRITE", + "VMEXIT_DR15_WRITE", + /* 64-83 */ + "VMEXIT_EXCEPTION_DE", + "VMEXIT_EXCEPTION_DB", + "VMEXIT_EXCEPTION_NMI", + "VMEXIT_EXCEPTION_BP", + "VMEXIT_EXCEPTION_OF", + "VMEXIT_EXCEPTION_BR", + "VMEXIT_EXCEPTION_UD", + "VMEXIT_EXCEPTION_NM", + "VMEXIT_EXCEPTION_DF", + "VMEXIT_EXCEPTION_09", + "VMEXIT_EXCEPTION_TS", + "VMEXIT_EXCEPTION_NP", + "VMEXIT_EXCEPTION_SS", + "VMEXIT_EXCEPTION_GP", + "VMEXIT_EXCEPTION_PF", + "VMEXIT_EXCEPTION_15", + "VMEXIT_EXCEPTION_MF", + "VMEXIT_EXCEPTION_AC", + "VMEXIT_EXCEPTION_MC", + "VMEXIT_EXCEPTION_XF", + /* 84-95 */ + "VMEXIT_EXCEPTION_20", + "VMEXIT_EXCEPTION_21", + "VMEXIT_EXCEPTION_22", + "VMEXIT_EXCEPTION_23", + "VMEXIT_EXCEPTION_24", + "VMEXIT_EXCEPTION_25", + "VMEXIT_EXCEPTION_26", + "VMEXIT_EXCEPTION_27", + "VMEXIT_EXCEPTION_28", + "VMEXIT_EXCEPTION_29", + "VMEXIT_EXCEPTION_30", + "VMEXIT_EXCEPTION_31", + /* 96-99 */ + "VMEXIT_INTR", + "VMEXIT_NMI", + "VMEXIT_SMI", + "VMEXIT_INIT", + /* 100-109 */ + "VMEXIT_VINTR", + "VMEXIT_CR0_SEL_WRITE", + "VMEXIT_IDTR_READ", + "VMEXIT_GDTR_READ", + "VMEXIT_LDTR_READ", + "VMEXIT_TR_READ", + "VMEXIT_IDTR_WRITE", + "VMEXIT_GDTR_WRITE", + "VMEXIT_LDTR_WRITE", + "VMEXIT_TR_WRITE", + /* 110-119 */ + "VMEXIT_RDTSC", + "VMEXIT_RDPMC", + "VMEXIT_PUSHF", + "VMEXIT_POPF", + "VMEXIT_CPUID", + "VMEXIT_RSM", + "VMEXIT_IRET", + "VMEXIT_SWINT", + "VMEXIT_INVD", + "VMEXIT_PAUSE", + /* 120-129 */ + "VMEXIT_HLT", + "VMEXIT_INVLPG", + "VMEXIT_INVLPGA", + "VMEXIT_IOIO", + "VMEXIT_MSR", + "VMEXIT_TASK_SWITCH", + "VMEXIT_FERR_FREEZE", + "VMEXIT_SHUTDOWN", + "VMEXIT_VMRUN", + "VMEXIT_VMMCALL", + /* 130-139 */ + "VMEXIT_VMLOAD", + "VMEXIT_VMSAVE", + "VMEXIT_STGI", + "VMEXIT_CLGI", + "VMEXIT_SKINIT", + "VMEXIT_RDTSCP", + "VMEXIT_ICEBP", + "VMEXIT_WBINVD", + "VMEXIT_MONITOR", + "VMEXIT_MWAIT", + /* 140 */ + "VMEXIT_MWAIT_CONDITIONAL", + [VMEXIT_NPF] = "VMEXIT_NPF", /* nested paging fault */ +}; + + +#if ( HVM_VMX_EXIT_REASON_MAX > HVM_SVM_EXIT_REASON_MAX ) +# define HVM_EXIT_REASON_MAX HVM_VMX_EXIT_REASON_MAX +# error - Strange! +#else +# define HVM_EXIT_REASON_MAX HVM_SVM_EXIT_REASON_MAX +#endif + +/* General hvm information */ +#define SPURIOUS_APIC_VECTOR 0xff +#define ERROR_APIC_VECTOR 0xfe +#define INVALIDATE_TLB_VECTOR 0xfd +#define EVENT_CHECK_VECTOR 0xfc +#define CALL_FUNCTION_VECTOR 0xfb +#define THERMAL_APIC_VECTOR 0xfa +#define LOCAL_TIMER_VECTOR 0xf9 + +#define EXTERNAL_INTERRUPT_MAX 256 + +/* Stringify numbers */ +char * hvm_extint_vector_name[EXTERNAL_INTERRUPT_MAX] = { + [SPURIOUS_APIC_VECTOR] = "SPURIOS_APIC", + [ERROR_APIC_VECTOR] = "ERROR_APIC", + [INVALIDATE_TLB_VECTOR]= "INVALIDATE_TLB", + [EVENT_CHECK_VECTOR]= "EVENT_CHECK", + [CALL_FUNCTION_VECTOR]= "CALL_FUNCTION", + [THERMAL_APIC_VECTOR]= "THERMAL_APIC", + [LOCAL_TIMER_VECTOR] = "LOCAL_TIMER", +}; + +#define HVM_TRAP_MAX 20 + +char * hvm_trap_name[HVM_TRAP_MAX] = { + [0] = "Divide", + [1] = "RESERVED", + [2] = "NMI", + [3] = "Breakpoint", + [4] = "Overflow", + [5] = "BOUND", + [6] = "Invalid Op", + [7] = "Coprocessor not present", + [8] = "Double Fault", + [9] = "Coprocessor segment overrun", + [10] = "TSS", + [11] = "Segment not present", + [12] = "Stack-segment fault", + [13] = "GP", + [14] = "Page fault", + [15] = "RESERVED", + [16] = "FPU", + [17] = "Alignment check", + [18] = "Machine check", + [19] = "SIMD", +}; + + +enum { + HVM_EVENT_HANDLER_NONE = 0, + HVM_EVENT_HANDLER_PF_XEN = 1, + HVM_EVENT_HANDLER_PF_INJECT, + HVM_EVENT_HANDLER_INJ_EXC, + HVM_EVENT_HANDLER_INJ_VIRQ, + HVM_EVENT_HANDLER_REINJ_VIRQ, + HVM_EVENT_HANDLER_IO_READ, + HVM_EVENT_HANDLER_IO_WRITE, + HVM_EVENT_HANDLER_CR_READ, /* 8 */ + HVM_EVENT_HANDLER_CR_WRITE, + HVM_EVENT_HANDLER_DR_READ, + HVM_EVENT_HANDLER_DR_WRITE, + HVM_EVENT_HANDLER_MSR_READ, + HVM_EVENT_HANDLER_MSR_WRITE, + HVM_EVENT_HANDLER_CPUID, + HVM_EVENT_HANDLER_INTR, + HVM_EVENT_HANDLER_NMI, /* 16 */ + HVM_EVENT_HANDLER_SMI, + HVM_EVENT_HANDLER_VMCALL, + HVM_EVENT_HANDLER_HLT, + HVM_EVENT_HANDLER_INVLPG, + HVM_EVENT_HANDLER_MCE, + HVM_EVENT_HANDLER_IO_ASSIST, + HVM_EVENT_HANDLER_MMIO_ASSIST, + HVM_EVENT_HANDLER_CLTS, + HVM_EVENT_HANDLER_LMSW, + HVM_EVENT_RDTSC, + HVM_EVENT_INTR_WINDOW=0x20, /* Oops... skipped 0x1b-1f */ + HVM_EVENT_NPF, + HVM_EVENT_REALMODE_EMULATE, + HVM_EVENT_TRAP, + HVM_EVENT_TRAP_DEBUG, + HVM_EVENT_VLAPIC, + HVM_EVENT_HANDLER_MAX +}; +char * hvm_event_handler_name[HVM_EVENT_HANDLER_MAX] = { + "(no handler)", + "pf_xen", + "pf_inject", + "inj_exc", + "inj_virq", + "reinj_virq", + "io_read", + "io_write", + "cr_read", /* 8 */ + "cr_write", + "dr_read", + "dr_write", + "msr_read", + "msr_write", + "cpuid", + "intr", + "nmi", /* 16 */ + "smi", + "vmcall", + "hlt", + "invlpg", + "mce", + "io_assist", + "mmio_assist", + "clts", /* 24 */ + "lmsw", + "rdtsc", + [HVM_EVENT_INTR_WINDOW]="intr_window", + "npf", + "realmode_emulate", + "trap", + "trap_debug", + "vlapic" +}; + +enum { + HVM_VOL_VMENTRY, + HVM_VOL_VMEXIT, + HVM_VOL_HANDLER, + HVM_VOL_MAX +}; + +enum { + GUEST_INTERRUPT_CASE_NONE, + /* This interrupt woke, no other interrupts until halt */ + GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE, + /* This interrupt woke, maybe another interrupt before halt */ + GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY, + /* Time from interrupt (running) to halt */ + GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT, + GUEST_INTERRUPT_CASE_MAX, +}; + +char *guest_interrupt_case_name[] = { + [GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE]="wake to halt alone", + /* This interrupt woke, maybe another interrupt before halt */ + [GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY] ="wake to halt any ", + /* Time from interrupt (running) to halt */ + [GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT] ="intr to halt ", +}; + +char *hvm_vol_name[HVM_VOL_MAX] = { + [HVM_VOL_VMENTRY]="vmentry", + [HVM_VOL_VMEXIT] ="vmexit", + [HVM_VOL_HANDLER]="handler", +}; + +enum { + HYPERCALL_set_trap_table = 0, + HYPERCALL_mmu_update, + HYPERCALL_set_gdt, + HYPERCALL_stack_switch, + HYPERCALL_set_callbacks, + HYPERCALL_fpu_taskswitch, + HYPERCALL_sched_op_compat, + HYPERCALL_platform_op, + HYPERCALL_set_debugreg, + HYPERCALL_get_debugreg, + HYPERCALL_update_descriptor, + HYPERCALL_memory_op=12, + HYPERCALL_multicall, + HYPERCALL_update_va_mapping, + HYPERCALL_set_timer_op, + HYPERCALL_event_channel_op_compat, + HYPERCALL_xen_version, + HYPERCALL_console_io, + HYPERCALL_physdev_op_compat, + HYPERCALL_grant_table_op, + HYPERCALL_vm_assist, + HYPERCALL_update_va_mapping_otherdomain, + HYPERCALL_iret, + HYPERCALL_vcpu_op, + HYPERCALL_set_segment_base, + HYPERCALL_mmuext_op, + HYPERCALL_acm_op, + HYPERCALL_nmi_op, + HYPERCALL_sched_op, + HYPERCALL_callback_op, + HYPERCALL_xenoprof_op, + HYPERCALL_event_channel_op, + HYPERCALL_physdev_op, + HYPERCALL_hvm_op, + HYPERCALL_sysctl, + HYPERCALL_domctl, + HYPERCALL_kexec_op, + HYPERCALL_MAX +}; + +char *hypercall_name[HYPERCALL_MAX] = { + [HYPERCALL_set_trap_table]="set_trap_table", + [HYPERCALL_mmu_update]="mmu_update", + [HYPERCALL_set_gdt]="set_gdt", + [HYPERCALL_stack_switch]="stack_switch", + [HYPERCALL_set_callbacks]="set_callbacks", + [HYPERCALL_fpu_taskswitch]="fpu_taskswitch", + [HYPERCALL_sched_op_compat]="sched_op(compat)", + [HYPERCALL_platform_op]="platform_op", + [HYPERCALL_set_debugreg]="set_debugreg", + [HYPERCALL_get_debugreg]="get_debugreg", + [HYPERCALL_update_descriptor]="update_descriptor", + [HYPERCALL_memory_op]="memory_op", + [HYPERCALL_multicall]="multicall", + [HYPERCALL_update_va_mapping]="update_va_mapping", + [HYPERCALL_set_timer_op]="set_timer_op", + [HYPERCALL_event_channel_op_compat]="evtchn_op(compat)", + [HYPERCALL_xen_version]="xen_version", + [HYPERCALL_console_io]="console_io", + [HYPERCALL_physdev_op_compat]="physdev_op(compat)", + [HYPERCALL_grant_table_op]="grant_table_op", + [HYPERCALL_vm_assist]="vm_assist", + [HYPERCALL_update_va_mapping_otherdomain]="update_va_mapping_otherdomain", + [HYPERCALL_iret]="iret", + [HYPERCALL_vcpu_op]="vcpu_op", + [HYPERCALL_set_segment_base]="set_segment_base", + [HYPERCALL_mmuext_op]="mmuext_op", + [HYPERCALL_acm_op]="acm_op", + [HYPERCALL_nmi_op]="nmi_op", + [HYPERCALL_sched_op]="sched_op", + [HYPERCALL_callback_op]="callback_op", + [HYPERCALL_xenoprof_op]="xenoprof_op", + [HYPERCALL_event_channel_op]="evtchn_op", + [HYPERCALL_physdev_op]="physdev_op", + [HYPERCALL_hvm_op]="hvm_op", + [HYPERCALL_sysctl]="sysctl", + [HYPERCALL_domctl]="domctl", + [HYPERCALL_kexec_op]="kexec_op" +}; + +enum { + PF_XEN_EMUL_LVL_0, + PF_XEN_EMUL_LVL_1, + PF_XEN_EMUL_LVL_2, + PF_XEN_EMUL_LVL_3, + PF_XEN_EMUL_LVL_4, + PF_XEN_EMUL_EARLY_UNSHADOW, + PF_XEN_EMUL_SET_CHANGED, + PF_XEN_EMUL_SET_UNCHANGED, + PF_XEN_EMUL_SET_FLUSH, + PF_XEN_EMUL_SET_ERROR, + PF_XEN_EMUL_PROMOTE, + PF_XEN_EMUL_DEMOTE, + PF_XEN_EMUL_PREALLOC_UNPIN, + PF_XEN_EMUL_PREALLOC_UNHOOK, + PF_XEN_EMUL_MAX, +}; + +char * pf_xen_emul_name[PF_XEN_EMUL_MAX] = { + [PF_XEN_EMUL_LVL_0]="non-linmap", + [PF_XEN_EMUL_LVL_1]="linmap l1", + [PF_XEN_EMUL_LVL_2]="linmap l2", + [PF_XEN_EMUL_LVL_3]="linmap l3", + [PF_XEN_EMUL_LVL_4]="linmap l4", + [PF_XEN_EMUL_EARLY_UNSHADOW]="early unshadow", + [PF_XEN_EMUL_SET_UNCHANGED]="set unchanged", + [PF_XEN_EMUL_SET_CHANGED]="set changed", + [PF_XEN_EMUL_SET_FLUSH]="set changed", + [PF_XEN_EMUL_SET_ERROR]="set changed", + [PF_XEN_EMUL_PROMOTE]="promote", + [PF_XEN_EMUL_DEMOTE]="demote", + [PF_XEN_EMUL_PREALLOC_UNPIN]="unpin", + [PF_XEN_EMUL_PREALLOC_UNHOOK]="unhook", +}; + +/* Rio only */ +enum { + PF_XEN_NON_EMUL_VA_USER, + PF_XEN_NON_EMUL_VA_KERNEL, + PF_XEN_NON_EMUL_EIP_USER, + PF_XEN_NON_EMUL_EIP_KERNEL, + PF_XEN_NON_EMUL_MAX, +}; + +char * pf_xen_non_emul_name[PF_XEN_NON_EMUL_MAX] = { + [PF_XEN_NON_EMUL_VA_USER]="va user", + [PF_XEN_NON_EMUL_VA_KERNEL]="va kernel", + [PF_XEN_NON_EMUL_EIP_USER]="eip user", + [PF_XEN_NON_EMUL_EIP_KERNEL]="eip kernel", +}; + +enum { + PF_XEN_FIXUP_PREALLOC_UNPIN, + PF_XEN_FIXUP_PREALLOC_UNHOOK, + PF_XEN_FIXUP_UNSYNC, + PF_XEN_FIXUP_OOS_ADD, + PF_XEN_FIXUP_OOS_EVICT, + PF_XEN_FIXUP_PROMOTE, + PF_XEN_FIXUP_UPDATE_ONLY, + PF_XEN_FIXUP_WRMAP, + PF_XEN_FIXUP_BRUTE_FORCE, + PF_XEN_FIXUP_MAX, +}; + +char * pf_xen_fixup_name[PF_XEN_FIXUP_MAX] = { + [PF_XEN_FIXUP_PREALLOC_UNPIN] = "unpin", + [PF_XEN_FIXUP_PREALLOC_UNHOOK] = "unhook", + [PF_XEN_FIXUP_UNSYNC] = "unsync", + [PF_XEN_FIXUP_OOS_ADD] = "oos-add", + [PF_XEN_FIXUP_OOS_EVICT] = "oos-evict", + [PF_XEN_FIXUP_PROMOTE] = "promote", + [PF_XEN_FIXUP_UPDATE_ONLY] = "update", + [PF_XEN_FIXUP_WRMAP] = "wrmap", + [PF_XEN_FIXUP_BRUTE_FORCE] = "wrmap-bf", +}; + +enum { + PF_XEN_NOT_SHADOW = 1, + PF_XEN_FAST_PROPAGATE, + PF_XEN_FAST_MMIO, + PF_XEN_FALSE_FAST_PATH, + PF_XEN_MMIO, + PF_XEN_FIXUP, + PF_XEN_DOMF_DYING, + PF_XEN_EMULATE, + PF_XEN_EMULATE_UNSHADOW_USER, + PF_XEN_EMULATE_UNSHADOW_EVTINJ, + PF_XEN_EMULATE_UNSHADOW_UNHANDLED, + PF_XEN_LAST_FAULT=PF_XEN_EMULATE_UNSHADOW_UNHANDLED, + PF_XEN_NON_EMULATE, + PF_XEN_NO_HANDLER, + PF_XEN_MAX, +}; + +#define SHADOW_WRMAP_BF 12 +#define SHADOW_PREALLOC_UNPIN 13 +#define SHADOW_RESYNC_FULL 14 +#define SHADOW_RESYNC_ONLY 15 + +char * pf_xen_name[PF_XEN_MAX] = { + [PF_XEN_NOT_SHADOW]="propagate", + [PF_XEN_FAST_PROPAGATE]="fast propagate", + [PF_XEN_FAST_MMIO]="fast mmio", + [PF_XEN_FALSE_FAST_PATH]="false fast path", + [PF_XEN_MMIO]="mmio", + [PF_XEN_FIXUP]="fixup", + [PF_XEN_DOMF_DYING]="dom dying", + [PF_XEN_EMULATE]="emulate", + [PF_XEN_EMULATE_UNSHADOW_USER]="unshadow:user-mode", + [PF_XEN_EMULATE_UNSHADOW_EVTINJ]="unshadow:evt inj", + [PF_XEN_EMULATE_UNSHADOW_UNHANDLED]="unshadow:unhandled instr", + [PF_XEN_NON_EMULATE]="fixup|mmio", + [PF_XEN_NO_HANDLER]="(no handler)", +}; + +#define CORR_VA_INVALID (0ULL-1) + +enum { + NONPF_MMIO_APIC, + NONPF_MMIO_NPF, + NONPF_MMIO_UNKNOWN, + NONPF_MMIO_MAX +}; + +struct mmio_info { + unsigned long long gpa; + unsigned long long va; /* Filled only by shadow */ + unsigned data; + unsigned data_valid:1, is_write:1; +}; + +struct pf_xen_extra { + unsigned long long va; + union { + unsigned flags; + struct { + unsigned flag_set_ad:1, + flag_set_a:1, + flag_shadow_l1_get_ref:1, + flag_shadow_l1_put_ref:1, + flag_l2_propagate:1, + flag_set_changed:1, + flag_set_flush:1, + flag_set_error:1, + flag_demote:1, + flag_promote:1, + flag_wrmap:1, + flag_wrmap_guess_found:1, + flag_wrmap_brute_force:1, + flag_early_unshadow:1, + flag_emulation_2nd_pt_written:1, + flag_emulation_last_failed:1, + flag_emulate_full_pt:1, + flag_prealloc_unhook:1, + flag_unsync:1, + flag_oos_fixup_add:1, + flag_oos_fixup_evict:1; + }; + }; /* Miami + ; fixup & emulate */ + unsigned int error_code; /* Rio only */ + + /* Calculated */ + int pf_case; /* Rio */ + + /* MMIO only */ + unsigned long long gpa; + unsigned int data; + + /* Emulate only */ + unsigned long long gl1e; /* Miami + */ + unsigned long long wval; /* Miami */ + unsigned long long corresponding_va; + unsigned int pt_index[5], pt_is_lo; + int pt_level; + + /* Other */ + unsigned long long gfn; + + /* Flags */ + unsigned corr_valid:1, + corr_is_kernel:1, + va_is_kernel:1; +}; + +struct pcpu_info; + +#define GUEST_INTERRUPT_MAX 350 +#define FAKE_VECTOR 349 +#define CR_MAX 9 +#define RESYNCS_MAX 17 +#define PF_XEN_FIXUP_UNSYNC_RESYNC_MAX 2 + +struct hvm_data; + +struct hvm_summary_handler_node { + void (*handler)(struct hvm_data *, void* data); + void *data; + struct hvm_summary_handler_node *next; +}; + +struct hvm_data { + /* Summary information */ + int init; + int vmexit_valid; + int summary_info; + struct vcpu_data *v; /* up-pointer */ + + /* SVM / VMX compatibility. FIXME - should be global */ + char ** exit_reason_name; + int exit_reason_max; + struct hvm_summary_handler_node *exit_reason_summary_handler_list[HVM_EXIT_REASON_MAX]; + + /* Information about particular exit reasons */ + struct { + struct event_cycle_summary exit_reason[HVM_EXIT_REASON_MAX]; + int extint[EXTERNAL_INTERRUPT_MAX+1]; + int *extint_histogram; + struct event_cycle_summary trap[HVM_TRAP_MAX]; + struct event_cycle_summary pf_xen[PF_XEN_MAX]; + struct event_cycle_summary pf_xen_emul[PF_XEN_EMUL_MAX]; + struct event_cycle_summary pf_xen_emul_early_unshadow[5]; + struct event_cycle_summary pf_xen_non_emul[PF_XEN_NON_EMUL_MAX]; + struct event_cycle_summary pf_xen_fixup[PF_XEN_FIXUP_MAX]; + struct event_cycle_summary pf_xen_fixup_unsync_resync[PF_XEN_FIXUP_UNSYNC_RESYNC_MAX+1]; + struct event_cycle_summary cr_write[CR_MAX]; + struct event_cycle_summary cr3_write_resyncs[RESYNCS_MAX+1]; + struct event_cycle_summary vmcall[HYPERCALL_MAX+1]; + struct event_cycle_summary generic[HVM_EVENT_HANDLER_MAX]; + struct event_cycle_summary mmio[NONPF_MMIO_MAX]; + struct hvm_gi_struct { + int count; + struct cycle_summary runtime[GUEST_INTERRUPT_CASE_MAX]; + /* OK, not summary info, but still... */ + int is_wake; + tsc_t start_tsc; + } guest_interrupt[GUEST_INTERRUPT_MAX + 1]; + /* IPI Latency */ + struct event_cycle_summary ipi_latency; + int ipi_count[256]; + struct { + struct io_address *mmio, *pio; + } io; + } summary; + + /* In-flight accumulation information */ + struct { + union { + struct { + unsigned port:31, + is_write:1; + unsigned int val; + } io; + struct pf_xen_extra pf_xen; + struct { + unsigned cr; + unsigned long long val; + int repromote; + } cr_write; + struct { + unsigned addr; + unsigned long long val; + } msr; + struct { + unsigned int event; + uint32_t d[4]; + } generic; + struct { + unsigned eax; + } vmcall; + struct { + unsigned vec; + } intr; + }; + /* MMIO gets its separate area, since many exits may use it */ + struct mmio_info mmio; + }inflight; + int resyncs; + void (*post_process)(struct hvm_data *); + tsc_t exit_tsc, arc_cycles, entry_tsc; + unsigned long long rip; + unsigned exit_reason, event_handler; + int short_summary_done:1, prealloc_unpin:1, wrmap_bf:1; + + /* Immediate processing */ + void *d; + + /* Wake-to-halt detection. See comment above. */ + struct { + unsigned waking:1; + /* Wake vector: keep track of time from vmentry until: + next halt, or next interrupt */ + int vector, interrupts, interrupts_wanting_tsc; + } w2h; + + /* Historical info */ + tsc_t last_rdtsc; +}; + +enum { + HVM_SHORT_SUMMARY_EMULATE, + HVM_SHORT_SUMMARY_UNSYNC, + HVM_SHORT_SUMMARY_FIXUP, + HVM_SHORT_SUMMARY_MMIO, + HVM_SHORT_SUMMARY_PROPAGATE, + HVM_SHORT_SUMMARY_CR3, + HVM_SHORT_SUMMARY_VMCALL, + HVM_SHORT_SUMMARY_INTERRUPT, + HVM_SHORT_SUMMARY_HLT, + HVM_SHORT_SUMMARY_OTHER, + HVM_SHORT_SUMMARY_MAX, +}; + +char *hvm_short_summary_name[HVM_SHORT_SUMMARY_MAX] = { + [HVM_SHORT_SUMMARY_EMULATE] ="emulate", + [HVM_SHORT_SUMMARY_UNSYNC] ="unsync", + [HVM_SHORT_SUMMARY_FIXUP] ="fixup", + [HVM_SHORT_SUMMARY_MMIO] ="mmio", + [HVM_SHORT_SUMMARY_PROPAGATE]="propagate", + [HVM_SHORT_SUMMARY_CR3] ="cr3", + [HVM_SHORT_SUMMARY_VMCALL] ="vmcall", + [HVM_SHORT_SUMMARY_INTERRUPT]="intr", + [HVM_SHORT_SUMMARY_HLT] ="hlt", + [HVM_SHORT_SUMMARY_OTHER] ="other", +}; + +struct hvm_short_summary_struct { + struct cycle_summary s[HVM_SHORT_SUMMARY_MAX]; +}; + +void init_hvm_data(struct hvm_data *h, struct vcpu_data *v) { + int i; + + if(h->init) + return; + + h->v = v; + + h->init = 1; + + if(opt.svm_mode) { + h->exit_reason_max = HVM_SVM_EXIT_REASON_MAX; + h->exit_reason_name = hvm_svm_exit_reason_name; + } else { + h->exit_reason_max = HVM_VMX_EXIT_REASON_MAX; + h->exit_reason_name = hvm_vmx_exit_reason_name; + } + + if(opt.histogram_interrupt_eip) { + int count = ((1ULL<<ADDR_SPACE_BITS)/opt.histogram_interrupt_increment); + size_t size = count * sizeof(int); + h->summary.extint_histogram = malloc(size); + if(h->summary.extint_histogram) + bzero(h->summary.extint_histogram, size); + else { + fprintf(stderr, "FATAL: Could not allocate %zd bytes for interrupt histogram!\n", + size); + error(ERR_SYSTEM, NULL); + } + + } + for(i=0; i<GUEST_INTERRUPT_MAX+1; i++) + h->summary.guest_interrupt[i].count=0; +} + +/* PV data */ +enum { + PV_HYPERCALL=1, + PV_TRAP=3, + PV_PAGE_FAULT, + PV_FORCED_INVALID_OP, + PV_EMULATE_PRIVOP, + PV_EMULATE_4GB, + PV_MATH_STATE_RESTORE, + PV_PAGING_FIXUP, + PV_GDT_LDT_MAPPING_FAULT, + PV_PTWR_EMULATION, + PV_PTWR_EMULATION_PAE, + PV_HYPERCALL_V2 = 13, + PV_HYPERCALL_SUBCALL = 14, + PV_MAX +}; + +char *pv_name[PV_MAX] = { + [PV_HYPERCALL]="hypercall", + [PV_TRAP]="trap", + [PV_PAGE_FAULT]="page_fault", + [PV_FORCED_INVALID_OP]="forced_invalid_op", + [PV_EMULATE_PRIVOP]="emulate privop", + [PV_EMULATE_4GB]="emulate 4g", + [PV_MATH_STATE_RESTORE]="math state restore", + [PV_PAGING_FIXUP]="paging fixup", + [PV_GDT_LDT_MAPPING_FAULT]="gdt/ldt mapping fault", + [PV_PTWR_EMULATION]="ptwr", + [PV_PTWR_EMULATION_PAE]="ptwr(pae)", + [PV_HYPERCALL_V2]="hypercall", + [PV_HYPERCALL_SUBCALL]="hypercall (subcall)", +}; + +#define PV_HYPERCALL_MAX 56 +#define PV_TRAP_MAX 20 + +struct pv_data { + unsigned summary_info:1; + int count[PV_MAX]; + int hypercall_count[PV_HYPERCALL_MAX]; + int trap_count[PV_TRAP_MAX]; +}; + +/* Sched data */ + +enum { + SCHED_DOM_ADD=1, + SCHED_DOM_REM, + SCHED_SLEEP, + SCHED_WAKE, + SCHED_YIELD, + SCHED_BLOCK, + SCHED_SHUTDOWN, + SCHED_CTL, + SCHED_ADJDOM, + SCHED_SWITCH, + SCHED_S_TIMER_FN, + SCHED_T_TIMER_FN, + SCHED_DOM_TIMER_FN, + SCHED_SWITCH_INFPREV, + SCHED_SWITCH_INFNEXT, + SCHED_SHUTDOWN_CODE, + SCHED_MAX +}; + +enum { + RUNSTATE_RUNNING=0, + RUNSTATE_RUNNABLE, + RUNSTATE_BLOCKED, + RUNSTATE_OFFLINE, + RUNSTATE_LOST, + RUNSTATE_QUEUED, + RUNSTATE_INIT, + RUNSTATE_MAX +}; + +int runstate_graph[RUNSTATE_MAX] = +{ + [RUNSTATE_BLOCKED]=0, + [RUNSTATE_OFFLINE]=1, + [RUNSTATE_RUNNABLE]=2, + [RUNSTATE_RUNNING]=3, + [RUNSTATE_LOST]=-1, + [RUNSTATE_QUEUED]=-2, + [RUNSTATE_INIT]=-2, +}; + +char * runstate_name[RUNSTATE_MAX]={ + [RUNSTATE_RUNNING]= "running", + [RUNSTATE_RUNNABLE]="runnable", + [RUNSTATE_BLOCKED]= "blocked", /* to be blocked */ + [RUNSTATE_OFFLINE]= "offline", + [RUNSTATE_QUEUED]= "queued", + [RUNSTATE_INIT]= "init", + [RUNSTATE_LOST]= "lost", +}; + +enum { + RUNNABLE_STATE_INVALID, + RUNNABLE_STATE_WAKE, + RUNNABLE_STATE_PREEMPT, + RUNNABLE_STATE_OTHER, + RUNNABLE_STATE_MAX +}; + +char * runnable_state_name[RUNNABLE_STATE_MAX]={ + [RUNNABLE_STATE_INVALID]="invalid", /* Should never show up */ + [RUNNABLE_STATE_WAKE]="wake", + [RUNNABLE_STATE_PREEMPT]="preempt", + [RUNNABLE_STATE_OTHER]="other", +}; + +/* Memory data */ +enum { + MEM_PAGE_GRANT_MAP = 1, + MEM_PAGE_GRANT_UNMAP, + MEM_PAGE_GRANT_TRANSFER, + MEM_SET_P2M_ENTRY, + MEM_DECREASE_RESERVATION, + MEM_POD_POPULATE = 16, + MEM_POD_ZERO_RECLAIM, + MEM_POD_SUPERPAGE_SPLINTER, + MEM_MAX +}; + +char *mem_name[MEM_MAX] = { + [MEM_PAGE_GRANT_MAP] = "grant-map", + [MEM_PAGE_GRANT_UNMAP] = "grant-unmap", + [MEM_PAGE_GRANT_TRANSFER] = "grant-transfer", + [MEM_SET_P2M_ENTRY] = "set-p2m", + [MEM_DECREASE_RESERVATION] = "decrease-reservation", + [MEM_POD_POPULATE] = "pod-populate", + [MEM_POD_ZERO_RECLAIM] = "pod-zero-reclaim", + [MEM_POD_SUPERPAGE_SPLINTER] = "pod-superpage-splinter", +}; + +/* Per-unit information. */ + +struct cr3_value_struct { + struct cr3_value_struct * next; + struct cr3_value_struct * gnext; + unsigned long long gmfn; + int cr3_id; + unsigned long long first_time, last_time, run_time; + struct cycle_summary total_time, guest_time, hv_time; + int switch_count, flush_count; + + struct hvm_short_summary_struct hvm; + + struct { + int now; + int count; + } prealloc_unpin; + + struct { + unsigned callback:1; + unsigned flush_count, switch_count; + unsigned fixup_user, emulate_corr_user; + } destroy; +}; + +#ifndef MAX_CPUS +#define MAX_CPUS 256 +#endif +typedef uint32_t cpu_mask_t; + +#define IDLE_DOMAIN 32767 +#define DEFAULT_DOMAIN 32768 + +#define MAX_VLAPIC_LIST 8 +struct vlapic_struct { + struct { + struct outstanding_ipi { + tsc_t first_tsc; + int vec, count; + int injected, valid; + } list[MAX_VLAPIC_LIST]; + } outstanding; +}; + +struct vcpu_data { + int vid; + struct domain_data *d; /* up-pointer */ + unsigned activated:1; + + int guest_paging_levels; + + /* Schedule info */ + struct { + int state; + int runnable_state; /* Only valid when state==RUNSTATE_RUNNABLE */ + tsc_t tsc; + /* TSC skew detection/correction */ + struct last_oldstate_struct { + int wrong, actual, pid; + tsc_t tsc; + } last_oldstate; + /* Performance counters */ + unsigned long long p1_start, p2_start; + } runstate; + struct pcpu_info *p; + tsc_t pcpu_tsc; + + /* Hardware tracking */ + struct { + long long val; + tsc_t start_time; + struct cr3_value_struct *data; + } cr3; + + /* IPI latency tracking */ + struct vlapic_struct vlapic; + + /* Summary info */ + struct cycle_framework f; + struct cycle_summary runstates[RUNSTATE_MAX]; + struct cycle_summary runnable_states[RUNNABLE_STATE_MAX]; + struct weighted_cpi_summary cpi; + struct cycle_summary cpu_affinity_all, + cpu_affinity_pcpu[MAX_CPUS]; + enum { + VCPU_DATA_NONE=0, + VCPU_DATA_HVM, + VCPU_DATA_PV + } data_type; + union { + struct hvm_data hvm; + struct pv_data pv; + }; +}; + +enum { + DOMAIN_RUNSTATE_BLOCKED=0, + DOMAIN_RUNSTATE_PARTIAL_RUN, + DOMAIN_RUNSTATE_FULL_RUN, + DOMAIN_RUNSTATE_PARTIAL_CONTENTION, + DOMAIN_RUNSTATE_CONCURRENCY_HAZARD, + DOMAIN_RUNSTATE_FULL_CONTENTION, + DOMAIN_RUNSTATE_LOST, + DOMAIN_RUNSTATE_MAX +}; + +char * domain_runstate_name[] = { + [DOMAIN_RUNSTATE_BLOCKED]="blocked", + [DOMAIN_RUNSTATE_PARTIAL_RUN]="partial run", + [DOMAIN_RUNSTATE_FULL_RUN]="full run", + [DOMAIN_RUNSTATE_PARTIAL_CONTENTION]="partial contention", + [DOMAIN_RUNSTATE_CONCURRENCY_HAZARD]="concurrency_hazard", + [DOMAIN_RUNSTATE_FULL_CONTENTION]="full_contention", + [DOMAIN_RUNSTATE_LOST]="lost", +}; + +enum { + POD_RECLAIM_CONTEXT_UNKNOWN=0, + POD_RECLAIM_CONTEXT_FAULT, + POD_RECLAIM_CONTEXT_BALLOON, + POD_RECLAIM_CONTEXT_MAX +}; + +char * pod_reclaim_context_name[] = { + [POD_RECLAIM_CONTEXT_UNKNOWN]="unknown", + [POD_RECLAIM_CONTEXT_FAULT]="fault", + [POD_RECLAIM_CONTEXT_BALLOON]="balloon", +}; + +#define POD_ORDER_MAX 4 + +struct domain_data { + struct domain_data *next; + int did; + struct vcpu_data *vcpu[MAX_CPUS]; + + int max_vid; + + int runstate; + tsc_t runstate_tsc; + struct cycle_summary total_time; + struct cycle_summary runstates[DOMAIN_RUNSTATE_MAX]; + struct cr3_value_struct *cr3_value_head; + struct eip_list_struct *emulate_eip_list; + struct eip_list_struct *interrupt_eip_list; + + int guest_interrupt[GUEST_INTERRUPT_MAX+1]; + struct hvm_short_summary_struct hvm_short; + struct { + int done[MEM_MAX]; + int done_interval[MEM_MAX]; + + int done_for[MEM_MAX]; + int done_for_interval[MEM_MAX]; + } memops; + + struct { + int reclaim_order[POD_ORDER_MAX]; + int reclaim_context[POD_RECLAIM_CONTEXT_MAX]; + int reclaim_context_order[POD_RECLAIM_CONTEXT_MAX][POD_ORDER_MAX]; + /* FIXME: Do a full cycle summary */ + int populate_order[POD_ORDER_MAX]; + } pod; +}; + +struct domain_data * domain_list=NULL; + +struct domain_data default_domain; + +enum { + TOPLEVEL_GEN=0, + TOPLEVEL_SCHED, + TOPLEVEL_DOM0OP, + TOPLEVEL_HVM, + TOPLEVEL_MEM, + TOPLEVEL_PV, + TOPLEVEL_SHADOW, + TOPLEVEL_HW, + TOPLEVEL_MAX=TOPLEVEL_HW+1, +}; + +char * toplevel_name[TOPLEVEL_MAX] = { + [TOPLEVEL_GEN]="gen", + [TOPLEVEL_SCHED]="sched", + [TOPLEVEL_DOM0OP]="dom0op", + [TOPLEVEL_HVM]="hvm", + [TOPLEVEL_MEM]="mem", + [TOPLEVEL_PV]="pv", + [TOPLEVEL_SHADOW]="shadow", + [TOPLEVEL_HW]="hw", +}; + +struct trace_volume { + unsigned long long toplevel[TOPLEVEL_MAX]; + unsigned long long sched_verbose; + unsigned long long hvm[HVM_VOL_MAX]; +} volume; + +#define UPDATE_VOLUME(_p,_x,_s) \ + do { \ + (_p)->volume.total._x += _s; \ + (_p)->volume.last_buffer._x += _s; \ + } while(0) + +void volume_clear(struct trace_volume *vol) +{ + bzero(vol, sizeof(*vol)); +} + +void volume_summary(struct trace_volume *vol) +{ + int j, k; + for(j=0; j<TOPLEVEL_MAX; j++) + if(vol->toplevel[j]) { + printf(" %-6s: %10lld\n", + toplevel_name[j], vol->toplevel[j]); + switch(j) { + case TOPLEVEL_SCHED: + if(vol->sched_verbose) + printf(" +-verbose: %10lld\n", + vol->sched_verbose); + break; + case TOPLEVEL_HVM: + for(k=0; k<HVM_VOL_MAX; k++) { + if(vol->hvm[k]) + printf(" +-%-7s: %10lld\n", + hvm_vol_name[k], vol->hvm[k]); + } + + break; + } + } +} + +struct pcpu_info { + /* Information about this pcpu */ + unsigned active:1, summary:1; + int pid; + + /* Information related to scanning thru the file */ + tsc_t first_tsc, last_tsc, order_tsc; + loff_t file_offset; + loff_t next_cpu_change_offset; + struct record_info ri; + int last_cpu_change_pid; + int power_state; + + /* Information related to tsc skew detection / correction */ + struct { + tsc_t offset; + cpu_mask_t downstream; /* To detect cycles in dependencies */ + } tsc_skew; + + /* Information related to domain tracking */ + struct vcpu_data * current; + struct { + unsigned active:1, + domain_valid:1, + seen_valid_schedule:1; /* Seen an actual schedule since lost records */ + unsigned did:16,vid:16; + tsc_t tsc; + } lost_record; + + /* Record volume */ + struct { + tsc_t buffer_first_tsc, + buffer_dom0_runstate_tsc, + buffer_dom0_runstate_cycles[RUNSTATE_MAX]; + int buffer_dom0_runstate; + unsigned buffer_size; + struct trace_volume total, last_buffer; + } volume; + + /* Time report */ + struct { + tsc_t tsc; + struct cycle_summary idle, running, lost; + } time; +}; + +void __fill_in_record_info(struct pcpu_info *p); + +#define INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX 10 + +struct { + int max_active_pcpu; + loff_t last_epoch_offset; + int early_eof; + int lost_cpus; + tsc_t now; + struct cycle_framework f; + tsc_t buffer_trace_virq_tsc; + struct pcpu_info pcpu[MAX_CPUS]; + + struct { + int id; + /* Invariant: head null => tail null; head !null => tail valid */ + struct cr3_value_struct *head, **tail; + } cr3; + + struct { + tsc_t start_tsc; + /* Information about specific interval output types */ + union { + struct { + struct interval_element ** values; + int count; + } array; + struct { + struct interval_list *head, **tail; + } list; + struct cr3_value_struct *cr3; + struct { + struct domain_data *d; + int guest_vector[INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX]; + } domain; + }; + } interval; +} P = { 0 }; + +/* Function prototypes */ +char * pcpu_string(int pcpu); +void pcpu_string_draw(struct pcpu_info *p); +void process_generic(struct record_info *ri); +void dump_generic(FILE *f, struct record_info *ri); +ssize_t __read_record(struct trace_record *rec, loff_t offset); +void error(enum error_level l, struct record_info *ri); +void update_io_address(struct io_address ** list, unsigned int pa, int dir, + tsc_t arc_cycles, unsigned int va); +int check_extra_words(struct record_info *ri, int expected_size, const char *record); +int vcpu_set_data_type(struct vcpu_data *v, int type); + +void cpumask_init(cpu_mask_t *c) { + *c = 0UL; +} + +void cpumask_clear(cpu_mask_t *c, int cpu) { + *c &= ~(1UL << cpu); +} + +void cpumask_set(cpu_mask_t *c, int cpu) { + *c |= (1UL << cpu); +} + +int cpumask_isset(const cpu_mask_t *c, int cpu) { + if(*c & (1UL<<cpu)) + return 1; + else + return 0; +} + +void cpumask_union(cpu_mask_t *d, const cpu_mask_t *s) { + *d |= *s; +} + +/* -- Time code -- */ + +void cycles_to_time(unsigned long long c, struct time_struct *t) { + t->time = ((c - P.f.first_tsc) << 10) / opt.cpu_qhz; + t->s = t->time / 1000000000; + t->ns = t->time - (t->s * 1000000000); +} + +void abs_cycles_to_time(unsigned long long ac, struct time_struct *t) { + if(ac > P.f.first_tsc) { + /* t->time = ((ac - P.f.first_tsc) * 1000) / (opt.cpu_hz / 1000000 ); */ + /* t->s = t->time / 1000000000; */ + /* t->ns = t->time % 1000000000; */ + t->time = ((ac - P.f.first_tsc) << 10) / opt.cpu_qhz; + t->s = t->time / 1000000000; + t->ns = t->time - (t->s * 1000000000); + } else { + t->time = t->s = t->ns = 0; + } +} + +tsc_t abs_cycles_to_global(unsigned long long ac) { + if(ac > P.f.first_tsc) + return ac - P.f.first_tsc; + else + return 0; +} + +void scatterplot_vs_time(tsc_t atsc, long long y) { + struct time_struct t; + + abs_cycles_to_time(atsc, &t); + + printf("%u.%09u %lld\n", t.s, t.ns, y); +} + +/* -- Summary Code -- */ + +/* With compliments to "Numerical Recipes in C", which provided the algorithm + * and basic template for this function. */ +long long percentile(long long * A, int N, int ple) { + int I, J, L, R, K; + + long long X, W; + + /* No samples! */ + if ( N == 0 ) + return 0; + + /* Find K, the element # we want */ + K=N*ple/100; + + /* Set the left and right boundaries of the current search space */ + L=0; R=N-1; + + while(L < R) { + /* X: The value to order everything higher / lower than */ + X=A[K]; + + /* Starting at the left and the right... */ + I=L; + J=R; + + do { + /* Find the first element on the left that is out-of-order w/ X */ + while(A[I]<X) + I++; + /* Find the first element on the right that is out-of-order w/ X */ + while(X<A[J]) + J--; + + /* If we found something out-of-order */ + if(I<=J) { + /* Switch the values */ + W=A[I]; + A[I]=A[J]; + A[J]=W; + + /* And move on */ + I++; J--; + } + } while (I <= J); /* Keep going until our pointers meet or pass */ + + /* Re-adjust L and R, based on which element we're looking for */ + if(J<K) + L=I; + if(K<I) + R=J; + } + + return A[K]; +} + +float weighted_percentile(float * A, /* values */ + unsigned long long * w, /* weights */ + int N, /* total */ + int ple) /* percentile */ +{ + int L, R, I, J, K; + unsigned long long L_weight, R_weight, I_weight, J_weight, + K_weight, N_weight; + + float X, t1; + unsigned long long t2; + + /* Calculate total weight */ + N_weight=0; + + for(I=0; I<N; I++) { + assert(w[I]!=0); + N_weight += w[I]; + } + + /* Find K_weight, the target weight we want */ + K_weight = N_weight * ple / 100; + + /* Set the left and right boundaries of the current search space */ + L=0; + L_weight = 0; + R=N-1; + R_weight = N_weight - w[R]; + + /* Search between L and R, narrowing down until we're done */ + while(L < R) { + /* Chose an ordering value from right in the middle */ + K = (L + R) >> 1; + /* X: The value to order everything higher / lower than */ + X=A[K]; + + /* Starting at the left and the right... */ + I=L; I_weight = L_weight; + J=R; J_weight = R_weight; + + do { + /* Find the first element on the left that is out-of-order w/ X */ + while(A[I]<X) { + I_weight += w[I]; + I++; + } + /* Find the first element on the right that is out-of-order w/ X */ + while(X<A[J]) { + J_weight -= w[J]; + J--; + } + + /* If we actually found something... */ + if(I<=J) { + /* Switch the values */ + t1=A[I]; + A[I]=A[J]; + A[J]=t1; + + t2=w[I]; + w[I]=w[J]; + w[J]=t2; + + /* And move in */ + I_weight += w[I]; + I++; + + J_weight -= w[J]; + J--; + } + } while (I <= J); /* Keep going until our pointers meet or pass */ + + /* Re-adjust L and R, based on which element we're looking for */ + if(J_weight<K_weight) + L=I; L_weight = I_weight; + if(K_weight<I_weight) + R=J; R_weight = J_weight; + } + + return A[L]; +} + +long long self_weighted_percentile(long long * A, + int N, /* total */ + int ple) /* percentile */ +{ + int L, R, I, J, K; + long long L_weight, R_weight, I_weight, J_weight, + K_weight, N_weight; + + long long X, t1; + + /* Calculate total weight */ + N_weight=0; + + for(I=0; I<N; I++) { + if(A[I] < 0) + fprintf(warn, "%s: Value %lld less than zero!\n", + __func__, A[I]); + assert(A[I]!=0); + N_weight += A[I]; + } + + /* Find K_weight, the target weight we want */ + K_weight = N_weight * ple / 100; + + /* Set the left and right boundaries of the current search space */ + L=0; + L_weight = 0; + R=N-1; + R_weight = N_weight - A[R]; + + /* Search between L and R, narrowing down until we're done */ + while(L < R) { + /* Chose an ordering value from right in the middle */ + K = (L + R) >> 1; + /* X: The value to order everything higher / lower than */ + X=A[K]; + + /* Starting at the left and the right... */ + I=L; I_weight = L_weight; + J=R; J_weight = R_weight; + + do { + /* Find the first element on the left that is out-of-order w/ X */ + while(A[I]<X) { + I_weight += A[I]; + I++; + } + /* Find the first element on the right that is out-of-order w/ X */ + while(X<A[J]) { + J_weight -= A[J]; + J--; + } + + /* If we actually found something... */ + if(I<=J) { + /* Switch the values */ + t1=A[I]; + A[I]=A[J]; + A[J]=t1; + + /* And move in */ + I_weight += A[I]; + I++; + + J_weight -= A[J]; + J--; + } + } while (I <= J); /* Keep going until our pointers meet or pass */ + + /* Re-adjust L and R, based on which element we're looking for */ + if(J_weight<K_weight) + L=I; L_weight = I_weight; + if(K_weight<I_weight) + R=J; R_weight = J_weight; + } + + return A[L]; +} + +static inline double __cycles_percent(long long cycles, long long total) { + return (double)(cycles*100) / total; +} + +static inline double __summary_percent(struct event_cycle_summary *s, + struct cycle_framework *f) { + return __cycles_percent(s->cycles, f->total_cycles); +} + +static inline double summary_percent_global(struct event_cycle_summary *s) { + return __summary_percent(s, &P.f); +} + +static inline void update_summary(struct event_cycle_summary *s, long long c) { +/* We don't know ahead of time how many samples there are, and working + * with dynamic stuff is a pain, and unnecessary. This algorithm will + * generate a sample set that approximates an even sample. We can + * then take the percentiles on this, and get an approximate value. */ + if(c) { + if(opt.sample_size) { + int lap = (s->cycles_count/opt.sample_size)+1, + index =s->cycles_count % opt.sample_size; + if((index - (lap/3))%lap == 0) { + if(!s->cycles_sample) { + s->cycles_sample = malloc(sizeof(*s->cycles_sample) * opt.sample_size); + if(!s->cycles_sample) { + fprintf(stderr, "%s: malloc failed!\n", __func__); + error(ERR_SYSTEM, NULL); + } + } + s->cycles_sample[index]=c; + } + } + s->cycles_count++; + s->cycles += c; + + s->interval.count++; + s->interval.cycles += c; + } + s->count++; +} + +static inline void clear_interval_summary(struct event_cycle_summary *s) { + s->interval.count = 0; + s->interval.cycles = 0; +} + +static inline void update_cycles(struct cycle_summary *s, long long c) { +/* We don't know ahead of time how many samples there are, and working + * with dynamic stuff is a pain, and unnecessary. This algorithm will + * generate a sample set that approximates an even sample. We can + * then take the percentiles on this, and get an approximate value. */ + int lap, index; + + if ( c == 0 ) + { + fprintf(warn, "%s: cycles 0! Not updating...\n", + __func__); + return; + } + + if ( opt.sample_size ) { + lap = (s->count/opt.sample_size)+1; + index =s->count % opt.sample_size; + + if((index - (lap/3))%lap == 0) { + if(!s->sample) { + s->sample = malloc(sizeof(*s->sample) * opt.sample_size); + if(!s->sample) { + fprintf(stderr, "%s: malloc failed!\n", __func__); + error(ERR_SYSTEM, NULL); + } + } + s->sample[index] = c; + } + } + + if(c > 0) { + s->cycles += c; + s->interval.cycles += c; + } else { + s->cycles += -c; + s->interval.cycles += -c; + } + s->count++; + s->interval.count++; +} + +static inline void clear_interval_cycles(struct interval_element *e) { + e->cycles = 0; + e->count = 0; + e->instructions = 0; +} + +static inline void update_cpi(struct weighted_cpi_summary *s, + unsigned long long i, + unsigned long long c) { +/* We don't know ahead of time how many samples there are, and working + * with dynamic stuff is a pain, and unnecessary. This algorithm will + * generate a sample set that approximates an even sample. We can + * then take the percentiles on this, and get an approximate value. */ + int lap, index; + + if ( opt.sample_size ) { + lap = (s->count/opt.sample_size)+1; + index =s->count % opt.sample_size; + + if((index - (lap/3))%lap == 0) { + if(!s->cpi) { + assert(!s->cpi_weight); + + s->cpi = malloc(sizeof(*s->cpi) * opt.sample_size); + s->cpi_weight = malloc(sizeof(*s->cpi_weight) * opt.sample_size); + if(!s->cpi || !s->cpi_weight) { + fprintf(stderr, "%s: malloc failed!\n", __func__); + error(ERR_SYSTEM, NULL); + } + } + assert(s->cpi_weight); + + s->cpi[index] = (float) c / i; + s->cpi_weight[index]=c; + } + } + + s->instructions += i; + s->cycles += c; + s->count++; + + s->interval.instructions += i; + s->interval.cycles += c; + s->interval.count++; +} + +static inline void clear_interval_cpi(struct weighted_cpi_summary *s) { + s->interval.cycles = 0; + s->interval.count = 0; + s->interval.instructions = 0; +} + +static inline void print_cpu_affinity(struct cycle_summary *s, char *p) { + if(s->count) { + long long avg; + + avg = s->cycles / s->count; + + if ( opt.sample_size ) { + long long p5, p50, p95; + int data_size = s->count; + if(data_size > opt.sample_size) + data_size = opt.sample_size; + + p50 = percentile(s->sample, data_size, 50); + p5 = percentile(s->sample, data_size, 5); + p95 = percentile(s->sample, data_size, 95); + + printf("%s: %7d %6lld {%6lld|%6lld|%6lld}\n", + p, s->count, avg, p5, p50, p95); + } else { + printf("%s: %7d %6lld\n", + p, s->count, avg); + } + } +} + +static inline void print_cpi_summary(struct weighted_cpi_summary *s) { + if(s->count) { + float avg; + + avg = (float)s->cycles / s->instructions; + + if ( opt.sample_size ) { + float p5, p50, p95; + int data_size = s->count; + + if(data_size > opt.sample_size) + data_size = opt.sample_size; + + p50 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 50); + p5 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 5); + p95 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 95); + + printf(" CPI summary: %2.2f {%2.2f|%2.2f|%2.2f}\n", + avg, p5, p50, p95); + } else { + printf(" CPI summary: %2.2f\n", avg); + } + } +} + +static inline void print_cycle_percent_summary(struct cycle_summary *s, + tsc_t total, char *p) { + if(s->count) { + long long avg; + double percent, seconds; + + avg = s->cycles / s->count; + + seconds = ((double)s->cycles) / opt.cpu_hz; + + percent = ((double)(s->cycles * 100)) / total; + + if ( opt.sample_size ) { + long long p5, p50, p95; + int data_size = s->count; + + if(data_size > opt.sample_size) + data_size = opt.sample_size; + + p50 = self_weighted_percentile(s->sample, data_size, 50); + p5 = self_weighted_percentile(s->sample, data_size, 5); + p95 = self_weighted_percentile(s->sample, data_size, 95); + + printf("%s: %7d %5.2lfs %5.2lf%% %6lld {%6lld|%6lld|%6lld}\n", + p, s->count, + seconds, + percent, + avg, p5, p50, p95); + } else { + printf("%s: %7d %5.2lfs %5.2lf%% %6lld\n", + p, s->count, + seconds, + percent, + avg); + } + } +} + +static inline void print_cycle_summary(struct cycle_summary *s, char *p) { + if(s->count) { + long long avg; + + avg = s->cycles / s->count; + + if ( opt.sample_size ) { + long long p5, p50, p95; + int data_size = s->count; + + if(data_size > opt.sample_size) + data_size = opt.sample_size; + + p50 = self_weighted_percentile(s->sample, data_size, 50); + p5 = self_weighted_percentile(s->sample, data_size, 5); + p95 = self_weighted_percentile(s->sample, data_size, 95); + + printf("%s: %7d %5.2lfs %6lld {%6lld|%6lld|%6lld}\n", + p, s->count, ((double)s->cycles)/opt.cpu_hz, + avg, p5, p50, p95); + } else { + printf("%s: %7d %5.2lfs %6lld\n", + p, s->count, ((double)s->cycles)/opt.cpu_hz, avg); + } + } +} + +#define PRINT_SUMMARY(_s, _p...) \ + do { \ + if((_s).count) { \ + if ( opt.sample_size ) { \ + unsigned long long p5, p50, p95; \ + int data_size=(_s).cycles_count; \ + if(data_size > opt.sample_size) \ + data_size=opt.sample_size; \ + p50=percentile((_s).cycles_sample, data_size, 50); \ + p5=percentile((_s).cycles_sample, data_size, 5); \ + p95=percentile((_s).cycles_sample, data_size, 95); \ + printf(_p); \ + printf(" %7d %5.2lfs %5.2lf%% %5lld cyc {%5lld|%5lld|%5lld}\n", \ + (_s).count, \ + ((double)(_s).cycles)/opt.cpu_hz, \ + summary_percent_global(&(_s)), \ + (_s).cycles_count ? (_s).cycles / (_s).cycles_count:0, \ + p5, p50, p95); \ + } else { \ + printf(_p); \ + printf(" %7d %5.2lfs %5.2lf%% %5lld cyc\n", \ + (_s).count, \ + ((double)(_s).cycles)/opt.cpu_hz, \ + summary_percent_global(&(_s)), \ + (_s).cycles_count ? (_s).cycles / (_s).cycles_count:0); \ + } \ + } \ + } while(0) + +#define INTERVAL_DESC_MAX 31 +struct interval_list { + struct interval_element *elem; + struct interval_list *next; + char desc[INTERVAL_DESC_MAX+1]; /* +1 for the null terminator */ +}; + +void __interval_cycle_percent_output(struct interval_element *e, tsc_t cycles) { + printf(" %.02lf", + __cycles_percent(e->cycles, cycles)); + clear_interval_cycles(e); +} + +void interval_cycle_percent_output(struct interval_element *e) { + __interval_cycle_percent_output(e, opt.interval.cycles); +} + +void interval_time_output(void) { + struct time_struct t; + abs_cycles_to_time(P.interval.start_tsc, &t); + + printf("%u.%09u", t.s, t.ns); +} + +void interval_table_output(void) { + int i; + + interval_time_output(); + + if(opt.interval.mode == INTERVAL_MODE_ARRAY) { + for(i=0; i<P.interval.array.count; i++) { + struct interval_element *e = P.interval.array.values[i]; + if(e) { + interval_cycle_percent_output(e); + } else { + printf(" 0.0"); + } + } + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { + struct interval_list *p; + for(p = P.interval.list.head; p; p = p->next) + interval_cycle_percent_output(p->elem); + } + printf("\n"); +} + +void interval_table_tail(void) { + struct interval_list *p; + + printf("time"); + + for(p=P.interval.list.head; p; p = p->next) + printf(" %s", p->desc); + + printf("\n"); +} + +void interval_table_alloc(int count) { + P.interval.array.count = count; + P.interval.array.values = malloc(count * sizeof(struct interval_list *)); + + if(!P.interval.array.values) { + fprintf(stderr, "Malloc failed!\n"); + error(ERR_SYSTEM, NULL); + } + + bzero(P.interval.array.values, count*sizeof(struct interval_list *)); +} + +void interval_list_add(struct interval_element *e, char *desc) { + struct interval_list *p; + + fprintf(warn, "%s: Adding element '%s'\n", __func__, desc); + + if((p=malloc(sizeof(*p)))==NULL) { + fprintf(stderr, "malloc() failed.\n"); + error(ERR_SYSTEM, NULL); + } + + bzero(p, sizeof(*p)); + + p->elem = e; + strncpy(p->desc, desc, INTERVAL_DESC_MAX); + + p->next=NULL; + + if(P.interval.list.head) + *P.interval.list.tail = p; + else + P.interval.list.head = p; + P.interval.list.tail = &p->next; +} + +void interval_cr3_schedule_time_header(void) { + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { + int i; + + printf("time"); + for(i=0; i<opt.interval.array.count; i++) { + printf(" %llx", opt.interval.array.values[i]); + } + printf("\n"); + } + /* Can't see into the future, so no header if cr3 values are + not specified. */ +} + +void interval_cr3_value_check(struct cr3_value_struct *cr3) { + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { + int i; + + for(i=0; i<opt.interval.array.count; i++) { + if(cr3->gmfn == opt.interval.array.values[i]) { + if(P.interval.array.values[i]) { + fprintf(stderr, "Fatal: duplicate cr3 value %llx!\n", + cr3->gmfn); + error(ERR_ASSERT, NULL); + } + fprintf(stderr, "%s: found gmfn %llx\n", + __func__, cr3->gmfn); + + P.interval.array.values[i] = &cr3->total_time.interval; + } + } + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { + char desc[32]; + snprintf(desc, 32, "%llx", cr3->gmfn); + interval_list_add(&cr3->total_time.interval, desc); + } else { + /* Custom */ + if(cr3->gmfn == opt.interval.array.values[0]) + P.interval.cr3 = cr3; + } +} + +void interval_cr3_schedule_ordered_output(void) { + struct cr3_value_struct *p; + int i; + + struct cr3_value_struct **qsort_array; + int N=0; + + int cr3_time_compare(const void *_a, const void *_b) { + struct cr3_value_struct *a=*(typeof(&a))_a; + struct cr3_value_struct *b=*(typeof(&a))_b; + + if(a->total_time.interval.cycles < b->total_time.interval.cycles) + return 1; + else if(b->total_time.interval.cycles == a->total_time.interval.cycles) { + if(a->total_time.interval.count < b->total_time.interval.count) + return 1; + else if(a->total_time.interval.count == b->total_time.interval.count) + return 0; + else + return -1; + } else + return -1; + } + + for(p=P.cr3.head; p; p=p->gnext) + N++; + + if(!N) + return; + + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); + + for(i=0, p=P.cr3.head; p; p=p->gnext, i++) + qsort_array[i]=p; + + qsort(qsort_array, N, sizeof(struct eip_list_struct *), + cr3_time_compare); + + interval_time_output(); + + for(i=0; i<N; i++) { + p = qsort_array[i]; + /* Rounding down means this will get ..1]% */ + if(p->total_time.interval.cycles > 0) { + printf(" %8llx: %.02lf %c\n", + p->gmfn, + __cycles_percent(p->total_time.interval.cycles, + opt.interval.cycles), + (p->first_time > P.interval.start_tsc)?'*':' '); + } + clear_interval_cycles(&p->total_time.interval); + } + + free(qsort_array); +} + +void interval_cr3_short_summary_header(void) { + int i; + + printf("time guest"); + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + printf(" %s", hvm_short_summary_name[i]); + printf("\n"); +} + +void interval_cr3_short_summary_output(void) { + struct cycle_summary *hss_array; + int i; + + if(P.interval.cr3) { + struct cr3_value_struct *p = P.interval.cr3; + + interval_time_output(); + + hss_array = p->hvm.s; + + printf(" %.02lf", + __cycles_percent(p->total_time.interval.cycles, + opt.interval.cycles)); + + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + __interval_cycle_percent_output(&hss_array[i].interval, + p->total_time.interval.cycles); + + clear_interval_cycles(&p->total_time.interval); + + printf("\n"); + } +} + +void interval_domain_value_check(struct domain_data *d) { + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { + int i; + + for(i=0; i<opt.interval.array.count; i++) { + if(d->did == opt.interval.array.values[i]) { + if(P.interval.array.values[i]) { + fprintf(stderr, "Fatal: duplicate domain value %d!\n", + d->did); + error(ERR_ASSERT, NULL); + } + + P.interval.array.values[i] = &d->total_time.interval; + } + } + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { + char desc[32]; + snprintf(desc, 32, "%d", d->did); + interval_list_add(&d->total_time.interval, desc); + } else { + if(d->did == opt.interval.array.values[0]) + P.interval.domain.d = d; + } +} + +void interval_domain_short_summary_header(void) { + int i; + + printf("time running"); + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + printf(" %s", hvm_short_summary_name[i]); + printf("\n"); +} + +void interval_domain_short_summary_output(void) { + + if(P.interval.domain.d) { + struct domain_data *d; + int i; + + d=P.interval.domain.d; + + interval_time_output(); + + interval_cycle_percent_output(&d->total_time.interval); + + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + interval_cycle_percent_output(&d->hvm_short.s[i].interval); + + printf("\n"); + } +} + +void interval_domain_guest_interrupt(struct hvm_data *h, int vector) { + struct domain_data *d = h->v->d; + int i; + + /* Check to see if this vector is in the "print list" */ + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { + if(P.interval.domain.guest_vector[i] == 0) { + P.interval.domain.guest_vector[i] = vector; + break; + } + if(P.interval.domain.guest_vector[i] == vector) + break; + } + + if(i == INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX) { + fprintf(stderr, "FATAL: used up all %d guest interrupt slots!\n", + INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX); + error(ERR_LIMIT, NULL); + } else { + d->guest_interrupt[vector]++; + } +} + +void interval_domain_guest_interrupt_tail(void) { + int i; + + printf("time running"); + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { + if(P.interval.domain.guest_vector[i] == 0) + break; + printf(" %d", P.interval.domain.guest_vector[i]); + } + printf("\n"); +} + +void interval_domain_guest_interrupt_output(void) { + + if(P.interval.domain.d) { + struct domain_data *d; + int i; + + d=P.interval.domain.d; + + interval_time_output(); + + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { + int v = P.interval.domain.guest_vector[i]; + + if(v == 0) + break; + + printf(" %d", d->guest_interrupt[v]); + + d->guest_interrupt[v]=0; + } + + printf("\n"); + } + +} + +void interval_domain_grant_maps_output(void) { + + if(P.interval.domain.d) { + struct domain_data *d; + + d=P.interval.domain.d; + + interval_time_output(); + + printf(" %d", d->memops.done_for_interval[MEM_PAGE_GRANT_MAP]); + + d->memops.done_for_interval[MEM_PAGE_GRANT_MAP] = 0; + + printf("\n"); + } +} + +/* General interval gateways */ + +void interval_callback(void) { + /* First, see if we're in generic mode. */ + switch(opt.interval.mode) { + case INTERVAL_MODE_LIST: + case INTERVAL_MODE_ARRAY: + interval_table_output(); + return; + default: + break; + } + + switch(opt.interval.output) { + case INTERVAL_CR3_SCHEDULE_ORDERED: + interval_cr3_schedule_ordered_output(); + break; + case INTERVAL_CR3_SHORT_SUMMARY: + interval_cr3_short_summary_output(); + break; + case INTERVAL_DOMAIN_SHORT_SUMMARY: + interval_domain_short_summary_output(); + break; + case INTERVAL_DOMAIN_GUEST_INTERRUPT: + interval_domain_guest_interrupt_output(); + break; + case INTERVAL_DOMAIN_GRANT_MAPS: + interval_domain_grant_maps_output(); + break; + default: + break; + } +} + +void interval_header(void) { + switch(opt.interval.output) { + case INTERVAL_CR3_SHORT_SUMMARY: + interval_cr3_short_summary_header(); + break; + case INTERVAL_DOMAIN_SHORT_SUMMARY: + interval_domain_short_summary_header(); + break; + default: + break; + } +} + +void interval_tail(void) { + if(opt.interval.mode == INTERVAL_MODE_LIST) { + interval_table_tail(); + return; + } + + switch(opt.interval.output) { + case INTERVAL_DOMAIN_GUEST_INTERRUPT: + interval_domain_guest_interrupt_tail(); + break; + default: + break; + } +} + +/* -- Eip list data -- */ + +void update_eip(struct eip_list_struct **head, unsigned long long eip, + unsigned long long cycles, int type, void * extra) { + struct eip_list_struct *p, **last=head; + + for(p=*head; p; last = (&p->next), p=p->next) + if(p->eip >= eip) + break; + + if(!p || p->eip != eip) { + p=malloc(sizeof(*p)); + if(!p) { + perror("malloc failed"); + error(ERR_SYSTEM, NULL); + } + + bzero(p, sizeof(*p)); + + p->eip=eip; + p->type = type; + + if(eip_list_type[type].new) { + eip_list_type[type].new(p, extra); + } + p->next = *last; + *last=p; + } else if(p->type != type) { + fprintf(stderr, "WARNING, mixed types! %d %d\n", p->type, type); + } else if(eip_list_type[type].update) { + eip_list_type[type].update(p, extra); + } + + update_summary(&p->summary, cycles); +} + +void dump_eip(struct eip_list_struct *head) { + struct eip_list_struct *p; + int i; + int total = 0; + + struct eip_list_struct **qsort_array; + int N=0; + + int eip_compare(const void *_a, const void *_b) { + struct eip_list_struct *a=*(typeof(&a))_a; + struct eip_list_struct *b=*(typeof(&a))_b; + + if(a->summary.cycles < b->summary.cycles) + return 1; + else if(b->summary.cycles == a->summary.cycles) { + if(a->summary.count < b->summary.count) + return 1; + else if(a->summary.count == b->summary.count) + return 0; + else + return -1; + } else + return -1; + } + + for(p=head; p; p=p->next) + { + total += p->summary.count; + N++; + } + + if(!N) + return; + + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); + + for(i=0, p=head; p; p=p->next, i++) + qsort_array[i]=p; + + qsort(qsort_array, N, sizeof(struct eip_list_struct *), + eip_compare); + + /* WARNING: don't use N after this point unless you copy this variable */ +#if 0 + if(opt.summary_eip_limit && opt.summary_eip_limit < N) + N=opt.summary_eip_limit; +#endif + + printf(" Total samples: %d\n", total); + + for(i=0; i<N; i++) { + p = qsort_array[i]; + if ( p->summary.cycles ) + PRINT_SUMMARY(p->summary, " %12llx%-45s: ", + p->eip, + find_symbol(p->eip)); + else + { + printf(" %12llx%-45s: ", + p->eip, + find_symbol(p->eip)); + printf(" %7d %5.2lf%%\n", + p->summary.count, + ((double)p->summary.count*100)/total); + } + + + if(eip_list_type[p->type].dump) { + eip_list_type[p->type].dump(p); + } + } + + free(qsort_array); +} + +/* -- HVM code -- */ +struct hvm_pf_xen_record { + //unsigned vcpu:16, domain:16; + union { + struct { + unsigned long long va; + unsigned int error_code; + } x64; + struct { + unsigned int va; + unsigned int error_code; + } x32; + }; +}; + +void hvm_update_short_summary(struct hvm_data *h, int element) { + struct vcpu_data *v = h->v; + + if(v->cr3.data) + update_cycles(&v->cr3.data->hvm.s[element], h->arc_cycles); + + update_cycles(&v->d->hvm_short.s[element], h->arc_cycles); + + h->short_summary_done=1; +} + +void hvm_short_summary(struct hvm_short_summary_struct *hss, + tsc_t total, char *prefix) { + char desc[80]; + int i; + + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) { + snprintf(desc, 80, "%s%s", prefix, hvm_short_summary_name[i]); + print_cycle_percent_summary(hss->s + i, total, desc); + } +} + +/* Wrapper to try to make sure this is only called once per + * call site, rather than walking through the list each time */ +#define hvm_set_summary_handler(_h, _s, _d) \ + do { \ + static int done=0; \ + int ret; \ + if(!done) { \ + if ((ret=__hvm_set_summary_handler(_h, _s, _d))) \ + fprintf(stderr, "%s: hvm_set_summary_handler returned %d\n", \ + __func__, ret); \ + done=1; \ + } \ + } while(0) + +int __hvm_set_summary_handler(struct hvm_data *h, void (*s)(struct hvm_data *h, void*d), void*d) { + /* Set summary handler */ + if(h->exit_reason < h->exit_reason_max) + { + struct hvm_summary_handler_node *p, **q; + + /* Find the end of the list, checking to make sure there are no + * duplicates along the way */ + q=&h->exit_reason_summary_handler_list[h->exit_reason]; + p = *q; + while(p) + { + if(p->handler == s && p->data == d) + { + fprintf(stderr, "%s: Unexpected duplicate handler %p,%p\n", + __func__, s, d); + error(ERR_STRICT, NULL); + return -EBUSY; + } + q=&p->next; + p=*q; + } + + assert(p==NULL); + + /* Insert the new handler */ + p=malloc(sizeof(*p)); + if (!p) { + fprintf(stderr, "%s: Malloc failed!\n", __func__); + error(ERR_SYSTEM, NULL); + } + p->handler=s; + p->data = d; + p->next=*q; + *q=p; + return 0; + } + return -EINVAL; +} + +void hvm_generic_postprocess(struct hvm_data *h); + +static int hvm_set_postprocess(struct hvm_data *h, void (*s)(struct hvm_data *h)) +{ + if ( h->post_process == NULL + || h->post_process == hvm_generic_postprocess ) + { + h->post_process = s; + return 0; + } + else + return 1; +} + +#define SIGN_EXTENDED_BITS (~((1ULL<<48)-1)) +#define HIGH_BIT(_v) ((_v) & (1ULL<<47)) +static inline int is_valid_addr64(unsigned long long va) +{ + if(HIGH_BIT(va)) + return ((va & SIGN_EXTENDED_BITS) == SIGN_EXTENDED_BITS); + else + return ((va & SIGN_EXTENDED_BITS) == 0); +} + +void hvm_pf_xen_summary(struct hvm_data *h, void *d) { + int i,j, k; + + printf(" page_fault\n"); + for(i=0; i<PF_XEN_MAX; i++) + { + if( pf_xen_name[i] ) + { + PRINT_SUMMARY(h->summary.pf_xen[i], + " %-25s ", pf_xen_name[i]); + } + else + { + PRINT_SUMMARY(h->summary.pf_xen[i], + " [%23d] ", i); + } + switch(i){ + case PF_XEN_NON_EMULATE: + for(j=0; j<PF_XEN_NON_EMUL_MAX; j++) + PRINT_SUMMARY(h->summary.pf_xen_non_emul[j], + " *%-13s ", pf_xen_non_emul_name[j]); + break; + case PF_XEN_EMULATE: + for(j=0; j<PF_XEN_EMUL_MAX; j++) { + PRINT_SUMMARY(h->summary.pf_xen_emul[j], + " *%-13s ", pf_xen_emul_name[j]); + if(j == PF_XEN_EMUL_EARLY_UNSHADOW) { + int k; + for(k=0; k<5; k++) { + PRINT_SUMMARY(h->summary.pf_xen_emul_early_unshadow[k], + " +[%d] ", k); + } + } + } + break; + case PF_XEN_FIXUP: + for(j=0; j<PF_XEN_FIXUP_MAX; j++) { + PRINT_SUMMARY(h->summary.pf_xen_fixup[j], + " *%-13s ", pf_xen_fixup_name[j]); + if(j == PF_XEN_FIXUP_UNSYNC ) { + for(k=0; k<PF_XEN_FIXUP_UNSYNC_RESYNC_MAX; k++) { + PRINT_SUMMARY(h->summary.pf_xen_fixup_unsync_resync[k], + " +[%3d] ", k); + } + PRINT_SUMMARY(h->summary.pf_xen_fixup_unsync_resync[k], + " +[max] "); + } + } + break; + } + } +} + +void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) +{ + switch(guest_paging_levels) { + /* Select a subfield of _bits bits starting at bit _shift from _x */ +#define _SUBFIELD(_bits, _shift, _x) \ + (((_x)>>(_shift)) & ((1ULL<<(_bits))-1)) + case 4: + /* Verify sign-extension */ + if((HIGH_BIT(e->va) + &&((e->va & SIGN_EXTENDED_BITS) != SIGN_EXTENDED_BITS)) + || (!HIGH_BIT(e->va) + && ((e->va & SIGN_EXTENDED_BITS) != 0))) { + fprintf(warn, "Strange, va %llx not properly sign extended for 4-level pagetables\n", + e->va); + } + e->pt_index[4]=_SUBFIELD(9,39,e->va); + e->pt_index[3]=_SUBFIELD(9,30,e->va); + e->pt_index[2]=_SUBFIELD(9,21,e->va); + e->pt_index[1]=_SUBFIELD(9,12,e->va); + /* These are only useful for the linear-pagetable code */ + e->pt_index[0]=_SUBFIELD(9,3,e->va); + if(e->va & 0x4) + e->pt_is_lo=0; + break; + case 3: + e->pt_index[3]=_SUBFIELD(2,30,e->va); + e->pt_index[2]=_SUBFIELD(9,21,e->va); + e->pt_index[1]=_SUBFIELD(9,12,e->va); + /* These are only useful for the linear-pagetable code */ + e->pt_index[0]=_SUBFIELD(9,3,e->va); + if(e->va & 0x4) + e->pt_is_lo=0; + break; + case 2: + e->pt_index[2]=_SUBFIELD(10,22,e->va); + e->pt_index[1]=_SUBFIELD(10,12,e->va); + /* This is only useful for the linear pagetable code */ + e->pt_index[0]=_SUBFIELD(10,2,e->va); + break; + case 0: + break; + default: + fprintf(warn, "Don't know how to handle %d-level pagetables\n", + guest_paging_levels); + } + + e->corresponding_va = CORR_VA_INVALID; + e->pt_level = 0; + + /* Detect accesses to Windows linear pagetables */ + switch(guest_paging_levels) + { + case 2: + if(e->pt_index[2] == 768) { + if(e->pt_index[1] == 768) + { + e->pt_level = 2; + e->corresponding_va=((1UL<<22)-1) + | e->pt_index[0]<<22; + } + else + { + e->pt_level = 1; + e->corresponding_va = ((1UL<<12)-1) + | e->pt_index[1]<<22 + | e->pt_index[0]<<12; + } + } + break; + case 3: + if(e->pt_index[3]==3 && (e->pt_index[2]>>2==0)) + { + if(e->pt_index[2]==3 && e->pt_index[1]>>2==0) + { + if(e->pt_index[1] == 3 && e->pt_index[0]>>2==0) + { + e->pt_level = 3; + e->corresponding_va=((1UL<<30)-1) + | e->pt_index[0]<<30; + } + else + { + e->pt_level = 2; + e->corresponding_va=((1UL<<21)-1) + | e->pt_index[1]<<30 + | e->pt_index[2]<<21; + } + } + else + { + e->pt_level = 1; + e->corresponding_va = ((1UL<<12)-1) + | e->pt_index[0]<<12 + | e->pt_index[1]<<21 + | e->pt_index[2]<<30; + } + } + break; + case 4: + if(e->pt_index[4] == 0x1ed) + { + if(e->pt_index[3] == 0x1ed) + { + if(e->pt_index[2] == 0x1ed) + { + if(e->pt_index[1] == 0x1ed) + { + e->pt_level = 4; + e->corresponding_va = ((1ULL<<39)-1) + | (unsigned long long)e->pt_index[0]<<39; + } + else + { + e->pt_level = 3; + e->corresponding_va = ((1ULL<<30)-1) + | (unsigned long long)e->pt_index[0]<<30 + | (unsigned long long)e->pt_index[1]<<39; + } + } + else + { + e->pt_level = 2; + e->corresponding_va = ((1ULL<<21)-1) + | (unsigned long long)e->pt_index[0]<<21 + | (unsigned long long)e->pt_index[1]<<30 + | (unsigned long long)e->pt_index[2]<<39; + } + } + else + { + e->pt_level = 1; + e->corresponding_va = ((1ULL<<12)-1) + | (unsigned long long)e->pt_index[0]<<12 + | (unsigned long long)e->pt_index[1]<<21 + | (unsigned long long)e->pt_index[2]<<30 + | (unsigned long long)e->pt_index[3]<<39; + } + + if(HIGH_BIT(e->corresponding_va)) + e->corresponding_va |= SIGN_EXTENDED_BITS; + } + break; + default: + break; + } +} + +void hvm_pf_xen_preprocess(unsigned event, struct hvm_data *h) { + struct pf_xen_extra *e = &h->inflight.pf_xen; + struct mmio_info *m = &h->inflight.mmio; + struct hvm_pf_xen_record *r = (typeof(r))h->d; + + if(event == TRC_HVM_PF_XEN64) + { + if(!is_valid_addr64(r->x64.va)) + fprintf(warn, "%s: invalid va %llx", + __func__, r->x64.va); + e->va = r->x64.va; + e->error_code = r->x64.error_code; + } + else + { + e->va = r->x32.va; + e->error_code = r->x32.error_code; + } + + if(m->data_valid) + e->pf_case = PF_XEN_MMIO; + else + { + pf_preprocess(e, h->v->guest_paging_levels); + + /* On rio traces, we try to infer emulation by looking for accesses + in the linear pagetable */ + if(e->pt_level > 0) + e->pf_case = PF_XEN_EMULATE; + else + e->pf_case = PF_XEN_NON_EMULATE; + } +} + +static inline int is_kernel(int paging_levels, unsigned long long va) { + switch(paging_levels) { + case 2: + case 3: + if(va & 0x80000000) + return 1; + else + return 0; + break; + case 4: + if(HIGH_BIT(va)) + return 1; + else return 0; + default: + return 0; + } + +} + +void hvm_pf_xen_postprocess(struct hvm_data *h) { + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if(opt.summary_info) { + if(e->pf_case) + update_summary(&h->summary.pf_xen[e->pf_case], + h->arc_cycles); + else + fprintf(warn, "Strange, pf_case 0!\n"); + switch(e->pf_case) + { + case PF_XEN_EMULATE: + update_eip(&h->v->d->emulate_eip_list, + h->rip, + h->arc_cycles, + 0, NULL); + break; + case PF_XEN_NON_EMULATE: + if(is_kernel(h->v->guest_paging_levels, h->rip)) + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_EIP_KERNEL], + h->arc_cycles); + else + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_EIP_USER], + h->arc_cycles); + if(is_kernel(h->v->guest_paging_levels, e->va)) + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_VA_KERNEL], + h->arc_cycles); + + else + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_VA_USER], + h->arc_cycles); + } + + /* Set summary handler */ + hvm_set_summary_handler(h, hvm_pf_xen_summary, NULL); + } +} + +void hvm_pf_xen_process(struct record_info *ri, struct hvm_data *h) { + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if(ri->event == TRC_HVM_PF_XEN64 + && h->v->guest_paging_levels != 4) + fprintf(warn, "Strange, PF_XEN64 but guest_paging_levels %d!\n", + h->v->guest_paging_levels); + else if(ri->event == TRC_HVM_PF_XEN + && h->v->guest_paging_levels == 4) + fprintf(warn, "Strange, PF_XEN but guest_paging_levels %d!\n", + h->v->guest_paging_levels); + + hvm_pf_xen_preprocess(ri->event, h); + + if(opt.dump_all) + { + if(e->pf_case == PF_XEN_EMULATE) + printf("]%s pf_xen:emulate va %llx ec %x level %d corr %llx e->pt_index[%d %d %d %d %d]\n", + ri->dump_header, e->va, e->error_code, + e->pt_level, e->corresponding_va, + e->pt_index[0], e->pt_index[1], e->pt_index[2], + e->pt_index[3], + e->pt_index[4]); + else + printf("]%s pf_xen va %llx ec %x e->pt_index[%d %d %d %d %d]\n", + ri->dump_header, e->va, e->error_code, + e->pt_index[0], e->pt_index[1], e->pt_index[2], + e->pt_index[3], + e->pt_index[4]); + } + + if ( hvm_set_postprocess(h, hvm_pf_xen_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +char * hvm_vlapic_icr_dest_shorthand_name[4] = { + "dest_field", "self", "all-inc", "all-exc" +}; + +void hvm_vlapic_vmentry_cleanup(struct vcpu_data *v, tsc_t tsc) +{ + int i; + + struct vlapic_struct *vla = &v->vlapic; + + for(i=0; i<MAX_VLAPIC_LIST; i++) + { + unsigned long long lat=0; + struct outstanding_ipi *o = vla->outstanding.list + i; + + if(!(o->valid && o->injected)) + continue; + + if(tsc >= o->first_tsc) + lat = tsc - o->first_tsc; + else + fprintf(warn, "Strange, vec %d first_tsc %lld > ri->tsc %lld!\n", + o->vec, o->first_tsc, tsc); + + if(opt.dump_ipi_latency + || (opt.dump_all && o->count > 1)) { + struct time_struct t; + cycles_to_time(lat, &t); + printf(" [vla] d%dv%d vec %d ipis %d, latency %lld (%u.%09u s)\n", + v->d->did, v->vid, o->vec, o->count, lat, + t.s, t.ns); + } + +#if 0 + /* FIXME: make general somehow */ + if(opt.summary_info) + { + update_summary(&h->summary.ipi_latency, lat); + h->summary.ipi_count[vla->outstanding_ipis]++; + } +#endif + + o->vec = o->count = o->injected = o->valid = o->first_tsc = 0; + } +} + +void hvm_vlapic_clear(struct vlapic_struct *vla) +{ + bzero(vla, sizeof(*vla)); +} + +struct outstanding_ipi *find_vec(struct vlapic_struct *vla, int vec) +{ + struct outstanding_ipi *o = NULL; + int i; + + /* Find the entry for this vector, or the first empty one. */ + for(i=0; i<MAX_VLAPIC_LIST; i++) + { + if(vla->outstanding.list[i].valid && vla->outstanding.list[i].vec == vec) + { + o = vla->outstanding.list + i; + break; + } else if(!vla->outstanding.list[i].valid && !o) + o = vla->outstanding.list + i; + } + + if(!o->valid) { + o->vec = vec; + o->valid = 1; + } + + return o; +} + +void hvm_vlapic_icr_handler(struct hvm_data *h) +{ + struct mmio_info *m = &h->inflight.mmio; + union { + unsigned int val; + struct { + unsigned vec:8, + delivery_mode:3, + dest_mode:1, + delivery_status:1, + _res1:1, + level:1, + trigger:1, + _res2:2, + dest_shorthand:2; + }; + } icr = { .val = m->data }; + + void ipi_send(struct vcpu_data *ov, int vec) + { + struct vlapic_struct *vla; + struct outstanding_ipi *o = NULL; + + if(ov->runstate.state == RUNSTATE_LOST) { + if(opt.dump_all) + fprintf(warn, "%s: v%d in state RUNSTATE_LOST, not counting ipi\n", + __func__, ov->vid); + return; + } + + vla = &ov->vlapic; + + o = find_vec(vla, vec); + + if(!o) + { + fprintf(warn, "%s: Couldn't find an open slot!\n", + __func__); + return; + } + + if(!o->first_tsc) + o->first_tsc = P.now; + + if(opt.dump_all && o->count == 0 && o->injected) + printf(" [vla] Pre-injection\n"); + + o->count++; + + if((opt.dump_all) +#if 0 + && (ov->runstate.state != RUNSTATE_RUNNING + || ov->hvm.vmexit_valid) +#endif + ) + printf(" [vla] d%dv%d vec %d state %s (outstanding ipis %d)\n", + ov->d->did, ov->vid, + o->vec, + runstate_name[ov->runstate.state], + o->count); + } + + if(m->is_write) { + if(opt.dump_all) { + printf(" [vla] d%dv%d icr vec %d %s\n", + h->v->d->did, h->v->vid, + icr.vec, + hvm_vlapic_icr_dest_shorthand_name[icr.dest_shorthand]); + } + + if(icr.dest_shorthand == 3) + { + struct vcpu_data *ov, *v = h->v; + struct domain_data *d = v->d; + int i; + + for(i=0; i<MAX_CPUS; i++) + { + ov = d->vcpu[i]; + if(!ov || ov == v) + continue; + + ipi_send(ov, icr.vec); + + } + } else if(icr.dest_shorthand != 1) { +#if 0 + fprintf(warn, "Strange, vlapic icr %s vec %d!\n", + hvm_vlapic_icr_dest_shorthand_name[icr.dest_shorthand], + icr.vec); +#endif + } + } else { + /* Read */ + if(opt.dump_all) { + printf(" [vla] d%dv%d icr status %s\n", + h->v->d->did, h->v->vid, + icr.delivery_status?"pending":"idle"); + } + } + +} + +void hvm_vlapic_inject(struct vcpu_data *v, int vec) +{ + struct vlapic_struct *vla = &v->vlapic; + struct outstanding_ipi *o = NULL; + + o = find_vec(vla, vec); + + if(o) { + if(opt.dump_all) + printf(" [vla] d%dv%d vec %d injecting\n", + v->d->did, v->vid, vec); + o->injected=1; + } else { + fprintf(stderr, "%s: Couldn't find an open ipi slot!\n", + __func__); + } +} + +void hvm_vlapic_eoi_handler(struct hvm_data *h) { + if(opt.dump_all) + printf(" [vla] d%dv%d eoi\n", + h->v->d->did, h->v->vid); +} + +void hvm_vlapic_handler(struct hvm_data *h) +{ + struct mmio_info *m = &h->inflight.mmio; + + switch(m->gpa) { + case 0xfee00300: + hvm_vlapic_icr_handler(h); + break; + case 0xfee000b0: + hvm_vlapic_eoi_handler(h); + break; + } + +} + +/* Also called by shadow_mmio_postprocess */ +#define MMIO_VGA_START (0xa0000) +#define MMIO_VGA_END (0xbffff) +void enumerate_mmio(struct hvm_data *h) +{ + struct mmio_info *m = &h->inflight.mmio; + + /* Skip vga area */ + if ( opt.mmio_enumeration_skip_vga + && m->gpa >= MMIO_VGA_START + && m->gpa < MMIO_VGA_END) + { + warn_once("WARNING: Not enumerationg MMIO in VGA range. Use --mmio-enumeration-skip-vga=0 to override.\n"); + return; + } + + if ( m->data_valid ) + update_io_address(&h->summary.io.mmio, m->gpa, m->is_write, h->arc_cycles, m->va); +} + +void hvm_mmio_summary(struct hvm_data *h, void *data) +{ + long reason=(long)data; + + PRINT_SUMMARY(h->summary.mmio[reason], + " mmio "); +} + +void hvm_mmio_assist_postprocess(struct hvm_data *h) +{ + long reason; + + switch(h->exit_reason) + { + case VMEXIT_NPF: + case EXIT_REASON_EPT_VIOLATION: + reason=NONPF_MMIO_NPF; + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); + break; + case EXIT_REASON_APIC_ACCESS: + reason=NONPF_MMIO_APIC; + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); + break; + default: + { + static int warned = 0; + if (!warned) + { + fprintf(stderr, "%s: Strange, MMIO with unexpected exit reason %d\n", + __func__, h->exit_reason); + warned=1; + } + reason=NONPF_MMIO_UNKNOWN; + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); + break; + } + } + + if(opt.summary_info) + { + update_summary(&h->summary.mmio[reason], + h->arc_cycles); + } + + if ( opt.with_mmio_enumeration ) + enumerate_mmio(h); +} + +#define HVM_IO_ASSIST_WRITE 0x200 +void hvm_mmio_assist_process(struct record_info *ri, struct hvm_data *h) +{ + struct mmio_info *m = &h->inflight.mmio; + union { + struct { + unsigned int gpa; + unsigned int data; + } x32; + struct { + unsigned long long gpa; + unsigned int data; + } x64; + } *r = (typeof(r))h->d; + + union { + unsigned event; + struct { + unsigned minor:8, + x64:1, + write:2; + }; + } mevt = { .event = ri->event }; + + if(mevt.x64) { + m->gpa = r->x64.gpa; + m->data = r->x64.data; + if(ri->extra_words*(sizeof(unsigned int))==sizeof(r->x64)) + m->data_valid=1; + } else { + m->gpa = r->x32.gpa; + m->data = r->x32.data; + if(ri->extra_words*(sizeof(unsigned int))==sizeof(r->x32)) + m->data_valid=1; + } + + m->is_write = mevt.write; + + if(opt.dump_all) + { + if(m->data_valid) + printf("]%s mmio_assist %c gpa %llx data %x\n", + ri->dump_header, + mevt.write?'w':'r', + m->gpa, m->data); + else + printf("]%s mmio_assist %c gpa %llx (no data)\n", ri->dump_header, + mevt.write?'w':'r', m->gpa); + } + + if((m->gpa & 0xfffff000) == 0xfee00000) + hvm_vlapic_handler(h); + + /* Catch MMIOs that don't go through the shadow code; tolerate + * failures to set (probably shadow_mmio) */ + hvm_set_postprocess(h, hvm_mmio_assist_postprocess); +} + +void hvm_inj_virq_process(struct record_info *ri, struct hvm_data *h) { + struct { + int vector, fake; + } *r = (typeof(r))h->d; + + if(opt.dump_all) { + printf(" %s inj_virq vec %u %s\n", + ri->dump_header, + r->vector, r->fake?"fake":"real"); + } + + if(opt.summary_info) + { + int vector = r->vector; + + if(vector >= GUEST_INTERRUPT_MAX) + vector = GUEST_INTERRUPT_MAX; + h->summary.guest_interrupt[vector].count++; + + if(opt.interval.output == INTERVAL_DOMAIN_GUEST_INTERRUPT) + interval_domain_guest_interrupt(h, vector); + } + + /* If we're waking, make this the wake vector */ + if(r->vector < GUEST_INTERRUPT_MAX ) { + int vector = r->vector; + if ( h->w2h.waking && h->w2h.vector == 0 ) { + if(h->summary.guest_interrupt[vector].start_tsc) { + fprintf(warn, "Strange, d%dv%d waking && wake_vector 0 but vec %d start_tsc %lld!\n", + h->v->d->did, h->v->vid, + vector, + h->summary.guest_interrupt[vector].start_tsc); + error(ERR_WARN, NULL); + } + if(h->w2h.interrupts) + fprintf(warn, "Strange, waking && wake_vector 0 but interrupts_this_wait_to_halt %d!\n", + h->w2h.interrupts); + + if(opt.dump_all) + printf(" [w2h] d%dv%d Setting wake_vector %d\n", + h->v->d->did, h->v->vid, vector); + + /* In svm mode, vector information is invalid */ + if ( opt.svm_mode && r->fake ) + h->w2h.vector = FAKE_VECTOR; + else + h->w2h.vector = vector; + h->summary.guest_interrupt[vector].is_wake = 1; + } + + if( h->summary.guest_interrupt[vector].start_tsc == 0 ) { + /* Note that we want start_tsc set at the next vmentry */ + h->summary.guest_interrupt[vector].start_tsc = 1; + h->w2h.interrupts_wanting_tsc++; + h->w2h.interrupts++; + + if(opt.dump_all) + printf(" [w2h] d%dv%d Starting vec %d\n", + h->v->d->did, h->v->vid, vector); + } + } + + hvm_vlapic_inject(h->v, r->vector); +} + +/* I/O Handling */ +struct io_address { + struct io_address *next; + unsigned int pa; + unsigned int va; + struct event_cycle_summary summary[2]; +}; + +void update_io_address(struct io_address ** list, unsigned int pa, int dir, + tsc_t arc_cycles, unsigned int va) { + struct io_address *p, *q=NULL; + + /* Keep list in order */ + for(p=*list; p && (p->pa != pa) && (p->pa < pa); q=p, p=p->next); + + /* If we didn't find it, make a new element. */ + if(!p || (p->pa != pa)) { + if((p=malloc(sizeof(*p)))==NULL) { + fprintf(stderr, "malloc() failed.\n"); + error(ERR_SYSTEM, NULL); + } + + bzero(p, sizeof(*p)); + + p->pa=pa; + p->va=va; + + /* If we stopped in the middle or at the end, add it in */ + if(q) { + p->next=q->next; + q->next=p; + } else { + /* Otherwise, we stopped after the first element; put it at the beginning */ + p->next = *list; + *list = p; + } + } + update_summary(&p->summary[dir], arc_cycles); +} + +void hvm_io_address_summary(struct io_address *list, char * s) { + if(!list) + return; + + printf("%s\n", s); + + for(; list; list=list->next) { + if ( list->va ) + { + PRINT_SUMMARY(list->summary[0], "%8x@%8x:[r] ", list->pa, list->va); + PRINT_SUMMARY(list->summary[1], "%8x@%8x:[w] ", list->pa, list->va); + } + else + { + PRINT_SUMMARY(list->summary[0], "%8x:[r] ", list->pa); + PRINT_SUMMARY(list->summary[1], "%8x:[w] ", list->pa); + } + } +} + +void hvm_io_write_postprocess(struct hvm_data *h) +{ + if(opt.with_pio_enumeration) + update_io_address(&h->summary.io.pio, h->inflight.io.port, 1, h->arc_cycles, 0); +} + +void hvm_io_read_postprocess(struct hvm_data *h) +{ + if(opt.with_pio_enumeration) + update_io_address(&h->summary.io.pio, h->inflight.io.port, 0, h->arc_cycles, 0); + if(opt.scatterplot_io && h->inflight.io.port == opt.scatterplot_io_port) + scatterplot_vs_time(h->exit_tsc, P.now - h->exit_tsc); +} + +void hvm_io_assist_process(struct record_info *ri, struct hvm_data *h) +{ + union { + struct { + unsigned int port; + unsigned int data; + } x32; + } *r = (typeof(r))h->d; + + union { + unsigned event; + struct { + unsigned minor:8, + x64:1, + write:2; + }; + } mevt = { .event = ri->event }; + + if(mevt.x64) { + fprintf(stderr, "FATAL: Unexpected 64-bit PIO\n"); + error(ERR_RECORD, ri); + return; + } + + h->inflight.io.port = r->x32.port; + h->inflight.io.val = r->x32.data; + + if(mevt.write) { + h->inflight.io.is_write = 1; + if ( hvm_set_postprocess(h, hvm_io_write_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); + } else { + h->inflight.io.is_write = 0; + if ( hvm_set_postprocess(h, hvm_io_read_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); + } + + if(opt.dump_all) + { + printf(" %s io %s port %x val %x\n", + ri->dump_header, + mevt.write?"write":"read", + r->x32.port, + r->x32.data); + } +} + +/* cr_write */ +/* CR3 list */ +void cr3_switch(unsigned long long val, struct hvm_data *h) { + struct vcpu_data *v = h->v; + /* Really only need absolute tsc here. Later change to global time. */ + unsigned long long now = P.now; + unsigned long long gmfn = val >> 12; + + if ( !h->init ) + return; + + if(opt.with_cr3_enumeration) { + if(v->cr3.data) { + struct cr3_value_struct *cur = v->cr3.data; + unsigned long long cycles = now - v->cr3.start_time; + + if(opt.summary_info) + update_cycles(&cur->total_time, cycles); + + cur->last_time = now; + } + + if(gmfn) { + struct cr3_value_struct *p, **last=&v->d->cr3_value_head; + + /* Always add to tail, so that we get consistent interval + ouptut as the number of cr3s grow */ + for(p=*last; p; last = (&p->next), p=p->next) + if(p->gmfn == gmfn) + break; + + if(!p) { + if((p=malloc(sizeof(*p)))==NULL) { + fprintf(stderr, "malloc() failed.\n"); + error(ERR_SYSTEM, NULL); + } + + bzero(p, sizeof(*p)); + + p->gmfn = gmfn; + p->cr3_id = P.cr3.id; + p->first_time = now; + + p->next=*last; + *last=p; + + p->gnext = NULL; + if(P.cr3.head) + *P.cr3.tail = p; + else + P.cr3.head = p; + P.cr3.tail = &p->gnext; + + P.cr3.id++; + + /* Add to the interval list if appropriate */ + if(opt.interval.check == INTERVAL_CHECK_CR3 + && v->d->did != DEFAULT_DOMAIN) + interval_cr3_value_check(p); + } + + if(p->prealloc_unpin.now) { + fprintf(warn, "Re-promoting previously unpinned cr3 %llx!\n", + p->gmfn); + p->prealloc_unpin.now = 0; + h->inflight.cr_write.repromote = 1; + } + + /* Accounting for new toplevel */ + v->cr3.start_time = now; + p->switch_count++; + if(p->destroy.callback) + p->destroy.switch_count++; + v->cr3.data = p; + } else { + v->cr3.data = NULL; + } + + if (opt.scatterplot_cr3_switch) { + scatterplot_vs_time(h->exit_tsc, + v->cr3.data ? (v->cr3.data->cr3_id) : 0); + } + } else { + if (opt.scatterplot_cr3_switch) + scatterplot_vs_time(h->exit_tsc, gmfn); + } + + v->cr3.val = val; +}; + +void cr3_prealloc_unpin(struct vcpu_data *v, unsigned long long gmfn) { + struct cr3_value_struct *cr3; + + /* Look for it in the list */ + for(cr3 = v->d->cr3_value_head; cr3; cr3=cr3->next) + if(cr3->gmfn == gmfn) + break; + + if(!cr3) + return; + + if(cr3->prealloc_unpin.now) + fprintf(warn, "Strange, gmfn %llx multiple unpins w/o access!\n", + gmfn); + + cr3->prealloc_unpin.now = 1; + cr3->prealloc_unpin.count++; + + if(opt.dump_all) + printf(" cr3 %llx unpinned %d times\n", + gmfn, cr3->prealloc_unpin.count); +} + +void cr3_dump_list(struct cr3_value_struct *head){ + struct cr3_value_struct *p; + struct cr3_value_struct **qsort_array; + int i, N=0; + + int cr3_compare_total(const void *_a, const void *_b) { + struct cr3_value_struct *a=*(typeof(&a))_a; + struct cr3_value_struct *b=*(typeof(&a))_b; + + if(a->total_time.cycles < b->total_time.cycles) + return 1; + else if(b->total_time.cycles == a->total_time.cycles) { + if(a->total_time.count < b->total_time.count) + return 1; + else if(a->total_time.count == b->total_time.count) + return 0; + else + return -1; + } else + return -1; + } + + int cr3_compare_start(const void *_a, const void *_b) { + struct cr3_value_struct *a=*(typeof(&a))_a; + struct cr3_value_struct *b=*(typeof(&a))_b; + + if(a->first_time > b->first_time) + return 1; + else if(b->first_time == a->first_time) + return 0; + else + return -1; + } + + if(!head) + return; + + /* Count the number of elements */ + for(p=head; p; p=p->next) + N++; + + if(!N) + return; + + /* Alloc a struct of the right size */ + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); + + /* Point the array into it */ + for(i=0, p=head; p; p=p->next, i++) + qsort_array[i]=p; + + /* Sort the array by time */ + qsort(qsort_array, N, sizeof(struct eip_list_struct *), + cr3_compare_start); + + /* WARNING: don't use N after this point unless you copy this variable */ +#if 0 + if(opt.summary_eip_limit && opt.summary_eip_limit < N) + N=opt.summary_eip_limit; +#endif + + /* Now print the results */ + printf(" cr3 values:\n"); + for(i=0; i<N; i++) { + char desc[30]; + struct time_struct first, last; + + p = qsort_array[i]; + + abs_cycles_to_time(p->first_time, &first); + abs_cycles_to_time(p->last_time, &last); + + + snprintf(desc, 30, " %8llx (id %d)", p->gmfn, p->cr3_id); + print_cycle_summary(&p->total_time, desc); + snprintf(desc, 30, " guest"); + print_cycle_percent_summary(&p->guest_time, p->run_time, desc); + snprintf(desc, 30, " hv "); + print_cycle_percent_summary(&p->hv_time, p->run_time, desc); + + hvm_short_summary(&p->hvm, p->run_time, " + "); + printf(" Seen: %4u.%09u-%4u.%09u switch %d flush %d\n", + first.s, first.ns, + last.s, last.ns, + p->switch_count, p->flush_count); + if(p->destroy.callback) + printf(" destroy: flush %u switch %u fixup %u emulate %u\n", + p->destroy.flush_count, + p->destroy.switch_count, + p->destroy.fixup_user, + p->destroy.emulate_corr_user); + } + + free(qsort_array); +} + +void hvm_cr3_write_summary(struct hvm_data *h) { + int j; + + for(j=0; j<RESYNCS_MAX; j++) + PRINT_SUMMARY(h->summary.cr3_write_resyncs[j], + " *[%3d] ", j); + PRINT_SUMMARY(h->summary.cr3_write_resyncs[j], + " *[MAX] "); +} + +void hvm_cr_write_summary(struct hvm_data *h, void *data) +{ + long cr=(long)data; + + PRINT_SUMMARY(h->summary.cr_write[cr], + " cr%ld ", cr); + if ( cr==3 ) + hvm_cr3_write_summary(h); +} + +void hvm_cr_write_postprocess(struct hvm_data *h) +{ + if(h->inflight.cr_write.cr == 3) { + struct vcpu_data *v = h->v; + unsigned long long new_val = h->inflight.cr_write.val; + unsigned long long oval; + int flush=0; + + if(v->cr3.val) { + oval = v->cr3.val; + + if(new_val == oval) { + if(v->cr3.data) { + v->cr3.data->flush_count++; + if(v->cr3.data->destroy.callback) + v->cr3.data->destroy.flush_count++; + } + flush=1; + } + } + + if(opt.summary_info) { + int resyncs = h->resyncs; + + if(resyncs > RESYNCS_MAX) + resyncs = RESYNCS_MAX; + + update_summary(&h->summary.cr3_write_resyncs[resyncs], + h->arc_cycles); + + update_summary(&h->summary.cr_write[3], + h->arc_cycles); + + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_CR3); + } + + if(!flush) + cr3_switch(new_val, h); + } else { + if(opt.summary_info) + { + if(h->inflight.cr_write.cr < CR_MAX) + update_summary(&h->summary.cr_write[h->inflight.cr_write.cr], + h->arc_cycles); + + } + } + + /* Set summary handler */ + /* FIXME - deal with cr_read_summary */ + if(h->exit_reason < h->exit_reason_max) + { + /* Want a different "set" for each cr */ + switch(h->inflight.cr_write.cr) + { +#define case_cr(_x) \ + case (_x): \ + hvm_set_summary_handler(h, hvm_cr_write_summary, (void *)(_x)); \ + break + case_cr(0); + case_cr(1); + case_cr(2); + case_cr(3); + case_cr(4); + case_cr(5); + case_cr(6); + case_cr(7); + case_cr(8); + case_cr(9); + case_cr(10); + case_cr(11); + case_cr(12); + case_cr(13); + case_cr(14); + case_cr(15); +#undef case_cr + default: + fprintf(stderr, "Unexpected cr: %d\n", h->inflight.cr_write.cr); + error(ERR_SANITY, NULL); + break; + } + } +} + +void hvm_cr_write_process(struct record_info *ri, struct hvm_data *h) +{ + union { + struct { + unsigned cr; + unsigned int val; + } x32; + struct { + unsigned cr; + unsigned long long val; + } __attribute__((packed)) x64; + } *r = (typeof(r))h->d; + unsigned cr; + unsigned long long val; + + if(ri->event & TRC_64_FLAG) { + h->inflight.cr_write.cr = cr = r->x64.cr; + h->inflight.cr_write.val = val = r->x64.val; + } else { + h->inflight.cr_write.cr = cr = r->x32.cr; + h->inflight.cr_write.val = val = r->x32.val; + } + + /* In vmx, in real mode, cr accesses may cause EXNMI vmexits. + * Account them under that heading; otherwise, complain */ + if ( hvm_set_postprocess(h, hvm_cr_write_postprocess) ) + fprintf(warn, "%s: Strange, h->postprocess already set!\n", + __func__); + + if(opt.dump_all) + { + if(cr == 3 && h->v->cr3.val) { + printf("]%s cr_write cr3 val %llx oval %llx %s\n", + ri->dump_header, + val, + h->v->cr3.val, + (h->v->cr3.val == val)?"flush":"switch"); + } else { + printf(" %s cr_write cr%d val %llx\n", + ri->dump_header, + cr, val); + + } + } + +} + +/* msr_write */ +void hvm_msr_write_summary(struct hvm_data *h, void *d) +{ +} + +void hvm_msr_write_postprocess(struct hvm_data *h) +{ + if(opt.summary_info) { + } + + /* Set summary handler */ + hvm_set_summary_handler(h, hvm_msr_write_summary, NULL); +} + +void hvm_msr_write_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned int addr; + unsigned long long val; + } __attribute__((packed)) *r = (typeof(r))h->d; + + if(check_extra_words(ri, sizeof(*r), "msr_write")) + return; + + h->inflight.msr.addr = r->addr; + h->inflight.msr.val = r->val; + + if(opt.dump_all) + { + printf(" %s msr_write addr %x val %llx\n", + ri->dump_header, + r->addr, r->val); + } + + if ( hvm_set_postprocess(h, hvm_msr_write_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +/* msr_read */ +void hvm_msr_read_summary(struct hvm_data *h, void *d) +{ +} + +void hvm_msr_read_postprocess(struct hvm_data *h) +{ + if(opt.summary_info) { + } + + /* Set summary handler */ + hvm_set_summary_handler(h, hvm_msr_read_summary, NULL); +} + +void hvm_msr_read_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned int addr; + unsigned long long val; + } __attribute__((packed)) *r = (typeof(r))h->d; + + if(check_extra_words(ri, sizeof(*r), "msr_read")) + return; + + h->inflight.msr.addr = r->addr; + h->inflight.msr.val = r->val; + + if(opt.dump_all) + { + printf(" %s msr_read addr %x val %llx\n", + ri->dump_header, + r->addr, r->val); + } + + if ( hvm_set_postprocess(h, hvm_msr_read_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void hvm_vmcall_summary(struct hvm_data *h, void *d) +{ + int i; + + for ( i=0; i<HYPERCALL_MAX ; i++) + { + PRINT_SUMMARY(h->summary.vmcall[i], + " [%10s] ", hypercall_name[i]); + } + PRINT_SUMMARY(h->summary.vmcall[HYPERCALL_MAX], + " [%10s] ", "max"); +} + +void hvm_vmcall_postprocess(struct hvm_data *h) +{ + unsigned eax = h->inflight.vmcall.eax ; + + if(opt.summary) + { + if ( eax < HYPERCALL_MAX ) + update_summary(&h->summary.vmcall[eax], + h->arc_cycles); + else + update_summary(&h->summary.vmcall[HYPERCALL_MAX], + h->arc_cycles); + hvm_set_summary_handler(h, hvm_vmcall_summary, NULL); + } +} + +void hvm_vmcall_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned int eax; + } *r = (typeof(r))h->d; + + if(opt.dump_all) { + if(r->eax < HYPERCALL_MAX) + printf(" %s vmcall %2x (%s)\n", + ri->dump_header, + r->eax, + hypercall_name[r->eax]); + else + printf(" %s vmcall %2x\n", + ri->dump_header, + r->eax); + } + + h->inflight.vmcall.eax = r->eax; + + if ( hvm_set_postprocess(h, hvm_vmcall_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void hvm_inj_exc_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned vec, ec; + } *r = (typeof(r))h->d; + + if ( opt.dump_all ) + { + if(r->vec < HVM_TRAP_MAX) + printf(" %3u.%09u %s inj_exc trap %s ec %x\n", + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), + hvm_trap_name[r->vec], r->ec); + else + printf(" %3u.%09u %s inj_exc trap %u ec %x\n", + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), + r->vec, r->ec); + } + +} + +void hvm_intr_summary(struct hvm_data *h, void *d) +{ + int i; + + for(i=0; i<EXTERNAL_INTERRUPT_MAX; i++) + if(h->summary.extint[i]) + { + if(hvm_extint_vector_name[i]) + printf(" %10s(%3d): %d\n", + hvm_extint_vector_name[i], + i, + h->summary.extint[i]); + else + printf(" [%3d]: %d\n", + i, + h->summary.extint[i]); + } + if(h->summary.extint[EXTERNAL_INTERRUPT_MAX]) + printf(" Other: : %d\n", + h->summary.extint[EXTERNAL_INTERRUPT_MAX]); +} + + +void hvm_intr_process(struct record_info *ri, struct hvm_data *h) +{ + unsigned vec = *(unsigned *)h->d; + + /* Vector is difficult to get in SVM mode */ + if ( opt.svm_mode ) + vec = 0; + + if( (h->rip >> ADDR_SPACE_BITS) != 00 + && (h->rip >> ADDR_SPACE_BITS) != ((0ULL-1)>> ADDR_SPACE_BITS) ) { + fprintf(stderr, "Unexpected rip %llx (shift %llx)\n", + h->rip, + h->rip >> ADDR_SPACE_BITS); + error(ERR_RECORD, NULL); + /* Can process with strange rip */ + } + + h->inflight.intr.vec = vec; + + if ( opt.dump_all ) + { + if ( vec < EXTERNAL_INTERRUPT_MAX && + hvm_extint_vector_name[vec] ) + printf(" %s intr vec %s(%x)\n", + ri->dump_header, + hvm_extint_vector_name[vec], + vec); + else + printf(" %s intr vec %x\n", + ri->dump_header, vec); + } + + if(opt.scatterplot_interrupt_eip + && vec == opt.scatterplot_interrupt_vector) + { + struct time_struct t; + /* Truncate to 40 bits */ + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); + + /* Want absolute tsc to global tsc */ + abs_cycles_to_time(h->exit_tsc, &t); + printf("d%dv%d %u.%09u %lld\n", + h->v->d->did, h->v->vid, + t.s, t.ns, + rip); + } + + if(opt.histogram_interrupt_eip + && vec == opt.histogram_interrupt_vector) + { + /* Truncate to 40 bits */ + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); + unsigned index = rip / opt.histogram_interrupt_increment; + + h->summary.extint_histogram[index]++; + } + + if(opt.with_interrupt_eip_enumeration + && vec == opt.interrupt_eip_enumeration_vector) + { + /* Truncate to 40 bits */ + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); + + /* Want absolute tsc to global tsc */ + update_eip(&h->v->d->interrupt_eip_list, rip, 0, 0, NULL); + } + + /* Disable generic postprocessing */ + /* FIXME: Do the summary stuff in a post-processor */ + h->post_process = NULL; + + if(opt.summary_info) { + if(opt.summary) + hvm_set_summary_handler(h, hvm_intr_summary, NULL); + + if(vec < EXTERNAL_INTERRUPT_MAX) + h->summary.extint[vec]++; + else + h->summary.extint[EXTERNAL_INTERRUPT_MAX]++; + } +} + + +void hvm_intr_window_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + uint32_t vector; + uint32_t source; + int32_t intr; + } *r = (typeof(r))h->d; + + char *intsrc_name[] = { + "none", + "pic", + "lapic", + "nmi", + "mce", + "vector" + }; + + if ( opt.dump_all ) + { + printf(" %s intr_window vec %u src %u(%s) ", + ri->dump_header, + (unsigned)r->vector, + (unsigned)r->source, + r->source < 6 ? intsrc_name[r->source]: "?"); + + if ( r->intr > 0 ) + printf("intr %x\n", + (unsigned)r->intr); + else + printf("intr #\n"); + } +} + +void hvm_pf_inject_process(struct record_info *ri, struct hvm_data *h) +{ + union { + struct { + unsigned ec; + unsigned int cr2; + } x32; + struct { + unsigned ec; + unsigned long long cr2; + } __attribute__((packed)) x64; + } *r = (typeof(r))h->d; + unsigned int ec; + unsigned long long cr2; + int is_64 = 0; + + if(ri->event & TRC_64_FLAG) { + is_64 = 1; + cr2 = r->x64.cr2; + ec = r->x64.ec; + } else { + cr2 = r->x32.cr2; + ec = r->x32.ec; + } + + if ( opt.dump_all ) + { + printf(" %3u.%09u %s pf_inject%s guest_cr2 %llx guest_ec %x\n", + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), + is_64?"64":"", + cr2, ec); + } +} + +void hvm_generic_postprocess_init(struct record_info *ri, struct hvm_data *h); + +void hvm_npf_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + uint64_t gpa; + uint64_t mfn; + uint32_t qualification; + uint32_t p2mt; + } *r = (typeof(r))h->d; + + if ( opt.dump_all ) + printf(" %s npf gpa %llx q %x mfn %llx t %d\n", + ri->dump_header, + (unsigned long long)r->gpa, r->qualification, + (unsigned long long)r->mfn, r->p2mt); + + if ( opt.summary_info ) + hvm_generic_postprocess_init(ri, h); +} + +void hvm_rdtsc_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned long long tsc; + } *r = (typeof(r))h->d; + + if ( opt.dump_all ) + printf(" %s rdtsc %llx %lld %s\n", + ri->dump_header, + (unsigned long long)r->tsc, + (unsigned long long)r->tsc, + h->last_rdtsc > r->tsc ? "BACKWARDS" : ""); + + if ( opt.scatterplot_rdtsc ) + { + struct time_struct t; + + abs_cycles_to_time(ri->tsc, &t); + + printf("%dv%d %u.%09u %llu\n", + h->v->d->did, h->v->vid, + t.s, t.ns, + r->tsc); + } + + h->last_rdtsc = r->tsc; +} + +void hvm_generic_summary(struct hvm_data *h, void *data) +{ + long evt = (long)data; + + assert(evt < HVM_EVENT_HANDLER_MAX); + + PRINT_SUMMARY(h->summary.generic[evt], + " %s ", hvm_event_handler_name[evt]); + +} + +void hvm_generic_postprocess_init(struct record_info *ri, struct hvm_data *h) +{ + if ( h->post_process != hvm_generic_postprocess ) + fprintf(warn, "%s: Strange, h->postprocess set!\n", + __func__); + h->inflight.generic.event = ri->event; + bcopy(h->d, h->inflight.generic.d, sizeof(unsigned int) * 4); +} + +void hvm_generic_postprocess(struct hvm_data *h) +{ + long evt = 0; + static unsigned registered[HVM_EVENT_HANDLER_MAX] = { 0 }; + + if ( h->inflight.generic.event ) + evt = (h->inflight.generic.event - TRC_HVM_HANDLER) + & ~(TRC_64_FLAG|HVM_IO_ASSIST_WRITE); + else { + static unsigned warned[HVM_EXIT_REASON_MAX] = { 0 }; + /* Some exits we don't expect a handler; just return */ + if(opt.svm_mode) + { + } + else + { + switch(h->exit_reason) + { + /* These just need us to go through the return path */ + case EXIT_REASON_PENDING_INTERRUPT: + case EXIT_REASON_TPR_BELOW_THRESHOLD: + /* Not much to log now; may need later */ + case EXIT_REASON_WBINVD: + return; + default: + break; + } + } + if ( !warned[h->exit_reason] ) + { + /* If we aren't a known exception, warn and log results */ + fprintf(warn, "%s: Strange, exit %x(%s) missing a handler\n", + __func__, h->exit_reason, + (h->exit_reason > h->exit_reason_max) + ? "[clipped]" + : h->exit_reason_name[h->exit_reason]); + warned[h->exit_reason]=1; + } + } + + if ( evt >= HVM_EVENT_HANDLER_MAX || evt < 0) + { + fprintf(warn, "%s: invalid hvm event %lx(%x)\n", + __func__, evt, h->inflight.generic.event); + error(ERR_RECORD, NULL); + return; + } + + if(opt.summary_info) { + update_summary(&h->summary.generic[evt], + h->arc_cycles); + + /* NB that h->exit_reason may be 0, so we offset by 1 */ + if ( registered[evt] ) + { + static unsigned warned[HVM_EXIT_REASON_MAX] = { 0 }; + if ( registered[evt] != h->exit_reason+1 && !warned[h->exit_reason]) + { + fprintf(warn, "%s: HVM evt %lx in %x and %x!\n", + __func__, evt, registered[evt]-1, h->exit_reason); + warned[h->exit_reason]=1; + } + } + else + { + int ret; + if((ret=__hvm_set_summary_handler(h, hvm_generic_summary, (void *)evt))) + fprintf(stderr, "%s: hvm_set_summary_handler returned %d\n", + __func__, ret); + registered[evt]=h->exit_reason+1; + } + /* HLT checked at hvm_vmexit_close() */ + } +} + +void hvm_generic_dump(struct record_info *ri, char * prefix) +{ + struct { + unsigned vcpu:16, domain:16; + unsigned d[4]; + } *cr = (typeof(cr))ri->d; + + char *evt_string, evt_number[256]; + int i, evt, is_64 = 0; + + evt = ri->event - TRC_HVM_HANDLER; + + if(evt & TRC_64_FLAG) { + evt &= ~(TRC_64_FLAG); + is_64=1; + } + + if(evt < HVM_EVENT_HANDLER_MAX) + { + evt_string = hvm_event_handler_name[evt]; + } + else + { + snprintf(evt_number, 256, "hvm_handler %d", evt); + evt_string = evt_number; + } + + printf("%s%s %s%s [", + prefix, + ri->dump_header, + evt_string, + is_64?"64":""); + + for(i=0; i<ri->extra_words; i++) { + printf(" %x", ri->d[i]); + } + + printf(" ]\n"); +} + +void hvm_handler_process(struct record_info *ri, struct hvm_data *h) { + /* Wait for first vmexit to initialize */ + if(!h->init) + { + if(opt.dump_all) + hvm_generic_dump(ri,"!"); + return; + } + + h->d = ri->d; + + /* Handle things that don't need a vmexit */ + switch(ri->event) { + default: + goto needs_vmexit; + /* Records about changing guest state */ + case TRC_HVM_PF_INJECT: + case TRC_HVM_PF_INJECT64: + hvm_pf_inject_process(ri, h); + break; + case TRC_HVM_REINJ_VIRQ: + if ( opt.dump_all ) + { + printf(" %3u.%09u %s inj_virq vec %u\n", + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), + *(unsigned*)h->d); + } + break; + case TRC_HVM_INJ_EXC: + hvm_inj_exc_process(ri, h); + break; + case TRC_HVM_INJ_VIRQ: + hvm_inj_virq_process(ri, h); + break; + case TRC_HVM_INTR_WINDOW: + hvm_intr_window_process(ri, h); + break; + case TRC_HVM_OP_DESTROY_PROC: + if(h->v->cr3.data) { + struct cr3_value_struct *cur = h->v->cr3.data; + if(cur->destroy.callback) + fprintf(warn, "Strange, double callback for cr3 gmfn %llx!\n", + cur->gmfn); + cur->destroy.callback = 1; + } else if(opt.with_cr3_enumeration) { + fprintf(warn, "Warning: destroy_proc: don't know current cr3\n"); + } + if ( opt.dump_all ) + { + printf(" %3u.%09u %s destroy_proc cur_cr3 %llx\n", + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), h->v->cr3.val); + } + break; + } + + return; + +needs_vmexit: + /* Wait for the next vmexit */ + if(!h->vmexit_valid) + { + if(opt.dump_all) + hvm_generic_dump(ri,"!"); + return; + } + + /* Keep generic "event handler" info */ + h->event_handler = ri->event - TRC_HVM_HANDLER; + + switch(ri->event) { + /* Records adding to the vmexit reason */ + case TRC_HVM_INTR: + hvm_intr_process(ri, h); + break; + case TRC_HVM_PF_XEN: + case TRC_HVM_PF_XEN64: + hvm_pf_xen_process(ri, h); + break; + case TRC_HVM_IOPORT_READ: + case TRC_HVM_IOPORT_WRITE: + hvm_io_assist_process(ri, h); + break; + case TRC_HVM_IOMEM_READ: + case TRC_HVM_IOMEM_WRITE: + case TRC_HVM_IOMEM_READ|TRC_64_FLAG: + case TRC_HVM_IOMEM_WRITE|TRC_64_FLAG: + hvm_mmio_assist_process(ri, h); + break; + case TRC_HVM_CR_WRITE: + case TRC_HVM_CR_WRITE64: + hvm_cr_write_process(ri, h); + break; + case TRC_HVM_MSR_WRITE: + hvm_msr_write_process(ri, h); + break; + case TRC_HVM_MSR_READ: + hvm_msr_read_process(ri, h); + break; + case TRC_HVM_VMMCALL: + hvm_vmcall_process(ri, h); + break; + case TRC_HVM_NPF: + hvm_npf_process(ri, h); + break; + case TRC_HVM_RDTSC: + hvm_rdtsc_process(ri, h); + break; + case TRC_HVM_DR_READ: + case TRC_HVM_DR_WRITE: + case TRC_HVM_CPUID: + case TRC_HVM_SMI: + case TRC_HVM_HLT: + case TRC_HVM_INVLPG: + case TRC_HVM_INVLPG64: + case TRC_HVM_MCE: + case TRC_HVM_CLTS: + case TRC_HVM_LMSW: + case TRC_HVM_LMSW64: + case TRC_HVM_NMI: + case TRC_HVM_REALMODE_EMULATE: + case TRC_HVM_TRAP: + case TRC_HVM_TRAP_DEBUG: + case TRC_HVM_CR_READ: + case TRC_HVM_CR_READ64: + default: + if(opt.dump_all) + hvm_generic_dump(ri, "]"); + if(opt.summary_info) + hvm_generic_postprocess_init(ri, h); + break; + } +} + +void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc); +void vcpu_prev_update(struct pcpu_info *p, struct vcpu_data *prev, + tsc_t tsc, int new_runstate); +struct vcpu_data * vcpu_find(int did, int vid); +void lose_vcpu(struct vcpu_data *v, tsc_t tsc); + +int domain_runstate(struct domain_data *d) { + int i; + int runstates[RUNSTATE_MAX]; + int ret=-1; + int max_vcpus = 0; + + if(d->did == DEFAULT_DOMAIN) + return 0; + + for(i=0; i<RUNSTATE_MAX; i++) + runstates[i]=0; + + for(i=0; i<=d->max_vid; i++) + if(d->vcpu[i] && d->vcpu[i]->runstate.state != RUNSTATE_INIT) { + max_vcpus++; + runstates[d->vcpu[i]->runstate.state]++; + } + + if(runstates[RUNSTATE_LOST] == max_vcpus) + ret=DOMAIN_RUNSTATE_LOST; + else if(runstates[RUNSTATE_RUNNING]) + { + if(runstates[RUNSTATE_RUNNABLE]) + ret=DOMAIN_RUNSTATE_CONCURRENCY_HAZARD; + else if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) + ret= DOMAIN_RUNSTATE_PARTIAL_RUN; + else + ret= DOMAIN_RUNSTATE_FULL_RUN; + } + else if(runstates[RUNSTATE_RUNNABLE]) + { + if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) + ret= DOMAIN_RUNSTATE_PARTIAL_CONTENTION; + else + ret= DOMAIN_RUNSTATE_FULL_CONTENTION; + } + else if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) + { + ret= DOMAIN_RUNSTATE_BLOCKED; + } else { + fprintf(warn, "Strange, no meaningful runstates for d%d!\n", + d->did); + } + + if ( ret < 0 ) + { + printf(" Max vid: %d (max_vcpus %d)\n", d->max_vid, max_vcpus); + for(i=0; i<=d->max_vid; i++) + if(d->vcpu[i]) + fprintf(warn, " v%d: %s\n", + i, runstate_name[d->vcpu[i]->runstate.state]); + + for(i=0; i<RUNSTATE_MAX; i++) + fprintf(warn, " %s: %d\n", + runstate_name[i], runstates[i]); + } + + if(ret >= 0) + return ret; + + error(ERR_ASSERT, NULL); + return -1; /* Never happens */ +} + +static inline void runstate_update(struct vcpu_data *v, int new_runstate, + tsc_t tsc) +{ + struct domain_data *d = v->d; + + if ( opt.scatterplot_runstate ) + { + struct time_struct t; + + abs_cycles_to_time(tsc, &t); + + printf("%dv%d %u.%09u %d\n", + d->did, v->vid, + t.s, t.ns, + runstate_graph[v->runstate.state]); + printf("%dv%d %u.%09u %d\n", + d->did, v->vid, + t.s, t.ns, + runstate_graph[new_runstate]); + } + + if(v->runstate.tsc > 0 && v->runstate.tsc < tsc) { + update_cycles(v->runstates + v->runstate.state, tsc - v->runstate.tsc); + + if ( opt.scatterplot_runstate_time ) + { + struct time_struct t, dt; + + abs_cycles_to_time(tsc, &t); + cycles_to_time(tsc - v->runstate.tsc, &dt); + + printf("%dv%d %u.%09u %u.%09u\n", + d->did, v->vid, + t.s, t.ns, + dt.s, dt.ns); + } + + if(v->runstate.state == RUNSTATE_RUNNING) + update_cycles(&v->d->total_time, tsc - v->runstate.tsc); + + if(v->runstate.state == RUNSTATE_RUNNABLE) + update_cycles(v->runnable_states + v->runstate.runnable_state, tsc - v->runstate.tsc); + + /* How much did dom0 run this buffer? */ + if(v->d->did == 0) { + int i; + for(i=0; i<MAX_CPUS; i++) { + struct pcpu_info * p = P.pcpu + i; + tsc_t start_tsc; + if(!p->active) + continue; + start_tsc = (p->volume.buffer_first_tsc > v->runstate.tsc) ? + p->volume.buffer_first_tsc : + v->runstate.tsc; + p->volume.buffer_dom0_runstate_cycles[v->runstate.state] + += tsc - start_tsc; +#if 0 + printf(" - updated p%d dom0_runstate %s to %lld cycles (+%lld)\n", + p->pid, runstate_name[v->runstate.state], + p->volume.buffer_dom0_runstate_cycles[v->runstate.state], + tsc - start_tsc); +#endif + p->volume.buffer_dom0_runstate = new_runstate; + p->volume.buffer_dom0_runstate_tsc = tsc; + } + } + } + + /* Detect "runnable" states */ + if ( new_runstate == RUNSTATE_RUNNABLE ) + { + switch(v->runstate.state) + { + case RUNSTATE_RUNNING: + v->runstate.runnable_state=RUNNABLE_STATE_PREEMPT; + break; + case RUNSTATE_BLOCKED: + case RUNSTATE_OFFLINE: + v->runstate.runnable_state=RUNNABLE_STATE_WAKE; + break; + default: + v->runstate.runnable_state=RUNNABLE_STATE_OTHER; + break; + } + } else + v->runstate.runnable_state=RUNNABLE_STATE_INVALID; + + v->runstate.state = new_runstate; + v->runstate.tsc = tsc; + + /* Determine the domain runstate */ + if(d->runstate_tsc > 0 && d->runstate_tsc < tsc) + update_cycles(d->runstates + d->runstate, tsc - d->runstate_tsc); + + d->runstate = domain_runstate(d); + + d->runstate_tsc = tsc; +} + +void hvm_vmexit_process(struct record_info *ri, struct hvm_data *h, + struct vcpu_data *v) { + struct { + union { + struct { + unsigned int exit_reason; + unsigned long long rip; + } __attribute__((packed)) x64; + struct { + unsigned int exit_reason; + unsigned int eip; + } x32; + }; + } *r; + + if ( ri->event & TRC_64_FLAG ) + { + if (check_extra_words(ri, sizeof(r->x64), "vmexit")) + return; + } + else + { + if (check_extra_words(ri, sizeof(r->x32), "vmexit")) + return; + } + + r = (typeof(r))ri->d; + + if(!h->init) + init_hvm_data(h, v); + + h->vmexit_valid=1; + bzero(&h->inflight, sizeof(h->inflight)); + + if(ri->event == TRC_HVM_VMEXIT64) { + if(v->guest_paging_levels != 4) + { + if ( verbosity >= 6 ) + fprintf(warn, "%s: VMEXIT64, but guest_paging_levels %d. Switching to 4.\n", + __func__, v->guest_paging_levels); + v->guest_paging_levels = 4; + } + if(!is_valid_addr64(r->x64.rip)) + fprintf(warn, "%s: invalid va %llx\n", + __func__, r->x64.rip); + h->rip = r->x64.rip; + h->exit_reason = r->x64.exit_reason; + } else { + if(v->guest_paging_levels == 4) + { + int new_paging_levels = opt.default_guest_paging_levels; + + if(new_paging_levels == 4) + new_paging_levels = 2; /* Wild guess */ + + if ( verbosity >= 6 ) + fprintf(warn, "%s: VMEXIT, but guest_paging_levels %d. Switching to %d(default).\n", + __func__, v->guest_paging_levels, new_paging_levels); + + v->guest_paging_levels = new_paging_levels; + } + h->rip = r->x32.eip; + h->exit_reason = r->x32.exit_reason; + } + + if(opt.scatterplot_vmexit_eip) + scatterplot_vs_time(ri->tsc, h->rip); + + if(h->exit_reason > h->exit_reason_max) + { + fprintf(warn, "h->exit_reason %x > exit_reason_max %x!\n", + (unsigned int)h->exit_reason, + (unsigned int)h->exit_reason_max); + error(ERR_RECORD, ri); + return; + } + + if(opt.dump_all) { + if ( h->exit_reason < h->exit_reason_max + && h->exit_reason_name[h->exit_reason] != NULL) + printf("]%s vmexit exit_reason %s eip %llx%s\n", + ri->dump_header, + h->exit_reason_name[h->exit_reason], + h->rip, + find_symbol(h->rip)); + else + printf("]%s vmexit exit_reason %x eip %llx%s\n", + ri->dump_header, + h->exit_reason, + h->rip, + find_symbol(h->rip)); + } + + if(h->v->cr3.data && h->entry_tsc) { + update_cycles(&h->v->cr3.data->guest_time, + ri->tsc - h->entry_tsc); + h->v->cr3.data->run_time += (ri->tsc - h->entry_tsc); + } + + h->exit_tsc = ri->tsc; + h->entry_tsc = 0; + h->resyncs = 0; + h->prealloc_unpin = 0; + h->wrmap_bf = 0; + h->short_summary_done = 0; + + h->post_process = hvm_generic_postprocess; + h->inflight.generic.event = 0; +} + +void hvm_close_vmexit(struct hvm_data *h, tsc_t tsc) { + + if(h->exit_tsc) { + if(h->exit_tsc > tsc) + h->arc_cycles = 0; + else { + h->arc_cycles = tsc - h->exit_tsc; + + if(opt.summary_info) { + update_summary(&h->summary.exit_reason[h->exit_reason], + h->arc_cycles); + h->summary_info = 1; + } + + if ( opt.scatterplot_extint_cycles + && h->exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT + && h->inflight.intr.vec == opt.scatterplot_extint_cycles_vector ) + { + struct time_struct t; + + abs_cycles_to_time(tsc, &t); + + printf("d%dv%d %u.%09u %lld\n", + h->v->d->did, + h->v->vid, + t.s, t.ns, + h->arc_cycles); + } + } + } + + if(h->post_process) + (h->post_process)(h); + + if(h->arc_cycles) { + if(opt.summary_info && !h->short_summary_done) { + switch(h->event_handler) { + case HVM_EVENT_HANDLER_VMCALL: + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_VMCALL); + break; + case HVM_EVENT_HANDLER_INTR: + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_INTERRUPT); + break; + case HVM_EVENT_HANDLER_HLT: + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_HLT); + break; + default: + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_OTHER); + break; + } + } + + + if(h->v->cr3.data) { + h->v->cr3.data->run_time += h->arc_cycles; + + if(opt.summary_info) + update_cycles(&h->v->cr3.data->hv_time, + h->arc_cycles); + } + } + + h->exit_tsc = 0; + h->vmexit_valid = 0; + h->post_process = NULL; + +} + +void hvm_vmentry_process(struct record_info *ri, struct hvm_data *h) { + if(!h->init) + { + if(opt.dump_all) + printf("!%s vmentry\n", + ri->dump_header); + return; + } + + /* Vista bug + * This has to be done here because irqs are injected on the path out + * to vmexit. */ + hvm_vlapic_vmentry_cleanup(h->v, ri->tsc); + + if(h->w2h.waking && opt.dump_all) + printf(" [w2h] d%dv%d Finishing waking\n", + h->v->d->did, h->v->vid); + + h->w2h.waking = 0; + + if ( h->w2h.interrupts_wanting_tsc ) { + int i; + for(i=0; i<GUEST_INTERRUPT_MAX; i++) + { + if ( h->summary.guest_interrupt[i].start_tsc == 1 ) + { + if(opt.dump_all) + printf(" [w2h] d%dv%d Setting vec %d tsc to %lld\n", + h->v->d->did, h->v->vid, i, ri->tsc); + h->summary.guest_interrupt[i].start_tsc = ri->tsc; + h->w2h.interrupts_wanting_tsc--; + if ( h->w2h.interrupts_wanting_tsc == 0 ) + break; + } + } + } + + if(!h->vmexit_valid) + { + if(opt.dump_all) + printf("!%s vmentry\n", + ri->dump_header); + return; + } + + if(opt.dump_all) { + unsigned long long arc_cycles = ri->tsc - h->exit_tsc; + printf("]%s vmentry cycles %lld %s\n", + ri->dump_header, arc_cycles, (arc_cycles>10000)?"!":""); + } + + hvm_close_vmexit(h, ri->tsc); + h->entry_tsc = ri->tsc; +} + +void hvm_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + struct vcpu_data *v = p->current; + struct hvm_data *h = &v->hvm; + + assert(p->current); + + if(vcpu_set_data_type(p->current, VCPU_DATA_HVM)) + return; + + if(ri->evt.sub == 2) + { + UPDATE_VOLUME(p, hvm[HVM_VOL_HANDLER], ri->size); + hvm_handler_process(ri, h); + } + else + { + switch(ri->event) { + /* HVM */ + case TRC_HVM_VMEXIT: + case TRC_HVM_VMEXIT64: + UPDATE_VOLUME(p, hvm[HVM_VOL_VMEXIT], ri->size); + hvm_vmexit_process(ri, h, v); + break; + case TRC_HVM_VMENTRY: + UPDATE_VOLUME(p, hvm[HVM_VOL_VMENTRY], ri->size); + hvm_vmentry_process(ri, &p->current->hvm); + break; + default: + fprintf(warn, "Unknown hvm event: %x", ri->event); + } + } +} + +void hvm_summary(struct hvm_data *h) { + int i; + + if(!h->summary_info) + return; + + printf("Exit reasons:\n"); + for(i=0; i<h->exit_reason_max; i++) { + struct hvm_summary_handler_node *p; + + if ( h->exit_reason_name[i] ) + PRINT_SUMMARY(h->summary.exit_reason[i], + " %-20s ", h->exit_reason_name[i]); + else + PRINT_SUMMARY(h->summary.exit_reason[i], + " %20d ", i); + + p=h->exit_reason_summary_handler_list[i]; + while(p) + { + p->handler(h, p->data); + p=p->next; + } + } + + printf("Guest interrupt counts:\n"); + for(i=0; i<GUEST_INTERRUPT_MAX; i++) + if(h->summary.guest_interrupt[i].count) { + int j; + printf(" [%3d] %d\n", + i, h->summary.guest_interrupt[i].count); + for(j=1; j<GUEST_INTERRUPT_CASE_MAX; j++) { + char desc[80]; + snprintf(desc, 80, " * %s", guest_interrupt_case_name[j]); + print_cycle_summary(h->summary.guest_interrupt[i].runtime+j, desc); + } + } + if(h->summary.guest_interrupt[i].count) + printf(" [%d+] %d\n", + i, h->summary.guest_interrupt[i].count); + + if(opt.histogram_interrupt_eip) + { + unsigned max = ((1ULL<<ADDR_SPACE_BITS)/opt.histogram_interrupt_increment); + printf("Interrupt eip histogram:\n"); + for(i=0; i<max; i++) + if(h->summary.extint_histogram[i]) + { + printf("[%llx-%llx]: %d\n", + opt.histogram_interrupt_increment * i, + (opt.histogram_interrupt_increment * (i+1)) - 1, + h->summary.extint_histogram[i]); + } + } + + PRINT_SUMMARY(h->summary.ipi_latency, + "IPI latency \n"); + for(i=0; i<256; i++) + if(h->summary.ipi_count[i]) + printf(" [%3d] %10d\n", + i, h->summary.ipi_count[i]); + hvm_io_address_summary(h->summary.io.pio, "IO address summary:"); + hvm_io_address_summary(h->summary.io.mmio, "MMIO address summary:"); +} + +/* ---- Shadow records ---- */ +union shadow_event +{ + unsigned event; + struct { + unsigned minor:8, + paging_levels:4; + }; +}; + +/* WARNING - not thread safe */ +#define FLAGSTRING(_name, _char) \ + if(e->flag_ ## _name) \ + flagstring[i] = _char; \ + i++; + +char * flag_string(struct pf_xen_extra *e) +{ + static char flagstring[32]; + int i=0; + + for(i=0; i<32; i++) + flagstring[i]='-'; + + i=0; + + if(e->flag_set_ad) + flagstring[i]='d'; + else if(e->flag_set_a) + flagstring[i]='a'; + i++; + + FLAGSTRING(shadow_l1_get_ref, 'g'); + FLAGSTRING(shadow_l1_put_ref, 'p'); + //FLAGSTRING(l2_propagate, '2'); + FLAGSTRING(demote, 'D'); + FLAGSTRING(promote, 'P'); + FLAGSTRING(wrmap, 'w'); + FLAGSTRING(wrmap_guess_found, 'G'); + //FLAGSTRING(wrmap_brute_force, 'b'); + FLAGSTRING(early_unshadow, 'e'); + FLAGSTRING(prealloc_unhook, 'H'); + FLAGSTRING(unsync, 'u'); + FLAGSTRING(oos_fixup_add, 'a'); + FLAGSTRING(oos_fixup_evict, 'x'); + + flagstring[i]=0; + + return flagstring; +} + +void shadow_emulate_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if ( opt.summary_info ) + { + update_eip(&h->v->d->emulate_eip_list, + h->rip, + h->arc_cycles, + 0, NULL); + update_summary(&h->summary.pf_xen[PF_XEN_EMULATE], h->arc_cycles); + update_summary(&h->summary.pf_xen_emul[e->pt_level], h->arc_cycles); + if(h->prealloc_unpin) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PREALLOC_UNPIN], h->arc_cycles); + if(e->flag_prealloc_unhook) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PREALLOC_UNHOOK], h->arc_cycles); + if(e->flag_early_unshadow) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_EARLY_UNSHADOW], h->arc_cycles); + if(e->flag_set_changed) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_CHANGED], h->arc_cycles); + else + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_UNCHANGED], h->arc_cycles); + if(e->flag_set_flush) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_FLUSH], h->arc_cycles); + if(e->flag_set_error) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_ERROR], h->arc_cycles); + if(e->flag_promote) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PROMOTE], h->arc_cycles); + if(e->flag_demote) + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_DEMOTE], h->arc_cycles); + /* more summary info */ + + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_EMULATE); + } + + if(opt.scatterplot_unpin_promote) { + if(e->flag_early_unshadow) + scatterplot_vs_time(h->exit_tsc, -10); + if(h->prealloc_unpin) + scatterplot_vs_time(h->exit_tsc, 0); + if(e->flag_promote) { + if(opt.with_cr3_enumeration) { + if(h->v->cr3.data) + scatterplot_vs_time(h->exit_tsc, h->v->cr3.data->cr3_id); + } else + scatterplot_vs_time(h->exit_tsc, 2); + } + } + + +} + +void shadow_emulate_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + union { + /* for PAE, guest_l1e may be 64 while guest_va may be 32; + so put it first for alignment sake. */ + struct { + unsigned gl1e, write_val; + unsigned va; + unsigned flags:29, emulation_count:3; + } gpl2; + struct { + unsigned long long gl1e, write_val; + unsigned va; + unsigned flags:29, emulation_count:3; + } gpl3; + struct { + unsigned long long gl1e, write_val; + unsigned long long va; + unsigned flags:29, emulation_count:3; + } gpl4; + } *r = (typeof(r))ri->d; + + union shadow_event sevt = { .event = ri->event }; + int rec_gpl = sevt.paging_levels + 2; + + if ( rec_gpl != h->v->guest_paging_levels ) + { + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", + __func__, rec_gpl, h->v->guest_paging_levels); + h->v->guest_paging_levels = rec_gpl; + } + + /* Fill in extended information */ + switch(rec_gpl) + { + case 2: + if(sizeof(r->gpl2) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, + ri->extra_words * 4); + + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl2.va; + e->flags = r->gpl2.flags; + e->gl1e = r->gpl2.gl1e; + e->wval = r->gpl2.write_val; + break; + case 3: + if(sizeof(r->gpl3) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl3.va; + e->flags = r->gpl3.flags; + e->gl1e = r->gpl3.gl1e; + e->wval = r->gpl3.write_val; + break; + case 4: + if(sizeof(r->gpl4) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl4.va; + e->flags = r->gpl4.flags; + e->gl1e = r->gpl4.gl1e; + e->wval = r->gpl4.write_val; + break; + } + + pf_preprocess(e,rec_gpl); + + if(opt.dump_all) + printf("]%s emulate va %llx gl1e %8llx wval %8llx flags %s(%x) pt_level %d corr %8llx\n", + ri->dump_header, + e->va, + e->gl1e, e->wval, + flag_string(e), e->flags, + e->pt_level, e->corresponding_va); + + if ( hvm_set_postprocess(h, shadow_emulate_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +struct shadow_emulate_other { + unsigned long long gfn, va; +}; + +#define SHADOW_OTHER_LOGS_GFN_NOT_GMFN 1 + +void shadow_parse_other(struct record_info *ri, + struct shadow_emulate_other *o, + struct hvm_data *h) { + union { + /* for PAE, guest_l1e may be 64 while guest_va may be 32; + so put it first for alignment sake. */ +#if SHADOW_OTHER_LOGS_GFN_NOT_GMFN + /* D'OH! Accidentally used mfn_t in the struct, so gmfns are always + 64-bit... :-/ */ + struct { + unsigned int gfn, va; + } gpl2; +#endif + struct { + unsigned long long gfn; + unsigned int va; + } gpl3; + struct { + unsigned long long gfn, va; + } gpl4; + } *r = (typeof(r))ri->d; + + + union shadow_event sevt = { .event = ri->event }; + int rec_gpl = sevt.paging_levels + 2; + + if ( rec_gpl != h->v->guest_paging_levels ) + { + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", + __func__, rec_gpl, h->v->guest_paging_levels); + h->v->guest_paging_levels = rec_gpl; + } + + switch(rec_gpl) + { +#if SHADOW_OTHER_LOGS_GFN_NOT_GMFN + case 2: + if(sizeof(r->gpl2) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl2), rec_gpl, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + o->va = r->gpl2.va; + o->gfn = r->gpl2.gfn; + break; +#else + case 2: + /* FALLTHRU */ +#endif + case 3: + if(sizeof(r->gpl3) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl3), rec_gpl, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + o->va = r->gpl3.va; + o->gfn = r->gpl3.gfn; + break; + case 4: + if(sizeof(r->gpl4) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl4), rec_gpl, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + o->va = r->gpl4.va; + o->gfn = r->gpl4.gfn; + break; + } +} + +#if 0 +void shadow_unsync_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if(h->resyncs > 1) + fprintf(warn, "Strange, %d resyncs for an unsync!\n", + h->resyncs); + + if(opt.summary_info) { + update_summary(&h->summary.pf_xen[PF_XEN_EMULATE_UNSYNC], + h->arc_cycles); + if(h->resyncs <= 1) + update_summary(&h->summary.pf_xen_unsync[h->resyncs], + h->arc_cycles); + } +} + + +void shadow_unsync_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + struct shadow_emulate_other r; + + shadow_parse_other(ri, &r, h); + + e->gmfn = r.gmfn; + e->va = r.va; + + pf_preprocess(e, h->v->guest_paging_levels); + + if(opt.dump_all) + printf("]%s shadow unsync gmfn %llx va %llx pt_level %d corr %llx\n", + ri->dump_header, + e->gmfn, + e->va, + e->pt_level, + e->corresponding_va); + + if ( hvm_set_postprocess(h, shadow_unsync_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} +#endif + +void shadow_fault_generic_postprocess(struct hvm_data *h); + +void shadow_emulate_other_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + struct shadow_emulate_other r; + union shadow_event sevt = { .event = ri->event }; + + shadow_parse_other(ri, &r, h); + + e->gfn = r.gfn; + e->va = r.va; + e->pf_case = sevt.minor; + + pf_preprocess(e, h->v->guest_paging_levels); + + if(opt.dump_all) + printf("]%s shadow %s gfn %llx va %llx\n", + ri->dump_header, + pf_xen_name[sevt.minor], + e->gfn, + e->va); + + if ( hvm_set_postprocess(h, shadow_fault_generic_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void shadow_fixup_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if ( opt.summary_info ) + { + update_summary(&h->summary.pf_xen[PF_XEN_FIXUP], h->arc_cycles); + if(h->prealloc_unpin) { + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_PREALLOC_UNPIN], h->arc_cycles); + } + if(e->flag_unsync) { + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_UNSYNC], h->arc_cycles); + if(h->resyncs < PF_XEN_FIXUP_UNSYNC_RESYNC_MAX) + update_summary(&h->summary.pf_xen_fixup_unsync_resync[h->resyncs], + h->arc_cycles); + else + update_summary(&h->summary.pf_xen_fixup_unsync_resync[PF_XEN_FIXUP_UNSYNC_RESYNC_MAX], + h->arc_cycles); + } + if(e->flag_oos_fixup_add) + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_OOS_ADD], h->arc_cycles); + if(e->flag_oos_fixup_evict) + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_OOS_EVICT], h->arc_cycles); + if(e->flag_promote) + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_PROMOTE], h->arc_cycles); + if(e->flag_wrmap) { + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_WRMAP], h->arc_cycles); + if(e->flag_wrmap_brute_force || h->wrmap_bf) + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_BRUTE_FORCE], h->arc_cycles); + } else if(e->flag_wrmap_brute_force || h->wrmap_bf) { + fprintf(warn, "Strange: wrmap_bf but not wrmap!\n"); + } + + + if(!(e->flag_promote || h->prealloc_unpin || e->flag_unsync)) + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_UPDATE_ONLY], h->arc_cycles); + /* more summary info */ + + if(e->flag_unsync) + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_UNSYNC); + else + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_FIXUP); + } + + if(opt.scatterplot_unpin_promote) { + if(h->prealloc_unpin) + scatterplot_vs_time(h->exit_tsc, 0); + if(e->flag_promote) { + if(opt.with_cr3_enumeration) { + if(h->v->cr3.data) + scatterplot_vs_time(h->exit_tsc, h->v->cr3.data->cr3_id); + } else + scatterplot_vs_time(h->exit_tsc, 2); + } + } +} + +void shadow_fixup_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + union { + /* for PAE, guest_l1e may be 64 while guest_va may be 32; + so put it first for alignment sake. */ + struct { + unsigned int gl1e, va, flags; + } gpl2; + struct { + unsigned long long gl1e; + unsigned int va, flags; + } gpl3; + struct { + unsigned long long gl1e, va; + unsigned int flags; + } gpl4; + } *r = (typeof(r))ri->d; + union shadow_event sevt = { .event = ri->event }; + int rec_gpl = sevt.paging_levels + 2; + + if ( rec_gpl != h->v->guest_paging_levels ) + { + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", + __func__, rec_gpl, h->v->guest_paging_levels); + h->v->guest_paging_levels = rec_gpl; + } + + switch(rec_gpl) + { + case 2: + if(sizeof(r->gpl2) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl2.va; + e->flags = r->gpl2.flags; + e->gl1e = r->gpl2.gl1e; + break; + case 3: + if(sizeof(r->gpl3) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl3.va; + e->flags = r->gpl3.flags; + e->gl1e = r->gpl3.gl1e; + break; + case 4: + if(sizeof(r->gpl4) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl4.va; + e->flags = r->gpl4.flags; + e->gl1e = r->gpl4.gl1e; + break; + } + + pf_preprocess(e,rec_gpl); + + if(opt.dump_all) + { + if ( e->flag_unsync ) + printf("]%s fixup:unsync va %llx gl1e %llx corr %llx flags (%x)%s\n", + ri->dump_header, + e->va, e->gl1e, + e->corresponding_va, + e->flags, + flag_string(e)); + else + printf("]%s fixup va %llx gl1e %llx flags (%x)%s\n", + ri->dump_header, + e->va, e->gl1e, e->flags, + flag_string(e)); + } + + if ( hvm_set_postprocess(h, shadow_fixup_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void shadow_mmio_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + if ( opt.summary_info ) + { + if(e->pf_case) + update_summary(&h->summary.pf_xen[e->pf_case], + h->arc_cycles); + else + fprintf(warn, "Strange, pf_case 0!\n"); + + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_MMIO); + } + + if(opt.with_mmio_enumeration) + enumerate_mmio(h); +} + +void shadow_mmio_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + struct mmio_info *m = &h->inflight.mmio; + union { + /* for PAE, guest_l1e may be 64 while guest_va may be 32; + so put it first for alignment sake. */ + struct { + unsigned int va; + } gpl2; + struct { + unsigned long long va; + } gpl4; + } *r = (typeof(r))ri->d; + union shadow_event sevt = { .event = ri->event }; + int rec_gpl = sevt.paging_levels + 2; + + if ( rec_gpl != h->v->guest_paging_levels ) + { + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", + __func__, rec_gpl, h->v->guest_paging_levels); + h->v->guest_paging_levels = rec_gpl; + } + + switch(rec_gpl) + { + case 2: + case 3: + if(sizeof(r->gpl2) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = m->va = r->gpl2.va; + break; + case 4: + if(sizeof(r->gpl4) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = m->va = r->gpl4.va; + break; + } + + if(opt.dump_all) + printf("]%s %smmio va %llx\n", + ri->dump_header, + (e->pf_case==PF_XEN_FAST_MMIO)?"fast ":"", + e->va); + + if ( hvm_set_postprocess(h, shadow_mmio_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void shadow_propagate_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + + if ( opt.summary_info ) + { + if(e->pf_case) + update_summary(&h->summary.pf_xen[e->pf_case], + h->arc_cycles); + else + fprintf(warn, "Strange, pf_case 0!\n"); + + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_PROPAGATE); + } +} + +void shadow_propagate_process(struct record_info *ri, struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + union { + /* for PAE, guest_l1e may be 64 while guest_va may be 32; + so put it first for alignment sake. */ + struct { + unsigned int gl1e, va, flags; + } gpl2; + struct { + unsigned long long gl1e; + unsigned int va, flags; + } gpl3; + struct { + unsigned long long gl1e, va; + unsigned int flags; + } gpl4; + } *r = (typeof(r))ri->d; + union shadow_event sevt = { .event = ri->event }; + int rec_gpl = sevt.paging_levels + 2; + + if ( rec_gpl != h->v->guest_paging_levels ) + { + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", + __func__, rec_gpl, h->v->guest_paging_levels); + h->v->guest_paging_levels = rec_gpl; + } + + switch(rec_gpl) + { + case 2: + if(sizeof(r->gpl2) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl2.va; + e->flags = r->gpl2.flags; + e->gl1e = r->gpl2.gl1e; + break; + case 3: + if(sizeof(r->gpl3) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl3.va; + e->flags = r->gpl3.flags; + e->gl1e = r->gpl3.gl1e; + break; + case 4: + if(sizeof(r->gpl4) != ri->extra_words * 4) + { + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, + ri->extra_words * 4); + error(ERR_RECORD, ri); + return; + } + e->va = r->gpl4.va; + e->flags = r->gpl4.flags; + e->gl1e = r->gpl4.gl1e; + break; + } + + if(opt.dump_all) + printf("]%s propagate va %llx gl1e %llx flags (%x)%s\n", + ri->dump_header, + e->va, e->gl1e, e->flags, + flag_string(e)); + + if ( hvm_set_postprocess(h, shadow_propagate_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void shadow_fault_generic_dump(unsigned int event, uint32_t *d, char *prefix, + char * dump_header) +{ + char *evt_string, evt_number[10]; + union shadow_event sevt = { .event = event }; + int i; + + if(sevt.minor < PF_XEN_MAX && pf_xen_name[sevt.minor]) + { + evt_string = pf_xen_name[sevt.minor]; + } + else + { + snprintf(evt_number, 10, "%d", sevt.minor); + evt_string = evt_number; + } + + printf("%s%s shadow %s gl %d [", + prefix, + dump_header, + evt_string, + sevt.paging_levels); + + for(i=0; i<4; i++) + { + printf(" %x", d[i]); + } + + printf(" ]\n"); +} + +void shadow_fault_generic_postprocess(struct hvm_data *h) +{ + struct pf_xen_extra *e = &h->inflight.pf_xen; + if ( e->pf_case < PF_XEN_NOT_SHADOW || e->pf_case > PF_XEN_LAST_FAULT ) + { + fprintf(warn, "%s: Strange, unexpected case %d\n", + __func__, e->pf_case); + return; + } + + if(opt.summary_info) { + update_summary(&h->summary.pf_xen[e->pf_case], + h->arc_cycles); + + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_PROPAGATE); + } +} + +void shadow_fault_generic_process(struct record_info *ri, struct hvm_data *h) +{ + union shadow_event sevt = { .event = ri->event }; + + /* pf-case traces, vs others */ + h->inflight.generic.event = ri->event; + bcopy(ri->d, h->inflight.generic.d, sizeof(unsigned int) * 4); + + if(opt.dump_all) + shadow_fault_generic_dump(h->inflight.generic.event, + h->inflight.generic.d, + "]", ri->dump_header); + + h->inflight.pf_xen.pf_case = sevt.minor; + if ( hvm_set_postprocess(h, shadow_fault_generic_postprocess) ) + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); +} + +void shadow_resync_process(struct record_info *ri, struct hvm_data *h) +{ + struct { + unsigned long long gfn; + } *r = (typeof(r))ri->d; + + if(opt.dump_all) + printf(" %s oos resync %s gfn %llx\n", + ri->dump_header, + (ri->event == TRC_SHADOW_RESYNC_FULL)?"full":"only", + r->gfn); + + h->resyncs++; +} + +void shadow_prealloc_unpin_process(struct record_info *ri, struct hvm_data *h) { + struct { + unsigned long long gfn; + } *r = (typeof(r))ri->d; + + if(opt.dump_all) + printf(" %s prealloc-unpin gfn %llx\n", + ri->dump_header, r->gfn); + + if(h->prealloc_unpin) + fprintf(warn, "Strange, more than one prealloc_unpin per arc!\n"); + + h->prealloc_unpin = 1; + + if(opt.with_cr3_enumeration) + cr3_prealloc_unpin(h->v, r->gfn); +} + +void shadow_wrmap_bf_process(struct record_info *ri, struct hvm_data *h) { + struct { + unsigned long long gfn; + } *r = (typeof(r))ri->d; + + if(opt.dump_all) + printf(" %s wrmap-bf gfn %llx\n", + ri->dump_header, r->gfn); + + h->wrmap_bf = 1; +} + +void shadow_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + struct hvm_data *h; + + union shadow_event sevt = { .event = ri->event }; + + int gpl = sevt.paging_levels + 2; + + assert(p->current); + if(vcpu_set_data_type(p->current, VCPU_DATA_HVM)) + return; + + h = &p->current->hvm; + + if(!h->init || !h->vmexit_valid) + { + if(opt.dump_all) + shadow_fault_generic_dump(ri->event, + ri->d, + "!", ri->dump_header); + return; + } + + if(sevt.minor <= PF_XEN_NOT_SHADOW) { + if(p->current->guest_paging_levels != gpl) + { + fprintf(warn, "%s: Changing guest paging levels to %d\n", + __func__, gpl); + p->current->guest_paging_levels = gpl; + } + } + + if(sevt.minor <= PF_XEN_LAST_FAULT) { + h->inflight.pf_xen.pf_case = sevt.minor; + if(opt.summary) { + hvm_set_summary_handler(h, hvm_pf_xen_summary, NULL); + } + } + + /* FIXME - mask out paging levels */ + switch(sevt.minor) + { + case PF_XEN_NOT_SHADOW: + shadow_propagate_process(ri, h); + break; + case PF_XEN_EMULATE: + shadow_emulate_process(ri, h); + break; + case PF_XEN_FIXUP: + shadow_fixup_process(ri, h); + break; + case PF_XEN_MMIO: + case PF_XEN_FAST_MMIO: + shadow_mmio_process(ri, h); + break; + case PF_XEN_EMULATE_UNSHADOW_USER: + case PF_XEN_EMULATE_UNSHADOW_EVTINJ: + case PF_XEN_EMULATE_UNSHADOW_UNHANDLED: + shadow_emulate_other_process(ri, h); + break; +#if 0 + case PF_XEN_EMULATE_UNSYNC: + shadow_unsync_process(ri, h); + break; +#endif + case SHADOW_RESYNC_FULL: + case SHADOW_RESYNC_ONLY: + shadow_resync_process(ri, h); + break; + case SHADOW_PREALLOC_UNPIN: + shadow_prealloc_unpin_process(ri, h); + break; + case SHADOW_WRMAP_BF: + shadow_wrmap_bf_process(ri, h); + break; + default: + if(sevt.minor <= PF_XEN_LAST_FAULT) { + shadow_fault_generic_process(ri, h); + } else { + warn_once("Warning: processing shadow as generic\n"); + process_generic(ri); + } + break; + } +} + +/* ---- PV guests ---- */ +union pv_event { + unsigned event; + struct { + unsigned minor:8, + x64:1, + unused1:3, + sub:4, + main:12, + unused:4; + }; +}; + +void pv_hypercall_process(struct record_info *ri, struct pv_data *pv) { + union { + struct { + uint32_t eip, eax; + } x32; + struct { + uint64_t eip; + uint32_t eax; + } x64; + } * r = (typeof(r)) ri->d; + union pv_event pevt = { .event = ri->event }; + unsigned long long eip; + unsigned int eax; + + if(pevt.x64) { + eip = r->x64.eip; + eax = r->x64.eax; + } else { + eip = r->x32.eip; + eax = r->x32.eax; + } + + if(opt.summary_info) { + if(eax < PV_HYPERCALL_MAX) + pv->hypercall_count[eax]++; + } + + if(opt.dump_all) { + if(eax < HYPERCALL_MAX) + printf(" %s hypercall %2x (%s) eip %llx\n", + ri->dump_header, eax, + hypercall_name[eax], eip); + else + printf(" %s hypercall %x eip %llx\n", + ri->dump_header, eax, eip); + } +} + +void pv_trap_process(struct record_info *ri, struct pv_data *pv) { + union { + struct { + unsigned int eip; + unsigned trapnr:15, + use_error_code:1, + error_code:16; + } x32; + struct { + unsigned long long eip; + unsigned trapnr:15, + use_error_code:1, + error_code:16; + } x64; + } * r = (typeof(r)) ri->d; + union pv_event pevt = { .event = ri->event }; + unsigned long long eip; + unsigned trapnr, use_ec, ec; + + if(pevt.x64) { + eip = r->x64.eip; + trapnr = r->x64.trapnr; + use_ec = r->x64.use_error_code; + ec = r->x64.error_code; + } else { + eip = r->x32.eip; + trapnr = r->x32.trapnr; + use_ec = r->x32.use_error_code; + ec = r->x32.error_code; + } + + if(opt.summary_info) { + if(trapnr < PV_TRAP_MAX) + pv->trap_count[trapnr]++; + } + + if(opt.dump_all) { + printf(" %s trap %x eip %llx", + ri->dump_header, trapnr, eip); + if(use_ec) + printf(" ec %x\n", ec); + else + printf("\n"); + } +} + +void pv_ptwr_emulation_process(struct record_info *ri, struct pv_data *pv) { + union pv_event pevt = { .event = ri->event }; + union { + /* gpl2 is deprecated */ + struct { + unsigned long long pte; + unsigned int addr, eip; + } gpl3; + struct { + unsigned long long pte; + unsigned long long addr, eip; + } gpl4; + } *r = (typeof(r))ri->d; + struct { + unsigned long long pte, addr, eip; + } e; + + switch ( pevt.minor ) { + case PV_PTWR_EMULATION_PAE: + if ( pevt.x64 ) + { + fprintf(warn, "Strange: PV_PTWR_EMULATION, but x64! %x\n", + ri->event); + error(ERR_RECORD, ri); + } + e.pte = r->gpl3.pte; + e.addr = r->gpl3.addr; + e.eip = r->gpl3.eip; + break; + case PV_PTWR_EMULATION: + if ( !pevt.x64 ) + { + fprintf(warn, "Strange: PV_PTWR_EMULATION, but !x64! %x\n", + ri->event); + error(ERR_RECORD, ri); + } + e.pte = r->gpl4.pte; + e.addr = r->gpl4.addr; + e.eip = r->gpl4.eip; + break; + default: + fprintf(warn, "ERROR: Unknown PV_PTRW minor type %d!\n", + pevt.minor); + error(ERR_RECORD, ri); + return; + } + + if ( opt.dump_all ) + { + printf(" %s ptwr l1e %llx eip %llx addr %llx\n", + ri->dump_header, + e.pte, e.eip, e.addr); + } +} + +void pv_generic_process(struct record_info *ri, struct pv_data *pv) { + union pv_event pevt = { .event = ri->event }; + if ( opt.dump_all ) { + if(pevt.minor < PV_MAX && pv_name[pevt.minor]) + printf(" %s %s", + ri->dump_header, + pv_name[pevt.minor]); + else + printf(" %s PV-%d ", + ri->dump_header, pevt.minor); + if (ri->extra_words) { + int i; + printf("[ "); + for(i=0; i<ri->extra_words; i++) { + printf("%x ", (unsigned)ri->d[i]); + } + printf("]"); + + } + printf("\n"); + } +} + +void pv_summary(struct pv_data *pv) { + int i, j; + + if(!pv->summary_info) + return; + + printf("PV events:\n"); + for(i=0; i<PV_MAX; i++) { + int count; + + count = pv->count[i]; + if (i == PV_HYPERCALL_V2) + count += pv->count[PV_HYPERCALL_SUBCALL]; + + if (count == 0) + continue; + + printf(" %s %d\n", pv_name[i], count); + + switch(i) { + case PV_HYPERCALL: + case PV_HYPERCALL_V2: + for(j=0; j<PV_HYPERCALL_MAX; j++) { + if(pv->hypercall_count[j]) + printf(" %-29s[%2d]: %6d\n", + hypercall_name[j], + j, + pv->hypercall_count[j]); + } + break; + case PV_TRAP: + for(j=0; j<PV_TRAP_MAX; j++) { + if(pv->trap_count[j]) + printf(" [%d] %d\n", + j, pv->trap_count[j]); + } + break; + } + } +} + +static const char *grant_table_op_str[] = { + "map_grant_ref", "unmap_grant_ref", "setup_table", "dump_table", + "transfer", "copy", "query_size", "unmap_and_replace", + "set_version", "get_status_frames", "get_version", "swap_grant_ref", +}; + +static const char *vcpu_op_str[] = { + "initialise", "up", "down", "is_up", "get_runstate_info", + "register_runstate_memory_area", "set_periodic_timer", + "stop_periodic_timer", "set_singleshot_timer", "stop_singleshot_timer", + "register_vcpu_info", "send_nmi", "get_physid", + "register_vcpu_time_memory_area", +}; + +static const char *sched_op_str[] = { + "yield", "block", "shutdown", "poll", "remote_shutdown", "shutdown_code", + "watchdog", +}; + +static const char *cmd_to_str(const char *strings[], size_t n, uint32_t cmd) +{ + static char buf[32]; + + if (cmd < n) + return strings[cmd]; + + snprintf(buf, sizeof(buf), "unknown (%d)", cmd); + return buf; +} + +#define CMD_TO_STR(op) \ + static const char * op ## _to_str(uint32_t cmd) { \ + return cmd_to_str(op ## _str, ARRAY_SIZE(op ## _str), cmd); \ + } + +CMD_TO_STR(grant_table_op); +CMD_TO_STR(vcpu_op); +CMD_TO_STR(sched_op); + +void pv_hypercall_gather_args(const struct record_info *ri, uint64_t *args) +{ + int i, word; + + /* Missing arguments are zeroed. */ + memset(args, 0, 6 * sizeof(uint64_t)); + + for (i = 0, word = 1; i < 6 && word < ri->extra_words; i++) { + int present = pv_hypercall_arg_present(ri, i); + + switch (present) { + case ARG_32BIT: + args[i] = ri->d[word]; + break; + case ARG_64BIT: + args[i] = ((uint64_t)ri->d[word + 1] << 32) | ri->d[word]; + break; + } + + /* Skip over any words for this argument. */ + word += present; + } +} + +static void pv_hypercall_print_args(const struct record_info *ri) +{ + int i, word; + + for (i = 0, word = 1; i < 6 && word < ri->extra_words; i++) { + int present = pv_hypercall_arg_present(ri, i); + + switch (present) { + case ARG_MISSING: + printf(" ??"); + break; + case ARG_32BIT: + printf(" %08x", ri->d[word]); + break; + case ARG_64BIT: + printf(" %016"PRIu64"", ((uint64_t)ri->d[word + 1] << 32) | ri->d[word]); + break; + } + + word += present; + } +} + +void pv_hypercall_v2_process(struct record_info *ri, struct pv_data *pv, + const char *indent) +{ + int op = pv_hypercall_op(ri); + + if(opt.summary_info) { + if(op < PV_HYPERCALL_MAX) + pv->hypercall_count[op]++; + } + + if(opt.dump_all) { + uint64_t args[6]; + + if(op < HYPERCALL_MAX) + printf(" %s%s hypercall %2x (%s)", + ri->dump_header, indent, op, hypercall_name[op]); + else + printf(" %s%s hypercall %2x", + ri->dump_header, indent, op); + + switch(op) { + case HYPERCALL_mmu_update: + pv_hypercall_gather_args(ri, args); + printf(" %d updates%s", (uint32_t)args[1] & ~MMU_UPDATE_PREEMPTED, + (args[1] & MMU_UPDATE_PREEMPTED) ? " (preempted)" : ""); + break; + case HYPERCALL_multicall: + pv_hypercall_gather_args(ri, args); + printf(" %d calls", (uint32_t)args[1]); + break; + case HYPERCALL_grant_table_op: + pv_hypercall_gather_args(ri, args); + printf(" %s %d ops", grant_table_op_to_str(args[0]), (uint32_t)args[2]); + break; + case HYPERCALL_vcpu_op: + pv_hypercall_gather_args(ri, args); + printf(" %s vcpu %d", vcpu_op_to_str(args[0]), (uint32_t)args[1]); + break; + case HYPERCALL_mmuext_op: + pv_hypercall_gather_args(ri, args); + printf(" %d ops", (uint32_t)args[1]); + break; + case HYPERCALL_sched_op: + pv_hypercall_gather_args(ri, args); + printf(" %s", sched_op_to_str(args[0])); + break; + default: + pv_hypercall_print_args(ri); + break; + } + printf("\n"); + } +} + +void pv_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + struct vcpu_data *v = p->current; + struct pv_data *pv = &v->pv; + + union pv_event pevt = { .event = ri->event }; + + if(vcpu_set_data_type(p->current, VCPU_DATA_PV)) + return; + + if(opt.summary_info) { + pv->summary_info=1; + + if(pevt.minor == PV_PTWR_EMULATION_PAE) + pv->count[PV_PTWR_EMULATION]++; + else + pv->count[pevt.minor]++; + } + + switch(pevt.minor) + { + case PV_HYPERCALL: + pv_hypercall_process(ri, pv); + break; + case PV_TRAP: + pv_trap_process(ri, pv); + break; + case PV_PTWR_EMULATION: + case PV_PTWR_EMULATION_PAE: + pv_ptwr_emulation_process(ri, pv); + break; + case PV_HYPERCALL_V2: + pv_hypercall_v2_process(ri, pv, ""); + break; + case PV_HYPERCALL_SUBCALL: + pv_hypercall_v2_process(ri, pv, " "); + break; + default: + pv_generic_process(ri, pv); + break; + } +} + +/* ---- Schedule ---- */ +struct vcpu_data * vcpu_create(struct domain_data *d, int vid) +{ + struct vcpu_data *v; + + assert(d->vcpu[vid] == NULL); + + fprintf(warn, "Creating vcpu %d for dom %d\n", vid, d->did); + + if((v=malloc(sizeof(*v)))==NULL) + { + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*d)); + error(ERR_SYSTEM, NULL); + } + + bzero(v, sizeof(*v)); + + v->vid = vid; + v->d = d; + v->p = NULL; + v->runstate.state = RUNSTATE_INIT; + v->runstate.last_oldstate.wrong = RUNSTATE_INIT; + + d->vcpu[vid] = v; + + assert(v == v->d->vcpu[v->vid]); + + if(vid > d->max_vid) + d->max_vid = vid; + + return v; +} + +/* Called by both domain_create and sched_default_domain_init */ +void domain_init(struct domain_data *d, int did) +{ + bzero(d, sizeof(*d)); + + d->did = did; + d->next = NULL; + + if(opt.interval.check == INTERVAL_CHECK_DOMAIN) + interval_domain_value_check(d); +} + +struct domain_data * domain_create(int did) +{ + struct domain_data *d; + + fprintf(warn, "Creating domain %d\n", did); + + if((d=malloc(sizeof(*d)))==NULL) + { + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*d)); + error(ERR_SYSTEM, NULL); + } + + /* Initialize domain & vcpus */ + domain_init(d, did); + + return d; + } + +struct domain_data * domain_find(int did) +{ + struct domain_data *d, *n, **q; + + /* Look for domain, keeping track of the last pointer so we can add + a domain if we need to. */ + for ( d = domain_list, q=&domain_list ; + d && (d->did < did) ; + q = &d->next, d=d->next ) ; + + if(d && d->did == did) + return d; + + /* Make a new domain */ + n = domain_create(did); + + /* Insert it into the list */ + n->next = d; + *q = n; + + return n; +} + +struct vcpu_data * vcpu_find(int did, int vid) +{ + struct domain_data *d; + struct vcpu_data *v; + + d = domain_find(did); + + v = d->vcpu[vid]; + + if(!v) + v = vcpu_create(d, vid); + + return v; +} + +void pcpu_runstate_update(struct pcpu_info *p, tsc_t tsc) +{ + if ( p->time.tsc ) + { + if ( p->current->d->did == IDLE_DOMAIN ) + update_cycles(&p->time.idle, tsc - p->time.tsc); + else + update_cycles(&p->time.running, tsc - p->time.tsc); + p->time.tsc = 0; + } +} + +void vcpu_prev_update(struct pcpu_info *p, struct vcpu_data *prev, + tsc_t tsc, int new_runstate) +{ + assert(prev == prev->d->vcpu[prev->vid]); + + if(prev->p != p) + { + fprintf(warn, "Strange, sched_switch on pcpu %d, prev->pcpu %d!\n", + p->pid, prev->p->pid); + prev->runstate.tsc = 0; + goto set; + } + + //assert(p->current); + + if ( !p->current ) + { + fprintf(warn, "%s: FATAL: p->current NULL!\n", __func__); + error(ERR_ASSERT, NULL); + } + + if(p->current != prev) + { + fprintf(warn, "Strange, sched_switch prev d%dv%d, pcpu %d current d%dv%d!\n", + prev->d->did, prev->vid, + p->pid, p->current->d->did, p->current->vid); + prev->runstate.tsc = 0; + goto set; + } + + if(prev->runstate.state != RUNSTATE_RUNNING) + { + fprintf(warn, "Strange, prev d%dv%d not running!\n", + prev->d->did, prev->vid); + prev->runstate.tsc = 0; + goto set; + } + +set: + pcpu_runstate_update(p, tsc); + p->current = NULL; + pcpu_string_draw(p); + runstate_update(prev, new_runstate, tsc); +} + +void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc) +{ + assert(next == next->d->vcpu[next->vid]); + //assert(p->current == NULL); + + if ( p->current != NULL ) + { + if ( p->lost_record.seen_valid_schedule == 0 ) + { + fprintf(warn, "%s: p->current non-NULL, but seen_valid_schedule 0. Ignoring.\n", + __func__); + runstate_update(p->current, RUNSTATE_LOST, tsc); + p->current = NULL; + } + else + { + fprintf(warn, "%s: FATAL: p->current not NULL! (d%dv%d, runstate %s)\n", + __func__, + p->current->d->did, + p->current->vid, + runstate_name[p->current->runstate.state]); + error(ERR_ASSERT, NULL); + } + } + + if(next->activated) + { + /* We may get lost records at start-of-day, so ignore + setting runstate of default vcpus */ + if(next->runstate.state == RUNSTATE_RUNNING + && next->d->did != DEFAULT_DOMAIN) + { + fprintf(warn, "Strange, next d%dv%d already running on proc %d!\n", + next->d->did, next->vid, + next->p->pid); + next->runstate.tsc = 0; + } + + /* If we're moving from one pcpu to another, record change & update tsc */ + if(next->p != p) { + if(next->pcpu_tsc) + { + update_cycles(&next->cpu_affinity_all, tsc - next->pcpu_tsc); + update_cycles(&next->cpu_affinity_pcpu[p->pid], tsc - next->pcpu_tsc); + } + next->pcpu_tsc = tsc; + } + } + else + { + next->guest_paging_levels = opt.default_guest_paging_levels; + next->activated = 1; + next->pcpu_tsc = tsc; + } + + runstate_update(next, RUNSTATE_RUNNING, tsc); + + if ( opt.scatterplot_pcpu + && next->d->did != IDLE_DOMAIN + && next->d->did != DEFAULT_DOMAIN ) + { + struct time_struct t; + + abs_cycles_to_time(tsc, &t); + + if ( next->p ) + printf("%dv%d %u.%09u %d\n", + next->d->did, next->vid, + t.s, t.ns, + next->p->pid); + printf("%dv%d %u.%09u %d\n", + next->d->did, next->vid, + t.s, t.ns, + p->pid); + } + + next->p = p; + p->current = next; + pcpu_string_draw(p); + p->time.tsc = tsc; + p->lost_record.seen_valid_schedule = 1; +} + +/* If current is the default domain, we're fixing up from something + * like start-of-day. Update what we can. */ +void vcpu_start(struct pcpu_info *p, struct vcpu_data *v) { + /* If vcpus are created, or first show up, in a "dead zone", this will + * fail. */ + if( !p->current || p->current->d->did != DEFAULT_DOMAIN) { + fprintf(stderr, "Strange, p->current not default domain!\n"); + error(ERR_FILE, NULL); + return; + } + + if(!p->first_tsc) { + fprintf(stderr, "Strange, p%d first_tsc 0!\n", p->pid); + error(ERR_FILE, NULL); + } + + if(p->first_tsc <= p->current->runstate.tsc) { + fprintf(stderr, "Strange, first_tsc %llx < default_domain runstate tsc %llx!\n", + p->first_tsc, + p->current->runstate.tsc); + error(ERR_FILE, NULL); + } + + /* Change default domain to 'queued' */ + runstate_update(p->current, RUNSTATE_QUEUED, p->first_tsc); + + /* FIXME: Copy over data from the default domain this interval */ + fprintf(warn, "Using first_tsc for d%dv%d (%lld cycles)\n", + v->d->did, v->vid, p->last_tsc - p->first_tsc); + + /* Simulate the time since the first tsc */ + runstate_update(v, RUNSTATE_RUNNING, p->first_tsc); + p->time.tsc = p->first_tsc; + p->current = v; + pcpu_string_draw(p); + v->p = p; +} + +void sched_runstate_process(struct pcpu_info *p) +{ + enum { + CHANGE=0, + CONTINUE + } type; + struct vcpu_data *v; + struct record_info *ri = &p->ri; + struct { + unsigned vcpu:16, dom:16; + unsigned long long p1, p2; + } __attribute__((packed)) * r = (typeof(r))ri->d; + union { + unsigned int event; + struct { + unsigned lo:4, + new_runstate:4, + old_runstate:4, + sub:4, + main:12, + unused:4; + }; + } _sevt = { .event = ri->event }; + struct { + int new_runstate, old_runstate; + } sevt; + int perfctrs; + struct last_oldstate_struct last_oldstate; + + switch(_sevt.lo) + { + case 1: + type = CHANGE; + sevt.new_runstate = _sevt.new_runstate; + sevt.old_runstate = _sevt.old_runstate; + break; + case 2: + type = CONTINUE; + sevt.new_runstate = sevt.old_runstate = RUNSTATE_RUNNING; + break; + default: + fprintf(warn, "FATAL: Unexpected runstate change type %d!\n", + _sevt.lo); + error(ERR_RECORD, NULL); + return; + } + + perfctrs = (ri->extra_words == 5); + + if(opt.dump_all) { + if( perfctrs ) { + printf(" %s %s {%lld,%lld} d%uv%u %s->%s\n", + ri->dump_header, + type?"runstate_continue":"runstate_change", + r->p1, r->p2, + r->dom, r->vcpu, + runstate_name[sevt.old_runstate], + runstate_name[sevt.new_runstate]); + } else { + printf(" %s %s d%uv%u %s->%s\n", + ri->dump_header, + type?"runstate_continue":"runstate_change", + r->dom, r->vcpu, + runstate_name[sevt.old_runstate], + runstate_name[sevt.new_runstate]); + } + } + + /* Sanity check: expected transitions */ + if ( type == CHANGE ) + { + if( (sevt.new_runstate == RUNSTATE_RUNNING + && sevt.old_runstate != RUNSTATE_RUNNABLE) + || (sevt.new_runstate == RUNSTATE_BLOCKED + && sevt.old_runstate == RUNSTATE_RUNNABLE ) ) + { + fprintf(warn, "Strange, d%dv%d unexpected runstate transition %s->%s\n", + r->dom, r->vcpu, + runstate_name[sevt.old_runstate], + runstate_name[sevt.new_runstate]); + } + } + + if(r->vcpu > MAX_CPUS) + { + fprintf(warn, "%s: vcpu %u > MAX_VCPUS %d!\n", + __func__, r->vcpu, MAX_CPUS); + return; + } + + v = vcpu_find(r->dom, r->vcpu); + + /* We want last_oldstate reset every time; so copy the last one and use + * that locally, clobbering the one in the vcpu struct. If it needs to + * be reset, it will be reset below. */ + last_oldstate = v->runstate.last_oldstate; + v->runstate.last_oldstate.wrong = RUNSTATE_INIT; + + /* Close vmexits when the putative reason for blocking / &c stops. + * This way, we don't account cpu contention to some other overhead. */ + if(sevt.new_runstate == RUNSTATE_RUNNABLE + && v->data_type == VCPU_DATA_HVM + && v->hvm.vmexit_valid) { + hvm_close_vmexit(&v->hvm, ri->tsc); + } + + /* Track waking state */ + if ( v->data_type == VCPU_DATA_HVM && v->runstate.state != RUNSTATE_LOST ) { + if ( sevt.new_runstate == RUNSTATE_RUNNABLE + && sevt.old_runstate == RUNSTATE_BLOCKED ) + { + /* Hmm... want to make sure we're not in some weird + vmexit state... have to look later. */ + if(opt.dump_all) + printf(" [w2h] d%dv%d Setting waking\n", v->d->did, v->vid); + v->hvm.w2h.waking = 1; + } + else if ( sevt.new_runstate != RUNSTATE_RUNNING + || sevt.old_runstate != RUNSTATE_RUNNABLE ) + { + if( v->hvm.w2h.waking + && sevt.old_runstate == RUNSTATE_RUNNING + && sevt.new_runstate != RUNSTATE_OFFLINE ) + { + /* NB: This is printed a lot unnecessairly when there is TSC skew */ + if ( sevt.old_runstate != v->runstate.state ) + fprintf(warn, "Strange, unexpected waking transition for d%dv%d: %s -> %s\n", + v->d->did, v->vid, + runstate_name[sevt.old_runstate], + runstate_name[sevt.new_runstate]); + v->hvm.w2h.waking = 0; + } + + /* Close wake-to-halt summary */ + /* FIXME: Need to think about handling preemption. */ + if (sevt.new_runstate == RUNSTATE_BLOCKED + && sevt.old_runstate == RUNSTATE_RUNNING + && v->hvm.w2h.interrupts ) { + int i; + for(i=0; i<GUEST_INTERRUPT_MAX; i++) { + struct hvm_gi_struct *g=v->hvm.summary.guest_interrupt + i; + tsc_t start_tsc = g->start_tsc; + if(start_tsc) { + tsc_t t = (start_tsc == 1) ? 0 : ri->tsc - start_tsc; + if(opt.dump_all) + printf(" [w2h] Halting vec %d is_wake %d time %lld\n", + i, + g->is_wake, + t); + + if(opt.scatterplot_wake_to_halt + && t + && g->is_wake) + scatterplot_vs_time(ri->tsc, t); + + if(opt.summary && t) { + if(g->is_wake) { + if(v->hvm.w2h.interrupts==1) + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE], + t); + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY], + t); + } else { + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT], + t); + } + } + g->start_tsc = 0; + g->is_wake = 0; + } + } + v->hvm.w2h.interrupts = 0; + v->hvm.w2h.vector = 0; + } + } + } + + /* Sanity checks / tsc skew detection */ + if( v->runstate.state != sevt.old_runstate + && v->runstate.state != RUNSTATE_INIT ) + { + if(v->runstate.state == RUNSTATE_LOST) { + if( sevt.new_runstate == RUNSTATE_RUNNING ) + goto update; + else if(opt.dump_all) + fprintf(warn, "%s: d%dv%d in runstate lost, not updating to %s\n", + __func__, v->d->did, v->vid, + runstate_name[sevt.new_runstate]); + goto no_update; + } else if (last_oldstate.wrong == sevt.new_runstate + && last_oldstate.actual == sevt.old_runstate) { + tsc_t lag, old_offset; + struct pcpu_info *p2; + + if(ri->tsc < last_oldstate.tsc) { + fprintf(warn, "WARNING: new tsc %lld < detected runstate tsc %lld! Not updating\n", + ri->tsc, last_oldstate.tsc); + goto no_update; + } + + p2 = P.pcpu + last_oldstate.pid; + + lag = ri->tsc + - last_oldstate.tsc; + + old_offset = p2->tsc_skew.offset; + + cpumask_union(&p2->tsc_skew.downstream, &p->tsc_skew.downstream); + cpumask_set(&p2->tsc_skew.downstream, p->pid); + + if(cpumask_isset(&p2->tsc_skew.downstream, p2->pid)) { + if ( opt.tsc_loop_fatal ) + { + fprintf(stderr, "FATAL: tsc skew dependency loop detected!\n"); + error(ERR_FILE, NULL); + } + else + { + int i; + fprintf(warn, "Tsc skew dependency loop detected! Resetting...\n"); + for ( i=0; i<=P.max_active_pcpu; i++) + { + struct pcpu_info *p = P.pcpu + i; + + p->tsc_skew.offset = 0; + cpumask_init(&p->tsc_skew.downstream); + } + goto no_update; + } + } + + p2->tsc_skew.offset += lag * 2; + + fprintf(warn, "TSC skew detected p%d->p%d, %lld cycles. Changing p%d offset from %lld to %lld\n", + p->pid, p2->pid, lag, + p2->pid, + old_offset, + p2->tsc_skew.offset); + + goto no_update; + } else { + fprintf(warn, "runstate_change old_runstate %s, d%dv%d runstate %s. Possible tsc skew.\n", + runstate_name[sevt.old_runstate], + v->d->did, v->vid, + runstate_name[v->runstate.state]); + + v->runstate.last_oldstate.wrong = sevt.old_runstate; + v->runstate.last_oldstate.actual = v->runstate.state; + v->runstate.last_oldstate.tsc = ri->tsc; + v->runstate.last_oldstate.pid = p->pid; + + if ( v->runstate.state == RUNSTATE_RUNNING ) + { + fprintf(warn, " Not updating.\n"); + goto no_update; + } + goto update; + } + fprintf(stderr, "FATAL: Logic hole in %s\n", __func__); + error(ERR_ASSERT, NULL); + } + +update: + /* Actually update the runstate. Special things to do if we're starting + * or stopping actually running on a physical cpu. */ + if ( type == CONTINUE ) + { + if( v->runstate.state == RUNSTATE_INIT ) { + /* Start-of-day; account first tsc -> now to v */ + vcpu_start(p, v); + } else { + /* Continue running. First, do some sanity checks */ + if ( v->runstate.state == RUNSTATE_LOST ) { + fprintf(warn, "WARNING: continue with d%dv%d in RUNSTATE_LOST. Resetting current.\n", + v->d->did, v->vid); + if ( p->current ) + vcpu_prev_update(p, p->current, ri->tsc, RUNSTATE_LOST); + vcpu_next_update(p, v, ri->tsc); + } + else if( v->runstate.state != RUNSTATE_RUNNING ) { + /* This should never happen. */ + fprintf(warn, "FATAL: sevt.old_runstate running, but d%dv%d runstate %s!\n", + v->d->did, v->vid, runstate_name[v->runstate.state]); + error(ERR_FILE, NULL); + } else if ( v->p != p ) { + fprintf(warn, "FATAL: continue on p%d, but d%dv%d p%d!\n", + p->pid, v->d->did, v->vid, + v->p ? v->p->pid : -1); + error(ERR_FILE, NULL); + } + + runstate_update(v, RUNSTATE_RUNNING, ri->tsc); + } + } + else if ( sevt.old_runstate == RUNSTATE_RUNNING + || v->runstate.state == RUNSTATE_RUNNING ) + { +#if 0 + /* A lot of traces include cpi that shouldn't... */ + if(perfctrs && v->runstate.tsc) { + unsigned long long run_cycles, run_instr; + double cpi; + + //run_cycles = r->p1 - v->runstate_p1_start; + run_cycles = ri->tsc - v->runstate.tsc; + run_instr = r->p2 - v->runstate.p2_start; + + cpi = ((double)run_cycles) / run_instr; + + if(opt.dump_all) { + printf(" cpi: %2.2lf ( %lld / %lld )\n", + cpi, run_cycles, run_instr); + } + + if(opt.scatterplot_cpi && v->d->did == 1) + printf("%lld,%2.2lf\n", + ri->tsc, cpi); + + if(opt.summary_info) + update_cpi(&v->cpi, run_instr, run_cycles); + } +#endif + /* + * Cases: + * old running, v running: + * normal (prev update p, lost record check) + * v running, old ! running: + * tsc skew (prev update v->p, lost record check) + * old running, v init: + start-of-day (fake update, prev p, lost record) + * old running, v !{running,init}: + * # (should never happen) + */ + if( sevt.old_runstate == RUNSTATE_RUNNING ) { + if( v->runstate.state == RUNSTATE_INIT ) { + /* Start-of-day; account first tsc -> now to v */ + vcpu_start(p, v); + } else if( v->runstate.state != RUNSTATE_RUNNING + && v->runstate.state != RUNSTATE_LOST ) { + /* This should never happen. */ + fprintf(warn, "FATAL: sevt.old_runstate running, but d%dv%d runstate %s!\n", + v->d->did, v->vid, runstate_name[v->runstate.state]); + error(ERR_FILE, NULL); + } + + vcpu_prev_update(p, v, ri->tsc, sevt.new_runstate); + } else { + vcpu_prev_update(v->p, v, ri->tsc, sevt.new_runstate); + } + + if(P.lost_cpus && v->d->did != IDLE_DOMAIN) { + if(opt.dump_all) + fprintf(warn, "%s: %d lost cpus, setting d%dv%d runstate to RUNSTATE_LOST\n", + __func__, P.lost_cpus, v->d->did, v->vid); + lose_vcpu(v, ri->tsc); + } + } + else if ( sevt.new_runstate == RUNSTATE_RUNNING ) + { + if(perfctrs) { + v->runstate.p1_start = r->p1; + v->runstate.p2_start = r->p2; + } + + vcpu_next_update(p, v, ri->tsc); + } + else if ( v->runstate.state != RUNSTATE_INIT ) + { + /* TSC skew at start-of-day is hard to deal with. Don't + * bring a vcpu out of INIT until it's seen to be actually + * running somewhere. */ + runstate_update(v, sevt.new_runstate, ri->tsc); + } + +no_update: + return; +} + +void sched_switch_process(struct pcpu_info *p) +{ + struct vcpu_data *prev, *next; + struct record_info *ri = &p->ri; + struct { + unsigned int prev_dom, prev_vcpu, next_dom, next_vcpu; + } * r = (typeof(r))ri->d; + + if(opt.dump_all) + printf("%s sched_switch prev d%uv%u next d%uv%u\n", + ri->dump_header, + r->prev_dom, r->prev_vcpu, + r->next_dom, r->next_vcpu); + + if(r->prev_vcpu > MAX_CPUS) + { + fprintf(warn, "%s: prev_vcpu %u > MAX_VCPUS %d!\n", + __func__, r->prev_vcpu, MAX_CPUS); + return; + } + + if(r->next_vcpu > MAX_CPUS) + { + fprintf(warn, "%s: next_vcpu %u > MAX_VCPUS %d!\n", + __func__, r->next_vcpu, MAX_CPUS); + return; + } + + prev = vcpu_find(r->prev_dom, r->prev_vcpu); + next = vcpu_find(r->next_dom, r->next_vcpu); + + vcpu_prev_update(p, prev, ri->tsc, RUNSTATE_QUEUED); /* FIXME */ + + vcpu_next_update(p, next, ri->tsc); +} + +void sched_default_vcpu_activate(struct pcpu_info *p) +{ + struct vcpu_data *v = default_domain.vcpu[p->pid]; + + if(!v) + v = vcpu_create(&default_domain, p->pid); + + assert(v == v->d->vcpu[v->vid]); + + v->activated = 1; + v->guest_paging_levels = opt.default_guest_paging_levels; + v->p = p; + v->runstate.state = RUNSTATE_RUNNING; + + p->current = v; + pcpu_string_draw(p); +} + +void sched_default_domain_init(void) +{ + struct domain_data *d = &default_domain; + + domain_init(d, DEFAULT_DOMAIN); +} + +void runstate_clear(tsc_t * runstate_cycles) +{ + int i; + for(i=0; i<RUNSTATE_MAX; i++) + runstate_cycles[i]=0; +} + +void runstate_summary(tsc_t * runstate_cycles) +{ + int i; + for(i=0; i<RUNSTATE_MAX; i++) + if(runstate_cycles[i]) { + struct time_struct t; + cycles_to_time(runstate_cycles[i], &t); + printf(" %s: %u.%09u s\n", + runstate_name[i], t.s, t.ns); + } +} + +void sched_summary_vcpu(struct vcpu_data *v) +{ + int i; + char desc[30]; + + /* FIXME: Update all records like this */ + if ( v->pcpu_tsc ) + { + update_cycles(&v->cpu_affinity_all, P.f.last_tsc - v->pcpu_tsc); + update_cycles(&v->cpu_affinity_pcpu[v->p->pid], P.f.last_tsc - v->pcpu_tsc); + } + + printf(" Runstates:\n"); + for(i=0; i<RUNSTATE_MAX; i++) { + snprintf(desc,30, " %8s", runstate_name[i]); + print_cycle_summary(v->runstates+i, desc); + if ( i==RUNSTATE_RUNNABLE ) + { + int j; + for(j=0; j<RUNNABLE_STATE_MAX; j++) { + if ( j == RUNNABLE_STATE_INVALID ) + continue; + snprintf(desc,30, " %8s", runnable_state_name[j]); + print_cycle_summary(v->runnable_states+j, desc); + } + } + } + print_cpi_summary(&v->cpi); + print_cpu_affinity(&v->cpu_affinity_all, " cpu affinity"); + for ( i = 0; i < MAX_CPUS ; i++) + { + snprintf(desc,30, " [%d]", i); + print_cpu_affinity(v->cpu_affinity_pcpu+i, desc); + } +} + +void sched_summary_domain(struct domain_data *d) +{ + int i; + char desc[30]; + + printf(" Runstates:\n"); + for(i=0; i<DOMAIN_RUNSTATE_MAX; i++) { + snprintf(desc,30, " %8s", domain_runstate_name[i]); + print_cycle_summary(d->runstates+i, desc); + } +} + + +void sched_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + if(ri->evt.sub == 0xf) { + switch(ri->event) + { + case TRC_SCHED_SWITCH: + sched_switch_process(p); + break; + default: + process_generic(&p->ri); + } + } else { + if(ri->evt.sub == 1) + sched_runstate_process(p); + else { + UPDATE_VOLUME(p, sched_verbose, ri->size); + process_generic(&p->ri); + } + } +} + +/* ---- Memory ---- */ +void mem_summary_domain(struct domain_data *d) { + int i, j; + + printf(" Grant table ops:\n"); + + printf(" Done by:\n"); + for(i=0; i<MEM_MAX; i++) + if(d->memops.done[i]) + printf(" %-14s: %d\n", + mem_name[i], + d->memops.done[i]); + + printf(" Done for:\n"); + for(i=0; i<MEM_MAX; i++) + if(d->memops.done_for[i]) + printf(" %-14s: %d\n", + mem_name[i], + d->memops.done_for[i]); + + printf(" Populate-on-demand:\n"); + printf(" Populated:\n"); + for(i=0; i<4; i++) + { + if ( d->pod.populate_order[i] ) + printf(" [%d] %d\n", i, + d->pod.populate_order[i]); + } + printf(" Reclaim order:\n"); + for(i=0; i<4; i++) + { + if ( d->pod.reclaim_order[i] ) + printf(" [%d] %d\n", i, + d->pod.reclaim_order[i]); + } + printf(" Reclaim contexts:\n"); + for(j=0; j<POD_RECLAIM_CONTEXT_MAX; j++) + { + if ( d->pod.reclaim_context[j] ) + { + printf(" * [%s] %d\n", + pod_reclaim_context_name[j], + d->pod.reclaim_context[j]); + for(i=0; i<4; i++) + { + if ( d->pod.reclaim_context_order[j][i] ) + printf(" [%d] %d\n", i, + d->pod.reclaim_context_order[j][i]); + } + } + } +} + +int p2m_canonical_order(int order) +{ + if ( order % 9 + || (order / 9) > 2 ) + { + fprintf(warn, "%s: Strange, non-canonical order %d\n", + __func__, order); + order = 4; + } else { + order /= 9; + } + return order; +} + +void mem_pod_zero_reclaim_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + int context = POD_RECLAIM_CONTEXT_UNKNOWN; + struct vcpu_data *v = p->current; + + struct { + uint64_t gfn, mfn; + int d:16,order:16; + } *r = (typeof(r))ri->d; + + if ( v && v->hvm.vmexit_valid ) + { + switch(v->hvm.exit_reason) + { + case EXIT_REASON_EPT_VIOLATION: + case EXIT_REASON_EXCEPTION_NMI: + context = POD_RECLAIM_CONTEXT_FAULT; + break; + case EXIT_REASON_VMCALL: + context = POD_RECLAIM_CONTEXT_BALLOON; + break; + } + } + + if ( opt.dump_all ) + { + printf(" %s pod_zero_reclaim d%d o%d g %llx m %llx ctx %s\n", + ri->dump_header, + r->d, r->order, + (unsigned long long)r->gfn, (unsigned long long)r->mfn, + pod_reclaim_context_name[context]); + + } + + if ( opt.summary_info ) + { + struct domain_data *d; + + if ( v && (d=v->d) ) + { + int order; + + order = p2m_canonical_order(r->order); + + d->pod.reclaim_order[order]++; + d->pod.reclaim_context[context]++; + d->pod.reclaim_context_order[context][order]++; + } + } +} + +void mem_pod_populate_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + struct { + uint64_t gfn, mfn; + int d:16,order:16; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s pod_populate d%d o%d g %llx m %llx\n", + ri->dump_header, + r->d, r->order, + (unsigned long long)r->gfn, (unsigned long long)r->mfn); + } + + if ( opt.summary_info ) + { + struct vcpu_data *v = p->current; + struct domain_data *d; + + if ( v && (d=v->d) ) + { + int order; + + order = p2m_canonical_order(r->order); + + d->pod.populate_order[order]++; + } + } +} + +void mem_pod_superpage_splinter_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + struct { + uint64_t gfn; + int d:16; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s pod_spage_splinter d%d g %llx\n", + ri->dump_header, + r->d, (unsigned long long)r->gfn); + } +} + +void mem_page_grant(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + struct { + unsigned domain; + } *r = (typeof(r))ri->d; + union pv_event pevt = { .event = ri->event }; + + if ( opt.dump_all ) + { + printf(" %s %s domain %u\n", ri->dump_header, mem_name[pevt.minor], r->domain); + } +} +void mem_set_p2m_entry_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + struct { + uint64_t gfn, mfn; + int p2mt; + int d:16,order:16; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s set_p2m_entry d%d o%d t %d g %llx m %llx\n", + ri->dump_header, + r->d, r->order, + r->p2mt, + (unsigned long long)r->gfn, (unsigned long long)r->mfn); + } +} + +void mem_decrease_reservation_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + struct { + uint64_t gfn; + int d:16,order:16; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s decrease_reservation d%d o%d g %llx\n", + ri->dump_header, + r->d, r->order, + (unsigned long long)r->gfn); + } +} + +void mem_process(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + struct { + int dom; + } *r = (typeof(r))ri->d; + + int minor = ri->evt.minor; + + switch ( minor ) + { + case MEM_PAGE_GRANT_MAP: + case MEM_PAGE_GRANT_UNMAP: + case MEM_PAGE_GRANT_TRANSFER: + mem_page_grant(p); + break; + case MEM_SET_P2M_ENTRY: + mem_set_p2m_entry_process(p); + break; + case MEM_DECREASE_RESERVATION: + mem_decrease_reservation_process(p); + break; + case MEM_POD_POPULATE: + mem_pod_populate_process(p); + break; + case MEM_POD_ZERO_RECLAIM: + mem_pod_zero_reclaim_process(p); + break; + case MEM_POD_SUPERPAGE_SPLINTER: + mem_pod_superpage_splinter_process(p); + break; + default: + if(opt.dump_all) { + dump_generic(stdout, ri); + } + + if(opt.summary_info && minor < MEM_MAX) { + struct domain_data *d; + + if(p->current) { + if (p->current->d) { + p->current->d->memops.done[minor]++; + p->current->d->memops.done_interval[minor]++; + } + if((d=domain_find(r->dom))) { + d->memops.done_for[minor]++; + d->memops.done_for_interval[minor]++; + } + } + } + break; + } + +} + +/* ---- PM ---- */ +#define CSTATE_MAX 5 +#define CSTATE_INVALID ((CSTATE_MAX)+1) +void pm_process(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + + switch ( ri->event ) + { + case TRC_PM_FREQ_CHANGE: + if (opt.dump_all ) + printf(" %s pm_freq_change o%d n%d\n", + ri->dump_header, + ri->d[0], + ri->d[1]); + break; + case TRC_PM_IDLE_ENTRY: + if (opt.dump_all ) + printf(" %s pm_idle_start c%d\n", + ri->dump_header, + ri->d[0]); + if ( ri->d[0] <= CSTATE_MAX ) + { + p->power_state=ri->d[0]; + pcpu_string_draw(p); + } + break; + case TRC_PM_IDLE_EXIT: + if (opt.dump_all ) + printf(" %s pm_idle_end c%d\n", + ri->dump_header, + ri->d[0]); + if ( p->power_state != ri->d[0] + && p->power_state != CSTATE_INVALID ) + printf("Strange, pm_idle_end %d, power_state %d!\n", + ri->d[0], p->power_state); + p->power_state = 0; + pcpu_string_draw(p); + break; + default: + if(opt.dump_all) { + dump_generic(stdout, ri); + } + break; + } + +} + +/* + * IRQ related stuff + */ + +#define MAX_VECTOR 256 +int global_vector_used[256] = {0}; +struct pci_dev { + uint8_t bus; + uint8_t devfn; + int vector_used[MAX_VECTOR]; + struct pci_dev *next; +} *pdev_list; + +#define MAX_IRQ 512 +struct irq_desc { + enum { + IRQ_NONE, + IRQ_MSI, + IRQ_GSI + } type; + struct pci_dev *dev; +} irq_table[MAX_IRQ]; + +struct pci_dev * pdev_find(uint8_t bus, uint8_t devfn) +{ + struct pci_dev *d, *n, **q; + + /* Look for domain, keeping track of the last pointer so we can add + a domain if we need to. */ + for ( d = pdev_list, q=&pdev_list ; + d && ( (d->bus < bus) + || (d->bus == bus && d->devfn < devfn) ) ; + q = &d->next, d=d->next ) ; + + if(d && d->bus == bus && d->devfn == devfn) + return d; + + /* Make a new domain */ + fprintf(warn, "Creating pdev %02x:%02x.%x\n", bus, devfn>>4, devfn&3); + + if((n=malloc(sizeof(*n)))==NULL) + { + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*n)); + error(ERR_SYSTEM, NULL); + } + + bzero(n, sizeof(*n)); + + n->bus=bus; + n->devfn=devfn; + + /* Insert it into the list */ + n->next = d; + *q = n; + + return n; +} + +void irq_process(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + + switch ( ri->event ) + { + case TRC_HW_IRQ_BIND_VECTOR: + { + struct { + int irq, vec; + unsigned mask[4]; + } *r = (typeof(r))ri->d; + if ( opt.dump_all ) + { + printf(" %s irq_bind_vector irq %x vec %x mask %04x %04x %04x %04x\n", + ri->dump_header, + r->irq, r->vec, + r->mask[3], + r->mask[2], + r->mask[1], + r->mask[0]); + } + break; + } + case TRC_HW_IRQ_HANDLED: + { + struct { + int irq, start_tsc, end_tsc; + } *r = (typeof(r))ri->d; + int arctime; + + arctime = r->end_tsc - r->start_tsc; + if ( opt.dump_all ) + { + printf(" %s irq_handled irq %x %d (%d,%d)\n", + ri->dump_header, + r->irq, arctime, r->start_tsc, r->end_tsc); + } + if ( opt.scatterplot_irq ) + { + struct time_struct t; + + abs_cycles_to_time(ri->tsc, &t); + + printf("i%x %u.%09u %d\n", + (unsigned)r->irq, + t.s, t.ns, + p->pid); + } + break; + } + case TRC_HW_IRQ_ASSIGN_VECTOR: + { + struct { + int irq, vec; + unsigned mask[4]; + } *r = (typeof(r))ri->d; + if ( opt.dump_all ) + { + printf(" %s irq_assign_vector irq %x vec %x mask %04x %04x %04x %04x\n", + ri->dump_header, + r->irq, r->vec, + r->mask[3], + r->mask[2], + r->mask[1], + r->mask[0]); + } + if ( r->irq < MAX_IRQ + && r->vec < MAX_VECTOR ) + { + if ( irq_table[r->irq].type == IRQ_MSI ) + { + if(global_vector_used[r->vec]) + fprintf(warn, " Vector collision on global table!\n"); + global_vector_used[r->vec]=1; + } + if( irq_table[r->irq].dev ) + { + struct pci_dev * pdev=irq_table[r->irq].dev; + + if(pdev->vector_used[r->vec]) + fprintf(warn, " Vector collision on %02x.%02x!\n", + pdev->bus, pdev->devfn); + pdev->vector_used[r->vec]=1; + } + } + break; + } + case TRC_HW_IRQ_MOVE_CLEANUP_DELAY: + { + struct { + int irq, vec, cpu; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s irq_move_cleanup_delay irq %x vec %x cpu %d\n", + ri->dump_header, + r->irq, r->vec, r->cpu); + } + break; + } + case TRC_HW_IRQ_MOVE_CLEANUP: + { + struct { + int irq; + int vec; + int cpu; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s irq_move_cleanup irq %x vec %x cpu %d\n", + ri->dump_header, + r->irq, r->vec, r->cpu); + } + if ( r->irq < MAX_IRQ + && r->vec < MAX_VECTOR ) + { + if ( irq_table[r->irq].type == IRQ_MSI ) + { + if(!global_vector_used[r->vec]) + fprintf(warn," Strange, cleanup on non-used vector\n"); + global_vector_used[r->vec]=0; + } + if ( irq_table[r->irq].dev ) + { + struct pci_dev * pdev=irq_table[r->irq].dev; + + if(!pdev->vector_used[r->vec]) + fprintf(warn," Strange, cleanup on non-used vector\n"); + pdev->vector_used[r->vec]=0; + } + } + break; + } + case TRC_HW_IRQ_UNMAPPED_VECTOR: + { + struct { + int vec; + } *r = (typeof(r))ri->d; + + if ( opt.dump_all ) + { + printf(" %s irq_unmapped_vector vec %x\n", + ri->dump_header, + r->vec); + } + break; + } + case TRC_HW_IRQ_CLEAR_VECTOR: + case TRC_HW_IRQ_MOVE_FINISH : + default: + if(opt.dump_all) { + dump_generic(stdout, ri); + } + break; + } +} + +#define TRC_HW_SUB_PM 1 +#define TRC_HW_SUB_IRQ 2 +void hw_process(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + + switch(ri->evt.sub) + { + case TRC_HW_SUB_PM: + pm_process(p); + break; + case TRC_HW_SUB_IRQ: + irq_process(p); + break; + } + +} +/* ---- Base ----- */ +void dump_generic(FILE * f, struct record_info *ri) +{ + int i; + + fprintf(f, "]%s %7x(%x:%x:%x) %u [", + ri->dump_header, + ri->event, + ri->evt.main, + ri->evt.sub, + ri->evt.minor, + ri->extra_words); + + for(i=0; i<ri->extra_words; i++) { + fprintf(f, " %x", ri->d[i]); + } + + fprintf(f, " ]\n"); +} + +void dump_raw(char * s, struct record_info *ri) +{ + int i; + + if(ri->rec.cycle_flag) + printf("%s %7x %d %14lld [", + s, ri->event, ri->extra_words, ri->tsc); + else + printf("%s %7x %d %14s [", + s, ri->event, ri->extra_words, "-"); + + for(i=0; i<7; i++) { + if ( i < ri->extra_words ) + printf(" %8x", ri->d[i]); + else + printf(" "); + } + + printf(" ] | "); + + for (i=0; i<8; i++) { + printf(" %08x", ri->rec.raw[i]); + } + + printf(" |\n"); +} + +void error(enum error_level l, struct record_info *ri) +{ + if ( l > opt.tolerance ) + { + if ( ri ) + dump_generic(warn, ri); + exit(1); + } +} + +int check_extra_words(struct record_info *ri, + int expected_size, + const char *record) +{ + static int off_by_one = 0; + int expected_extra = expected_size / sizeof(unsigned int); + + if(ri->extra_words != expected_extra + && !(off_by_one && ri->extra_words == expected_extra + 1) ) + { + if ( !off_by_one && ri->extra_words == expected_extra + 1 ) + { + fprintf(warn, "Detected off-by-one bug; relaxing expectations\n"); + off_by_one=1; + } + else { + fprintf(warn, "ERROR: %s extra_words %d, expected %d!\n", + record, + ri->extra_words, expected_extra); + error(ERR_RECORD, ri); + return 1; + } + } + return 0; +} + +void process_generic(struct record_info *ri) { + + error(ERR_STRICT, ri); + + if(opt.dump_all) { + dump_generic(stdout, ri); + } +} + +int vcpu_set_data_type(struct vcpu_data *v, int type) +{ + if (v->data_type == VCPU_DATA_NONE ) + { + v->data_type = type; + switch(type) + { + case VCPU_DATA_HVM: + init_hvm_data(&v->hvm, v); + break; + default: + break; + } + } + else + assert(v->data_type == type); + return 0; +} + + +void lose_vcpu(struct vcpu_data *v, tsc_t tsc) +{ + if(v->data_type == VCPU_DATA_HVM) + v->hvm.vmexit_valid=0; + runstate_update(v, RUNSTATE_LOST, tsc); + hvm_vlapic_clear(&v->vlapic); + + if(v->data_type == VCPU_DATA_HVM) { + int i; + if(opt.dump_all) + printf(" [w2h] Clearing w2h state for d%dv%d\n", + v->d->did, v->vid); + v->hvm.w2h.interrupts=0; + v->hvm.w2h.vector=0; + v->hvm.w2h.waking = 0; + for(i=0; i<GUEST_INTERRUPT_MAX; i++) { + if(opt.dump_all && v->hvm.summary.guest_interrupt[i].start_tsc) { + printf(" Interrupt %d clearing start_tsc %lld\n", + i, v->hvm.summary.guest_interrupt[i].start_tsc); + } + v->hvm.summary.guest_interrupt[i].start_tsc = 0; + } + } +} + +struct lost_record_struct { + int lost_records; + unsigned did:16,vid:16; + tsc_t first_tsc; +}; + +void process_lost_records(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + struct lost_record_struct *r = (typeof(r))ri->d; + tsc_t first_tsc; /* TSC of first record that was lost */ + + /* Sanity checks */ + if(ri->extra_words != 4) + { + fprintf(warn, "FATAL: Lost record has unexpected extra words %d!\n", + ri->extra_words); + error(ERR_RECORD, ri); + return; + } + + first_tsc = r->first_tsc; + + if(opt.dump_all) + { + if(p->current) + printf(" %s lost_records count %d d%uv%u (cur d%dv%d) first_tsc %lld\n", + ri->dump_header, r->lost_records, + r->did, r->vid, + p->current->d->did, p->current->vid, + r->first_tsc); + else + printf(" %s lost_records count %d d%uv%u (cur X) first_tsc %lld\n", + ri->dump_header, r->lost_records, + r->did, r->vid, + r->first_tsc); + } + +#if 0 + if(opt.dump_trace_volume_on_lost_record) + volume_summary(&p->volume.last_buffer); +#endif + + if ( p->current ) { + + hvm_vlapic_clear(&p->current->vlapic); + if(p->current->data_type == VCPU_DATA_HVM) { + p->current->hvm.vmexit_valid=0; + cr3_switch(0, &p->current->hvm); + } + + /* We may lose scheduling records; so we need to: + * - Point all records until now to the next schedule in the + * "default" domain + * - Make sure there are no warnings / strangeness with the + * current vcpu (if it gets scheduled elsewhere). + */ + vcpu_prev_update(p, p->current, first_tsc, RUNSTATE_LOST); + } +#if 0 + vcpu_next_update(p, default_domain.vcpu[p->pid], first_tsc); + if(p->current->data_type == VCPU_DATA_HVM) { + p->current->hvm.vmexit_valid=0; + } +#endif + + /* The lost record trace is processed early -- i.e., + * After the last good record, rather than when the next + * record is processed. Between the time it's processed and + * the time it actually went in, the vcpu may be scheduled on + * other processors. So we can't switch vcpus until the first + * TSC'd record after the lost record. */ + if(!p->lost_record.active) { + P.lost_cpus++; + if(P.lost_cpus > P.max_active_pcpu + 1) { + fprintf(warn, "ERROR: P.lost_cpus %d > P.max_active_pcpu + 1 %d!\n", + P.lost_cpus, P.max_active_pcpu + 1); + error(ERR_ASSERT, NULL); + } + } else + fprintf(warn, "Strange, lost record for pcpu %d, but lost_record still active!\n", + p->pid); + + p->lost_record.active = 1; + p->lost_record.tsc = first_tsc; + pcpu_string_draw(p); + + { + /* Any vcpu which is not actively running may be scheduled on the + * lost cpu. To avoid mis-accounting, we need to reset */ + struct domain_data *d; + int i; + for(d=domain_list ; d; d=d->next) + { + if(d->did != DEFAULT_DOMAIN) { + for(i=0; i<MAX_CPUS; i++) + if(d->vcpu[i] && + d->vcpu[i]->runstate.state != RUNSTATE_RUNNING) { + if(opt.dump_all) + fprintf(warn, "%s: setting d%dv%d to RUNSTATE_LOST\n", + __func__, d->did, i); + lose_vcpu(d->vcpu[i], first_tsc); + } + } + } + } + + p->lost_record.domain_valid=1; + p->lost_record.did=r->did; + p->lost_record.vid=r->vid; +} + + +void process_lost_records_end(struct pcpu_info *p) +{ + struct record_info *ri = &p->ri; + struct lost_record_struct *r = (typeof(r))ri->d; + + if(!p->lost_record.active) { + fprintf(warn, "FATAL: lost_records_end but pid %d not lost!\n", + p->pid); + error(ERR_FILE, NULL); + return; + } + + /* Lost records. If this is the first record on a pcpu after the loss, + * Update the information. */ + if(ri->tsc > p->lost_record.tsc) + { + if(opt.dump_all) + printf(" %s lost_records end ---\n", + pcpu_string(p->pid)); + + update_cycles(&p->time.lost, ri->tsc - p->lost_record.tsc); + + if(p->lost_record.domain_valid) { + int did = p->lost_record.did, + vid = p->lost_record.vid; + + if(opt.dump_all) + printf(" %s lost_records end d%dv%d---\n", + pcpu_string(p->pid), + did, vid); + if(p->current) + { + fprintf(warn, "FATAL: lost_record valid (d%dv%d), but current d%dv%d!\n", + did, vid, + p->current->d->did, p->current->vid); + error(ERR_FILE, NULL); + return; + } + + if(opt.dump_all) + fprintf(warn, "Changing p%d current to d%dv%d\n", + p->pid, did, vid); + vcpu_next_update(p, + vcpu_find(did, vid), + ri->tsc); + p->lost_record.domain_valid=0; + p->lost_record.seen_valid_schedule=0; /* Let next vcpu_next_update know that + this one was inferred */ + } else { + if(opt.dump_all) + printf(" %s lost_records end (domain invalid)---\n", + pcpu_string(p->pid)); + } + + + p->lost_record.active = 0; + pcpu_string_draw(p); + P.lost_cpus--; + if(P.lost_cpus < 0) { + fprintf(warn, "ERROR: lost_cpus fell below 0 for pcpu %d!\n", + p->pid); + error(ERR_ASSERT, NULL); + } + } +} + +void base_process(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + switch(ri->event) + { + case TRC_LOST_RECORDS: + process_lost_records(p); + break; + case TRC_LOST_RECORDS_END: + process_lost_records_end(p); + break; + default: + process_generic(ri); + } + } + + + +/* Non-compat only */ +void record_order_insert(struct pcpu_info *new); +void record_order_remove(struct pcpu_info *rem); +void record_order_bubble(struct pcpu_info *last); + +struct cpu_change_data { + int cpu; + unsigned window_size; +}; + +void activate_early_eof(void) { + struct pcpu_info *p; + int i; + + fprintf(warn, "Short cpu_change window, activating early_eof\n"); + + P.early_eof = 1; + + for(i=0; i<=P.max_active_pcpu; i++) { + p = P.pcpu + i; + if(p->active && p->file_offset > P.last_epoch_offset) { + fprintf(warn, " deactivating pid %d\n", + p->pid); + p->active = 0; + } + } +} + +loff_t scan_for_new_pcpu(loff_t offset) { + ssize_t r; + struct trace_record rec; + struct cpu_change_data *cd; + + r=__read_record(&rec, offset); + + if(r==0) + return 0; + + if(rec.event != TRC_TRACE_CPU_CHANGE + || rec.cycle_flag) + { + fprintf(stderr, "%s: Unexpected record event %x!\n", + __func__, rec.event); + error(ERR_ASSERT, NULL); /* Actually file, but can't recover */ + } + + cd = (typeof(cd))rec.u.notsc.data; + + if ( cd->cpu > MAX_CPUS ) + { + fprintf(stderr, "%s: cpu %d exceeds MAX_CPU %d!\n", + __func__, cd->cpu, MAX_CPUS); + /* FIXME: Figure out if we could handle this more gracefully */ + error(ERR_ASSERT, NULL); + } + + if(cd->cpu > P.max_active_pcpu || !P.pcpu[cd->cpu].active) { + struct pcpu_info *p = P.pcpu + cd->cpu; + + fprintf(warn, "%s: Activating pcpu %d at offset %lld\n", + __func__, cd->cpu, (unsigned long long)offset); + + p->active = 1; + /* Process this cpu_change record first */ + p->ri.rec = rec; + p->ri.size = r; + __fill_in_record_info(p); + + p->file_offset = offset; + p->next_cpu_change_offset = offset; + + record_order_insert(p); + + offset += r + cd->window_size; + + sched_default_vcpu_activate(p); + + if ( cd->cpu > P.max_active_pcpu ) + P.max_active_pcpu = cd->cpu; + + return offset; + } else { + return 0; + } +} + +/* + * Conceptually, when we reach a cpu_change record that's not for our pcpu, + * we want to scan forward through the file until we reach one that's for us. + * However, looping through involves reading the file, which we'd rather + * do in one place. Because cpu_change records don't include a tsc, + * the same pcpu will be processed repeatedly until the cpu_change + * equals p->pid. + * + * There are two additional things we need to do in this algorithm: + * + Detect new pcpus as they come online + * + De-activate pcpus which don't have any more records + * + * Detecting new pcpus which are less than P.max_active_pcpu is straight- + * forward: when max_active_pcpu is searching for its next cpu window, + * it will pass by the new cpu's window, and can activate it then. + * + * Detecting new pcpus greater than P.max_active_pcpu is a little harder; + * When max_active_pcpu is scanning for its next cpu window, after it's found + * it, we need to scan one more window forward to see if its' an already-active + * pcpu; if not, activate it. + * + * We also need to deal with truncated files, where records from one pcpu may + * be present but not from another pcpu due to lack of disk space. The best + * thing to do is to find the last "epoch" and essentially truncate the file + * to that. + */ +void deactivate_pcpu(struct pcpu_info *p) +{ + if ( p->current ) + { + pcpu_runstate_update(p, p->last_tsc); + + fprintf(warn, "%s: setting d%dv%d to state LOST\n", + __func__, p->current->d->did, + p->current->vid); + lose_vcpu(p->current, p->last_tsc); + } + p->active = 0; + + record_order_remove(p); + + if ( p->pid == P.max_active_pcpu ) + { + int i, max_active_pcpu = -1; + for(i=0; i<=P.max_active_pcpu; i++) + { + if(!P.pcpu[i].active) + continue; + + max_active_pcpu = i; + } + P.max_active_pcpu = max_active_pcpu; + fprintf(warn, "%s: Setting max_active_pcpu to %d\n", + __func__, max_active_pcpu); + } + +} + +/* Helper function to process tsc-related record info */ +void process_record_tsc(tsc_t order_tsc, struct record_info *ri) +{ + /* Find the first tsc set */ + if(ri->tsc && ri->tsc >= P.f.first_tsc) { + /* We use the order_tsc to account for the second processing of + * a lost record. */ + tsc_t tsc = order_tsc; + + if(P.f.first_tsc == 0) { + P.f.first_tsc = tsc; + if ( opt.interval_mode ) { + P.interval.start_tsc = tsc; + } + } else { + if ( opt.interval_mode ) { + if(P.interval.start_tsc > tsc) { + fprintf(warn, "FATAL: order_tsc %lld < interval.start_tsc %lld!\n", + tsc, P.interval.start_tsc); + error(ERR_FILE, NULL); + } else { + while ( tsc - P.interval.start_tsc > opt.interval.cycles ) { + interval_callback(); + P.interval.start_tsc += opt.interval.cycles; + } + } + } + } + + P.f.last_tsc=tsc; + + P.f.total_cycles = P.f.last_tsc - P.f.first_tsc; + + P.now = tsc; + } +} + +/* Standardized part of dump output */ +void create_dump_header(struct record_info *ri, struct pcpu_info *p) +{ + char * c; + int len, r; + + len = DUMP_HEADER_MAX; + c = ri->dump_header; + + abs_cycles_to_time(ri->tsc, &ri->t); + + if ( ri->t.time ) + { + r=snprintf(c, len, "%3u.%09u", ri->t.s, ri->t.ns); + c+=r; + len-=r; + } + else + { + r=snprintf(c, + len, + " "); + c+=r; + len-=r; + } + + r = snprintf(c, len, " %s", pcpu_string(ri->cpu)); + c+=r; + len-=r; + + if ( p->current ) + { + r = snprintf(c, len, " d%dv%d", p->current->d->did, p->current->vid); + c+=r; + len-=r; + } + else + { + r = snprintf(c, len, " d?v?"); + c+=r; + len-=r; + } +} + +int find_toplevel_event(struct record_info *ri) +{ + int toplevel=0, i, count; + + for(i=0, count=0; i<TOPLEVEL_MAX; i++) + if(ri->evt.main & (1UL<<i)) + { + toplevel=i; + count++; + } + + /* Sanity check: One and only one bit should be set */ + if(count != 1) + { + fprintf(warn, "FATAL: unexpected number bits(%d) in evt.main! event %x main %x sub %x minor %x\n", + count, + ri->event, + ri->evt.main, ri->evt.sub, ri->evt.minor); + error(ERR_RECORD, NULL); + return -1; + } + + return toplevel; +} + + +void process_cpu_change(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + struct cpu_change_data *r = (typeof(r))ri->d; + + if(opt.dump_all && verbosity >= 6) { + printf("]%s cpu_change this-cpu %u record-cpu %u window_size %u(0x%08x)\n", + ri->dump_header, p->pid, r->cpu, r->window_size, + r->window_size); + } + + /* File sanity check */ + if(p->file_offset != p->next_cpu_change_offset) { + fprintf(warn, "Strange, pcpu %d expected offet %llx, actual %llx!\n", + p->pid, (unsigned long long)p->next_cpu_change_offset, + (unsigned long long)p->file_offset); + } + + if(r->cpu > MAX_CPUS) + { + fprintf(stderr, "FATAL: cpu %d > MAX_CPUS %d.\n", + r->cpu, MAX_CPUS); + /* Actually file, but takes some work to skip */ + error(ERR_ASSERT, NULL); + } + + /* Detect beginning of new "epoch" while scanning thru file */ + if((p->last_cpu_change_pid > r->cpu) + && (p->file_offset > P.last_epoch_offset)) { + P.last_epoch_offset = p->file_offset; + } + + /* If that pcpu has never been activated, activate it. */ + if(!P.pcpu[r->cpu].active && P.pcpu[r->cpu].file_offset == 0) + { + struct pcpu_info * p2 = P.pcpu + r->cpu; + + p2->active = 1; + if(r->cpu > P.max_active_pcpu) + P.max_active_pcpu = r->cpu; + + /* Taking this record as the first record should make everything + * run swimmingly. */ + p2->ri = *ri; + p2->ri.cpu = r->cpu; + p2->ri.d = p2->ri.rec.u.notsc.data; + p2->file_offset = p->file_offset; + p2->next_cpu_change_offset = p->file_offset; + + fprintf(warn, "%s: Activating pcpu %d at offset %lld\n", + __func__, r->cpu, (unsigned long long)p->file_offset); + + record_order_insert(p2); + + sched_default_vcpu_activate(p2); + } + + p->last_cpu_change_pid = r->cpu; + + /* If this isn't the cpu we're looking for, skip the whole bunch */ + if(p->pid != r->cpu) + { + p->file_offset += ri->size + r->window_size; + p->next_cpu_change_offset = p->file_offset; + + if(p->file_offset > G.file_size) { + activate_early_eof(); + } else if(P.early_eof && p->file_offset > P.last_epoch_offset) { + fprintf(warn, "%s: early_eof activated, pcpu %d past last_epoch_offset %llx, deactivating.\n", + __func__, p->pid, (unsigned long long)P.last_epoch_offset); + deactivate_pcpu(p); + } + } + else + { + /* Track information about dom0 scheduling and records */ + if(opt.dump_trace_volume_on_lost_record) { + tsc_t cycles; + struct time_struct t; + + /* Update dom0 runstates */ + cycles = (p->volume.buffer_first_tsc > p->volume.buffer_dom0_runstate_tsc) ? + p->volume.buffer_first_tsc : + p->volume.buffer_dom0_runstate_tsc; + p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate] + += ri->tsc - cycles; + + printf(" - updated p%d dom0_runstate %s to %lld cycles (+%lld)\n", + p->pid, runstate_name[p->volume.buffer_dom0_runstate], + p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate], + ri->tsc - cycles); + + /* print info */ + cycles = ri->tsc - p->volume.buffer_first_tsc; + cycles_to_time(cycles, &t); + printf("Buffer time: %u.%09u (%lld cycles)\n", + t.s, t.ns, cycles); + if(p->volume.buffer_size) + printf("Rate: %lld cycles / byte\n", + cycles / p->volume.buffer_size); + if(P.buffer_trace_virq_tsc) + { + cycles = ri->tsc - P.buffer_trace_virq_tsc; + cycles_to_time(cycles, &t); + printf("trace_virq latency: %u.%09u (%lld cycles)\n", + t.s, t.ns, cycles); + P.buffer_trace_virq_tsc = 0; + } + else + { + printf("No trace_virq record found.\n"); + } + printf("Dom0 runstates this buffer:\n"); + runstate_summary(p->volume.buffer_dom0_runstate_cycles); + volume_summary(&p->volume.last_buffer); + + /* reset info */ + p->volume.buffer_first_tsc = 0; + p->volume.buffer_size = r->window_size; + runstate_clear(p->volume.buffer_dom0_runstate_cycles); + volume_clear(&p->volume.last_buffer); + } + + p->file_offset += ri->size; + p->next_cpu_change_offset = p->file_offset + r->window_size; + + if(p->next_cpu_change_offset > G.file_size) + activate_early_eof(); + else if(p->pid == P.max_active_pcpu) + scan_for_new_pcpu(p->next_cpu_change_offset); + + } +} + +struct tl_assert_mask { + unsigned p_current:1, + not_idle_domain:1; + int vcpu_data_mode; +}; +static struct tl_assert_mask tl_assert_checks[TOPLEVEL_MAX] = { + [TRC_HVM_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_HVM }, + [TRC_SHADOW_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_HVM }, + [TRC_PV_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_PV }, +}; + +/* There are a lot of common assumptions for the various processing + * routines. Check them all in one place, doing something else if + * they don't pass. */ +int toplevel_assert_check(int toplevel, struct pcpu_info *p) +{ + struct tl_assert_mask mask; + + mask = tl_assert_checks[toplevel]; + + if (mask.p_current && p->current == NULL) + { + fprintf(warn, "WARNING: p->current null! Not processing\n"); + goto fail; + } + + if( mask.not_idle_domain ) + { + /* Can't do this check w/o first doing above check */ + assert(mask.p_current); + + if ( p->current->d->did == IDLE_DOMAIN) { + fprintf(warn, "WARNING: Unexpected record for idle domain! Not processing\n"); + goto fail; + } + } + + if ( mask.vcpu_data_mode ) + { + struct vcpu_data *v; + assert(mask.p_current); + + v = p->current; + + if ( ! (v->data_type == VCPU_DATA_NONE + || v->data_type == mask.vcpu_data_mode) ) + { + /* This may happen for track_dirty_vram, which causes a SHADOW_WRMAP_BF trace f/ dom0 */ + fprintf(warn, "WARNING: Unexpected vcpu data type for d%dv%d on proc %d! Expected %d got %d. Not processing\n", + v->d->did, v->vid, p->pid, + mask.vcpu_data_mode, + v->data_type); + goto fail; + } + } + + return 1; + +fail: + dump_generic(warn, &p->ri); + return 0; +} + +void process_record(struct pcpu_info *p) { + struct record_info *ri = &p->ri; + int toplevel; + + /* Process only TRC_TRACE_CPU_CHANGE */ + if(ri->event == TRC_TRACE_CPU_CHANGE) { + process_cpu_change(p); + return; + } + + if ( opt.dump_no_processing ) + goto out; + + p->summary = 1; + + if( opt.dump_raw_process ) + dump_raw("* ", ri); + + process_record_tsc(p->order_tsc, ri); + + if(opt.dump_all) + create_dump_header(ri, p); + + + toplevel = find_toplevel_event(ri); + if ( toplevel < 0 ) + return; + + /* Unify toplevel assertions */ + if ( toplevel_assert_check(toplevel, p) ) + { + switch(toplevel) { + case TRC_GEN_MAIN: + base_process(p); + break; + case TRC_SCHED_MAIN: + sched_process(p); + break; + case TRC_HVM_MAIN: + hvm_process(p); + break; + case TRC_SHADOW_MAIN: + shadow_process(p); + break; + case TRC_PV_MAIN: + pv_process(p); + break; + case TRC_MEM_MAIN: + mem_process(p); + break; + case TRC_HW_MAIN: + hw_process(p); + break; + case TRC_DOM0OP_MAIN: + default: + process_generic(ri); + } + } + + UPDATE_VOLUME(p, toplevel[toplevel], ri->size); + + if(!p->volume.buffer_first_tsc) + p->volume.buffer_first_tsc = ri->tsc; + + out: + /* Lost records gets processed twice */ + if(ri->event != TRC_LOST_RECORDS) + p->file_offset += ri->size; +} + +static inline ssize_t get_rec_size(struct trace_record *rec) { + ssize_t s; + + s = sizeof(uint32_t); + + if(rec->cycle_flag) + s += sizeof(tsc_t); + + s += rec->extra_words * sizeof(uint32_t); + + return s; +} + +#define STDIN 0 + +void progress_child_exec(void) { + fclose(stdin); + dup2(G.progress.pipe[0], STDIN); + + execlp("zenity", "zenity", "--progress", "--auto-close", "--title", + "Analyzing", "--text", G.trace_file, "--auto-kill", NULL); +} + +void progress_init(void) { + int pid; + + if (pipe(G.progress.pipe) < 0) + perror("pipe"); + + if(!(pid = fork())) { + progress_child_exec(); + + fprintf(stderr, "%s: exec failed (%s), disabling progress bar\n", + __func__, strerror(errno)); + opt.progress = 0; + exit(1); + } else if( pid < 0 ) { + fprintf(stderr, "%s: could not fork: %s, disabling progress bar\n", + __func__, strerror(errno)); + opt.progress = 0; + } + + if( (G.progress.out = fdopen(G.progress.pipe[1], "w")) < 0 ) { + fprintf(stderr, "%s: could not fdopen pipe: %s, disabling progress bar\n", + __func__, strerror(errno)); + opt.progress = 0; + } + +} + +void progress_update(loff_t offset) { + long long p; + + p = ( offset * 100 ) / G.file_size; + + fprintf(G.progress.out, "%lld\n", p); + fflush(G.progress.out); + + p += 1; + + G.progress.update_offset = ( G.file_size * p ) / 100; + +#if 0 + fprintf(stderr, "Progress: %lld %% Next update_offset: %lld\n", + p-1, + G.progress.update_offset); +#endif +} + +void progress_finish(void) { + int pid; + + fprintf(G.progress.out, "100\n"); + fflush(G.progress.out); + fclose(G.progress.out); + + wait(NULL); + + if(!(pid = fork())) { + /* Child */ + char text[128]; + + snprintf(text, 128, "Finished analyzing %s", + G.trace_file); + execlp("zenity", "zenity", "--info", "--text", text, NULL); + } +} + +ssize_t __read_record(struct trace_record *rec, loff_t offset) +{ + ssize_t r, rsize; + + r=mread64(G.mh, rec, sizeof(*rec), offset); + + if(r < 0) { + /* Read error */ + perror("read"); + fprintf(stderr, "offset %llx\n", (unsigned long long)offset); + return 0; + } else if(r==0) { + /* End-of-file */ + return 0; + } else if(r < sizeof(uint32_t)) { + /* Full header not read */ + fprintf(stderr, "%s: short read (%zd bytes)\n", + __func__, r); + error(ERR_SYSTEM, NULL); + } + + rsize=get_rec_size(rec); + + if(r < rsize) { + /* Full record not read */ + fprintf(stderr, "%s: short read (%zd, expected %zd)\n", + __func__, r, rsize); + return 0; + } + + return rsize; +} + +void __fill_in_record_info(struct pcpu_info *p) +{ + struct record_info *ri; + tsc_t tsc=0; + + ri = &p->ri; + + ri->event = ri->rec.event; + ri->extra_words = ri->rec.extra_words; + + if(ri->rec.cycle_flag) { + tsc = (((tsc_t)ri->rec.u.tsc.tsc_hi) << 32) + | ri->rec.u.tsc.tsc_lo; + + tsc += p->tsc_skew.offset; + + ri->tsc = tsc; + ri->d = ri->rec.u.tsc.data; + + if(p->first_tsc == 0) + p->first_tsc = tsc; + + /* We process lost record twice: once at the first_tsc, + once at the time it was placed in the log */ + if(ri->event == TRC_LOST_RECORDS && ri->extra_words == 4) { + struct lost_record_struct *r = (typeof(r))ri->d; + p->order_tsc = r->first_tsc + p->tsc_skew.offset; + } else + p->order_tsc = tsc; + + p->last_tsc = tsc; + } else { + ri->tsc = p->last_tsc; + ri->d = ri->rec.u.notsc.data; + } + + if ( opt.dump_raw_reads ) { + char s[256]; + snprintf(s, 256, "R p%2d o%016llx ", + p->pid, (unsigned long long)p->file_offset); + dump_raw(s, ri); + } + + /* Updated tracing uses CPU_CHANGE. If we hit one of these, + * it will process very next (since the tsc isn't updated), and + * we'll skip forward appropriately. */ + ri->cpu = p->pid; +} + +ssize_t read_record(struct pcpu_info * p) { + loff_t * offset; + struct record_info *ri; + + offset = &p->file_offset; + ri = &p->ri; + + ri->size = __read_record(&ri->rec, *offset); + if(ri->size) + { + __fill_in_record_info(p); + } + else + { + fprintf(warn, "%s: read returned zero, deactivating pcpu %d\n", + __func__, p->pid); + deactivate_pcpu(p); + } + + return ri->size; +} + +/* + * This funciton gets called for every record when doing dump. Try to + * make it efficient by changing the minimum amount from the last + * call. Do this by: + * - Keeping track of the last pcpu called, so we can just set that to - + * - Keeping track of how many pcpus we've "drawn", and only "drawing" new ones + * - Updating the current one + * + * FIXME: Need to deal with pcpu states changing... + * + * WARNING not thread-safe + */ + +char __pcpu_string[MAX_CPUS+1] = { 0 }; +void pcpu_string_draw(struct pcpu_info *p) +{ + char *s = __pcpu_string; + int i=p->pid; + + if(p->lost_record.active) + s[i]='l'; + else if (!p->current) + s[i]=' '; + else if (p->current->d->did == DEFAULT_DOMAIN) + s[i]='.'; + else if (p->current->d->did == IDLE_DOMAIN) + { + if ( opt.dump_show_power_states ) + s[i]=p->power_state+'0'; + else + s[i]='-'; + } + else + s[i]='|'; +} + +char * pcpu_string(int pcpu) +{ + char *s = __pcpu_string; + static int max_active_pcpu=-1, last_pcpu=-1; + + assert(P.max_active_pcpu < MAX_CPUS); + assert(pcpu <= P.max_active_pcpu); + + if(last_pcpu >= 0) + pcpu_string_draw(P.pcpu+last_pcpu); + + if(P.max_active_pcpu > max_active_pcpu) + { + int i; + for(i=max_active_pcpu + 1; i<= P.max_active_pcpu; i++) + pcpu_string_draw(P.pcpu+i); + max_active_pcpu=P.max_active_pcpu; + } + + s[pcpu]='x'; + last_pcpu = pcpu; + + return s; +} + +/* Null terminated */ +struct pcpu_info *record_order[MAX_CPUS+1] = { 0 }; + +/* In the case of identical tsc values, the old algorithm would favor the + * pcpu with the lowest number. By default the new algorithm favors the + * pcpu which has been processed most recently. + * + * I think the second way is better; but it's good to be able to use the + * old ordering, at very lest to verify that there are no (other) ordering + * differences. Enabling the below flag will cause the insertion / bubble + * routines to order by pcpu id as well as tsc, preserving the old order. */ +//#define PRESERVE_PCPU_ORDERING + +/* Steady state: + * + Entire list is in order, except (potentially) for the first entry + * + last is pointing to the first entry. + */ +void record_order_bubble(struct pcpu_info *last) +{ + int i; + + /* Find the pcpu to "bubble". This is usually the + * first one, but if other pcpus have been activated, it may + * not be. */ + for(i=0; record_order[i] && record_order[i]!=last; i++); + + assert(record_order[i]); + + /* Now bubble it down */ + for( ; + record_order[i+1] + && ( record_order[i+1]->order_tsc < last->order_tsc +#ifdef PRESERVE_PCPU_ORDERING + || ( record_order[i+1]->order_tsc == last->order_tsc + && record_order[i+1]->pid < last->pid ) +#endif + ) ; + i++) + record_order[i]=record_order[i+1]; + record_order[i]=last; +} + +void record_order_insert(struct pcpu_info *new) +{ + int i; + struct pcpu_info *p=NULL, *t=NULL; + + /* Sanity check: Make sure it's not already in there */ + for(i=0; record_order[i]; i++) + assert(record_order[i]!=new); + + /* Find where to insert it */ + for(i=0; + record_order[i] + && ( record_order[i]->order_tsc < new->order_tsc +#ifdef PRESERVE_PCPU_ORDERING + || ( record_order[i]->order_tsc == new->order_tsc + && record_order[i]->pid < new->pid ) +#endif + ) ; + i++) + ; + + /* And insert it */ + for( p=new; p ; i++) + { + t=record_order[i]; + record_order[i]=p; + p=t; + } +} + +void record_order_remove(struct pcpu_info *rem) +{ + int i; + + /* Find where the record is */ + for(i=0; record_order[i] && record_order[i]!=rem; i++) + ; + + /* Sanity check: Make sure it's actually there! */ + assert(record_order[i]); + + /* And move everyone forward */ + for(; (record_order[i]=record_order[i+1]); i++) + ; +} + +struct pcpu_info * choose_next_record(void) +{ + struct pcpu_info *min_p=NULL; + + min_p=record_order[0]; + + if(opt.progress && min_p && min_p->file_offset >= G.progress.update_offset) + progress_update(min_p->file_offset); + + /* If there are active pcpus, make sure we chose one */ + assert(min_p || (P.max_active_pcpu==-1)); + + return min_p; +} + +void process_records(void) { + while(1) { + struct pcpu_info *p = NULL; + + if(!(p=choose_next_record())) + return; + + process_record(p); + + /* Lost records gets processed twice. */ + if(p->ri.event == TRC_LOST_RECORDS) { + p->ri.event = TRC_LOST_RECORDS_END; + if(p->ri.tsc > p->order_tsc) + p->order_tsc = p->ri.tsc; + else { + fprintf(warn, "Strange, lost_record ri->tsc %lld !> p->order_tsc %lld!\n", + p->ri.tsc, p->order_tsc); + error(ERR_FILE, NULL); + } + } + else + read_record(p); + + /* Update this pcpu in the processing order */ + if ( p->active ) + record_order_bubble(p); + } +} + +void vcpu_summary(struct vcpu_data *v) +{ + printf("-- v%d --\n", v->vid); + sched_summary_vcpu(v); + switch(v->data_type) { + case VCPU_DATA_HVM: + hvm_summary(&v->hvm); + break; + case VCPU_DATA_PV: + pv_summary(&v->pv); + break; + default: + break; + } +} + +void domain_summary(void) +{ + struct domain_data * d; + int i; + + if(opt.show_default_domain_summary) { + d = &default_domain; + printf("|-- Default domain --|\n"); + + for( i = 0; i < MAX_CPUS ; i++ ) + { + if(d->vcpu[i]) + vcpu_summary(d->vcpu[i]); + } + } + + for ( d = domain_list ; d ; d=d->next ) + { + int i; + printf("|-- Domain %d --|\n", d->did); + + sched_summary_domain(d); + + mem_summary_domain(d); + + for( i = 0; i < MAX_CPUS ; i++ ) + { + if(d->vcpu[i]) + vcpu_summary(d->vcpu[i]); + } + + printf("Emulate eip list\n"); + dump_eip(d->emulate_eip_list); + + if ( opt.with_interrupt_eip_enumeration ) + { + printf("Interrupt eip list (vector %d)\n", + opt.interrupt_eip_enumeration_vector); + dump_eip(d->interrupt_eip_list); + } + + cr3_dump_list(d->cr3_value_head); + } +} + +char * stringify_cpu_hz(long long cpu_hz); + +void summary(void) { + int i; + printf("Total time: %.2lf seconds (using cpu speed %s)\n", + ((double)(P.f.total_cycles))/opt.cpu_hz, + stringify_cpu_hz(opt.cpu_hz)); + printf("--- Log volume summary ---\n"); + for(i=0; i<MAX_CPUS; i++) + { + struct pcpu_info *p = P.pcpu+i; + if(!p->summary) + continue; + printf(" - cpu %d -\n", i); + volume_summary(&p->volume.total); + } + domain_summary(); +} + +void report_pcpu(void) { + int i, active=0; + + for(i=0; i<MAX_CPUS; i++) + { + struct pcpu_info *p = P.pcpu+i; + if(!p->summary) + continue; + printf("pcpu %d\n", i); + + print_cycle_summary(&p->time.running, " running"); + print_cycle_summary(&p->time.idle, " idle"); + print_cycle_summary(&p->time.lost, " lost"); + + if ( p->time.running.count ) + active++; + } + printf("Total active cpus: %d\n", active); + +} + +void init_pcpus(void) { + int i=0; + loff_t offset = 0; + + for(i=0; i<MAX_CPUS; i++) + { + P.pcpu[i].pid=i; + P.pcpu[i].lost_record.seen_valid_schedule=1; + P.pcpu[i].power_state=CSTATE_INVALID; + } + + P.max_active_pcpu = -1; + + sched_default_domain_init(); + + /* Scan through the cpu_change recs until we see a duplicate */ + do { + offset = scan_for_new_pcpu(offset); + + if(!offset) { + fprintf(warn, "%s: through first trace write, done for now.\n", + __func__); + } + } while(offset); + +} + +enum { + OPT_NULL=0, + /* Dumping info */ + OPT_DUMP_RAW_READS, + OPT_DUMP_RAW_PROCESS, + OPT_DUMP_NO_PROCESSING, + OPT_DUMP_IPI_LATENCY, + OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD, + OPT_DUMP_SHOW_POWER_STATES, + /* Extra tracking functionality */ + OPT_WITH_CR3_ENUMERATION, + OPT_WITH_PIO_ENUMERATION, + OPT_WITH_MMIO_ENUMERATION, + OPT_WITH_INTERRUPT_EIP_ENUMERATION, + OPT_SCATTERPLOT_INTERRUPT_EIP, + OPT_SCATTERPLOT_CPI, + OPT_SCATTERPLOT_UNPIN_PROMOTE, + OPT_SCATTERPLOT_CR3_SWITCH, + OPT_SCATTERPLOT_WAKE_TO_HALT, + OPT_SCATTERPLOT_IO, + OPT_SCATTERPLOT_VMEXIT_EIP, + OPT_SCATTERPLOT_RUNSTATE, + OPT_SCATTERPLOT_RUNSTATE_TIME, + OPT_SCATTERPLOT_PCPU, + OPT_SCATTERPLOT_EXTINT_CYCLES, + OPT_SCATTERPLOT_RDTSC, + OPT_SCATTERPLOT_IRQ, + OPT_HISTOGRAM_INTERRUPT_EIP, + /* Interval options */ + OPT_INTERVAL_CR3_SCHEDULE_TIME, + OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL, + OPT_INTERVAL_CR3_SCHEDULE_ORDERED, + OPT_INTERVAL_CR3_SHORT_SUMMARY, + OPT_INTERVAL_DOMAIN_TOTAL_TIME, + OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL, + OPT_INTERVAL_DOMAIN_SHORT_SUMMARY, + OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT, + OPT_INTERVAL_DOMAIN_GRANT_MAPS, + /* Summary info */ + OPT_SHOW_DEFAULT_DOMAIN_SUMMARY, + OPT_MMIO_ENUMERATION_SKIP_VGA, + OPT_SAMPLE_SIZE, + OPT_REPORT_PCPU, + /* Guest info */ + OPT_DEFAULT_GUEST_PAGING_LEVELS, + OPT_SYMBOL_FILE, + /* Hardware info */ + OPT_SVM_MODE, + OPT_CPU_HZ, + /* Misc */ + OPT_PROGRESS, + OPT_TOLERANCE, + OPT_TSC_LOOP_FATAL, + /* Specific letters */ + OPT_DUMP_ALL='a', + OPT_INTERVAL_LENGTH='i', + OPT_SUMMARY='s', +}; + +enum { + OPT_GROUP_SUMMARY=1, + OPT_GROUP_DUMP, + OPT_GROUP_INTERVAL, + OPT_GROUP_EXTRA, + OPT_GROUP_GUEST, + OPT_GROUP_HARDWARE +}; + +#define xstr(x) str(x) +#define str(x) #x + +#define GHZ 1000000000LL +#define MHZ 1000000LL +#define KHZ 1000LL + +void parse_cpu_hz(char * arg) { + float hz_base; + char * next_ptr; + + hz_base=strtof(arg, &next_ptr); + if(next_ptr == arg) { + fprintf(stderr, "Invalid cpu_hz %s\n", arg); + exit(1); + } + switch(*next_ptr) { + case '\0': + opt.cpu_hz=(long long)hz_base; + break; + case 'G': + opt.cpu_hz= hz_base * GHZ; + break; + case 'M': + opt.cpu_hz=hz_base * MHZ; + break; + case 'K': + opt.cpu_hz=hz_base * KHZ; + break; + default: + fprintf(stderr, "Unknown suffix %c\n", *next_ptr); + exit(1); + } + /* Just a convenient pre-calculation */ + opt.cpu_qhz = QHZ_FROM_HZ(opt.cpu_hz); +} + +/* WARNING not thread-safe */ +char * stringify_cpu_hz(long long cpu_hz) { + static char cpu_string[20], suffix; + float hz; + + if(cpu_hz > GHZ) { + hz = (float)cpu_hz / GHZ; + suffix = 'G'; + } else if(cpu_hz > MHZ) { + hz = (float)cpu_hz / MHZ; + suffix = 'M'; + } else if(cpu_hz > KHZ) { + hz = (float)cpu_hz / KHZ; + suffix = 'k'; + } else { + hz = cpu_hz; + suffix = ' '; + } + + snprintf(cpu_string, 20, "%1.2lf %cHz", hz, suffix); + + return cpu_string; +} + +int parse_array(char *arg, struct array_struct *a) { + char *p, *q; + int n=1, i; + + /* Count the number of commas (and thus the number of elements) */ + for(p=arg; *p; p++) + if(*p == ',') + n++; + + fprintf(warn, "%s: Found %d elements\n", __func__, n); + fflush(warn); + a->count = n; + a->values = malloc(n * sizeof(unsigned long long)); + + if(!a->values) { + fprintf(stderr, "Malloc failed!\n"); + error(ERR_SYSTEM, NULL); + } + + /* Now parse the elements */ + p = q = arg; + for(i=0; i<n; i++) { + a->values[i] = strtoull(p, &q, 0); + if(p == q) { + fprintf(stderr, "Bad format: %s\n", q); + return -1; + } + fprintf(warn, "%s: Found element 0x%llx (%lld)\n", + __func__, a->values[i], + a->values[i]); + fflush(warn); + if(*q == ',') + q++; + else if(*q != '\0') { + fprintf(stderr, "Bad format: %s\n", q); + return -1; + } + p=q; + } + + return n; +} + +error_t cmd_parser(int key, char *arg, struct argp_state *state) +{ + switch (key) + { + /* Dump group */ + case OPT_DUMP_ALL: + opt.dump_all = 1; + G.output_defined = 1; + break; + case OPT_DUMP_RAW_READS: + opt.dump_raw_reads = 1; + G.output_defined = 1; + break; + case OPT_DUMP_NO_PROCESSING: + opt.dump_no_processing = 1; + opt.dump_raw_reads = 1; + G.output_defined = 1; + break; + case OPT_DUMP_RAW_PROCESS: + opt.dump_raw_process = 1; + G.output_defined = 1; + break; + case OPT_DUMP_IPI_LATENCY: + opt.dump_ipi_latency = 1; + break; + case OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD: + opt.dump_trace_volume_on_lost_record = 1; + break; + case OPT_DUMP_SHOW_POWER_STATES: + opt.dump_show_power_states = 1; + break; + /* Extra group */ + case OPT_WITH_CR3_ENUMERATION: + opt.with_cr3_enumeration=1; + break; + case OPT_WITH_PIO_ENUMERATION: + opt.with_pio_enumeration=1; + break; + case OPT_WITH_MMIO_ENUMERATION: + opt.with_mmio_enumeration=1; + break; + case OPT_SHOW_DEFAULT_DOMAIN_SUMMARY: + opt.show_default_domain_summary=1; + break; + case OPT_SAMPLE_SIZE: + { + char * inval; + opt.sample_size = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + break; + } + case OPT_MMIO_ENUMERATION_SKIP_VGA: + { + char * inval; + opt.mmio_enumeration_skip_vga = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + break; + } + case OPT_SCATTERPLOT_INTERRUPT_EIP: + { + char * inval; + G.output_defined = 1; + opt.scatterplot_interrupt_eip=1; + opt.scatterplot_interrupt_vector = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + } + break; + case OPT_WITH_INTERRUPT_EIP_ENUMERATION: + { + char * inval; + opt.with_interrupt_eip_enumeration=1; + opt.interrupt_eip_enumeration_vector = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + } + break; + case OPT_SCATTERPLOT_CPI: + G.output_defined = 1; + opt.scatterplot_cpi=1; + break; + case OPT_SCATTERPLOT_UNPIN_PROMOTE: + G.output_defined = 1; + opt.scatterplot_unpin_promote=1; + break; + case OPT_SCATTERPLOT_CR3_SWITCH: + G.output_defined = 1; + opt.scatterplot_cr3_switch=1; + break; + case OPT_SCATTERPLOT_WAKE_TO_HALT: + G.output_defined = 1; + opt.scatterplot_wake_to_halt=1; + break; + case OPT_SCATTERPLOT_VMEXIT_EIP: + G.output_defined = 1; + opt.scatterplot_vmexit_eip=1; + break; + case OPT_SCATTERPLOT_EXTINT_CYCLES: + { + char * inval; + G.output_defined = 1; + opt.scatterplot_extint_cycles=1; + opt.scatterplot_extint_cycles_vector = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + } + break; + case OPT_SCATTERPLOT_RDTSC: + G.output_defined = 1; + opt.scatterplot_rdtsc=1; + break; + case OPT_SCATTERPLOT_IRQ: + G.output_defined = 1; + opt.scatterplot_irq=1; + break; + case OPT_SCATTERPLOT_IO: + { + char * inval; + G.output_defined = 1; + opt.scatterplot_io=1; + opt.scatterplot_io_port = (int)strtol(arg, &inval, 0); + if( inval == arg ) + argp_usage(state); + } + break; + case OPT_SCATTERPLOT_RUNSTATE: + G.output_defined = 1; + opt.scatterplot_runstate=1; + break; + case OPT_SCATTERPLOT_RUNSTATE_TIME: + G.output_defined = 1; + opt.scatterplot_runstate_time=1; + break; + case OPT_SCATTERPLOT_PCPU: + G.output_defined = 1; + opt.scatterplot_pcpu=1; + break; + case OPT_HISTOGRAM_INTERRUPT_EIP: + { + char * inval, *p; + + opt.histogram_interrupt_eip=1; + opt.histogram_interrupt_vector = (int)strtol(arg, &inval, 0); + + if( inval == arg ) + argp_usage(state); + + p = inval; + + if(*p == ',') + opt.histogram_interrupt_increment = (unsigned long long)strtoull(p+1, &inval, 0); + else + opt.histogram_interrupt_increment = 0x1000000; + + printf("Making histogram of eips at interrupt %d, increment %llx\n", + opt.histogram_interrupt_vector, + opt.histogram_interrupt_increment); + } + break; + + case OPT_INTERVAL_LENGTH: + { + char * inval; + + opt.interval.msec = (unsigned) (strtof(arg, &inval) * 1000); + + if ( inval == arg ) + argp_usage(state); + + break; + } + + case OPT_INTERVAL_CR3_SCHEDULE_TIME: + { + if(parse_array(arg, &opt.interval.array) < 0) + goto usage; + interval_table_alloc(opt.interval.array.count); + opt.interval.output = INTERVAL_CR3_SCHEDULE_TIME; + opt.interval.check = INTERVAL_CHECK_CR3; + opt.interval.mode = INTERVAL_MODE_ARRAY; + opt.interval_mode = 1; + opt.summary_info = 1; + opt.with_cr3_enumeration = 1; + G.output_defined = 1; + break; + usage: + fprintf(stderr, "Invalid input for cr3_schedule_time\n"); + argp_usage(state); + break; + } + + case OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL: + opt.interval.output = INTERVAL_CR3_SCHEDULE_TIME; + opt.interval.check = INTERVAL_CHECK_CR3; + opt.interval.mode = INTERVAL_MODE_LIST; + opt.interval_mode = 1; + opt.summary_info = 1; + opt.with_cr3_enumeration = 1; + G.output_defined = 1; + break; + + case OPT_INTERVAL_CR3_SCHEDULE_ORDERED: + opt.interval.output = INTERVAL_CR3_SCHEDULE_ORDERED; + opt.interval.check = INTERVAL_CHECK_CR3; + opt.interval_mode = 1; + opt.summary_info = 1; + opt.with_cr3_enumeration = 1; + G.output_defined = 1; + break; + + case OPT_INTERVAL_CR3_SHORT_SUMMARY: + { + if(parse_array(arg, &opt.interval.array) < 0 + || opt.interval.array.count != 1) + goto usage; + opt.interval.output = INTERVAL_CR3_SHORT_SUMMARY; + opt.interval.check = INTERVAL_CHECK_CR3; + opt.interval_mode = 1; + opt.summary_info = 1; + opt.with_cr3_enumeration = 1; + G.output_defined = 1; + break; + } + + case OPT_INTERVAL_DOMAIN_TOTAL_TIME: + { + if(parse_array(arg, &opt.interval.array) < 0) + goto idtt_usage; + interval_table_alloc(opt.interval.array.count); + opt.interval.output = INTERVAL_DOMAIN_TOTAL_TIME; + opt.interval.check = INTERVAL_CHECK_DOMAIN; + opt.interval.mode = INTERVAL_MODE_ARRAY; + opt.interval_mode = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + idtt_usage: + fprintf(stderr, "Invalid input for domain_total_time\n"); + argp_usage(state); + break; + } + + case OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL: + opt.interval.output = INTERVAL_DOMAIN_TOTAL_TIME; + opt.interval.check = INTERVAL_CHECK_DOMAIN; + opt.interval.mode = INTERVAL_MODE_LIST; + opt.interval_mode = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + + case OPT_INTERVAL_DOMAIN_SHORT_SUMMARY: + { + if((parse_array(arg, &opt.interval.array) < 0) + || opt.interval.array.count != 1) + argp_usage(state); + + opt.interval.output = INTERVAL_DOMAIN_SHORT_SUMMARY; + opt.interval.check = INTERVAL_CHECK_DOMAIN; + opt.interval_mode = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + } + + case OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT: + { + if((parse_array(arg, &opt.interval.array) < 0) + || opt.interval.array.count != 1) + argp_usage(state); + + opt.interval.output = INTERVAL_DOMAIN_GUEST_INTERRUPT; + opt.interval.check = INTERVAL_CHECK_DOMAIN; + opt.interval_mode = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + } + + case OPT_INTERVAL_DOMAIN_GRANT_MAPS: + { + if((parse_array(arg, &opt.interval.array) < 0) + || opt.interval.array.count != 1) + argp_usage(state); + + opt.interval.output = INTERVAL_DOMAIN_GRANT_MAPS; + opt.interval.check = INTERVAL_CHECK_DOMAIN; + opt.interval_mode = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + } + + /* Summary group */ + case OPT_SUMMARY: + opt.summary = 1; + opt.summary_info = 1; + G.output_defined = 1; + break; + case OPT_REPORT_PCPU: + opt.report_pcpu = 1; + //opt.summary_info = 1; + G.output_defined = 1; + break; + /* Guest info group */ + case OPT_DEFAULT_GUEST_PAGING_LEVELS: + { + char *inval; + opt.default_guest_paging_levels = (int)strtol(arg, &inval, 0); + if ( inval == arg ) + argp_usage(state); + } + break; + case OPT_SYMBOL_FILE: + /* FIXME - strcpy */ + G.symbol_file = arg; + break; + /* Hardware info group */ + case OPT_SVM_MODE: + opt.svm_mode = 1; + break; + case OPT_CPU_HZ: + parse_cpu_hz(arg); + break; + break; + + case OPT_TOLERANCE: + { + char * inval; + + opt.tolerance = (int)strtol(arg, &inval, 0); + + if( inval == arg ) + argp_usage(state); + + if ( opt.tolerance > ERR_MAX_TOLERABLE ) + { + fprintf(stderr, "ERROR: Max tolerable error %d\n", + ERR_MAX_TOLERABLE); + exit(1); + } + + printf("Tolerating errors at or below %d\n", + opt.tolerance); + } + break; + + case OPT_PROGRESS: + opt.progress = 1; + break; + + case OPT_TSC_LOOP_FATAL: + opt.tsc_loop_fatal = 1; + break; + + case ARGP_KEY_ARG: + { + /* FIXME - strcpy */ + if (state->arg_num == 0) + G.trace_file = arg; + else + argp_usage(state); + } + break; + case ARGP_KEY_END: + { + if(opt.interval_mode) { + opt.interval.cycles = ( opt.interval.msec * opt.cpu_hz ) / 1000 ; + interval_header(); + } + + if(!G.output_defined) + { + fprintf(stderr, "No output defined, using summary.\n"); + opt.summary = 1; + opt.summary_info = 1; + } + fprintf(stderr, "Using %s hardware-assisted virtualization.\n", + opt.svm_mode?"SVM":"VMX"); + } + break; + + default: + return ARGP_ERR_UNKNOWN; + } + + return 0; +} + +const struct argp_option cmd_opts[] = { + /* Dump group */ + { .name = "dump-all", + .key = OPT_DUMP_ALL, + .group = OPT_GROUP_DUMP, + .doc = "Dump all records as they come in.", }, + + { .name = "dump-raw-reads", + .key = OPT_DUMP_RAW_READS, + .group = OPT_GROUP_DUMP, + .doc = "Dump raw data as it's read from disk. Useful mainly for debugging the analysis tool.", }, + + { .name = "dump-no-processing", + .key = OPT_DUMP_NO_PROCESSING, + .group = OPT_GROUP_DUMP, + .doc = "Don't do any processing on records other than cpu changes. Implies dump-raw-reads (or you wouldn't get anything).", }, + + { .name = "dump-raw-process", + .key = OPT_DUMP_RAW_PROCESS, + .group = OPT_GROUP_DUMP, + .doc = "Dump raw data as it's processed. Useful mainly for debugging the analysis tool.", }, + + { .name = "dump-ipi-latency", + .key = OPT_DUMP_IPI_LATENCY, + .group = OPT_GROUP_DUMP, + .doc = "Dump IPI latency info as IPIs are delivered (vector 0xd1 only).", }, + + { .name = "dump-trace-volume-on-lost-record", + .key = OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD, + .group = OPT_GROUP_DUMP, + .doc = "Dump the volume of trace types in the previous cpu buffer when a lost record is created.", }, + + { .name = "dump-show-power-states", + .key = OPT_DUMP_SHOW_POWER_STATES, + .group = OPT_GROUP_DUMP, + .doc = "Show the power-state of the physical cpu when dumping output.", }, + + /* Extra processing group */ + { .name = "with-cr3-enumeration", + .key = OPT_WITH_CR3_ENUMERATION, + .group = OPT_GROUP_EXTRA, + .doc = "Keep track of per-cr3 values", }, + + { .name = "with-pio-enumeration", + .key = OPT_WITH_PIO_ENUMERATION, + .group = OPT_GROUP_EXTRA, + .doc = "Report summary info on indiviaul IO addresses", }, + + { .name = "with-mmio-enumeration", + .key = OPT_WITH_MMIO_ENUMERATION, + .group = OPT_GROUP_EXTRA, + .doc = "Report summary info on indiviaul MMIO addresses.", }, + + { .name = "with-interrupt-eip-enumeration", + .key = OPT_WITH_INTERRUPT_EIP_ENUMERATION, + .arg = "vector", + .group = OPT_GROUP_EXTRA, + .doc = "Report a summary on eips interrupted by specified vector.", }, + + { .name = "scatterplot-interrupt-eip", + .key = OPT_SCATTERPLOT_INTERRUPT_EIP, + .arg = "vector", + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of eips as a function of time.", }, + + { .name = "scatterplot-extint-cycles", + .key = OPT_SCATTERPLOT_EXTINT_CYCLES, + .arg = "vector", + .group = OPT_GROUP_EXTRA, + .doc = "Output a scatterplot of vmexit cycles for external interrupts of the given vector as a funciton of time.", }, + + { .name = "scatterplot-cpi", + .key = OPT_SCATTERPLOT_CPI, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of cpi.", }, + + { .name = "scatterplot-unpin-promote", + .key = OPT_SCATTERPLOT_UNPIN_PROMOTE, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of unpins and promotions. If " \ + "--with-cr3-enumeration is included, promotions include current cr3.", }, + + { .name = "scatterplot-cr3-switch", + .key = OPT_SCATTERPLOT_CR3_SWITCH, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of cr3 switches.", }, + + { .name = "scatterplot-wake-to-halt", + .key = OPT_SCATTERPLOT_WAKE_TO_HALT, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of wake-to-halt.", }, + + { .name = "scatterplot-vmexit-eip", + .key = OPT_SCATTERPLOT_VMEXIT_EIP, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of vmexit eips.", }, + + { .name = "scatterplot-io", + .key = OPT_SCATTERPLOT_IO, + .arg = "port", + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of io latencies for givein address as a function of time.", }, + + { .name = "scatterplot-runstate", + .key = OPT_SCATTERPLOT_RUNSTATE, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of runstate.", }, + + { .name = "scatterplot-runstate-time", + .key = OPT_SCATTERPLOT_RUNSTATE_TIME, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of time in a runstate.", }, + + { .name = "scatterplot-pcpu", + .key = OPT_SCATTERPLOT_PCPU, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of which pcpu vcpus are run on.", }, + + { .name = "scatterplot-rdtsc", + .key = OPT_SCATTERPLOT_RDTSC, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of rdtsc values.", }, + + { .name = "scatterplot-irq", + .key = OPT_SCATTERPLOT_IRQ, + .group = OPT_GROUP_EXTRA, + .doc = "Output scatterplot of irqs on pcpus.", }, + + { .name = "histogram-interrupt-eip", + .key = OPT_HISTOGRAM_INTERRUPT_EIP, + .arg = "vector[,increment]", + .group = OPT_GROUP_EXTRA, + .doc = "Output histograms of eips.", }, + + { .name = "interval", + .key = OPT_INTERVAL_LENGTH, + .arg = "sec", + .group = OPT_GROUP_INTERVAL, + .doc = "Interval length to do time-based graphs, in seconds", }, + + { .name = "interval-cr3-schedule-time", + .key = OPT_INTERVAL_CR3_SCHEDULE_TIME, + .arg = "gmfn[,gmfn...]", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the listed cr3 value(s) every interval.", }, + + { .name = "interval-cr3-schedule-time-all", + .key = OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL, + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with all cr3 values every interval.", }, + + { .name = "interval-cr3-schedule-ordered", + .key = OPT_INTERVAL_CR3_SCHEDULE_ORDERED, + .group = OPT_GROUP_INTERVAL, + .doc = "Print summary with the top 10 cr3 values every interval.", }, + + { .name = "interval-cr3-short-summary", + .key = OPT_INTERVAL_CR3_SHORT_SUMMARY, + .arg = "gmfn", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the hvm short summary of cr3 value every interval.", }, + + { .name = "interval-domain-total-time", + .key = OPT_INTERVAL_DOMAIN_TOTAL_TIME, + .arg = "domain[,domain...]", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the listed domain(s) total runtime every interval.", }, + + { .name = "interval-domain-total-time-all", + .key = OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL, + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with all domains every interval.", }, + + { .name = "interval-domain-short-summary", + .key = OPT_INTERVAL_DOMAIN_SHORT_SUMMARY, + .arg = "domain-id", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the hvm short summary of given domain every interval.", }, + + { .name = "interval-domain-guest-interrupt", + .key = OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT, + .arg = "domain-id", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the guest interrupt count of given domain every interval.", }, + + { .name = "interval-domain-grant-maps", + .key = OPT_INTERVAL_DOMAIN_GRANT_MAPS, + .arg = "domain-id", + .group = OPT_GROUP_INTERVAL, + .doc = "Print a csv with the grant maps done on behalf of a given domain every interval.", }, + + /* Summary group */ + { .name = "show-default-domain-summary", + .key = OPT_SHOW_DEFAULT_DOMAIN_SUMMARY, + .group = OPT_GROUP_SUMMARY, + .doc = "Show default domain information on summary", }, + + { .name = "mmio-enumeration-skip-vga", + .key = OPT_MMIO_ENUMERATION_SKIP_VGA, + .arg = "[0|1]", + .group = OPT_GROUP_SUMMARY, + .doc = "Control whether we enumerate MMIO accesses to the VGA area, which can be extremly high during boot. Default: 0", }, + + { .name = "sample-size", + .key = OPT_SAMPLE_SIZE, + .arg = "size", + .group = OPT_GROUP_SUMMARY, + .doc = "Keep [size] samples for percentile purposes. Enter 0 to " \ + "disable. Default 10240.", }, + + { .name = "summary", + .key = OPT_SUMMARY, + .group = OPT_GROUP_SUMMARY, + .doc = "Output a summary", }, + + { .name = "report-pcpu", + .key = OPT_REPORT_PCPU, + .group = OPT_GROUP_SUMMARY, + .doc = "Report utilization for pcpus", }, + + /* Guest info */ + { .name = "default-guest-paging-levels", + .key = OPT_DEFAULT_GUEST_PAGING_LEVELS, + .group = OPT_GROUP_GUEST, + .arg = "L", + .doc = "Default guest paging levels. Mainly necessary for Rio, as Miami traces include guest paging levels where appropriate.", }, + + { .name = "symbol-file", + .key = OPT_SYMBOL_FILE, + .group = OPT_GROUP_GUEST, + .arg = "filename", + .doc = "A symbol file for interpreting guest eips.", }, + + /* Hardware info */ + { .name = "cpu-hz", + .key = OPT_CPU_HZ, + .group = OPT_GROUP_HARDWARE, + .arg = "HZ", + .doc = "Cpu speed of the tracing host, used to convert tsc into seconds.", }, + + { .name = "svm-mode", + .key = OPT_SVM_MODE, + .group = OPT_GROUP_HARDWARE, + .doc = "Assume AMD SVM-style vmexit error codes. (Default is Intel VMX.)", }, + + { .name = "progress", + .key = OPT_PROGRESS, + .doc = "Progress dialog. Requires the zenity (GTK+) executable.", }, + + { .name = "tsc-loop-fatal", + .key = OPT_TSC_LOOP_FATAL, + .doc = "Stop processing and exit if tsc skew tracking detects a dependency loop.", }, + + { .name = "tolerance", + .key = OPT_TOLERANCE, + .arg = "errlevel", + .doc = "Sets tolerance for errors found in the file. Default is 3; max is 6.", }, + + + { 0 }, +}; + +const struct argp parser_def = { + .options = cmd_opts, + .parser = cmd_parser, + .args_doc = "[trace file]", + .doc = "", +}; + +const char *argp_program_version = "xenalyze - Open-source xen-unstable (3.4)"; +const char *argp_program_bug_address = "George Dunlap <george.dunlap@eu.citrix.com>"; + + +int main(int argc, char *argv[]) { + /* Start with warn at stderr. */ + warn = stderr; + + argp_parse(&parser_def, argc, argv, 0, NULL, NULL); + + if (G.trace_file == NULL) + exit(1); + + if ( (G.fd = open(G.trace_file, O_RDONLY|O_LARGEFILE)) < 0) { + perror("open"); + error(ERR_SYSTEM, NULL); + } else { + struct stat64 s; + fstat64(G.fd, &s); + G.file_size = s.st_size; + } + + if ( (G.mh = mread_init(G.fd)) == NULL ) + perror("mread"); + + if (G.symbol_file != NULL) + parse_symbol_file(G.symbol_file); + + if(opt.dump_all) + warn = stdout; + + init_pcpus(); + + if(opt.progress) + progress_init(); + + process_records(); + + if(opt.interval_mode) + interval_tail(); + + if(opt.summary) + summary(); + + if(opt.report_pcpu) + report_pcpu(); + + if(opt.progress) + progress_finish(); + + return 0; +} +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v5 1/8] xenalyze: add to tools/xentrace/ 2015-06-09 11:23 ` [PATCH v5 1/8] xenalyze: add to tools/xentrace/ Olaf Hering @ 2015-06-11 15:23 ` George Dunlap 2015-06-11 16:04 ` Olaf Hering 0 siblings, 1 reply; 20+ messages in thread From: George Dunlap @ 2015-06-11 15:23 UTC (permalink / raw) To: Olaf Hering Cc: Ian Jackson, Stefano Stabellini, Wei Liu, Ian Campbell, xen-devel On Tue, Jun 9, 2015 at 12:23 PM, Olaf Hering <olaf@aepfle.de> wrote: > This merges xenalyze.hg, changeset 150:24308507be1d, > into tools/xentrace/xenalyze.c to have the tool and > public/trace.h in one place. > > Signed-off-by: Olaf Hering <olaf@aepfle.de> > Acked-by: Wei Liu <wei.liu2@citrix.com> > Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Normally in this case you wouldn't retain the Acked-by with this change, even though I was the one that suggested it. :-) First, it looks like maybe this wasn't based on 24308507be1d, but on 8083183a7238? At least there seems to be changes in it that aren't in the other one. Secondly, it's not identical to what's checked in there, but has a handful of changes; namely: * Use <public/trace.h> rather than "trace.h", both in xenalyze.c and pv.h. * Remove __atribute__((packed)) from various structures. With an updated changelog, then: Acked-by: George Dunlap <george.dunlap@eu.citrix.com> > Cc: Ian Jackson <ian.jackson@eu.citrix.com> > Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> > Cc: Ian Campbell <ian.campbell@citrix.com> > Cc: Wei Liu <wei.liu2@citrix.com> > --- > .gitignore | 1 + > tools/xentrace/Makefile | 6 + > tools/xentrace/analyze.h | 107 + > tools/xentrace/mread.c | 160 + > tools/xentrace/mread.h | 18 + > tools/xentrace/pv.h | 41 + > tools/xentrace/xenalyze.c | 10407 ++++++++++++++++++++++++++++++++++++++++++++ > 7 files changed, 10740 insertions(+) > > diff --git a/.gitignore b/.gitignore > index 3bc9cd9..3f42ded 100644 > --- a/.gitignore > +++ b/.gitignore > @@ -173,6 +173,7 @@ tools/misc/gtracestat > tools/misc/xenlockprof > tools/misc/lowmemd > tools/misc/xencov > +tools/xentrace/xenalyze > tools/pygrub/build/* > tools/python/build/* > tools/security/secpol_tool > diff --git a/tools/xentrace/Makefile b/tools/xentrace/Makefile > index 5360960..8932b73 100644 > --- a/tools/xentrace/Makefile > +++ b/tools/xentrace/Makefile > @@ -7,6 +7,8 @@ CFLAGS += $(CFLAGS_libxenctrl) > LDLIBS += $(LDLIBS_libxenctrl) > > BIN = > +BIN-$(CONFIG_X86) = xenalyze > +BIN += $(BIN-y) > SBIN = xentrace xentrace_setsize > LIBBIN = xenctx > SCRIPTS = xentrace_format > @@ -26,6 +28,7 @@ install: build > [ -z "$(LIBBIN)" ] || $(INSTALL_DIR) $(DESTDIR)$(LIBEXEC_BIN) > $(INSTALL_DIR) $(DESTDIR)$(MAN1DIR) > $(INSTALL_DIR) $(DESTDIR)$(MAN8DIR) > + $(INSTALL_PROG) $(BIN) $(DESTDIR)$(bindir) > $(INSTALL_PROG) $(SBIN) $(DESTDIR)$(sbindir) > $(INSTALL_PYTHON_PROG) $(SCRIPTS) $(DESTDIR)$(bindir) > [ -z "$(LIBBIN)" ] || $(INSTALL_PROG) $(LIBBIN) $(DESTDIR)$(LIBEXEC_BIN) > @@ -48,5 +51,8 @@ xenctx: xenctx.o > xentrace_setsize: setsize.o > $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS) $(APPEND_LDFLAGS) > > +xenalyze: xenalyze.o mread.o > + $(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) $(APPEND_LDFLAGS) > + > -include $(DEPS) > > diff --git a/tools/xentrace/analyze.h b/tools/xentrace/analyze.h > new file mode 100644 > index 0000000..40ee551 > --- /dev/null > +++ b/tools/xentrace/analyze.h > @@ -0,0 +1,107 @@ > +#ifndef __ANALYZE_H > +# define __ANALYZE_H > + > +#include <stdint.h> > + > +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) > + > +#define TRC_GEN_MAIN 0 > +#define TRC_SCHED_MAIN 1 > +#define TRC_DOM0OP_MAIN 2 > +#define TRC_HVM_MAIN 3 > +#define TRC_MEM_MAIN 4 > +#define TRC_PV_MAIN 5 > +#define TRC_SHADOW_MAIN 6 > +#define TRC_HW_MAIN 7 > + > +#define TRC_LOST_RECORDS_END (TRC_GEN + 50) > + > +#define NR_CPUS 128 > +#if __x86_64__ > +# define BITS_PER_LONG 64 > +#else > +# define BITS_PER_LONG 32 > +#endif > + > +#define BITS_TO_LONGS(bits) \ > + (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG) > +#define DECLARE_BITMAP(name,bits) \ > + unsigned long name[BITS_TO_LONGS(bits)] > +typedef struct cpumask{ DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t; > + > +enum { > + TRCE_SFLAG_SET_AD, > + TRCE_SFLAG_SET_A, > + TRCE_SFLAG_SHADOW_L1_GET_REF, > + TRCE_SFLAG_SHADOW_L1_PUT_REF, > + TRCE_SFLAG_L2_PROPAGATE, > + TRCE_SFLAG_SET_CHANGED, > + TRCE_SFLAG_SET_FLUSH, > + TRCE_SFLAG_SET_ERROR, > + TRCE_SFLAG_DEMOTE, > + TRCE_SFLAG_PROMOTE, > + TRCE_SFLAG_WRMAP, > + TRCE_SFLAG_WRMAP_GUESS_FOUND, > + TRCE_SFLAG_WRMAP_BRUTE_FORCE, > + TRCE_SFLAG_EARLY_UNSHADOW, > + TRCE_SFLAG_EMULATION_2ND_PT_WRITTEN, > + TRCE_SFLAG_EMULATION_LAST_FAILED, > + TRCE_SFLAG_EMULATE_FULL_PT, > + TRCE_SFLAG_PREALLOC_UNPIN, > + TRCE_SFLAG_PREALLOC_UNHOOK > +}; > + > +#define TRC_HVM_OP_DESTROY_PROC (TRC_HVM_HANDLER + 0x100) > + > +typedef unsigned long long tsc_t; > + > +/* -- on-disk trace buffer definitions -- */ > +struct trace_record { > + union { > + struct { > + unsigned event:28, > + extra_words:3, > + cycle_flag:1; > + union { > + struct { > + uint32_t tsc_lo, tsc_hi; > + uint32_t data[7]; > + } tsc; > + struct { > + uint32_t data[7]; > + } notsc; > + } u; > + }; > + uint32_t raw[8]; > + }; > +}; > + > +/* -- General info about a current record -- */ > +struct time_struct { > + unsigned long long time; > + unsigned int s, ns; > +}; > + > +#define DUMP_HEADER_MAX 256 > + > +struct record_info { > + int cpu; > + tsc_t tsc; > + union { > + unsigned event; > + struct { > + unsigned minor:12, > + sub:4, > + main:12, > + unused:4; > + } evt; > + }; > + int extra_words; > + int size; > + uint32_t *d; > + char dump_header[DUMP_HEADER_MAX]; > + struct time_struct t; > + struct trace_record rec; > +}; > + > +#endif > diff --git a/tools/xentrace/mread.c b/tools/xentrace/mread.c > new file mode 100644 > index 0000000..a63d16c > --- /dev/null > +++ b/tools/xentrace/mread.c > @@ -0,0 +1,160 @@ > +#include <stdio.h> > +#include <stdlib.h> > +#include <strings.h> > +#include <sys/types.h> > +#include <sys/stat.h> > +#include <sys/mman.h> > +#include <errno.h> > +#include "mread.h" > + > +mread_handle_t mread_init(int fd) > +{ > + struct stat64 s; > + mread_handle_t h; > + > + h=malloc(sizeof(struct mread_ctrl)); > + > + if (!h) > + { > + perror("malloc"); > + exit(1); > + } > + > + bzero(h, sizeof(struct mread_ctrl)); > + > + h->fd = fd; > + > + fstat64(fd, &s); > + h->file_size = s.st_size; > + > + return h; > +} > + > +ssize_t mread64(mread_handle_t h, void *rec, ssize_t len, loff_t offset) > +{ > + /* Idea: have a "cache" of N mmaped regions. If the offset is > + * in one of the regions, just copy it. If not, evict one of the > + * regions and map the appropriate range. > + * > + * Basic algorithm: > + * - See if the offset is in one of the regions > + * - If not, map it > + * - evict an old region > + * - map the new region > + * - Copy > + */ > + char * b=NULL; > + int bind=-1; > + loff_t boffset=0; > + ssize_t bsize; > + > +#define dprintf(x...) > +//#define dprintf fprintf > + > + dprintf(warn, "%s: offset %llx len %d\n", __func__, > + offset, len); > + if ( offset > h->file_size ) > + { > + dprintf(warn, " offset > file size %llx, returning 0\n", > + h->file_size); > + return 0; > + } > + if ( offset + len > h->file_size ) > + { > + dprintf(warn, " offset+len > file size %llx, truncating\n", > + h->file_size); > + len = h->file_size - offset; > + } > + > + /* Try to find the offset in our range */ > + dprintf(warn, " Trying last, %d\n", last); > + if ( h->map[h->last].buffer > + && (offset & MREAD_BUF_MASK) == h->map[h->last].start_offset ) > + { > + bind=h->last; > + goto copy; > + } > + > + /* Scan to see if it's anywhere else */ > + dprintf(warn, " Scanning\n"); > + for(bind=0; bind<MREAD_MAPS; bind++) > + if ( h->map[bind].buffer > + && (offset & MREAD_BUF_MASK) == h->map[bind].start_offset ) > + { > + dprintf(warn, " Found, index %d\n", bind); > + break; > + } > + > + /* If we didn't find it, evict someone and map it */ > + if ( bind == MREAD_MAPS ) > + { > + dprintf(warn, " Clock\n"); > + while(1) > + { > + h->clock++; > + if(h->clock >= MREAD_MAPS) > + h->clock=0; > + dprintf(warn, " %d\n", h->clock); > + if(h->map[h->clock].buffer == NULL) > + { > + dprintf(warn, " Buffer null, using\n"); > + break; > + } > + if(!h->map[h->clock].accessed) > + { > + dprintf(warn, " Not accessed, using\n"); > + break; > + } > + h->map[h->clock].accessed=0; > + } > + if(h->map[h->clock].buffer) > + { > + dprintf(warn, " Unmapping\n"); > + munmap(h->map[h->clock].buffer, MREAD_BUF_SIZE); > + } > + /* FIXME: Try MAP_HUGETLB? */ > + /* FIXME: Make sure this works on large files... */ > + h->map[h->clock].start_offset = offset & MREAD_BUF_MASK; > + dprintf(warn, " Mapping %llx from offset %llx\n", > + MREAD_BUF_SIZE, h->map[h->clock].start_offset); > + h->map[h->clock].buffer = mmap(NULL, MREAD_BUF_SIZE, PROT_READ, > + MAP_SHARED, > + h->fd, > + h->map[h->clock].start_offset); > + dprintf(warn, " mmap returned %p\n", h->map[h->clock].buffer); > + if ( h->map[h->clock].buffer == MAP_FAILED ) > + { > + h->map[h->clock].buffer = NULL; > + perror("mmap"); > + exit(1); > + } > + bind = h->clock; > + } > + > + h->last=bind; > +copy: > + h->map[bind].accessed=1; > + b=h->map[bind].buffer; > + boffset=offset - h->map[bind].start_offset; > + if ( boffset + len > MREAD_BUF_SIZE ) > + bsize = MREAD_BUF_SIZE - boffset; > + else > + bsize = len; > + dprintf(warn, " Using index %d, buffer at %p, buffer offset %llx len %d\n", > + bind, b, boffset, bsize); > + > + bcopy(b+boffset, rec, bsize); > + > + /* Handle the boundary case; make sure this is after doing anything > + * with the static variables*/ > + if ( len > bsize ) > + { > + dprintf(warn, " Finishing up by reading l %d o %llx\n", > + len-bsize, offset+bsize); > + mread64(h, rec+bsize, len-bsize, offset+bsize); > + } > + > + /* FIXME: ?? */ > + return len; > +#undef dprintf > +} > diff --git a/tools/xentrace/mread.h b/tools/xentrace/mread.h > new file mode 100644 > index 0000000..8df41a8 > --- /dev/null > +++ b/tools/xentrace/mread.h > @@ -0,0 +1,18 @@ > +#define MREAD_MAPS 8 > +#define MREAD_BUF_SHIFT 9 > +#define PAGE_SHIFT 12 > +#define MREAD_BUF_SIZE (1ULL<<(PAGE_SHIFT+MREAD_BUF_SHIFT)) > +#define MREAD_BUF_MASK (~(MREAD_BUF_SIZE-1)) > +typedef struct mread_ctrl { > + int fd; > + loff_t file_size; > + struct mread_buffer { > + char * buffer; > + loff_t start_offset; > + int accessed; > + } map[MREAD_MAPS]; > + int clock, last; > +} *mread_handle_t; > + > +mread_handle_t mread_init(int fd); > +ssize_t mread64(mread_handle_t h, void *dst, ssize_t len, loff_t offset); > diff --git a/tools/xentrace/pv.h b/tools/xentrace/pv.h > new file mode 100644 > index 0000000..3e6ad77 > --- /dev/null > +++ b/tools/xentrace/pv.h > @@ -0,0 +1,41 @@ > +/* > + * PV event decoding. > + * > + * Copyright (C) 2012 Citrix Systems R&D Ltd. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + */ > +#ifndef __PV_H > + > +#include "analyze.h" > +#include <xen/trace.h> > + > +#ifdef __cplusplus > +extern "C" { > +#endif > + > +#define ARG_MISSING 0x0 > +#define ARG_32BIT 0x1 > +#define ARG_64BIT 0x2 > + > +#define MMU_UPDATE_PREEMPTED (~(~0U>>1)) > + > +static inline uint32_t pv_hypercall_op(const struct record_info *ri) > +{ > + return ri->d[0] & ~TRC_PV_HYPERCALL_V2_ARG_MASK; > +} > + > +static inline int pv_hypercall_arg_present(const struct record_info *ri, int arg) > +{ > + return (ri->d[0] >> (20 + 2*arg)) & 0x3; > +} > + > +void pv_hypercall_gather_args(const struct record_info *ri, uint64_t *args); > + > +#ifdef __cplusplus > +} /* extern "C" */ > +#endif > + > +#endif > diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c > new file mode 100644 > index 0000000..a0a3ac1 > --- /dev/null > +++ b/tools/xentrace/xenalyze.c > @@ -0,0 +1,10407 @@ > +/* > + * xenalyze.c: Analyzing xentrace output > + * > + * Written by George Dunlap. > + * > + * Copyright (c) 2006-2007, XenSource Inc. > + * Copyright (c) 2007-2008, Citrix Systems R&D Ltd, UK > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * You should have received a copy of the GNU General Public License along with > + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple > + * Place - Suite 330, Boston, MA 02111-1307 USA. > + */ > +#define _XOPEN_SOURCE 600 > +#include <stdio.h> > +#include <stdlib.h> > +#include <argp.h> > +#include <inttypes.h> > +#include <sys/types.h> > +#include <sys/wait.h> > +#include <sys/stat.h> > +#include <fcntl.h> > +#include <unistd.h> > +#include <xen/trace.h> > +#include "analyze.h" > +#include "mread.h" > +#include "pv.h" > +#include <errno.h> > +#include <strings.h> > +#include <string.h> > +#include <assert.h> > + > +struct mread_ctrl; > + > + > +#define DEFAULT_CPU_HZ 2400000000LL > +#define QHZ_FROM_HZ(_hz) (((_hz) << 10)/ 1000000000) > + > +#define ADDR_SPACE_BITS 48 > +#define DEFAULT_SAMPLE_SIZE 10240 > +#define DEFAULT_INTERVAL_LENGTH 1000 > + > +struct array_struct { > + unsigned long long *values; > + int count; > +}; > + > +#define warn_once(_x...) \ > + do { \ > + static int _w=1; \ > + if ( _w ) { \ > + _w=0; \ > + fprintf(warn, ##_x); \ > + } \ > + } while(0) \ > + > +/* -- Global variables -- */ > +struct { > + int fd; > + struct mread_ctrl *mh; > + struct symbol_struct * symbols; > + char * symbol_file; > + char * trace_file; > + int output_defined; > + loff_t file_size; > + struct { > + loff_t update_offset; > + int pipe[2]; > + FILE* out; > + int pid; > + } progress; > +} G = { > + .fd=-1, > + .symbols = NULL, > + .symbol_file = NULL, > + .trace_file = NULL, > + .output_defined = 0, > + .file_size = 0, > + .progress = { .update_offset = 0 }, > +}; > + > +/* > + Kinds of errors: > + Unexpected values > + - RIP with information in high bits (not all 0 or 1) > + - exit reason too high > + Unexpected record layout > + - x64 bit set in PIO,PV_PTWR_EMULATION_PAE, > + - Unknown minor type (PV_PTWR_EMULATION, RUNSTATE_CHANGE > + - Wrong record size > + - More than one bit set in evt.main field > + Unexpected sequences > + - wake tsc tracking > + - TSC dependency loop > + - Mismatch between non-running old event states > + - Runstate continue while running on another pcpu > + - lost_record_end seen in non-lost pcpu > + - Unexpected non-CPU_CHANGE record during new_pcpu scan > + - record tsc < interval start tsc > + - lost_record tsc !> order tsc > + Limited resources > + - interrupt interval slots > + - record cpu > MAX_CPUS > + Algorithm asserts > + - Duplicate CR3/domain values > + - Logic holes > + - domain runstates > + - runstate / tsc skew > + - vcpu_{prev,next}_update p->current{==,!=}null > + - vcpu start conditions > + - lost_cpu count higher than # of seen cpus / < 0 > + - lost cpu has non-null p->current > + Symbol file > + -file doesn't open > + -file not ordered > + System > + - short read > + - malloc failed > + Args > + - Invalid cpu_hz value / suffix > + - No trace file > + - Can't open trace file > +*/ > +enum error_level { > + ERR_NONE=0, > + ERR_STRICT, /* Be unreasonably picky */ > + ERR_WARN, /* Something midly unexpected */ > + ERR_SANITY, /* Sanity checks: RIP with info in high bits */ > + ERR_RECORD, /* Something that keeps you from processing the record */ > + ERR_FILE, /* Probably caused by a corrupt file */ > + ERR_LIMIT, /* Exceeded limits; data will be lost */ > + ERR_MAX_TOLERABLE=ERR_LIMIT, > + /* -- Unrecoverable past this point -- */ > + ERR_ASSERT, /* Algoritm assert */ > + ERR_SYSTEM, /* System error: cannot allocate memory, short read, &c */ > +}; > + > +int verbosity = 5; > + > +struct { > + unsigned > + scatterplot_interrupt_eip:1, > + scatterplot_cpi:1, > + scatterplot_unpin_promote:1, > + scatterplot_cr3_switch:1, > + scatterplot_wake_to_halt:1, > + scatterplot_io:1, > + scatterplot_vmexit_eip:1, > + scatterplot_runstate:1, > + scatterplot_runstate_time:1, > + scatterplot_pcpu:1, > + scatterplot_extint_cycles:1, > + scatterplot_rdtsc:1, > + scatterplot_irq:1, > + histogram_interrupt_eip:1, > + interval_mode:1, > + dump_all:1, > + dump_raw_process:1, > + dump_raw_reads:1, > + dump_no_processing:1, > + dump_ipi_latency:1, > + dump_trace_volume_on_lost_record:1, > + dump_show_power_states:1, > + with_cr3_enumeration:1, > + with_pio_enumeration:1, > + with_mmio_enumeration:1, > + with_interrupt_eip_enumeration:1, > + show_default_domain_summary:1, > + mmio_enumeration_skip_vga:1, > + progress:1, > + svm_mode:1, > + summary:1, > + report_pcpu:1, > + tsc_loop_fatal:1, > + summary_info; > + long long cpu_qhz, cpu_hz; > + int scatterplot_interrupt_vector; > + int scatterplot_extint_cycles_vector; > + int scatterplot_io_port; > + int histogram_interrupt_vector; > + unsigned long long histogram_interrupt_increment; > + int interrupt_eip_enumeration_vector; > + int default_guest_paging_levels; > + int sample_size; > + enum error_level tolerance; /* Tolerate up to this level of error */ > + struct { > + tsc_t cycles; > + /* Used if interval is specified in seconds to delay calculating > + * time_interval until all arguments have been processed (specifically, > + * cpu_hz). */ > + unsigned msec; > + enum { > + INTERVAL_CR3_SCHEDULE_TIME, > + INTERVAL_CR3_SCHEDULE_ORDERED, > + INTERVAL_CR3_SHORT_SUMMARY, > + INTERVAL_DOMAIN_TOTAL_TIME, > + INTERVAL_DOMAIN_SHORT_SUMMARY, > + INTERVAL_DOMAIN_GUEST_INTERRUPT, > + INTERVAL_DOMAIN_GRANT_MAPS > + } output; > + enum { > + INTERVAL_MODE_CUSTOM, > + INTERVAL_MODE_ARRAY, > + INTERVAL_MODE_LIST > + } mode; > + enum { > + INTERVAL_CHECK_NONE, > + INTERVAL_CHECK_CR3, > + INTERVAL_CHECK_DOMAIN > + } check; > + /* Options for specific interval output types */ > + union { > + struct array_struct array; > + }; > + int count; > + } interval; > +} opt = { > + .scatterplot_interrupt_eip=0, > + .scatterplot_cpi=0, > + .scatterplot_unpin_promote=0, > + .scatterplot_cr3_switch=0, > + .scatterplot_wake_to_halt=0, > + .scatterplot_vmexit_eip=0, > + .scatterplot_runstate=0, > + .scatterplot_runstate_time=0, > + .scatterplot_pcpu=0, > + .scatterplot_extint_cycles=0, > + .scatterplot_rdtsc=0, > + .scatterplot_irq=0, > + .histogram_interrupt_eip=0, > + .dump_all = 0, > + .dump_raw_process = 0, > + .dump_raw_reads = 0, > + .dump_no_processing = 0, > + .dump_ipi_latency = 0, > + .dump_trace_volume_on_lost_record = 0, > + .dump_show_power_states = 0, > + .with_cr3_enumeration = 0, > + .with_pio_enumeration = 1, > + .with_mmio_enumeration = 0, > + .with_interrupt_eip_enumeration = 0, > + .show_default_domain_summary = 0, > + .mmio_enumeration_skip_vga = 1, > + .progress = 0, > + .svm_mode = 0, > + .summary = 0, > + .report_pcpu = 0, > + .tsc_loop_fatal = 0, > + .cpu_hz = DEFAULT_CPU_HZ, > + /* Pre-calculate a multiplier that makes the rest of the > + * calculations easier */ > + .cpu_qhz = QHZ_FROM_HZ(DEFAULT_CPU_HZ), > + .default_guest_paging_levels = 2, > + .sample_size = DEFAULT_SAMPLE_SIZE, > + .tolerance = ERR_SANITY, > + .interval = { .msec = DEFAULT_INTERVAL_LENGTH }, > +}; > + > +FILE *warn = NULL; > + > +/* -- Summary data -- */ > +struct cycle_framework { > + tsc_t first_tsc, last_tsc, total_cycles; > +}; > + > +struct interval_element { > + int count; > + long long cycles; > + long long instructions; > +}; > + > +struct event_cycle_summary { > + int count, cycles_count; > + long long cycles; > + long long *cycles_sample; > + struct interval_element interval; > +}; > + > +struct cycle_summary { > + int count; > + unsigned long long cycles; > + long long *sample; > + struct interval_element interval; > +}; > + > +struct weighted_cpi_summary { > + int count; > + unsigned long long instructions; > + unsigned long long cycles; > + float *cpi; > + unsigned long long *cpi_weight; > + struct interval_element interval; > +}; > + > +/* -- Symbol list information -- */ > +#define SYMBOL_ENTRIES_PER_STRUCT 1023 > +#define SYMBOL_NAME_SIZE 124 > +struct symbol_struct { > + int count; > + struct { > + unsigned long long addr; > + char name[SYMBOL_NAME_SIZE]; > + } symbols[SYMBOL_ENTRIES_PER_STRUCT]; > + struct symbol_struct *next; > +}; > + > +void error(enum error_level l, struct record_info *ri); > + > +void parse_symbol_file(char *fn) { > + unsigned long long last_addr = 0; > + FILE * symbol_file; > + struct symbol_struct ** p=&G.symbols; > + > + if((symbol_file=fopen(fn, "rb"))==NULL) { > + fprintf(stderr, "Could not open symbol file %s\n", fn); > + perror("open"); > + error(ERR_SYSTEM, NULL); > + } > + while(!feof(symbol_file)) { > + /* Allocate a new struct if we need it */ > + if(!*p) { > + *p = malloc(sizeof(**p)); > + if(!*p) { > + fprintf(stderr, "Malloc failed!\n"); > + error(ERR_SYSTEM, NULL); > + } > + (*p)->count=0; > + (*p)->next=NULL; > + } > + > + /* FIXME -- use SYMBOL_NAME_SIZE */ > + /* FIXME -- use regexp. This won't work for symbols with spaces (yes they exist) */ > + (*p)->symbols[(*p)->count].addr = 0xDEADBEEF; > + if ( fscanf(symbol_file, "%llx %128s", > + &(*p)->symbols[(*p)->count].addr, > + (*p)->symbols[(*p)->count].name) == 0 ) > + break; > + > + > + if( ((*p)->symbols[(*p)->count].addr > 0) > + && ((*p)->symbols[(*p)->count].addr < last_addr) ) { > + fprintf(stderr, "Symbol file not properly ordered: %llx %s < %llx!\n", > + (*p)->symbols[(*p)->count].addr, > + (*p)->symbols[(*p)->count].name, > + last_addr); > + /* Could be recovered from; just free existing strings and set symbols to NULL */ > + error(ERR_ASSERT, NULL); > + } else > + last_addr = (*p)->symbols[(*p)->count].addr; > + > + (*p)->count++; > + > + /* If this struct is full, point to the next. It will be allocated > + if needed. */ > + if((*p)->count == SYMBOL_ENTRIES_PER_STRUCT) { > + p=&((*p)->next); > + } > + } > +} > + > +/* WARNING not thread safe */ > +char * find_symbol(unsigned long long addr) { > + struct symbol_struct * p=G.symbols; > + int i; > + char * lastname="ZERO"; > + unsigned long long offset=addr; > + static char name[128]; > + > + if(!p) { > + name[0]=0; > + return name; > + } > + > + while(1) { > + if(!p) > + goto finish; > + for(i=0; i<p->count; i++) { > + if(p->symbols[i].addr > addr) > + goto finish; > + else { > + lastname=p->symbols[i].name; > + offset=addr - p->symbols[i].addr; > + } > + } > + p=p->next; > + } > + finish: > + snprintf(name, 128, "(%s +%llx)", > + lastname, offset); > + return name; > +} > + > +/* -- Eip list data -- */ > +enum { > + EIP_LIST_TYPE_NONE=0, > + EIP_LIST_TYPE_MAX > +}; > + > +struct eip_list_struct { > + struct eip_list_struct *next; > + unsigned long long eip; > + struct event_cycle_summary summary; > + int type; > + void * extra; > +}; > + > +struct { > + void (*update)(struct eip_list_struct *, void *); > + void (*new)(struct eip_list_struct *, void *); > + void (*dump)(struct eip_list_struct *); > +} eip_list_type[EIP_LIST_TYPE_MAX] = { > + [EIP_LIST_TYPE_NONE] = { > + .update=NULL, > + .new=NULL, > + .dump=NULL }, > +}; > + > + > +/* --- HVM class of events --- */ > + > +/* > + * -- Algorithms -- > + * > + * Interrupt Wake-to-halt detection > + * > + * Purpose: To correlate device interrupts to vcpu runtime. > + * > + * Diagram: > + * ... > + * blocked -> runnable <- set to waking > + * ... > + * runnable -> running > + * inj_virq A <- Note "waking" interrupt > + * vmenter <- Start tsc of "wake-to-halt" interval. > + Turn off 'waking'. > + * ... > + * inj_virq B <- Note alternate interrupt > + * vmenter <- Start tsc of "interrupt-to-halt" interval > + * ... > + * vmexit <- End tsc of "x-to-halt" interval > + * running -> blocked <- Process > + * > + * The "waking" interrupts we want to sub-classify into > + * "wake-only" (when interrupt was the only interrupt from wake to halt) and > + * "wake-all" (whether this was the only interrupt or not). > + */ > + > +/* VMX data */ > +#define EXIT_REASON_EXCEPTION_NMI 0 > +#define EXIT_REASON_EXTERNAL_INTERRUPT 1 > +#define EXIT_REASON_TRIPLE_FAULT 2 > +#define EXIT_REASON_INIT 3 > +#define EXIT_REASON_SIPI 4 > +#define EXIT_REASON_IO_SMI 5 > +#define EXIT_REASON_OTHER_SMI 6 > +#define EXIT_REASON_PENDING_INTERRUPT 7 > +#define EXIT_REASON_PENDING_VIRT_NMI 8 > +#define EXIT_REASON_TASK_SWITCH 9 > +#define EXIT_REASON_CPUID 10 > +#define EXIT_REASON_GETSEC 11 > +#define EXIT_REASON_HLT 12 > +#define EXIT_REASON_INVD 13 > +#define EXIT_REASON_INVLPG 14 > +#define EXIT_REASON_RDPMC 15 > +#define EXIT_REASON_RDTSC 16 > +#define EXIT_REASON_RSM 17 > +#define EXIT_REASON_VMCALL 18 > +#define EXIT_REASON_VMCLEAR 19 > +#define EXIT_REASON_VMLAUNCH 20 > +#define EXIT_REASON_VMPTRLD 21 > +#define EXIT_REASON_VMPTRST 22 > +#define EXIT_REASON_VMREAD 23 > +#define EXIT_REASON_VMRESUME 24 > +#define EXIT_REASON_VMWRITE 25 > +#define EXIT_REASON_VMOFF 26 > +#define EXIT_REASON_VMON 27 > +#define EXIT_REASON_CR_ACCESS 28 > +#define EXIT_REASON_DR_ACCESS 29 > +#define EXIT_REASON_IO_INSTRUCTION 30 > +#define EXIT_REASON_MSR_READ 31 > +#define EXIT_REASON_MSR_WRITE 32 > +#define EXIT_REASON_INVALID_GUEST_STATE 33 > +#define EXIT_REASON_MSR_LOADING 34 > +#define EXIT_REASON_MWAIT_INSTRUCTION 36 > +#define EXIT_REASON_MONITOR_TRAP_FLAG 37 > +#define EXIT_REASON_MONITOR_INSTRUCTION 39 > +#define EXIT_REASON_PAUSE_INSTRUCTION 40 > +#define EXIT_REASON_MACHINE_CHECK 41 > +#define EXIT_REASON_TPR_BELOW_THRESHOLD 43 > +#define EXIT_REASON_APIC_ACCESS 44 > +#define EXIT_REASON_ACCESS_GDTR_OR_IDTR 46 > +#define EXIT_REASON_ACCESS_LDTR_OR_TR 47 > +#define EXIT_REASON_EPT_VIOLATION 48 > +#define EXIT_REASON_EPT_MISCONFIG 49 > +#define EXIT_REASON_INVEPT 50 > +#define EXIT_REASON_RDTSCP 51 > +#define EXIT_REASON_VMX_PREEMPTION_TIMER_EXPIRED 52 > +#define EXIT_REASON_INVVPID 53 > +#define EXIT_REASON_WBINVD 54 > +#define EXIT_REASON_XSETBV 55 > + > +#define HVM_VMX_EXIT_REASON_MAX (EXIT_REASON_XSETBV+1) > + > +char * hvm_vmx_exit_reason_name[HVM_VMX_EXIT_REASON_MAX] = { > + [0] = "NONE", > + [EXIT_REASON_EXCEPTION_NMI]="EXCEPTION_NMI", > + [EXIT_REASON_EXTERNAL_INTERRUPT]="EXTERNAL_INTERRUPT", > + [EXIT_REASON_TRIPLE_FAULT]="TRIPLE_FAULT", > + [EXIT_REASON_INIT]="INIT", > + [EXIT_REASON_SIPI]="SIPI", > + [EXIT_REASON_IO_SMI]="IO_SMI", > + [EXIT_REASON_OTHER_SMI]="OTHER_SMI", > + [EXIT_REASON_PENDING_INTERRUPT]="PENDING_INTERRUPT", > + [EXIT_REASON_PENDING_VIRT_NMI]="PENDING_VIRT_NMI", > + [EXIT_REASON_TASK_SWITCH]="TASK_SWITCH", > + [EXIT_REASON_CPUID]="CPUID", > + [EXIT_REASON_GETSEC]="GETSEC", > + [EXIT_REASON_HLT]="HLT", > + [EXIT_REASON_INVD]="INVD", > + [EXIT_REASON_INVLPG]="INVLPG", > + [EXIT_REASON_RDPMC]="RDPMC", > + [EXIT_REASON_RDTSC]="RDTSC", > + [EXIT_REASON_RSM]="RSM", > + [EXIT_REASON_VMCALL]="VMCALL", > + [EXIT_REASON_VMCLEAR]="VMCLEAR", > + [EXIT_REASON_VMLAUNCH]="VMLAUNCH", > + [EXIT_REASON_VMPTRLD]="VMPTRLD", > + [EXIT_REASON_VMPTRST]="VMPTRST", > + [EXIT_REASON_VMREAD]="VMREAD", > + [EXIT_REASON_VMRESUME]="VMRESUME", > + [EXIT_REASON_VMWRITE]="VMWRITE", > + [EXIT_REASON_VMOFF]="VMOFF", > + [EXIT_REASON_VMON]="VMON", > + [EXIT_REASON_CR_ACCESS]="CR_ACCESS", > + [EXIT_REASON_DR_ACCESS]="DR_ACCESS", > + [EXIT_REASON_IO_INSTRUCTION]="IO_INSTRUCTION", > + [EXIT_REASON_MSR_READ]="MSR_READ", > + [EXIT_REASON_MSR_WRITE]="MSR_WRITE", > + [EXIT_REASON_INVALID_GUEST_STATE]="INVALID_GUEST_STATE", > + [EXIT_REASON_MSR_LOADING]="MSR_LOADING", > + [EXIT_REASON_MWAIT_INSTRUCTION]="MWAIT_INSTRUCTION", > + [EXIT_REASON_MONITOR_TRAP_FLAG]="MONITOR_TRAP_FLAG", > + [EXIT_REASON_MONITOR_INSTRUCTION]="MONITOR_INSTRUCTION", > + [EXIT_REASON_PAUSE_INSTRUCTION]="PAUSE_INSTRUCTION", > + [EXIT_REASON_MACHINE_CHECK]="MACHINE_CHECK", > + [EXIT_REASON_TPR_BELOW_THRESHOLD]="TPR_BELOW_THRESHOLD", > + [EXIT_REASON_APIC_ACCESS]="APIC_ACCESS", > + [EXIT_REASON_EPT_VIOLATION]="EPT_VIOLATION", > + [EXIT_REASON_EPT_MISCONFIG]="EPT_MISCONFIG", > + [EXIT_REASON_INVEPT]="INVEPT", > + [EXIT_REASON_RDTSCP]="RDTSCP", > + [EXIT_REASON_VMX_PREEMPTION_TIMER_EXPIRED]="VMX_PREEMPTION_TIMER_EXPIRED", > + [EXIT_REASON_INVVPID]="INVVPID", > + [EXIT_REASON_WBINVD]="WBINVD", > + [EXIT_REASON_XSETBV]="XSETBV", > +}; > + > +/* SVM data */ > +enum VMEXIT_EXITCODE > +{ > + /* control register read exitcodes */ > + VMEXIT_CR0_READ = 0, > + VMEXIT_CR1_READ = 1, > + VMEXIT_CR2_READ = 2, > + VMEXIT_CR3_READ = 3, > + VMEXIT_CR4_READ = 4, > + VMEXIT_CR5_READ = 5, > + VMEXIT_CR6_READ = 6, > + VMEXIT_CR7_READ = 7, > + VMEXIT_CR8_READ = 8, > + VMEXIT_CR9_READ = 9, > + VMEXIT_CR10_READ = 10, > + VMEXIT_CR11_READ = 11, > + VMEXIT_CR12_READ = 12, > + VMEXIT_CR13_READ = 13, > + VMEXIT_CR14_READ = 14, > + VMEXIT_CR15_READ = 15, > + > + /* control register write exitcodes */ > + VMEXIT_CR0_WRITE = 16, > + VMEXIT_CR1_WRITE = 17, > + VMEXIT_CR2_WRITE = 18, > + VMEXIT_CR3_WRITE = 19, > + VMEXIT_CR4_WRITE = 20, > + VMEXIT_CR5_WRITE = 21, > + VMEXIT_CR6_WRITE = 22, > + VMEXIT_CR7_WRITE = 23, > + VMEXIT_CR8_WRITE = 24, > + VMEXIT_CR9_WRITE = 25, > + VMEXIT_CR10_WRITE = 26, > + VMEXIT_CR11_WRITE = 27, > + VMEXIT_CR12_WRITE = 28, > + VMEXIT_CR13_WRITE = 29, > + VMEXIT_CR14_WRITE = 30, > + VMEXIT_CR15_WRITE = 31, > + > + /* debug register read exitcodes */ > + VMEXIT_DR0_READ = 32, > + VMEXIT_DR1_READ = 33, > + VMEXIT_DR2_READ = 34, > + VMEXIT_DR3_READ = 35, > + VMEXIT_DR4_READ = 36, > + VMEXIT_DR5_READ = 37, > + VMEXIT_DR6_READ = 38, > + VMEXIT_DR7_READ = 39, > + VMEXIT_DR8_READ = 40, > + VMEXIT_DR9_READ = 41, > + VMEXIT_DR10_READ = 42, > + VMEXIT_DR11_READ = 43, > + VMEXIT_DR12_READ = 44, > + VMEXIT_DR13_READ = 45, > + VMEXIT_DR14_READ = 46, > + VMEXIT_DR15_READ = 47, > + > + /* debug register write exitcodes */ > + VMEXIT_DR0_WRITE = 48, > + VMEXIT_DR1_WRITE = 49, > + VMEXIT_DR2_WRITE = 50, > + VMEXIT_DR3_WRITE = 51, > + VMEXIT_DR4_WRITE = 52, > + VMEXIT_DR5_WRITE = 53, > + VMEXIT_DR6_WRITE = 54, > + VMEXIT_DR7_WRITE = 55, > + VMEXIT_DR8_WRITE = 56, > + VMEXIT_DR9_WRITE = 57, > + VMEXIT_DR10_WRITE = 58, > + VMEXIT_DR11_WRITE = 59, > + VMEXIT_DR12_WRITE = 60, > + VMEXIT_DR13_WRITE = 61, > + VMEXIT_DR14_WRITE = 62, > + VMEXIT_DR15_WRITE = 63, > + > + /* processor exception exitcodes (VMEXIT_EXCP[0-31]) */ > + VMEXIT_EXCEPTION_DE = 64, /* divide-by-zero-error */ > + VMEXIT_EXCEPTION_DB = 65, /* debug */ > + VMEXIT_EXCEPTION_NMI = 66, /* non-maskable-interrupt */ > + VMEXIT_EXCEPTION_BP = 67, /* breakpoint */ > + VMEXIT_EXCEPTION_OF = 68, /* overflow */ > + VMEXIT_EXCEPTION_BR = 69, /* bound-range */ > + VMEXIT_EXCEPTION_UD = 70, /* invalid-opcode*/ > + VMEXIT_EXCEPTION_NM = 71, /* device-not-available */ > + VMEXIT_EXCEPTION_DF = 72, /* double-fault */ > + VMEXIT_EXCEPTION_09 = 73, /* unsupported (reserved) */ > + VMEXIT_EXCEPTION_TS = 74, /* invalid-tss */ > + VMEXIT_EXCEPTION_NP = 75, /* segment-not-present */ > + VMEXIT_EXCEPTION_SS = 76, /* stack */ > + VMEXIT_EXCEPTION_GP = 77, /* general-protection */ > + VMEXIT_EXCEPTION_PF = 78, /* page-fault */ > + VMEXIT_EXCEPTION_15 = 79, /* reserved */ > + VMEXIT_EXCEPTION_MF = 80, /* x87 floating-point exception-pending */ > + VMEXIT_EXCEPTION_AC = 81, /* alignment-check */ > + VMEXIT_EXCEPTION_MC = 82, /* machine-check */ > + VMEXIT_EXCEPTION_XF = 83, /* simd floating-point */ > + > + /* exceptions 20-31 (exitcodes 84-95) are reserved */ > + > + /* ...and the rest of the #VMEXITs */ > + VMEXIT_INTR = 96, > + VMEXIT_NMI = 97, > + VMEXIT_SMI = 98, > + VMEXIT_INIT = 99, > + VMEXIT_VINTR = 100, > + VMEXIT_CR0_SEL_WRITE = 101, > + VMEXIT_IDTR_READ = 102, > + VMEXIT_GDTR_READ = 103, > + VMEXIT_LDTR_READ = 104, > + VMEXIT_TR_READ = 105, > + VMEXIT_IDTR_WRITE = 106, > + VMEXIT_GDTR_WRITE = 107, > + VMEXIT_LDTR_WRITE = 108, > + VMEXIT_TR_WRITE = 109, > + VMEXIT_RDTSC = 110, > + VMEXIT_RDPMC = 111, > + VMEXIT_PUSHF = 112, > + VMEXIT_POPF = 113, > + VMEXIT_CPUID = 114, > + VMEXIT_RSM = 115, > + VMEXIT_IRET = 116, > + VMEXIT_SWINT = 117, > + VMEXIT_INVD = 118, > + VMEXIT_PAUSE = 119, > + VMEXIT_HLT = 120, > + VMEXIT_INVLPG = 121, > + VMEXIT_INVLPGA = 122, > + VMEXIT_IOIO = 123, > + VMEXIT_MSR = 124, > + VMEXIT_TASK_SWITCH = 125, > + VMEXIT_FERR_FREEZE = 126, > + VMEXIT_SHUTDOWN = 127, > + VMEXIT_VMRUN = 128, > + VMEXIT_VMMCALL = 129, > + VMEXIT_VMLOAD = 130, > + VMEXIT_VMSAVE = 131, > + VMEXIT_STGI = 132, > + VMEXIT_CLGI = 133, > + VMEXIT_SKINIT = 134, > + VMEXIT_RDTSCP = 135, > + VMEXIT_ICEBP = 136, > + VMEXIT_WBINVD = 137, > + VMEXIT_MONITOR = 138, > + VMEXIT_MWAIT = 139, > + VMEXIT_MWAIT_CONDITIONAL= 140, > + VMEXIT_NPF = 1024, /* nested paging fault */ > + VMEXIT_INVALID = -1 > +}; > + > +#define HVM_SVM_EXIT_REASON_MAX 1025 > +char * hvm_svm_exit_reason_name[HVM_SVM_EXIT_REASON_MAX] = { > + /* 0-15 */ > + "VMEXIT_CR0_READ", > + "VMEXIT_CR1_READ", > + "VMEXIT_CR2_READ", > + "VMEXIT_CR3_READ", > + "VMEXIT_CR4_READ", > + "VMEXIT_CR5_READ", > + "VMEXIT_CR6_READ", > + "VMEXIT_CR7_READ", > + "VMEXIT_CR8_READ", > + "VMEXIT_CR9_READ", > + "VMEXIT_CR10_READ", > + "VMEXIT_CR11_READ", > + "VMEXIT_CR12_READ", > + "VMEXIT_CR13_READ", > + "VMEXIT_CR14_READ", > + "VMEXIT_CR15_READ", > + /* 16-31 */ > + "VMEXIT_CR0_WRITE", > + "VMEXIT_CR1_WRITE", > + "VMEXIT_CR2_WRITE", > + "VMEXIT_CR3_WRITE", > + "VMEXIT_CR4_WRITE", > + "VMEXIT_CR5_WRITE", > + "VMEXIT_CR6_WRITE", > + "VMEXIT_CR7_WRITE", > + "VMEXIT_CR8_WRITE", > + "VMEXIT_CR9_WRITE", > + "VMEXIT_CR10_WRITE", > + "VMEXIT_CR11_WRITE", > + "VMEXIT_CR12_WRITE", > + "VMEXIT_CR13_WRITE", > + "VMEXIT_CR14_WRITE", > + "VMEXIT_CR15_WRITE", > + /* 32-47 */ > + "VMEXIT_DR0_READ", > + "VMEXIT_DR1_READ", > + "VMEXIT_DR2_READ", > + "VMEXIT_DR3_READ", > + "VMEXIT_DR4_READ", > + "VMEXIT_DR5_READ", > + "VMEXIT_DR6_READ", > + "VMEXIT_DR7_READ", > + "VMEXIT_DR8_READ", > + "VMEXIT_DR9_READ", > + "VMEXIT_DR10_READ", > + "VMEXIT_DR11_READ", > + "VMEXIT_DR12_READ", > + "VMEXIT_DR13_READ", > + "VMEXIT_DR14_READ", > + "VMEXIT_DR15_READ", > + /* 48-63 */ > + "VMEXIT_DR0_WRITE", > + "VMEXIT_DR1_WRITE", > + "VMEXIT_DR2_WRITE", > + "VMEXIT_DR3_WRITE", > + "VMEXIT_DR4_WRITE", > + "VMEXIT_DR5_WRITE", > + "VMEXIT_DR6_WRITE", > + "VMEXIT_DR7_WRITE", > + "VMEXIT_DR8_WRITE", > + "VMEXIT_DR9_WRITE", > + "VMEXIT_DR10_WRITE", > + "VMEXIT_DR11_WRITE", > + "VMEXIT_DR12_WRITE", > + "VMEXIT_DR13_WRITE", > + "VMEXIT_DR14_WRITE", > + "VMEXIT_DR15_WRITE", > + /* 64-83 */ > + "VMEXIT_EXCEPTION_DE", > + "VMEXIT_EXCEPTION_DB", > + "VMEXIT_EXCEPTION_NMI", > + "VMEXIT_EXCEPTION_BP", > + "VMEXIT_EXCEPTION_OF", > + "VMEXIT_EXCEPTION_BR", > + "VMEXIT_EXCEPTION_UD", > + "VMEXIT_EXCEPTION_NM", > + "VMEXIT_EXCEPTION_DF", > + "VMEXIT_EXCEPTION_09", > + "VMEXIT_EXCEPTION_TS", > + "VMEXIT_EXCEPTION_NP", > + "VMEXIT_EXCEPTION_SS", > + "VMEXIT_EXCEPTION_GP", > + "VMEXIT_EXCEPTION_PF", > + "VMEXIT_EXCEPTION_15", > + "VMEXIT_EXCEPTION_MF", > + "VMEXIT_EXCEPTION_AC", > + "VMEXIT_EXCEPTION_MC", > + "VMEXIT_EXCEPTION_XF", > + /* 84-95 */ > + "VMEXIT_EXCEPTION_20", > + "VMEXIT_EXCEPTION_21", > + "VMEXIT_EXCEPTION_22", > + "VMEXIT_EXCEPTION_23", > + "VMEXIT_EXCEPTION_24", > + "VMEXIT_EXCEPTION_25", > + "VMEXIT_EXCEPTION_26", > + "VMEXIT_EXCEPTION_27", > + "VMEXIT_EXCEPTION_28", > + "VMEXIT_EXCEPTION_29", > + "VMEXIT_EXCEPTION_30", > + "VMEXIT_EXCEPTION_31", > + /* 96-99 */ > + "VMEXIT_INTR", > + "VMEXIT_NMI", > + "VMEXIT_SMI", > + "VMEXIT_INIT", > + /* 100-109 */ > + "VMEXIT_VINTR", > + "VMEXIT_CR0_SEL_WRITE", > + "VMEXIT_IDTR_READ", > + "VMEXIT_GDTR_READ", > + "VMEXIT_LDTR_READ", > + "VMEXIT_TR_READ", > + "VMEXIT_IDTR_WRITE", > + "VMEXIT_GDTR_WRITE", > + "VMEXIT_LDTR_WRITE", > + "VMEXIT_TR_WRITE", > + /* 110-119 */ > + "VMEXIT_RDTSC", > + "VMEXIT_RDPMC", > + "VMEXIT_PUSHF", > + "VMEXIT_POPF", > + "VMEXIT_CPUID", > + "VMEXIT_RSM", > + "VMEXIT_IRET", > + "VMEXIT_SWINT", > + "VMEXIT_INVD", > + "VMEXIT_PAUSE", > + /* 120-129 */ > + "VMEXIT_HLT", > + "VMEXIT_INVLPG", > + "VMEXIT_INVLPGA", > + "VMEXIT_IOIO", > + "VMEXIT_MSR", > + "VMEXIT_TASK_SWITCH", > + "VMEXIT_FERR_FREEZE", > + "VMEXIT_SHUTDOWN", > + "VMEXIT_VMRUN", > + "VMEXIT_VMMCALL", > + /* 130-139 */ > + "VMEXIT_VMLOAD", > + "VMEXIT_VMSAVE", > + "VMEXIT_STGI", > + "VMEXIT_CLGI", > + "VMEXIT_SKINIT", > + "VMEXIT_RDTSCP", > + "VMEXIT_ICEBP", > + "VMEXIT_WBINVD", > + "VMEXIT_MONITOR", > + "VMEXIT_MWAIT", > + /* 140 */ > + "VMEXIT_MWAIT_CONDITIONAL", > + [VMEXIT_NPF] = "VMEXIT_NPF", /* nested paging fault */ > +}; > + > + > +#if ( HVM_VMX_EXIT_REASON_MAX > HVM_SVM_EXIT_REASON_MAX ) > +# define HVM_EXIT_REASON_MAX HVM_VMX_EXIT_REASON_MAX > +# error - Strange! > +#else > +# define HVM_EXIT_REASON_MAX HVM_SVM_EXIT_REASON_MAX > +#endif > + > +/* General hvm information */ > +#define SPURIOUS_APIC_VECTOR 0xff > +#define ERROR_APIC_VECTOR 0xfe > +#define INVALIDATE_TLB_VECTOR 0xfd > +#define EVENT_CHECK_VECTOR 0xfc > +#define CALL_FUNCTION_VECTOR 0xfb > +#define THERMAL_APIC_VECTOR 0xfa > +#define LOCAL_TIMER_VECTOR 0xf9 > + > +#define EXTERNAL_INTERRUPT_MAX 256 > + > +/* Stringify numbers */ > +char * hvm_extint_vector_name[EXTERNAL_INTERRUPT_MAX] = { > + [SPURIOUS_APIC_VECTOR] = "SPURIOS_APIC", > + [ERROR_APIC_VECTOR] = "ERROR_APIC", > + [INVALIDATE_TLB_VECTOR]= "INVALIDATE_TLB", > + [EVENT_CHECK_VECTOR]= "EVENT_CHECK", > + [CALL_FUNCTION_VECTOR]= "CALL_FUNCTION", > + [THERMAL_APIC_VECTOR]= "THERMAL_APIC", > + [LOCAL_TIMER_VECTOR] = "LOCAL_TIMER", > +}; > + > +#define HVM_TRAP_MAX 20 > + > +char * hvm_trap_name[HVM_TRAP_MAX] = { > + [0] = "Divide", > + [1] = "RESERVED", > + [2] = "NMI", > + [3] = "Breakpoint", > + [4] = "Overflow", > + [5] = "BOUND", > + [6] = "Invalid Op", > + [7] = "Coprocessor not present", > + [8] = "Double Fault", > + [9] = "Coprocessor segment overrun", > + [10] = "TSS", > + [11] = "Segment not present", > + [12] = "Stack-segment fault", > + [13] = "GP", > + [14] = "Page fault", > + [15] = "RESERVED", > + [16] = "FPU", > + [17] = "Alignment check", > + [18] = "Machine check", > + [19] = "SIMD", > +}; > + > + > +enum { > + HVM_EVENT_HANDLER_NONE = 0, > + HVM_EVENT_HANDLER_PF_XEN = 1, > + HVM_EVENT_HANDLER_PF_INJECT, > + HVM_EVENT_HANDLER_INJ_EXC, > + HVM_EVENT_HANDLER_INJ_VIRQ, > + HVM_EVENT_HANDLER_REINJ_VIRQ, > + HVM_EVENT_HANDLER_IO_READ, > + HVM_EVENT_HANDLER_IO_WRITE, > + HVM_EVENT_HANDLER_CR_READ, /* 8 */ > + HVM_EVENT_HANDLER_CR_WRITE, > + HVM_EVENT_HANDLER_DR_READ, > + HVM_EVENT_HANDLER_DR_WRITE, > + HVM_EVENT_HANDLER_MSR_READ, > + HVM_EVENT_HANDLER_MSR_WRITE, > + HVM_EVENT_HANDLER_CPUID, > + HVM_EVENT_HANDLER_INTR, > + HVM_EVENT_HANDLER_NMI, /* 16 */ > + HVM_EVENT_HANDLER_SMI, > + HVM_EVENT_HANDLER_VMCALL, > + HVM_EVENT_HANDLER_HLT, > + HVM_EVENT_HANDLER_INVLPG, > + HVM_EVENT_HANDLER_MCE, > + HVM_EVENT_HANDLER_IO_ASSIST, > + HVM_EVENT_HANDLER_MMIO_ASSIST, > + HVM_EVENT_HANDLER_CLTS, > + HVM_EVENT_HANDLER_LMSW, > + HVM_EVENT_RDTSC, > + HVM_EVENT_INTR_WINDOW=0x20, /* Oops... skipped 0x1b-1f */ > + HVM_EVENT_NPF, > + HVM_EVENT_REALMODE_EMULATE, > + HVM_EVENT_TRAP, > + HVM_EVENT_TRAP_DEBUG, > + HVM_EVENT_VLAPIC, > + HVM_EVENT_HANDLER_MAX > +}; > +char * hvm_event_handler_name[HVM_EVENT_HANDLER_MAX] = { > + "(no handler)", > + "pf_xen", > + "pf_inject", > + "inj_exc", > + "inj_virq", > + "reinj_virq", > + "io_read", > + "io_write", > + "cr_read", /* 8 */ > + "cr_write", > + "dr_read", > + "dr_write", > + "msr_read", > + "msr_write", > + "cpuid", > + "intr", > + "nmi", /* 16 */ > + "smi", > + "vmcall", > + "hlt", > + "invlpg", > + "mce", > + "io_assist", > + "mmio_assist", > + "clts", /* 24 */ > + "lmsw", > + "rdtsc", > + [HVM_EVENT_INTR_WINDOW]="intr_window", > + "npf", > + "realmode_emulate", > + "trap", > + "trap_debug", > + "vlapic" > +}; > + > +enum { > + HVM_VOL_VMENTRY, > + HVM_VOL_VMEXIT, > + HVM_VOL_HANDLER, > + HVM_VOL_MAX > +}; > + > +enum { > + GUEST_INTERRUPT_CASE_NONE, > + /* This interrupt woke, no other interrupts until halt */ > + GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE, > + /* This interrupt woke, maybe another interrupt before halt */ > + GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY, > + /* Time from interrupt (running) to halt */ > + GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT, > + GUEST_INTERRUPT_CASE_MAX, > +}; > + > +char *guest_interrupt_case_name[] = { > + [GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE]="wake to halt alone", > + /* This interrupt woke, maybe another interrupt before halt */ > + [GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY] ="wake to halt any ", > + /* Time from interrupt (running) to halt */ > + [GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT] ="intr to halt ", > +}; > + > +char *hvm_vol_name[HVM_VOL_MAX] = { > + [HVM_VOL_VMENTRY]="vmentry", > + [HVM_VOL_VMEXIT] ="vmexit", > + [HVM_VOL_HANDLER]="handler", > +}; > + > +enum { > + HYPERCALL_set_trap_table = 0, > + HYPERCALL_mmu_update, > + HYPERCALL_set_gdt, > + HYPERCALL_stack_switch, > + HYPERCALL_set_callbacks, > + HYPERCALL_fpu_taskswitch, > + HYPERCALL_sched_op_compat, > + HYPERCALL_platform_op, > + HYPERCALL_set_debugreg, > + HYPERCALL_get_debugreg, > + HYPERCALL_update_descriptor, > + HYPERCALL_memory_op=12, > + HYPERCALL_multicall, > + HYPERCALL_update_va_mapping, > + HYPERCALL_set_timer_op, > + HYPERCALL_event_channel_op_compat, > + HYPERCALL_xen_version, > + HYPERCALL_console_io, > + HYPERCALL_physdev_op_compat, > + HYPERCALL_grant_table_op, > + HYPERCALL_vm_assist, > + HYPERCALL_update_va_mapping_otherdomain, > + HYPERCALL_iret, > + HYPERCALL_vcpu_op, > + HYPERCALL_set_segment_base, > + HYPERCALL_mmuext_op, > + HYPERCALL_acm_op, > + HYPERCALL_nmi_op, > + HYPERCALL_sched_op, > + HYPERCALL_callback_op, > + HYPERCALL_xenoprof_op, > + HYPERCALL_event_channel_op, > + HYPERCALL_physdev_op, > + HYPERCALL_hvm_op, > + HYPERCALL_sysctl, > + HYPERCALL_domctl, > + HYPERCALL_kexec_op, > + HYPERCALL_MAX > +}; > + > +char *hypercall_name[HYPERCALL_MAX] = { > + [HYPERCALL_set_trap_table]="set_trap_table", > + [HYPERCALL_mmu_update]="mmu_update", > + [HYPERCALL_set_gdt]="set_gdt", > + [HYPERCALL_stack_switch]="stack_switch", > + [HYPERCALL_set_callbacks]="set_callbacks", > + [HYPERCALL_fpu_taskswitch]="fpu_taskswitch", > + [HYPERCALL_sched_op_compat]="sched_op(compat)", > + [HYPERCALL_platform_op]="platform_op", > + [HYPERCALL_set_debugreg]="set_debugreg", > + [HYPERCALL_get_debugreg]="get_debugreg", > + [HYPERCALL_update_descriptor]="update_descriptor", > + [HYPERCALL_memory_op]="memory_op", > + [HYPERCALL_multicall]="multicall", > + [HYPERCALL_update_va_mapping]="update_va_mapping", > + [HYPERCALL_set_timer_op]="set_timer_op", > + [HYPERCALL_event_channel_op_compat]="evtchn_op(compat)", > + [HYPERCALL_xen_version]="xen_version", > + [HYPERCALL_console_io]="console_io", > + [HYPERCALL_physdev_op_compat]="physdev_op(compat)", > + [HYPERCALL_grant_table_op]="grant_table_op", > + [HYPERCALL_vm_assist]="vm_assist", > + [HYPERCALL_update_va_mapping_otherdomain]="update_va_mapping_otherdomain", > + [HYPERCALL_iret]="iret", > + [HYPERCALL_vcpu_op]="vcpu_op", > + [HYPERCALL_set_segment_base]="set_segment_base", > + [HYPERCALL_mmuext_op]="mmuext_op", > + [HYPERCALL_acm_op]="acm_op", > + [HYPERCALL_nmi_op]="nmi_op", > + [HYPERCALL_sched_op]="sched_op", > + [HYPERCALL_callback_op]="callback_op", > + [HYPERCALL_xenoprof_op]="xenoprof_op", > + [HYPERCALL_event_channel_op]="evtchn_op", > + [HYPERCALL_physdev_op]="physdev_op", > + [HYPERCALL_hvm_op]="hvm_op", > + [HYPERCALL_sysctl]="sysctl", > + [HYPERCALL_domctl]="domctl", > + [HYPERCALL_kexec_op]="kexec_op" > +}; > + > +enum { > + PF_XEN_EMUL_LVL_0, > + PF_XEN_EMUL_LVL_1, > + PF_XEN_EMUL_LVL_2, > + PF_XEN_EMUL_LVL_3, > + PF_XEN_EMUL_LVL_4, > + PF_XEN_EMUL_EARLY_UNSHADOW, > + PF_XEN_EMUL_SET_CHANGED, > + PF_XEN_EMUL_SET_UNCHANGED, > + PF_XEN_EMUL_SET_FLUSH, > + PF_XEN_EMUL_SET_ERROR, > + PF_XEN_EMUL_PROMOTE, > + PF_XEN_EMUL_DEMOTE, > + PF_XEN_EMUL_PREALLOC_UNPIN, > + PF_XEN_EMUL_PREALLOC_UNHOOK, > + PF_XEN_EMUL_MAX, > +}; > + > +char * pf_xen_emul_name[PF_XEN_EMUL_MAX] = { > + [PF_XEN_EMUL_LVL_0]="non-linmap", > + [PF_XEN_EMUL_LVL_1]="linmap l1", > + [PF_XEN_EMUL_LVL_2]="linmap l2", > + [PF_XEN_EMUL_LVL_3]="linmap l3", > + [PF_XEN_EMUL_LVL_4]="linmap l4", > + [PF_XEN_EMUL_EARLY_UNSHADOW]="early unshadow", > + [PF_XEN_EMUL_SET_UNCHANGED]="set unchanged", > + [PF_XEN_EMUL_SET_CHANGED]="set changed", > + [PF_XEN_EMUL_SET_FLUSH]="set changed", > + [PF_XEN_EMUL_SET_ERROR]="set changed", > + [PF_XEN_EMUL_PROMOTE]="promote", > + [PF_XEN_EMUL_DEMOTE]="demote", > + [PF_XEN_EMUL_PREALLOC_UNPIN]="unpin", > + [PF_XEN_EMUL_PREALLOC_UNHOOK]="unhook", > +}; > + > +/* Rio only */ > +enum { > + PF_XEN_NON_EMUL_VA_USER, > + PF_XEN_NON_EMUL_VA_KERNEL, > + PF_XEN_NON_EMUL_EIP_USER, > + PF_XEN_NON_EMUL_EIP_KERNEL, > + PF_XEN_NON_EMUL_MAX, > +}; > + > +char * pf_xen_non_emul_name[PF_XEN_NON_EMUL_MAX] = { > + [PF_XEN_NON_EMUL_VA_USER]="va user", > + [PF_XEN_NON_EMUL_VA_KERNEL]="va kernel", > + [PF_XEN_NON_EMUL_EIP_USER]="eip user", > + [PF_XEN_NON_EMUL_EIP_KERNEL]="eip kernel", > +}; > + > +enum { > + PF_XEN_FIXUP_PREALLOC_UNPIN, > + PF_XEN_FIXUP_PREALLOC_UNHOOK, > + PF_XEN_FIXUP_UNSYNC, > + PF_XEN_FIXUP_OOS_ADD, > + PF_XEN_FIXUP_OOS_EVICT, > + PF_XEN_FIXUP_PROMOTE, > + PF_XEN_FIXUP_UPDATE_ONLY, > + PF_XEN_FIXUP_WRMAP, > + PF_XEN_FIXUP_BRUTE_FORCE, > + PF_XEN_FIXUP_MAX, > +}; > + > +char * pf_xen_fixup_name[PF_XEN_FIXUP_MAX] = { > + [PF_XEN_FIXUP_PREALLOC_UNPIN] = "unpin", > + [PF_XEN_FIXUP_PREALLOC_UNHOOK] = "unhook", > + [PF_XEN_FIXUP_UNSYNC] = "unsync", > + [PF_XEN_FIXUP_OOS_ADD] = "oos-add", > + [PF_XEN_FIXUP_OOS_EVICT] = "oos-evict", > + [PF_XEN_FIXUP_PROMOTE] = "promote", > + [PF_XEN_FIXUP_UPDATE_ONLY] = "update", > + [PF_XEN_FIXUP_WRMAP] = "wrmap", > + [PF_XEN_FIXUP_BRUTE_FORCE] = "wrmap-bf", > +}; > + > +enum { > + PF_XEN_NOT_SHADOW = 1, > + PF_XEN_FAST_PROPAGATE, > + PF_XEN_FAST_MMIO, > + PF_XEN_FALSE_FAST_PATH, > + PF_XEN_MMIO, > + PF_XEN_FIXUP, > + PF_XEN_DOMF_DYING, > + PF_XEN_EMULATE, > + PF_XEN_EMULATE_UNSHADOW_USER, > + PF_XEN_EMULATE_UNSHADOW_EVTINJ, > + PF_XEN_EMULATE_UNSHADOW_UNHANDLED, > + PF_XEN_LAST_FAULT=PF_XEN_EMULATE_UNSHADOW_UNHANDLED, > + PF_XEN_NON_EMULATE, > + PF_XEN_NO_HANDLER, > + PF_XEN_MAX, > +}; > + > +#define SHADOW_WRMAP_BF 12 > +#define SHADOW_PREALLOC_UNPIN 13 > +#define SHADOW_RESYNC_FULL 14 > +#define SHADOW_RESYNC_ONLY 15 > + > +char * pf_xen_name[PF_XEN_MAX] = { > + [PF_XEN_NOT_SHADOW]="propagate", > + [PF_XEN_FAST_PROPAGATE]="fast propagate", > + [PF_XEN_FAST_MMIO]="fast mmio", > + [PF_XEN_FALSE_FAST_PATH]="false fast path", > + [PF_XEN_MMIO]="mmio", > + [PF_XEN_FIXUP]="fixup", > + [PF_XEN_DOMF_DYING]="dom dying", > + [PF_XEN_EMULATE]="emulate", > + [PF_XEN_EMULATE_UNSHADOW_USER]="unshadow:user-mode", > + [PF_XEN_EMULATE_UNSHADOW_EVTINJ]="unshadow:evt inj", > + [PF_XEN_EMULATE_UNSHADOW_UNHANDLED]="unshadow:unhandled instr", > + [PF_XEN_NON_EMULATE]="fixup|mmio", > + [PF_XEN_NO_HANDLER]="(no handler)", > +}; > + > +#define CORR_VA_INVALID (0ULL-1) > + > +enum { > + NONPF_MMIO_APIC, > + NONPF_MMIO_NPF, > + NONPF_MMIO_UNKNOWN, > + NONPF_MMIO_MAX > +}; > + > +struct mmio_info { > + unsigned long long gpa; > + unsigned long long va; /* Filled only by shadow */ > + unsigned data; > + unsigned data_valid:1, is_write:1; > +}; > + > +struct pf_xen_extra { > + unsigned long long va; > + union { > + unsigned flags; > + struct { > + unsigned flag_set_ad:1, > + flag_set_a:1, > + flag_shadow_l1_get_ref:1, > + flag_shadow_l1_put_ref:1, > + flag_l2_propagate:1, > + flag_set_changed:1, > + flag_set_flush:1, > + flag_set_error:1, > + flag_demote:1, > + flag_promote:1, > + flag_wrmap:1, > + flag_wrmap_guess_found:1, > + flag_wrmap_brute_force:1, > + flag_early_unshadow:1, > + flag_emulation_2nd_pt_written:1, > + flag_emulation_last_failed:1, > + flag_emulate_full_pt:1, > + flag_prealloc_unhook:1, > + flag_unsync:1, > + flag_oos_fixup_add:1, > + flag_oos_fixup_evict:1; > + }; > + }; /* Miami + ; fixup & emulate */ > + unsigned int error_code; /* Rio only */ > + > + /* Calculated */ > + int pf_case; /* Rio */ > + > + /* MMIO only */ > + unsigned long long gpa; > + unsigned int data; > + > + /* Emulate only */ > + unsigned long long gl1e; /* Miami + */ > + unsigned long long wval; /* Miami */ > + unsigned long long corresponding_va; > + unsigned int pt_index[5], pt_is_lo; > + int pt_level; > + > + /* Other */ > + unsigned long long gfn; > + > + /* Flags */ > + unsigned corr_valid:1, > + corr_is_kernel:1, > + va_is_kernel:1; > +}; > + > +struct pcpu_info; > + > +#define GUEST_INTERRUPT_MAX 350 > +#define FAKE_VECTOR 349 > +#define CR_MAX 9 > +#define RESYNCS_MAX 17 > +#define PF_XEN_FIXUP_UNSYNC_RESYNC_MAX 2 > + > +struct hvm_data; > + > +struct hvm_summary_handler_node { > + void (*handler)(struct hvm_data *, void* data); > + void *data; > + struct hvm_summary_handler_node *next; > +}; > + > +struct hvm_data { > + /* Summary information */ > + int init; > + int vmexit_valid; > + int summary_info; > + struct vcpu_data *v; /* up-pointer */ > + > + /* SVM / VMX compatibility. FIXME - should be global */ > + char ** exit_reason_name; > + int exit_reason_max; > + struct hvm_summary_handler_node *exit_reason_summary_handler_list[HVM_EXIT_REASON_MAX]; > + > + /* Information about particular exit reasons */ > + struct { > + struct event_cycle_summary exit_reason[HVM_EXIT_REASON_MAX]; > + int extint[EXTERNAL_INTERRUPT_MAX+1]; > + int *extint_histogram; > + struct event_cycle_summary trap[HVM_TRAP_MAX]; > + struct event_cycle_summary pf_xen[PF_XEN_MAX]; > + struct event_cycle_summary pf_xen_emul[PF_XEN_EMUL_MAX]; > + struct event_cycle_summary pf_xen_emul_early_unshadow[5]; > + struct event_cycle_summary pf_xen_non_emul[PF_XEN_NON_EMUL_MAX]; > + struct event_cycle_summary pf_xen_fixup[PF_XEN_FIXUP_MAX]; > + struct event_cycle_summary pf_xen_fixup_unsync_resync[PF_XEN_FIXUP_UNSYNC_RESYNC_MAX+1]; > + struct event_cycle_summary cr_write[CR_MAX]; > + struct event_cycle_summary cr3_write_resyncs[RESYNCS_MAX+1]; > + struct event_cycle_summary vmcall[HYPERCALL_MAX+1]; > + struct event_cycle_summary generic[HVM_EVENT_HANDLER_MAX]; > + struct event_cycle_summary mmio[NONPF_MMIO_MAX]; > + struct hvm_gi_struct { > + int count; > + struct cycle_summary runtime[GUEST_INTERRUPT_CASE_MAX]; > + /* OK, not summary info, but still... */ > + int is_wake; > + tsc_t start_tsc; > + } guest_interrupt[GUEST_INTERRUPT_MAX + 1]; > + /* IPI Latency */ > + struct event_cycle_summary ipi_latency; > + int ipi_count[256]; > + struct { > + struct io_address *mmio, *pio; > + } io; > + } summary; > + > + /* In-flight accumulation information */ > + struct { > + union { > + struct { > + unsigned port:31, > + is_write:1; > + unsigned int val; > + } io; > + struct pf_xen_extra pf_xen; > + struct { > + unsigned cr; > + unsigned long long val; > + int repromote; > + } cr_write; > + struct { > + unsigned addr; > + unsigned long long val; > + } msr; > + struct { > + unsigned int event; > + uint32_t d[4]; > + } generic; > + struct { > + unsigned eax; > + } vmcall; > + struct { > + unsigned vec; > + } intr; > + }; > + /* MMIO gets its separate area, since many exits may use it */ > + struct mmio_info mmio; > + }inflight; > + int resyncs; > + void (*post_process)(struct hvm_data *); > + tsc_t exit_tsc, arc_cycles, entry_tsc; > + unsigned long long rip; > + unsigned exit_reason, event_handler; > + int short_summary_done:1, prealloc_unpin:1, wrmap_bf:1; > + > + /* Immediate processing */ > + void *d; > + > + /* Wake-to-halt detection. See comment above. */ > + struct { > + unsigned waking:1; > + /* Wake vector: keep track of time from vmentry until: > + next halt, or next interrupt */ > + int vector, interrupts, interrupts_wanting_tsc; > + } w2h; > + > + /* Historical info */ > + tsc_t last_rdtsc; > +}; > + > +enum { > + HVM_SHORT_SUMMARY_EMULATE, > + HVM_SHORT_SUMMARY_UNSYNC, > + HVM_SHORT_SUMMARY_FIXUP, > + HVM_SHORT_SUMMARY_MMIO, > + HVM_SHORT_SUMMARY_PROPAGATE, > + HVM_SHORT_SUMMARY_CR3, > + HVM_SHORT_SUMMARY_VMCALL, > + HVM_SHORT_SUMMARY_INTERRUPT, > + HVM_SHORT_SUMMARY_HLT, > + HVM_SHORT_SUMMARY_OTHER, > + HVM_SHORT_SUMMARY_MAX, > +}; > + > +char *hvm_short_summary_name[HVM_SHORT_SUMMARY_MAX] = { > + [HVM_SHORT_SUMMARY_EMULATE] ="emulate", > + [HVM_SHORT_SUMMARY_UNSYNC] ="unsync", > + [HVM_SHORT_SUMMARY_FIXUP] ="fixup", > + [HVM_SHORT_SUMMARY_MMIO] ="mmio", > + [HVM_SHORT_SUMMARY_PROPAGATE]="propagate", > + [HVM_SHORT_SUMMARY_CR3] ="cr3", > + [HVM_SHORT_SUMMARY_VMCALL] ="vmcall", > + [HVM_SHORT_SUMMARY_INTERRUPT]="intr", > + [HVM_SHORT_SUMMARY_HLT] ="hlt", > + [HVM_SHORT_SUMMARY_OTHER] ="other", > +}; > + > +struct hvm_short_summary_struct { > + struct cycle_summary s[HVM_SHORT_SUMMARY_MAX]; > +}; > + > +void init_hvm_data(struct hvm_data *h, struct vcpu_data *v) { > + int i; > + > + if(h->init) > + return; > + > + h->v = v; > + > + h->init = 1; > + > + if(opt.svm_mode) { > + h->exit_reason_max = HVM_SVM_EXIT_REASON_MAX; > + h->exit_reason_name = hvm_svm_exit_reason_name; > + } else { > + h->exit_reason_max = HVM_VMX_EXIT_REASON_MAX; > + h->exit_reason_name = hvm_vmx_exit_reason_name; > + } > + > + if(opt.histogram_interrupt_eip) { > + int count = ((1ULL<<ADDR_SPACE_BITS)/opt.histogram_interrupt_increment); > + size_t size = count * sizeof(int); > + h->summary.extint_histogram = malloc(size); > + if(h->summary.extint_histogram) > + bzero(h->summary.extint_histogram, size); > + else { > + fprintf(stderr, "FATAL: Could not allocate %zd bytes for interrupt histogram!\n", > + size); > + error(ERR_SYSTEM, NULL); > + } > + > + } > + for(i=0; i<GUEST_INTERRUPT_MAX+1; i++) > + h->summary.guest_interrupt[i].count=0; > +} > + > +/* PV data */ > +enum { > + PV_HYPERCALL=1, > + PV_TRAP=3, > + PV_PAGE_FAULT, > + PV_FORCED_INVALID_OP, > + PV_EMULATE_PRIVOP, > + PV_EMULATE_4GB, > + PV_MATH_STATE_RESTORE, > + PV_PAGING_FIXUP, > + PV_GDT_LDT_MAPPING_FAULT, > + PV_PTWR_EMULATION, > + PV_PTWR_EMULATION_PAE, > + PV_HYPERCALL_V2 = 13, > + PV_HYPERCALL_SUBCALL = 14, > + PV_MAX > +}; > + > +char *pv_name[PV_MAX] = { > + [PV_HYPERCALL]="hypercall", > + [PV_TRAP]="trap", > + [PV_PAGE_FAULT]="page_fault", > + [PV_FORCED_INVALID_OP]="forced_invalid_op", > + [PV_EMULATE_PRIVOP]="emulate privop", > + [PV_EMULATE_4GB]="emulate 4g", > + [PV_MATH_STATE_RESTORE]="math state restore", > + [PV_PAGING_FIXUP]="paging fixup", > + [PV_GDT_LDT_MAPPING_FAULT]="gdt/ldt mapping fault", > + [PV_PTWR_EMULATION]="ptwr", > + [PV_PTWR_EMULATION_PAE]="ptwr(pae)", > + [PV_HYPERCALL_V2]="hypercall", > + [PV_HYPERCALL_SUBCALL]="hypercall (subcall)", > +}; > + > +#define PV_HYPERCALL_MAX 56 > +#define PV_TRAP_MAX 20 > + > +struct pv_data { > + unsigned summary_info:1; > + int count[PV_MAX]; > + int hypercall_count[PV_HYPERCALL_MAX]; > + int trap_count[PV_TRAP_MAX]; > +}; > + > +/* Sched data */ > + > +enum { > + SCHED_DOM_ADD=1, > + SCHED_DOM_REM, > + SCHED_SLEEP, > + SCHED_WAKE, > + SCHED_YIELD, > + SCHED_BLOCK, > + SCHED_SHUTDOWN, > + SCHED_CTL, > + SCHED_ADJDOM, > + SCHED_SWITCH, > + SCHED_S_TIMER_FN, > + SCHED_T_TIMER_FN, > + SCHED_DOM_TIMER_FN, > + SCHED_SWITCH_INFPREV, > + SCHED_SWITCH_INFNEXT, > + SCHED_SHUTDOWN_CODE, > + SCHED_MAX > +}; > + > +enum { > + RUNSTATE_RUNNING=0, > + RUNSTATE_RUNNABLE, > + RUNSTATE_BLOCKED, > + RUNSTATE_OFFLINE, > + RUNSTATE_LOST, > + RUNSTATE_QUEUED, > + RUNSTATE_INIT, > + RUNSTATE_MAX > +}; > + > +int runstate_graph[RUNSTATE_MAX] = > +{ > + [RUNSTATE_BLOCKED]=0, > + [RUNSTATE_OFFLINE]=1, > + [RUNSTATE_RUNNABLE]=2, > + [RUNSTATE_RUNNING]=3, > + [RUNSTATE_LOST]=-1, > + [RUNSTATE_QUEUED]=-2, > + [RUNSTATE_INIT]=-2, > +}; > + > +char * runstate_name[RUNSTATE_MAX]={ > + [RUNSTATE_RUNNING]= "running", > + [RUNSTATE_RUNNABLE]="runnable", > + [RUNSTATE_BLOCKED]= "blocked", /* to be blocked */ > + [RUNSTATE_OFFLINE]= "offline", > + [RUNSTATE_QUEUED]= "queued", > + [RUNSTATE_INIT]= "init", > + [RUNSTATE_LOST]= "lost", > +}; > + > +enum { > + RUNNABLE_STATE_INVALID, > + RUNNABLE_STATE_WAKE, > + RUNNABLE_STATE_PREEMPT, > + RUNNABLE_STATE_OTHER, > + RUNNABLE_STATE_MAX > +}; > + > +char * runnable_state_name[RUNNABLE_STATE_MAX]={ > + [RUNNABLE_STATE_INVALID]="invalid", /* Should never show up */ > + [RUNNABLE_STATE_WAKE]="wake", > + [RUNNABLE_STATE_PREEMPT]="preempt", > + [RUNNABLE_STATE_OTHER]="other", > +}; > + > +/* Memory data */ > +enum { > + MEM_PAGE_GRANT_MAP = 1, > + MEM_PAGE_GRANT_UNMAP, > + MEM_PAGE_GRANT_TRANSFER, > + MEM_SET_P2M_ENTRY, > + MEM_DECREASE_RESERVATION, > + MEM_POD_POPULATE = 16, > + MEM_POD_ZERO_RECLAIM, > + MEM_POD_SUPERPAGE_SPLINTER, > + MEM_MAX > +}; > + > +char *mem_name[MEM_MAX] = { > + [MEM_PAGE_GRANT_MAP] = "grant-map", > + [MEM_PAGE_GRANT_UNMAP] = "grant-unmap", > + [MEM_PAGE_GRANT_TRANSFER] = "grant-transfer", > + [MEM_SET_P2M_ENTRY] = "set-p2m", > + [MEM_DECREASE_RESERVATION] = "decrease-reservation", > + [MEM_POD_POPULATE] = "pod-populate", > + [MEM_POD_ZERO_RECLAIM] = "pod-zero-reclaim", > + [MEM_POD_SUPERPAGE_SPLINTER] = "pod-superpage-splinter", > +}; > + > +/* Per-unit information. */ > + > +struct cr3_value_struct { > + struct cr3_value_struct * next; > + struct cr3_value_struct * gnext; > + unsigned long long gmfn; > + int cr3_id; > + unsigned long long first_time, last_time, run_time; > + struct cycle_summary total_time, guest_time, hv_time; > + int switch_count, flush_count; > + > + struct hvm_short_summary_struct hvm; > + > + struct { > + int now; > + int count; > + } prealloc_unpin; > + > + struct { > + unsigned callback:1; > + unsigned flush_count, switch_count; > + unsigned fixup_user, emulate_corr_user; > + } destroy; > +}; > + > +#ifndef MAX_CPUS > +#define MAX_CPUS 256 > +#endif > +typedef uint32_t cpu_mask_t; > + > +#define IDLE_DOMAIN 32767 > +#define DEFAULT_DOMAIN 32768 > + > +#define MAX_VLAPIC_LIST 8 > +struct vlapic_struct { > + struct { > + struct outstanding_ipi { > + tsc_t first_tsc; > + int vec, count; > + int injected, valid; > + } list[MAX_VLAPIC_LIST]; > + } outstanding; > +}; > + > +struct vcpu_data { > + int vid; > + struct domain_data *d; /* up-pointer */ > + unsigned activated:1; > + > + int guest_paging_levels; > + > + /* Schedule info */ > + struct { > + int state; > + int runnable_state; /* Only valid when state==RUNSTATE_RUNNABLE */ > + tsc_t tsc; > + /* TSC skew detection/correction */ > + struct last_oldstate_struct { > + int wrong, actual, pid; > + tsc_t tsc; > + } last_oldstate; > + /* Performance counters */ > + unsigned long long p1_start, p2_start; > + } runstate; > + struct pcpu_info *p; > + tsc_t pcpu_tsc; > + > + /* Hardware tracking */ > + struct { > + long long val; > + tsc_t start_time; > + struct cr3_value_struct *data; > + } cr3; > + > + /* IPI latency tracking */ > + struct vlapic_struct vlapic; > + > + /* Summary info */ > + struct cycle_framework f; > + struct cycle_summary runstates[RUNSTATE_MAX]; > + struct cycle_summary runnable_states[RUNNABLE_STATE_MAX]; > + struct weighted_cpi_summary cpi; > + struct cycle_summary cpu_affinity_all, > + cpu_affinity_pcpu[MAX_CPUS]; > + enum { > + VCPU_DATA_NONE=0, > + VCPU_DATA_HVM, > + VCPU_DATA_PV > + } data_type; > + union { > + struct hvm_data hvm; > + struct pv_data pv; > + }; > +}; > + > +enum { > + DOMAIN_RUNSTATE_BLOCKED=0, > + DOMAIN_RUNSTATE_PARTIAL_RUN, > + DOMAIN_RUNSTATE_FULL_RUN, > + DOMAIN_RUNSTATE_PARTIAL_CONTENTION, > + DOMAIN_RUNSTATE_CONCURRENCY_HAZARD, > + DOMAIN_RUNSTATE_FULL_CONTENTION, > + DOMAIN_RUNSTATE_LOST, > + DOMAIN_RUNSTATE_MAX > +}; > + > +char * domain_runstate_name[] = { > + [DOMAIN_RUNSTATE_BLOCKED]="blocked", > + [DOMAIN_RUNSTATE_PARTIAL_RUN]="partial run", > + [DOMAIN_RUNSTATE_FULL_RUN]="full run", > + [DOMAIN_RUNSTATE_PARTIAL_CONTENTION]="partial contention", > + [DOMAIN_RUNSTATE_CONCURRENCY_HAZARD]="concurrency_hazard", > + [DOMAIN_RUNSTATE_FULL_CONTENTION]="full_contention", > + [DOMAIN_RUNSTATE_LOST]="lost", > +}; > + > +enum { > + POD_RECLAIM_CONTEXT_UNKNOWN=0, > + POD_RECLAIM_CONTEXT_FAULT, > + POD_RECLAIM_CONTEXT_BALLOON, > + POD_RECLAIM_CONTEXT_MAX > +}; > + > +char * pod_reclaim_context_name[] = { > + [POD_RECLAIM_CONTEXT_UNKNOWN]="unknown", > + [POD_RECLAIM_CONTEXT_FAULT]="fault", > + [POD_RECLAIM_CONTEXT_BALLOON]="balloon", > +}; > + > +#define POD_ORDER_MAX 4 > + > +struct domain_data { > + struct domain_data *next; > + int did; > + struct vcpu_data *vcpu[MAX_CPUS]; > + > + int max_vid; > + > + int runstate; > + tsc_t runstate_tsc; > + struct cycle_summary total_time; > + struct cycle_summary runstates[DOMAIN_RUNSTATE_MAX]; > + struct cr3_value_struct *cr3_value_head; > + struct eip_list_struct *emulate_eip_list; > + struct eip_list_struct *interrupt_eip_list; > + > + int guest_interrupt[GUEST_INTERRUPT_MAX+1]; > + struct hvm_short_summary_struct hvm_short; > + struct { > + int done[MEM_MAX]; > + int done_interval[MEM_MAX]; > + > + int done_for[MEM_MAX]; > + int done_for_interval[MEM_MAX]; > + } memops; > + > + struct { > + int reclaim_order[POD_ORDER_MAX]; > + int reclaim_context[POD_RECLAIM_CONTEXT_MAX]; > + int reclaim_context_order[POD_RECLAIM_CONTEXT_MAX][POD_ORDER_MAX]; > + /* FIXME: Do a full cycle summary */ > + int populate_order[POD_ORDER_MAX]; > + } pod; > +}; > + > +struct domain_data * domain_list=NULL; > + > +struct domain_data default_domain; > + > +enum { > + TOPLEVEL_GEN=0, > + TOPLEVEL_SCHED, > + TOPLEVEL_DOM0OP, > + TOPLEVEL_HVM, > + TOPLEVEL_MEM, > + TOPLEVEL_PV, > + TOPLEVEL_SHADOW, > + TOPLEVEL_HW, > + TOPLEVEL_MAX=TOPLEVEL_HW+1, > +}; > + > +char * toplevel_name[TOPLEVEL_MAX] = { > + [TOPLEVEL_GEN]="gen", > + [TOPLEVEL_SCHED]="sched", > + [TOPLEVEL_DOM0OP]="dom0op", > + [TOPLEVEL_HVM]="hvm", > + [TOPLEVEL_MEM]="mem", > + [TOPLEVEL_PV]="pv", > + [TOPLEVEL_SHADOW]="shadow", > + [TOPLEVEL_HW]="hw", > +}; > + > +struct trace_volume { > + unsigned long long toplevel[TOPLEVEL_MAX]; > + unsigned long long sched_verbose; > + unsigned long long hvm[HVM_VOL_MAX]; > +} volume; > + > +#define UPDATE_VOLUME(_p,_x,_s) \ > + do { \ > + (_p)->volume.total._x += _s; \ > + (_p)->volume.last_buffer._x += _s; \ > + } while(0) > + > +void volume_clear(struct trace_volume *vol) > +{ > + bzero(vol, sizeof(*vol)); > +} > + > +void volume_summary(struct trace_volume *vol) > +{ > + int j, k; > + for(j=0; j<TOPLEVEL_MAX; j++) > + if(vol->toplevel[j]) { > + printf(" %-6s: %10lld\n", > + toplevel_name[j], vol->toplevel[j]); > + switch(j) { > + case TOPLEVEL_SCHED: > + if(vol->sched_verbose) > + printf(" +-verbose: %10lld\n", > + vol->sched_verbose); > + break; > + case TOPLEVEL_HVM: > + for(k=0; k<HVM_VOL_MAX; k++) { > + if(vol->hvm[k]) > + printf(" +-%-7s: %10lld\n", > + hvm_vol_name[k], vol->hvm[k]); > + } > + > + break; > + } > + } > +} > + > +struct pcpu_info { > + /* Information about this pcpu */ > + unsigned active:1, summary:1; > + int pid; > + > + /* Information related to scanning thru the file */ > + tsc_t first_tsc, last_tsc, order_tsc; > + loff_t file_offset; > + loff_t next_cpu_change_offset; > + struct record_info ri; > + int last_cpu_change_pid; > + int power_state; > + > + /* Information related to tsc skew detection / correction */ > + struct { > + tsc_t offset; > + cpu_mask_t downstream; /* To detect cycles in dependencies */ > + } tsc_skew; > + > + /* Information related to domain tracking */ > + struct vcpu_data * current; > + struct { > + unsigned active:1, > + domain_valid:1, > + seen_valid_schedule:1; /* Seen an actual schedule since lost records */ > + unsigned did:16,vid:16; > + tsc_t tsc; > + } lost_record; > + > + /* Record volume */ > + struct { > + tsc_t buffer_first_tsc, > + buffer_dom0_runstate_tsc, > + buffer_dom0_runstate_cycles[RUNSTATE_MAX]; > + int buffer_dom0_runstate; > + unsigned buffer_size; > + struct trace_volume total, last_buffer; > + } volume; > + > + /* Time report */ > + struct { > + tsc_t tsc; > + struct cycle_summary idle, running, lost; > + } time; > +}; > + > +void __fill_in_record_info(struct pcpu_info *p); > + > +#define INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX 10 > + > +struct { > + int max_active_pcpu; > + loff_t last_epoch_offset; > + int early_eof; > + int lost_cpus; > + tsc_t now; > + struct cycle_framework f; > + tsc_t buffer_trace_virq_tsc; > + struct pcpu_info pcpu[MAX_CPUS]; > + > + struct { > + int id; > + /* Invariant: head null => tail null; head !null => tail valid */ > + struct cr3_value_struct *head, **tail; > + } cr3; > + > + struct { > + tsc_t start_tsc; > + /* Information about specific interval output types */ > + union { > + struct { > + struct interval_element ** values; > + int count; > + } array; > + struct { > + struct interval_list *head, **tail; > + } list; > + struct cr3_value_struct *cr3; > + struct { > + struct domain_data *d; > + int guest_vector[INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX]; > + } domain; > + }; > + } interval; > +} P = { 0 }; > + > +/* Function prototypes */ > +char * pcpu_string(int pcpu); > +void pcpu_string_draw(struct pcpu_info *p); > +void process_generic(struct record_info *ri); > +void dump_generic(FILE *f, struct record_info *ri); > +ssize_t __read_record(struct trace_record *rec, loff_t offset); > +void error(enum error_level l, struct record_info *ri); > +void update_io_address(struct io_address ** list, unsigned int pa, int dir, > + tsc_t arc_cycles, unsigned int va); > +int check_extra_words(struct record_info *ri, int expected_size, const char *record); > +int vcpu_set_data_type(struct vcpu_data *v, int type); > + > +void cpumask_init(cpu_mask_t *c) { > + *c = 0UL; > +} > + > +void cpumask_clear(cpu_mask_t *c, int cpu) { > + *c &= ~(1UL << cpu); > +} > + > +void cpumask_set(cpu_mask_t *c, int cpu) { > + *c |= (1UL << cpu); > +} > + > +int cpumask_isset(const cpu_mask_t *c, int cpu) { > + if(*c & (1UL<<cpu)) > + return 1; > + else > + return 0; > +} > + > +void cpumask_union(cpu_mask_t *d, const cpu_mask_t *s) { > + *d |= *s; > +} > + > +/* -- Time code -- */ > + > +void cycles_to_time(unsigned long long c, struct time_struct *t) { > + t->time = ((c - P.f.first_tsc) << 10) / opt.cpu_qhz; > + t->s = t->time / 1000000000; > + t->ns = t->time - (t->s * 1000000000); > +} > + > +void abs_cycles_to_time(unsigned long long ac, struct time_struct *t) { > + if(ac > P.f.first_tsc) { > + /* t->time = ((ac - P.f.first_tsc) * 1000) / (opt.cpu_hz / 1000000 ); */ > + /* t->s = t->time / 1000000000; */ > + /* t->ns = t->time % 1000000000; */ > + t->time = ((ac - P.f.first_tsc) << 10) / opt.cpu_qhz; > + t->s = t->time / 1000000000; > + t->ns = t->time - (t->s * 1000000000); > + } else { > + t->time = t->s = t->ns = 0; > + } > +} > + > +tsc_t abs_cycles_to_global(unsigned long long ac) { > + if(ac > P.f.first_tsc) > + return ac - P.f.first_tsc; > + else > + return 0; > +} > + > +void scatterplot_vs_time(tsc_t atsc, long long y) { > + struct time_struct t; > + > + abs_cycles_to_time(atsc, &t); > + > + printf("%u.%09u %lld\n", t.s, t.ns, y); > +} > + > +/* -- Summary Code -- */ > + > +/* With compliments to "Numerical Recipes in C", which provided the algorithm > + * and basic template for this function. */ > +long long percentile(long long * A, int N, int ple) { > + int I, J, L, R, K; > + > + long long X, W; > + > + /* No samples! */ > + if ( N == 0 ) > + return 0; > + > + /* Find K, the element # we want */ > + K=N*ple/100; > + > + /* Set the left and right boundaries of the current search space */ > + L=0; R=N-1; > + > + while(L < R) { > + /* X: The value to order everything higher / lower than */ > + X=A[K]; > + > + /* Starting at the left and the right... */ > + I=L; > + J=R; > + > + do { > + /* Find the first element on the left that is out-of-order w/ X */ > + while(A[I]<X) > + I++; > + /* Find the first element on the right that is out-of-order w/ X */ > + while(X<A[J]) > + J--; > + > + /* If we found something out-of-order */ > + if(I<=J) { > + /* Switch the values */ > + W=A[I]; > + A[I]=A[J]; > + A[J]=W; > + > + /* And move on */ > + I++; J--; > + } > + } while (I <= J); /* Keep going until our pointers meet or pass */ > + > + /* Re-adjust L and R, based on which element we're looking for */ > + if(J<K) > + L=I; > + if(K<I) > + R=J; > + } > + > + return A[K]; > +} > + > +float weighted_percentile(float * A, /* values */ > + unsigned long long * w, /* weights */ > + int N, /* total */ > + int ple) /* percentile */ > +{ > + int L, R, I, J, K; > + unsigned long long L_weight, R_weight, I_weight, J_weight, > + K_weight, N_weight; > + > + float X, t1; > + unsigned long long t2; > + > + /* Calculate total weight */ > + N_weight=0; > + > + for(I=0; I<N; I++) { > + assert(w[I]!=0); > + N_weight += w[I]; > + } > + > + /* Find K_weight, the target weight we want */ > + K_weight = N_weight * ple / 100; > + > + /* Set the left and right boundaries of the current search space */ > + L=0; > + L_weight = 0; > + R=N-1; > + R_weight = N_weight - w[R]; > + > + /* Search between L and R, narrowing down until we're done */ > + while(L < R) { > + /* Chose an ordering value from right in the middle */ > + K = (L + R) >> 1; > + /* X: The value to order everything higher / lower than */ > + X=A[K]; > + > + /* Starting at the left and the right... */ > + I=L; I_weight = L_weight; > + J=R; J_weight = R_weight; > + > + do { > + /* Find the first element on the left that is out-of-order w/ X */ > + while(A[I]<X) { > + I_weight += w[I]; > + I++; > + } > + /* Find the first element on the right that is out-of-order w/ X */ > + while(X<A[J]) { > + J_weight -= w[J]; > + J--; > + } > + > + /* If we actually found something... */ > + if(I<=J) { > + /* Switch the values */ > + t1=A[I]; > + A[I]=A[J]; > + A[J]=t1; > + > + t2=w[I]; > + w[I]=w[J]; > + w[J]=t2; > + > + /* And move in */ > + I_weight += w[I]; > + I++; > + > + J_weight -= w[J]; > + J--; > + } > + } while (I <= J); /* Keep going until our pointers meet or pass */ > + > + /* Re-adjust L and R, based on which element we're looking for */ > + if(J_weight<K_weight) > + L=I; L_weight = I_weight; > + if(K_weight<I_weight) > + R=J; R_weight = J_weight; > + } > + > + return A[L]; > +} > + > +long long self_weighted_percentile(long long * A, > + int N, /* total */ > + int ple) /* percentile */ > +{ > + int L, R, I, J, K; > + long long L_weight, R_weight, I_weight, J_weight, > + K_weight, N_weight; > + > + long long X, t1; > + > + /* Calculate total weight */ > + N_weight=0; > + > + for(I=0; I<N; I++) { > + if(A[I] < 0) > + fprintf(warn, "%s: Value %lld less than zero!\n", > + __func__, A[I]); > + assert(A[I]!=0); > + N_weight += A[I]; > + } > + > + /* Find K_weight, the target weight we want */ > + K_weight = N_weight * ple / 100; > + > + /* Set the left and right boundaries of the current search space */ > + L=0; > + L_weight = 0; > + R=N-1; > + R_weight = N_weight - A[R]; > + > + /* Search between L and R, narrowing down until we're done */ > + while(L < R) { > + /* Chose an ordering value from right in the middle */ > + K = (L + R) >> 1; > + /* X: The value to order everything higher / lower than */ > + X=A[K]; > + > + /* Starting at the left and the right... */ > + I=L; I_weight = L_weight; > + J=R; J_weight = R_weight; > + > + do { > + /* Find the first element on the left that is out-of-order w/ X */ > + while(A[I]<X) { > + I_weight += A[I]; > + I++; > + } > + /* Find the first element on the right that is out-of-order w/ X */ > + while(X<A[J]) { > + J_weight -= A[J]; > + J--; > + } > + > + /* If we actually found something... */ > + if(I<=J) { > + /* Switch the values */ > + t1=A[I]; > + A[I]=A[J]; > + A[J]=t1; > + > + /* And move in */ > + I_weight += A[I]; > + I++; > + > + J_weight -= A[J]; > + J--; > + } > + } while (I <= J); /* Keep going until our pointers meet or pass */ > + > + /* Re-adjust L and R, based on which element we're looking for */ > + if(J_weight<K_weight) > + L=I; L_weight = I_weight; > + if(K_weight<I_weight) > + R=J; R_weight = J_weight; > + } > + > + return A[L]; > +} > + > +static inline double __cycles_percent(long long cycles, long long total) { > + return (double)(cycles*100) / total; > +} > + > +static inline double __summary_percent(struct event_cycle_summary *s, > + struct cycle_framework *f) { > + return __cycles_percent(s->cycles, f->total_cycles); > +} > + > +static inline double summary_percent_global(struct event_cycle_summary *s) { > + return __summary_percent(s, &P.f); > +} > + > +static inline void update_summary(struct event_cycle_summary *s, long long c) { > +/* We don't know ahead of time how many samples there are, and working > + * with dynamic stuff is a pain, and unnecessary. This algorithm will > + * generate a sample set that approximates an even sample. We can > + * then take the percentiles on this, and get an approximate value. */ > + if(c) { > + if(opt.sample_size) { > + int lap = (s->cycles_count/opt.sample_size)+1, > + index =s->cycles_count % opt.sample_size; > + if((index - (lap/3))%lap == 0) { > + if(!s->cycles_sample) { > + s->cycles_sample = malloc(sizeof(*s->cycles_sample) * opt.sample_size); > + if(!s->cycles_sample) { > + fprintf(stderr, "%s: malloc failed!\n", __func__); > + error(ERR_SYSTEM, NULL); > + } > + } > + s->cycles_sample[index]=c; > + } > + } > + s->cycles_count++; > + s->cycles += c; > + > + s->interval.count++; > + s->interval.cycles += c; > + } > + s->count++; > +} > + > +static inline void clear_interval_summary(struct event_cycle_summary *s) { > + s->interval.count = 0; > + s->interval.cycles = 0; > +} > + > +static inline void update_cycles(struct cycle_summary *s, long long c) { > +/* We don't know ahead of time how many samples there are, and working > + * with dynamic stuff is a pain, and unnecessary. This algorithm will > + * generate a sample set that approximates an even sample. We can > + * then take the percentiles on this, and get an approximate value. */ > + int lap, index; > + > + if ( c == 0 ) > + { > + fprintf(warn, "%s: cycles 0! Not updating...\n", > + __func__); > + return; > + } > + > + if ( opt.sample_size ) { > + lap = (s->count/opt.sample_size)+1; > + index =s->count % opt.sample_size; > + > + if((index - (lap/3))%lap == 0) { > + if(!s->sample) { > + s->sample = malloc(sizeof(*s->sample) * opt.sample_size); > + if(!s->sample) { > + fprintf(stderr, "%s: malloc failed!\n", __func__); > + error(ERR_SYSTEM, NULL); > + } > + } > + s->sample[index] = c; > + } > + } > + > + if(c > 0) { > + s->cycles += c; > + s->interval.cycles += c; > + } else { > + s->cycles += -c; > + s->interval.cycles += -c; > + } > + s->count++; > + s->interval.count++; > +} > + > +static inline void clear_interval_cycles(struct interval_element *e) { > + e->cycles = 0; > + e->count = 0; > + e->instructions = 0; > +} > + > +static inline void update_cpi(struct weighted_cpi_summary *s, > + unsigned long long i, > + unsigned long long c) { > +/* We don't know ahead of time how many samples there are, and working > + * with dynamic stuff is a pain, and unnecessary. This algorithm will > + * generate a sample set that approximates an even sample. We can > + * then take the percentiles on this, and get an approximate value. */ > + int lap, index; > + > + if ( opt.sample_size ) { > + lap = (s->count/opt.sample_size)+1; > + index =s->count % opt.sample_size; > + > + if((index - (lap/3))%lap == 0) { > + if(!s->cpi) { > + assert(!s->cpi_weight); > + > + s->cpi = malloc(sizeof(*s->cpi) * opt.sample_size); > + s->cpi_weight = malloc(sizeof(*s->cpi_weight) * opt.sample_size); > + if(!s->cpi || !s->cpi_weight) { > + fprintf(stderr, "%s: malloc failed!\n", __func__); > + error(ERR_SYSTEM, NULL); > + } > + } > + assert(s->cpi_weight); > + > + s->cpi[index] = (float) c / i; > + s->cpi_weight[index]=c; > + } > + } > + > + s->instructions += i; > + s->cycles += c; > + s->count++; > + > + s->interval.instructions += i; > + s->interval.cycles += c; > + s->interval.count++; > +} > + > +static inline void clear_interval_cpi(struct weighted_cpi_summary *s) { > + s->interval.cycles = 0; > + s->interval.count = 0; > + s->interval.instructions = 0; > +} > + > +static inline void print_cpu_affinity(struct cycle_summary *s, char *p) { > + if(s->count) { > + long long avg; > + > + avg = s->cycles / s->count; > + > + if ( opt.sample_size ) { > + long long p5, p50, p95; > + int data_size = s->count; > + if(data_size > opt.sample_size) > + data_size = opt.sample_size; > + > + p50 = percentile(s->sample, data_size, 50); > + p5 = percentile(s->sample, data_size, 5); > + p95 = percentile(s->sample, data_size, 95); > + > + printf("%s: %7d %6lld {%6lld|%6lld|%6lld}\n", > + p, s->count, avg, p5, p50, p95); > + } else { > + printf("%s: %7d %6lld\n", > + p, s->count, avg); > + } > + } > +} > + > +static inline void print_cpi_summary(struct weighted_cpi_summary *s) { > + if(s->count) { > + float avg; > + > + avg = (float)s->cycles / s->instructions; > + > + if ( opt.sample_size ) { > + float p5, p50, p95; > + int data_size = s->count; > + > + if(data_size > opt.sample_size) > + data_size = opt.sample_size; > + > + p50 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 50); > + p5 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 5); > + p95 = weighted_percentile(s->cpi, s->cpi_weight, data_size, 95); > + > + printf(" CPI summary: %2.2f {%2.2f|%2.2f|%2.2f}\n", > + avg, p5, p50, p95); > + } else { > + printf(" CPI summary: %2.2f\n", avg); > + } > + } > +} > + > +static inline void print_cycle_percent_summary(struct cycle_summary *s, > + tsc_t total, char *p) { > + if(s->count) { > + long long avg; > + double percent, seconds; > + > + avg = s->cycles / s->count; > + > + seconds = ((double)s->cycles) / opt.cpu_hz; > + > + percent = ((double)(s->cycles * 100)) / total; > + > + if ( opt.sample_size ) { > + long long p5, p50, p95; > + int data_size = s->count; > + > + if(data_size > opt.sample_size) > + data_size = opt.sample_size; > + > + p50 = self_weighted_percentile(s->sample, data_size, 50); > + p5 = self_weighted_percentile(s->sample, data_size, 5); > + p95 = self_weighted_percentile(s->sample, data_size, 95); > + > + printf("%s: %7d %5.2lfs %5.2lf%% %6lld {%6lld|%6lld|%6lld}\n", > + p, s->count, > + seconds, > + percent, > + avg, p5, p50, p95); > + } else { > + printf("%s: %7d %5.2lfs %5.2lf%% %6lld\n", > + p, s->count, > + seconds, > + percent, > + avg); > + } > + } > +} > + > +static inline void print_cycle_summary(struct cycle_summary *s, char *p) { > + if(s->count) { > + long long avg; > + > + avg = s->cycles / s->count; > + > + if ( opt.sample_size ) { > + long long p5, p50, p95; > + int data_size = s->count; > + > + if(data_size > opt.sample_size) > + data_size = opt.sample_size; > + > + p50 = self_weighted_percentile(s->sample, data_size, 50); > + p5 = self_weighted_percentile(s->sample, data_size, 5); > + p95 = self_weighted_percentile(s->sample, data_size, 95); > + > + printf("%s: %7d %5.2lfs %6lld {%6lld|%6lld|%6lld}\n", > + p, s->count, ((double)s->cycles)/opt.cpu_hz, > + avg, p5, p50, p95); > + } else { > + printf("%s: %7d %5.2lfs %6lld\n", > + p, s->count, ((double)s->cycles)/opt.cpu_hz, avg); > + } > + } > +} > + > +#define PRINT_SUMMARY(_s, _p...) \ > + do { \ > + if((_s).count) { \ > + if ( opt.sample_size ) { \ > + unsigned long long p5, p50, p95; \ > + int data_size=(_s).cycles_count; \ > + if(data_size > opt.sample_size) \ > + data_size=opt.sample_size; \ > + p50=percentile((_s).cycles_sample, data_size, 50); \ > + p5=percentile((_s).cycles_sample, data_size, 5); \ > + p95=percentile((_s).cycles_sample, data_size, 95); \ > + printf(_p); \ > + printf(" %7d %5.2lfs %5.2lf%% %5lld cyc {%5lld|%5lld|%5lld}\n", \ > + (_s).count, \ > + ((double)(_s).cycles)/opt.cpu_hz, \ > + summary_percent_global(&(_s)), \ > + (_s).cycles_count ? (_s).cycles / (_s).cycles_count:0, \ > + p5, p50, p95); \ > + } else { \ > + printf(_p); \ > + printf(" %7d %5.2lfs %5.2lf%% %5lld cyc\n", \ > + (_s).count, \ > + ((double)(_s).cycles)/opt.cpu_hz, \ > + summary_percent_global(&(_s)), \ > + (_s).cycles_count ? (_s).cycles / (_s).cycles_count:0); \ > + } \ > + } \ > + } while(0) > + > +#define INTERVAL_DESC_MAX 31 > +struct interval_list { > + struct interval_element *elem; > + struct interval_list *next; > + char desc[INTERVAL_DESC_MAX+1]; /* +1 for the null terminator */ > +}; > + > +void __interval_cycle_percent_output(struct interval_element *e, tsc_t cycles) { > + printf(" %.02lf", > + __cycles_percent(e->cycles, cycles)); > + clear_interval_cycles(e); > +} > + > +void interval_cycle_percent_output(struct interval_element *e) { > + __interval_cycle_percent_output(e, opt.interval.cycles); > +} > + > +void interval_time_output(void) { > + struct time_struct t; > + abs_cycles_to_time(P.interval.start_tsc, &t); > + > + printf("%u.%09u", t.s, t.ns); > +} > + > +void interval_table_output(void) { > + int i; > + > + interval_time_output(); > + > + if(opt.interval.mode == INTERVAL_MODE_ARRAY) { > + for(i=0; i<P.interval.array.count; i++) { > + struct interval_element *e = P.interval.array.values[i]; > + if(e) { > + interval_cycle_percent_output(e); > + } else { > + printf(" 0.0"); > + } > + } > + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { > + struct interval_list *p; > + for(p = P.interval.list.head; p; p = p->next) > + interval_cycle_percent_output(p->elem); > + } > + printf("\n"); > +} > + > +void interval_table_tail(void) { > + struct interval_list *p; > + > + printf("time"); > + > + for(p=P.interval.list.head; p; p = p->next) > + printf(" %s", p->desc); > + > + printf("\n"); > +} > + > +void interval_table_alloc(int count) { > + P.interval.array.count = count; > + P.interval.array.values = malloc(count * sizeof(struct interval_list *)); > + > + if(!P.interval.array.values) { > + fprintf(stderr, "Malloc failed!\n"); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(P.interval.array.values, count*sizeof(struct interval_list *)); > +} > + > +void interval_list_add(struct interval_element *e, char *desc) { > + struct interval_list *p; > + > + fprintf(warn, "%s: Adding element '%s'\n", __func__, desc); > + > + if((p=malloc(sizeof(*p)))==NULL) { > + fprintf(stderr, "malloc() failed.\n"); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(p, sizeof(*p)); > + > + p->elem = e; > + strncpy(p->desc, desc, INTERVAL_DESC_MAX); > + > + p->next=NULL; > + > + if(P.interval.list.head) > + *P.interval.list.tail = p; > + else > + P.interval.list.head = p; > + P.interval.list.tail = &p->next; > +} > + > +void interval_cr3_schedule_time_header(void) { > + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { > + int i; > + > + printf("time"); > + for(i=0; i<opt.interval.array.count; i++) { > + printf(" %llx", opt.interval.array.values[i]); > + } > + printf("\n"); > + } > + /* Can't see into the future, so no header if cr3 values are > + not specified. */ > +} > + > +void interval_cr3_value_check(struct cr3_value_struct *cr3) { > + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { > + int i; > + > + for(i=0; i<opt.interval.array.count; i++) { > + if(cr3->gmfn == opt.interval.array.values[i]) { > + if(P.interval.array.values[i]) { > + fprintf(stderr, "Fatal: duplicate cr3 value %llx!\n", > + cr3->gmfn); > + error(ERR_ASSERT, NULL); > + } > + fprintf(stderr, "%s: found gmfn %llx\n", > + __func__, cr3->gmfn); > + > + P.interval.array.values[i] = &cr3->total_time.interval; > + } > + } > + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { > + char desc[32]; > + snprintf(desc, 32, "%llx", cr3->gmfn); > + interval_list_add(&cr3->total_time.interval, desc); > + } else { > + /* Custom */ > + if(cr3->gmfn == opt.interval.array.values[0]) > + P.interval.cr3 = cr3; > + } > +} > + > +void interval_cr3_schedule_ordered_output(void) { > + struct cr3_value_struct *p; > + int i; > + > + struct cr3_value_struct **qsort_array; > + int N=0; > + > + int cr3_time_compare(const void *_a, const void *_b) { > + struct cr3_value_struct *a=*(typeof(&a))_a; > + struct cr3_value_struct *b=*(typeof(&a))_b; > + > + if(a->total_time.interval.cycles < b->total_time.interval.cycles) > + return 1; > + else if(b->total_time.interval.cycles == a->total_time.interval.cycles) { > + if(a->total_time.interval.count < b->total_time.interval.count) > + return 1; > + else if(a->total_time.interval.count == b->total_time.interval.count) > + return 0; > + else > + return -1; > + } else > + return -1; > + } > + > + for(p=P.cr3.head; p; p=p->gnext) > + N++; > + > + if(!N) > + return; > + > + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); > + > + for(i=0, p=P.cr3.head; p; p=p->gnext, i++) > + qsort_array[i]=p; > + > + qsort(qsort_array, N, sizeof(struct eip_list_struct *), > + cr3_time_compare); > + > + interval_time_output(); > + > + for(i=0; i<N; i++) { > + p = qsort_array[i]; > + /* Rounding down means this will get ..1]% */ > + if(p->total_time.interval.cycles > 0) { > + printf(" %8llx: %.02lf %c\n", > + p->gmfn, > + __cycles_percent(p->total_time.interval.cycles, > + opt.interval.cycles), > + (p->first_time > P.interval.start_tsc)?'*':' '); > + } > + clear_interval_cycles(&p->total_time.interval); > + } > + > + free(qsort_array); > +} > + > +void interval_cr3_short_summary_header(void) { > + int i; > + > + printf("time guest"); > + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) > + printf(" %s", hvm_short_summary_name[i]); > + printf("\n"); > +} > + > +void interval_cr3_short_summary_output(void) { > + struct cycle_summary *hss_array; > + int i; > + > + if(P.interval.cr3) { > + struct cr3_value_struct *p = P.interval.cr3; > + > + interval_time_output(); > + > + hss_array = p->hvm.s; > + > + printf(" %.02lf", > + __cycles_percent(p->total_time.interval.cycles, > + opt.interval.cycles)); > + > + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) > + __interval_cycle_percent_output(&hss_array[i].interval, > + p->total_time.interval.cycles); > + > + clear_interval_cycles(&p->total_time.interval); > + > + printf("\n"); > + } > +} > + > +void interval_domain_value_check(struct domain_data *d) { > + if( opt.interval.mode == INTERVAL_MODE_ARRAY ) { > + int i; > + > + for(i=0; i<opt.interval.array.count; i++) { > + if(d->did == opt.interval.array.values[i]) { > + if(P.interval.array.values[i]) { > + fprintf(stderr, "Fatal: duplicate domain value %d!\n", > + d->did); > + error(ERR_ASSERT, NULL); > + } > + > + P.interval.array.values[i] = &d->total_time.interval; > + } > + } > + } else if(opt.interval.mode == INTERVAL_MODE_LIST) { > + char desc[32]; > + snprintf(desc, 32, "%d", d->did); > + interval_list_add(&d->total_time.interval, desc); > + } else { > + if(d->did == opt.interval.array.values[0]) > + P.interval.domain.d = d; > + } > +} > + > +void interval_domain_short_summary_header(void) { > + int i; > + > + printf("time running"); > + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) > + printf(" %s", hvm_short_summary_name[i]); > + printf("\n"); > +} > + > +void interval_domain_short_summary_output(void) { > + > + if(P.interval.domain.d) { > + struct domain_data *d; > + int i; > + > + d=P.interval.domain.d; > + > + interval_time_output(); > + > + interval_cycle_percent_output(&d->total_time.interval); > + > + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) > + interval_cycle_percent_output(&d->hvm_short.s[i].interval); > + > + printf("\n"); > + } > +} > + > +void interval_domain_guest_interrupt(struct hvm_data *h, int vector) { > + struct domain_data *d = h->v->d; > + int i; > + > + /* Check to see if this vector is in the "print list" */ > + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { > + if(P.interval.domain.guest_vector[i] == 0) { > + P.interval.domain.guest_vector[i] = vector; > + break; > + } > + if(P.interval.domain.guest_vector[i] == vector) > + break; > + } > + > + if(i == INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX) { > + fprintf(stderr, "FATAL: used up all %d guest interrupt slots!\n", > + INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX); > + error(ERR_LIMIT, NULL); > + } else { > + d->guest_interrupt[vector]++; > + } > +} > + > +void interval_domain_guest_interrupt_tail(void) { > + int i; > + > + printf("time running"); > + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { > + if(P.interval.domain.guest_vector[i] == 0) > + break; > + printf(" %d", P.interval.domain.guest_vector[i]); > + } > + printf("\n"); > +} > + > +void interval_domain_guest_interrupt_output(void) { > + > + if(P.interval.domain.d) { > + struct domain_data *d; > + int i; > + > + d=P.interval.domain.d; > + > + interval_time_output(); > + > + for(i=0; i<INTERVAL_DOMAIN_GUEST_INTERRUPT_MAX; i++) { > + int v = P.interval.domain.guest_vector[i]; > + > + if(v == 0) > + break; > + > + printf(" %d", d->guest_interrupt[v]); > + > + d->guest_interrupt[v]=0; > + } > + > + printf("\n"); > + } > + > +} > + > +void interval_domain_grant_maps_output(void) { > + > + if(P.interval.domain.d) { > + struct domain_data *d; > + > + d=P.interval.domain.d; > + > + interval_time_output(); > + > + printf(" %d", d->memops.done_for_interval[MEM_PAGE_GRANT_MAP]); > + > + d->memops.done_for_interval[MEM_PAGE_GRANT_MAP] = 0; > + > + printf("\n"); > + } > +} > + > +/* General interval gateways */ > + > +void interval_callback(void) { > + /* First, see if we're in generic mode. */ > + switch(opt.interval.mode) { > + case INTERVAL_MODE_LIST: > + case INTERVAL_MODE_ARRAY: > + interval_table_output(); > + return; > + default: > + break; > + } > + > + switch(opt.interval.output) { > + case INTERVAL_CR3_SCHEDULE_ORDERED: > + interval_cr3_schedule_ordered_output(); > + break; > + case INTERVAL_CR3_SHORT_SUMMARY: > + interval_cr3_short_summary_output(); > + break; > + case INTERVAL_DOMAIN_SHORT_SUMMARY: > + interval_domain_short_summary_output(); > + break; > + case INTERVAL_DOMAIN_GUEST_INTERRUPT: > + interval_domain_guest_interrupt_output(); > + break; > + case INTERVAL_DOMAIN_GRANT_MAPS: > + interval_domain_grant_maps_output(); > + break; > + default: > + break; > + } > +} > + > +void interval_header(void) { > + switch(opt.interval.output) { > + case INTERVAL_CR3_SHORT_SUMMARY: > + interval_cr3_short_summary_header(); > + break; > + case INTERVAL_DOMAIN_SHORT_SUMMARY: > + interval_domain_short_summary_header(); > + break; > + default: > + break; > + } > +} > + > +void interval_tail(void) { > + if(opt.interval.mode == INTERVAL_MODE_LIST) { > + interval_table_tail(); > + return; > + } > + > + switch(opt.interval.output) { > + case INTERVAL_DOMAIN_GUEST_INTERRUPT: > + interval_domain_guest_interrupt_tail(); > + break; > + default: > + break; > + } > +} > + > +/* -- Eip list data -- */ > + > +void update_eip(struct eip_list_struct **head, unsigned long long eip, > + unsigned long long cycles, int type, void * extra) { > + struct eip_list_struct *p, **last=head; > + > + for(p=*head; p; last = (&p->next), p=p->next) > + if(p->eip >= eip) > + break; > + > + if(!p || p->eip != eip) { > + p=malloc(sizeof(*p)); > + if(!p) { > + perror("malloc failed"); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(p, sizeof(*p)); > + > + p->eip=eip; > + p->type = type; > + > + if(eip_list_type[type].new) { > + eip_list_type[type].new(p, extra); > + } > + p->next = *last; > + *last=p; > + } else if(p->type != type) { > + fprintf(stderr, "WARNING, mixed types! %d %d\n", p->type, type); > + } else if(eip_list_type[type].update) { > + eip_list_type[type].update(p, extra); > + } > + > + update_summary(&p->summary, cycles); > +} > + > +void dump_eip(struct eip_list_struct *head) { > + struct eip_list_struct *p; > + int i; > + int total = 0; > + > + struct eip_list_struct **qsort_array; > + int N=0; > + > + int eip_compare(const void *_a, const void *_b) { > + struct eip_list_struct *a=*(typeof(&a))_a; > + struct eip_list_struct *b=*(typeof(&a))_b; > + > + if(a->summary.cycles < b->summary.cycles) > + return 1; > + else if(b->summary.cycles == a->summary.cycles) { > + if(a->summary.count < b->summary.count) > + return 1; > + else if(a->summary.count == b->summary.count) > + return 0; > + else > + return -1; > + } else > + return -1; > + } > + > + for(p=head; p; p=p->next) > + { > + total += p->summary.count; > + N++; > + } > + > + if(!N) > + return; > + > + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); > + > + for(i=0, p=head; p; p=p->next, i++) > + qsort_array[i]=p; > + > + qsort(qsort_array, N, sizeof(struct eip_list_struct *), > + eip_compare); > + > + /* WARNING: don't use N after this point unless you copy this variable */ > +#if 0 > + if(opt.summary_eip_limit && opt.summary_eip_limit < N) > + N=opt.summary_eip_limit; > +#endif > + > + printf(" Total samples: %d\n", total); > + > + for(i=0; i<N; i++) { > + p = qsort_array[i]; > + if ( p->summary.cycles ) > + PRINT_SUMMARY(p->summary, " %12llx%-45s: ", > + p->eip, > + find_symbol(p->eip)); > + else > + { > + printf(" %12llx%-45s: ", > + p->eip, > + find_symbol(p->eip)); > + printf(" %7d %5.2lf%%\n", > + p->summary.count, > + ((double)p->summary.count*100)/total); > + } > + > + > + if(eip_list_type[p->type].dump) { > + eip_list_type[p->type].dump(p); > + } > + } > + > + free(qsort_array); > +} > + > +/* -- HVM code -- */ > +struct hvm_pf_xen_record { > + //unsigned vcpu:16, domain:16; > + union { > + struct { > + unsigned long long va; > + unsigned int error_code; > + } x64; > + struct { > + unsigned int va; > + unsigned int error_code; > + } x32; > + }; > +}; > + > +void hvm_update_short_summary(struct hvm_data *h, int element) { > + struct vcpu_data *v = h->v; > + > + if(v->cr3.data) > + update_cycles(&v->cr3.data->hvm.s[element], h->arc_cycles); > + > + update_cycles(&v->d->hvm_short.s[element], h->arc_cycles); > + > + h->short_summary_done=1; > +} > + > +void hvm_short_summary(struct hvm_short_summary_struct *hss, > + tsc_t total, char *prefix) { > + char desc[80]; > + int i; > + > + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) { > + snprintf(desc, 80, "%s%s", prefix, hvm_short_summary_name[i]); > + print_cycle_percent_summary(hss->s + i, total, desc); > + } > +} > + > +/* Wrapper to try to make sure this is only called once per > + * call site, rather than walking through the list each time */ > +#define hvm_set_summary_handler(_h, _s, _d) \ > + do { \ > + static int done=0; \ > + int ret; \ > + if(!done) { \ > + if ((ret=__hvm_set_summary_handler(_h, _s, _d))) \ > + fprintf(stderr, "%s: hvm_set_summary_handler returned %d\n", \ > + __func__, ret); \ > + done=1; \ > + } \ > + } while(0) > + > +int __hvm_set_summary_handler(struct hvm_data *h, void (*s)(struct hvm_data *h, void*d), void*d) { > + /* Set summary handler */ > + if(h->exit_reason < h->exit_reason_max) > + { > + struct hvm_summary_handler_node *p, **q; > + > + /* Find the end of the list, checking to make sure there are no > + * duplicates along the way */ > + q=&h->exit_reason_summary_handler_list[h->exit_reason]; > + p = *q; > + while(p) > + { > + if(p->handler == s && p->data == d) > + { > + fprintf(stderr, "%s: Unexpected duplicate handler %p,%p\n", > + __func__, s, d); > + error(ERR_STRICT, NULL); > + return -EBUSY; > + } > + q=&p->next; > + p=*q; > + } > + > + assert(p==NULL); > + > + /* Insert the new handler */ > + p=malloc(sizeof(*p)); > + if (!p) { > + fprintf(stderr, "%s: Malloc failed!\n", __func__); > + error(ERR_SYSTEM, NULL); > + } > + p->handler=s; > + p->data = d; > + p->next=*q; > + *q=p; > + return 0; > + } > + return -EINVAL; > +} > + > +void hvm_generic_postprocess(struct hvm_data *h); > + > +static int hvm_set_postprocess(struct hvm_data *h, void (*s)(struct hvm_data *h)) > +{ > + if ( h->post_process == NULL > + || h->post_process == hvm_generic_postprocess ) > + { > + h->post_process = s; > + return 0; > + } > + else > + return 1; > +} > + > +#define SIGN_EXTENDED_BITS (~((1ULL<<48)-1)) > +#define HIGH_BIT(_v) ((_v) & (1ULL<<47)) > +static inline int is_valid_addr64(unsigned long long va) > +{ > + if(HIGH_BIT(va)) > + return ((va & SIGN_EXTENDED_BITS) == SIGN_EXTENDED_BITS); > + else > + return ((va & SIGN_EXTENDED_BITS) == 0); > +} > + > +void hvm_pf_xen_summary(struct hvm_data *h, void *d) { > + int i,j, k; > + > + printf(" page_fault\n"); > + for(i=0; i<PF_XEN_MAX; i++) > + { > + if( pf_xen_name[i] ) > + { > + PRINT_SUMMARY(h->summary.pf_xen[i], > + " %-25s ", pf_xen_name[i]); > + } > + else > + { > + PRINT_SUMMARY(h->summary.pf_xen[i], > + " [%23d] ", i); > + } > + switch(i){ > + case PF_XEN_NON_EMULATE: > + for(j=0; j<PF_XEN_NON_EMUL_MAX; j++) > + PRINT_SUMMARY(h->summary.pf_xen_non_emul[j], > + " *%-13s ", pf_xen_non_emul_name[j]); > + break; > + case PF_XEN_EMULATE: > + for(j=0; j<PF_XEN_EMUL_MAX; j++) { > + PRINT_SUMMARY(h->summary.pf_xen_emul[j], > + " *%-13s ", pf_xen_emul_name[j]); > + if(j == PF_XEN_EMUL_EARLY_UNSHADOW) { > + int k; > + for(k=0; k<5; k++) { > + PRINT_SUMMARY(h->summary.pf_xen_emul_early_unshadow[k], > + " +[%d] ", k); > + } > + } > + } > + break; > + case PF_XEN_FIXUP: > + for(j=0; j<PF_XEN_FIXUP_MAX; j++) { > + PRINT_SUMMARY(h->summary.pf_xen_fixup[j], > + " *%-13s ", pf_xen_fixup_name[j]); > + if(j == PF_XEN_FIXUP_UNSYNC ) { > + for(k=0; k<PF_XEN_FIXUP_UNSYNC_RESYNC_MAX; k++) { > + PRINT_SUMMARY(h->summary.pf_xen_fixup_unsync_resync[k], > + " +[%3d] ", k); > + } > + PRINT_SUMMARY(h->summary.pf_xen_fixup_unsync_resync[k], > + " +[max] "); > + } > + } > + break; > + } > + } > +} > + > +void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) > +{ > + switch(guest_paging_levels) { > + /* Select a subfield of _bits bits starting at bit _shift from _x */ > +#define _SUBFIELD(_bits, _shift, _x) \ > + (((_x)>>(_shift)) & ((1ULL<<(_bits))-1)) > + case 4: > + /* Verify sign-extension */ > + if((HIGH_BIT(e->va) > + &&((e->va & SIGN_EXTENDED_BITS) != SIGN_EXTENDED_BITS)) > + || (!HIGH_BIT(e->va) > + && ((e->va & SIGN_EXTENDED_BITS) != 0))) { > + fprintf(warn, "Strange, va %llx not properly sign extended for 4-level pagetables\n", > + e->va); > + } > + e->pt_index[4]=_SUBFIELD(9,39,e->va); > + e->pt_index[3]=_SUBFIELD(9,30,e->va); > + e->pt_index[2]=_SUBFIELD(9,21,e->va); > + e->pt_index[1]=_SUBFIELD(9,12,e->va); > + /* These are only useful for the linear-pagetable code */ > + e->pt_index[0]=_SUBFIELD(9,3,e->va); > + if(e->va & 0x4) > + e->pt_is_lo=0; > + break; > + case 3: > + e->pt_index[3]=_SUBFIELD(2,30,e->va); > + e->pt_index[2]=_SUBFIELD(9,21,e->va); > + e->pt_index[1]=_SUBFIELD(9,12,e->va); > + /* These are only useful for the linear-pagetable code */ > + e->pt_index[0]=_SUBFIELD(9,3,e->va); > + if(e->va & 0x4) > + e->pt_is_lo=0; > + break; > + case 2: > + e->pt_index[2]=_SUBFIELD(10,22,e->va); > + e->pt_index[1]=_SUBFIELD(10,12,e->va); > + /* This is only useful for the linear pagetable code */ > + e->pt_index[0]=_SUBFIELD(10,2,e->va); > + break; > + case 0: > + break; > + default: > + fprintf(warn, "Don't know how to handle %d-level pagetables\n", > + guest_paging_levels); > + } > + > + e->corresponding_va = CORR_VA_INVALID; > + e->pt_level = 0; > + > + /* Detect accesses to Windows linear pagetables */ > + switch(guest_paging_levels) > + { > + case 2: > + if(e->pt_index[2] == 768) { > + if(e->pt_index[1] == 768) > + { > + e->pt_level = 2; > + e->corresponding_va=((1UL<<22)-1) > + | e->pt_index[0]<<22; > + } > + else > + { > + e->pt_level = 1; > + e->corresponding_va = ((1UL<<12)-1) > + | e->pt_index[1]<<22 > + | e->pt_index[0]<<12; > + } > + } > + break; > + case 3: > + if(e->pt_index[3]==3 && (e->pt_index[2]>>2==0)) > + { > + if(e->pt_index[2]==3 && e->pt_index[1]>>2==0) > + { > + if(e->pt_index[1] == 3 && e->pt_index[0]>>2==0) > + { > + e->pt_level = 3; > + e->corresponding_va=((1UL<<30)-1) > + | e->pt_index[0]<<30; > + } > + else > + { > + e->pt_level = 2; > + e->corresponding_va=((1UL<<21)-1) > + | e->pt_index[1]<<30 > + | e->pt_index[2]<<21; > + } > + } > + else > + { > + e->pt_level = 1; > + e->corresponding_va = ((1UL<<12)-1) > + | e->pt_index[0]<<12 > + | e->pt_index[1]<<21 > + | e->pt_index[2]<<30; > + } > + } > + break; > + case 4: > + if(e->pt_index[4] == 0x1ed) > + { > + if(e->pt_index[3] == 0x1ed) > + { > + if(e->pt_index[2] == 0x1ed) > + { > + if(e->pt_index[1] == 0x1ed) > + { > + e->pt_level = 4; > + e->corresponding_va = ((1ULL<<39)-1) > + | (unsigned long long)e->pt_index[0]<<39; > + } > + else > + { > + e->pt_level = 3; > + e->corresponding_va = ((1ULL<<30)-1) > + | (unsigned long long)e->pt_index[0]<<30 > + | (unsigned long long)e->pt_index[1]<<39; > + } > + } > + else > + { > + e->pt_level = 2; > + e->corresponding_va = ((1ULL<<21)-1) > + | (unsigned long long)e->pt_index[0]<<21 > + | (unsigned long long)e->pt_index[1]<<30 > + | (unsigned long long)e->pt_index[2]<<39; > + } > + } > + else > + { > + e->pt_level = 1; > + e->corresponding_va = ((1ULL<<12)-1) > + | (unsigned long long)e->pt_index[0]<<12 > + | (unsigned long long)e->pt_index[1]<<21 > + | (unsigned long long)e->pt_index[2]<<30 > + | (unsigned long long)e->pt_index[3]<<39; > + } > + > + if(HIGH_BIT(e->corresponding_va)) > + e->corresponding_va |= SIGN_EXTENDED_BITS; > + } > + break; > + default: > + break; > + } > +} > + > +void hvm_pf_xen_preprocess(unsigned event, struct hvm_data *h) { > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + struct mmio_info *m = &h->inflight.mmio; > + struct hvm_pf_xen_record *r = (typeof(r))h->d; > + > + if(event == TRC_HVM_PF_XEN64) > + { > + if(!is_valid_addr64(r->x64.va)) > + fprintf(warn, "%s: invalid va %llx", > + __func__, r->x64.va); > + e->va = r->x64.va; > + e->error_code = r->x64.error_code; > + } > + else > + { > + e->va = r->x32.va; > + e->error_code = r->x32.error_code; > + } > + > + if(m->data_valid) > + e->pf_case = PF_XEN_MMIO; > + else > + { > + pf_preprocess(e, h->v->guest_paging_levels); > + > + /* On rio traces, we try to infer emulation by looking for accesses > + in the linear pagetable */ > + if(e->pt_level > 0) > + e->pf_case = PF_XEN_EMULATE; > + else > + e->pf_case = PF_XEN_NON_EMULATE; > + } > +} > + > +static inline int is_kernel(int paging_levels, unsigned long long va) { > + switch(paging_levels) { > + case 2: > + case 3: > + if(va & 0x80000000) > + return 1; > + else > + return 0; > + break; > + case 4: > + if(HIGH_BIT(va)) > + return 1; > + else return 0; > + default: > + return 0; > + } > + > +} > + > +void hvm_pf_xen_postprocess(struct hvm_data *h) { > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if(opt.summary_info) { > + if(e->pf_case) > + update_summary(&h->summary.pf_xen[e->pf_case], > + h->arc_cycles); > + else > + fprintf(warn, "Strange, pf_case 0!\n"); > + switch(e->pf_case) > + { > + case PF_XEN_EMULATE: > + update_eip(&h->v->d->emulate_eip_list, > + h->rip, > + h->arc_cycles, > + 0, NULL); > + break; > + case PF_XEN_NON_EMULATE: > + if(is_kernel(h->v->guest_paging_levels, h->rip)) > + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_EIP_KERNEL], > + h->arc_cycles); > + else > + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_EIP_USER], > + h->arc_cycles); > + if(is_kernel(h->v->guest_paging_levels, e->va)) > + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_VA_KERNEL], > + h->arc_cycles); > + > + else > + update_summary(&h->summary.pf_xen_non_emul[PF_XEN_NON_EMUL_VA_USER], > + h->arc_cycles); > + } > + > + /* Set summary handler */ > + hvm_set_summary_handler(h, hvm_pf_xen_summary, NULL); > + } > +} > + > +void hvm_pf_xen_process(struct record_info *ri, struct hvm_data *h) { > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if(ri->event == TRC_HVM_PF_XEN64 > + && h->v->guest_paging_levels != 4) > + fprintf(warn, "Strange, PF_XEN64 but guest_paging_levels %d!\n", > + h->v->guest_paging_levels); > + else if(ri->event == TRC_HVM_PF_XEN > + && h->v->guest_paging_levels == 4) > + fprintf(warn, "Strange, PF_XEN but guest_paging_levels %d!\n", > + h->v->guest_paging_levels); > + > + hvm_pf_xen_preprocess(ri->event, h); > + > + if(opt.dump_all) > + { > + if(e->pf_case == PF_XEN_EMULATE) > + printf("]%s pf_xen:emulate va %llx ec %x level %d corr %llx e->pt_index[%d %d %d %d %d]\n", > + ri->dump_header, e->va, e->error_code, > + e->pt_level, e->corresponding_va, > + e->pt_index[0], e->pt_index[1], e->pt_index[2], > + e->pt_index[3], > + e->pt_index[4]); > + else > + printf("]%s pf_xen va %llx ec %x e->pt_index[%d %d %d %d %d]\n", > + ri->dump_header, e->va, e->error_code, > + e->pt_index[0], e->pt_index[1], e->pt_index[2], > + e->pt_index[3], > + e->pt_index[4]); > + } > + > + if ( hvm_set_postprocess(h, hvm_pf_xen_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +char * hvm_vlapic_icr_dest_shorthand_name[4] = { > + "dest_field", "self", "all-inc", "all-exc" > +}; > + > +void hvm_vlapic_vmentry_cleanup(struct vcpu_data *v, tsc_t tsc) > +{ > + int i; > + > + struct vlapic_struct *vla = &v->vlapic; > + > + for(i=0; i<MAX_VLAPIC_LIST; i++) > + { > + unsigned long long lat=0; > + struct outstanding_ipi *o = vla->outstanding.list + i; > + > + if(!(o->valid && o->injected)) > + continue; > + > + if(tsc >= o->first_tsc) > + lat = tsc - o->first_tsc; > + else > + fprintf(warn, "Strange, vec %d first_tsc %lld > ri->tsc %lld!\n", > + o->vec, o->first_tsc, tsc); > + > + if(opt.dump_ipi_latency > + || (opt.dump_all && o->count > 1)) { > + struct time_struct t; > + cycles_to_time(lat, &t); > + printf(" [vla] d%dv%d vec %d ipis %d, latency %lld (%u.%09u s)\n", > + v->d->did, v->vid, o->vec, o->count, lat, > + t.s, t.ns); > + } > + > +#if 0 > + /* FIXME: make general somehow */ > + if(opt.summary_info) > + { > + update_summary(&h->summary.ipi_latency, lat); > + h->summary.ipi_count[vla->outstanding_ipis]++; > + } > +#endif > + > + o->vec = o->count = o->injected = o->valid = o->first_tsc = 0; > + } > +} > + > +void hvm_vlapic_clear(struct vlapic_struct *vla) > +{ > + bzero(vla, sizeof(*vla)); > +} > + > +struct outstanding_ipi *find_vec(struct vlapic_struct *vla, int vec) > +{ > + struct outstanding_ipi *o = NULL; > + int i; > + > + /* Find the entry for this vector, or the first empty one. */ > + for(i=0; i<MAX_VLAPIC_LIST; i++) > + { > + if(vla->outstanding.list[i].valid && vla->outstanding.list[i].vec == vec) > + { > + o = vla->outstanding.list + i; > + break; > + } else if(!vla->outstanding.list[i].valid && !o) > + o = vla->outstanding.list + i; > + } > + > + if(!o->valid) { > + o->vec = vec; > + o->valid = 1; > + } > + > + return o; > +} > + > +void hvm_vlapic_icr_handler(struct hvm_data *h) > +{ > + struct mmio_info *m = &h->inflight.mmio; > + union { > + unsigned int val; > + struct { > + unsigned vec:8, > + delivery_mode:3, > + dest_mode:1, > + delivery_status:1, > + _res1:1, > + level:1, > + trigger:1, > + _res2:2, > + dest_shorthand:2; > + }; > + } icr = { .val = m->data }; > + > + void ipi_send(struct vcpu_data *ov, int vec) > + { > + struct vlapic_struct *vla; > + struct outstanding_ipi *o = NULL; > + > + if(ov->runstate.state == RUNSTATE_LOST) { > + if(opt.dump_all) > + fprintf(warn, "%s: v%d in state RUNSTATE_LOST, not counting ipi\n", > + __func__, ov->vid); > + return; > + } > + > + vla = &ov->vlapic; > + > + o = find_vec(vla, vec); > + > + if(!o) > + { > + fprintf(warn, "%s: Couldn't find an open slot!\n", > + __func__); > + return; > + } > + > + if(!o->first_tsc) > + o->first_tsc = P.now; > + > + if(opt.dump_all && o->count == 0 && o->injected) > + printf(" [vla] Pre-injection\n"); > + > + o->count++; > + > + if((opt.dump_all) > +#if 0 > + && (ov->runstate.state != RUNSTATE_RUNNING > + || ov->hvm.vmexit_valid) > +#endif > + ) > + printf(" [vla] d%dv%d vec %d state %s (outstanding ipis %d)\n", > + ov->d->did, ov->vid, > + o->vec, > + runstate_name[ov->runstate.state], > + o->count); > + } > + > + if(m->is_write) { > + if(opt.dump_all) { > + printf(" [vla] d%dv%d icr vec %d %s\n", > + h->v->d->did, h->v->vid, > + icr.vec, > + hvm_vlapic_icr_dest_shorthand_name[icr.dest_shorthand]); > + } > + > + if(icr.dest_shorthand == 3) > + { > + struct vcpu_data *ov, *v = h->v; > + struct domain_data *d = v->d; > + int i; > + > + for(i=0; i<MAX_CPUS; i++) > + { > + ov = d->vcpu[i]; > + if(!ov || ov == v) > + continue; > + > + ipi_send(ov, icr.vec); > + > + } > + } else if(icr.dest_shorthand != 1) { > +#if 0 > + fprintf(warn, "Strange, vlapic icr %s vec %d!\n", > + hvm_vlapic_icr_dest_shorthand_name[icr.dest_shorthand], > + icr.vec); > +#endif > + } > + } else { > + /* Read */ > + if(opt.dump_all) { > + printf(" [vla] d%dv%d icr status %s\n", > + h->v->d->did, h->v->vid, > + icr.delivery_status?"pending":"idle"); > + } > + } > + > +} > + > +void hvm_vlapic_inject(struct vcpu_data *v, int vec) > +{ > + struct vlapic_struct *vla = &v->vlapic; > + struct outstanding_ipi *o = NULL; > + > + o = find_vec(vla, vec); > + > + if(o) { > + if(opt.dump_all) > + printf(" [vla] d%dv%d vec %d injecting\n", > + v->d->did, v->vid, vec); > + o->injected=1; > + } else { > + fprintf(stderr, "%s: Couldn't find an open ipi slot!\n", > + __func__); > + } > +} > + > +void hvm_vlapic_eoi_handler(struct hvm_data *h) { > + if(opt.dump_all) > + printf(" [vla] d%dv%d eoi\n", > + h->v->d->did, h->v->vid); > +} > + > +void hvm_vlapic_handler(struct hvm_data *h) > +{ > + struct mmio_info *m = &h->inflight.mmio; > + > + switch(m->gpa) { > + case 0xfee00300: > + hvm_vlapic_icr_handler(h); > + break; > + case 0xfee000b0: > + hvm_vlapic_eoi_handler(h); > + break; > + } > + > +} > + > +/* Also called by shadow_mmio_postprocess */ > +#define MMIO_VGA_START (0xa0000) > +#define MMIO_VGA_END (0xbffff) > +void enumerate_mmio(struct hvm_data *h) > +{ > + struct mmio_info *m = &h->inflight.mmio; > + > + /* Skip vga area */ > + if ( opt.mmio_enumeration_skip_vga > + && m->gpa >= MMIO_VGA_START > + && m->gpa < MMIO_VGA_END) > + { > + warn_once("WARNING: Not enumerationg MMIO in VGA range. Use --mmio-enumeration-skip-vga=0 to override.\n"); > + return; > + } > + > + if ( m->data_valid ) > + update_io_address(&h->summary.io.mmio, m->gpa, m->is_write, h->arc_cycles, m->va); > +} > + > +void hvm_mmio_summary(struct hvm_data *h, void *data) > +{ > + long reason=(long)data; > + > + PRINT_SUMMARY(h->summary.mmio[reason], > + " mmio "); > +} > + > +void hvm_mmio_assist_postprocess(struct hvm_data *h) > +{ > + long reason; > + > + switch(h->exit_reason) > + { > + case VMEXIT_NPF: > + case EXIT_REASON_EPT_VIOLATION: > + reason=NONPF_MMIO_NPF; > + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); > + break; > + case EXIT_REASON_APIC_ACCESS: > + reason=NONPF_MMIO_APIC; > + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); > + break; > + default: > + { > + static int warned = 0; > + if (!warned) > + { > + fprintf(stderr, "%s: Strange, MMIO with unexpected exit reason %d\n", > + __func__, h->exit_reason); > + warned=1; > + } > + reason=NONPF_MMIO_UNKNOWN; > + hvm_set_summary_handler(h, hvm_mmio_summary, (void *)reason); > + break; > + } > + } > + > + if(opt.summary_info) > + { > + update_summary(&h->summary.mmio[reason], > + h->arc_cycles); > + } > + > + if ( opt.with_mmio_enumeration ) > + enumerate_mmio(h); > +} > + > +#define HVM_IO_ASSIST_WRITE 0x200 > +void hvm_mmio_assist_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct mmio_info *m = &h->inflight.mmio; > + union { > + struct { > + unsigned int gpa; > + unsigned int data; > + } x32; > + struct { > + unsigned long long gpa; > + unsigned int data; > + } x64; > + } *r = (typeof(r))h->d; > + > + union { > + unsigned event; > + struct { > + unsigned minor:8, > + x64:1, > + write:2; > + }; > + } mevt = { .event = ri->event }; > + > + if(mevt.x64) { > + m->gpa = r->x64.gpa; > + m->data = r->x64.data; > + if(ri->extra_words*(sizeof(unsigned int))==sizeof(r->x64)) > + m->data_valid=1; > + } else { > + m->gpa = r->x32.gpa; > + m->data = r->x32.data; > + if(ri->extra_words*(sizeof(unsigned int))==sizeof(r->x32)) > + m->data_valid=1; > + } > + > + m->is_write = mevt.write; > + > + if(opt.dump_all) > + { > + if(m->data_valid) > + printf("]%s mmio_assist %c gpa %llx data %x\n", > + ri->dump_header, > + mevt.write?'w':'r', > + m->gpa, m->data); > + else > + printf("]%s mmio_assist %c gpa %llx (no data)\n", ri->dump_header, > + mevt.write?'w':'r', m->gpa); > + } > + > + if((m->gpa & 0xfffff000) == 0xfee00000) > + hvm_vlapic_handler(h); > + > + /* Catch MMIOs that don't go through the shadow code; tolerate > + * failures to set (probably shadow_mmio) */ > + hvm_set_postprocess(h, hvm_mmio_assist_postprocess); > +} > + > +void hvm_inj_virq_process(struct record_info *ri, struct hvm_data *h) { > + struct { > + int vector, fake; > + } *r = (typeof(r))h->d; > + > + if(opt.dump_all) { > + printf(" %s inj_virq vec %u %s\n", > + ri->dump_header, > + r->vector, r->fake?"fake":"real"); > + } > + > + if(opt.summary_info) > + { > + int vector = r->vector; > + > + if(vector >= GUEST_INTERRUPT_MAX) > + vector = GUEST_INTERRUPT_MAX; > + h->summary.guest_interrupt[vector].count++; > + > + if(opt.interval.output == INTERVAL_DOMAIN_GUEST_INTERRUPT) > + interval_domain_guest_interrupt(h, vector); > + } > + > + /* If we're waking, make this the wake vector */ > + if(r->vector < GUEST_INTERRUPT_MAX ) { > + int vector = r->vector; > + if ( h->w2h.waking && h->w2h.vector == 0 ) { > + if(h->summary.guest_interrupt[vector].start_tsc) { > + fprintf(warn, "Strange, d%dv%d waking && wake_vector 0 but vec %d start_tsc %lld!\n", > + h->v->d->did, h->v->vid, > + vector, > + h->summary.guest_interrupt[vector].start_tsc); > + error(ERR_WARN, NULL); > + } > + if(h->w2h.interrupts) > + fprintf(warn, "Strange, waking && wake_vector 0 but interrupts_this_wait_to_halt %d!\n", > + h->w2h.interrupts); > + > + if(opt.dump_all) > + printf(" [w2h] d%dv%d Setting wake_vector %d\n", > + h->v->d->did, h->v->vid, vector); > + > + /* In svm mode, vector information is invalid */ > + if ( opt.svm_mode && r->fake ) > + h->w2h.vector = FAKE_VECTOR; > + else > + h->w2h.vector = vector; > + h->summary.guest_interrupt[vector].is_wake = 1; > + } > + > + if( h->summary.guest_interrupt[vector].start_tsc == 0 ) { > + /* Note that we want start_tsc set at the next vmentry */ > + h->summary.guest_interrupt[vector].start_tsc = 1; > + h->w2h.interrupts_wanting_tsc++; > + h->w2h.interrupts++; > + > + if(opt.dump_all) > + printf(" [w2h] d%dv%d Starting vec %d\n", > + h->v->d->did, h->v->vid, vector); > + } > + } > + > + hvm_vlapic_inject(h->v, r->vector); > +} > + > +/* I/O Handling */ > +struct io_address { > + struct io_address *next; > + unsigned int pa; > + unsigned int va; > + struct event_cycle_summary summary[2]; > +}; > + > +void update_io_address(struct io_address ** list, unsigned int pa, int dir, > + tsc_t arc_cycles, unsigned int va) { > + struct io_address *p, *q=NULL; > + > + /* Keep list in order */ > + for(p=*list; p && (p->pa != pa) && (p->pa < pa); q=p, p=p->next); > + > + /* If we didn't find it, make a new element. */ > + if(!p || (p->pa != pa)) { > + if((p=malloc(sizeof(*p)))==NULL) { > + fprintf(stderr, "malloc() failed.\n"); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(p, sizeof(*p)); > + > + p->pa=pa; > + p->va=va; > + > + /* If we stopped in the middle or at the end, add it in */ > + if(q) { > + p->next=q->next; > + q->next=p; > + } else { > + /* Otherwise, we stopped after the first element; put it at the beginning */ > + p->next = *list; > + *list = p; > + } > + } > + update_summary(&p->summary[dir], arc_cycles); > +} > + > +void hvm_io_address_summary(struct io_address *list, char * s) { > + if(!list) > + return; > + > + printf("%s\n", s); > + > + for(; list; list=list->next) { > + if ( list->va ) > + { > + PRINT_SUMMARY(list->summary[0], "%8x@%8x:[r] ", list->pa, list->va); > + PRINT_SUMMARY(list->summary[1], "%8x@%8x:[w] ", list->pa, list->va); > + } > + else > + { > + PRINT_SUMMARY(list->summary[0], "%8x:[r] ", list->pa); > + PRINT_SUMMARY(list->summary[1], "%8x:[w] ", list->pa); > + } > + } > +} > + > +void hvm_io_write_postprocess(struct hvm_data *h) > +{ > + if(opt.with_pio_enumeration) > + update_io_address(&h->summary.io.pio, h->inflight.io.port, 1, h->arc_cycles, 0); > +} > + > +void hvm_io_read_postprocess(struct hvm_data *h) > +{ > + if(opt.with_pio_enumeration) > + update_io_address(&h->summary.io.pio, h->inflight.io.port, 0, h->arc_cycles, 0); > + if(opt.scatterplot_io && h->inflight.io.port == opt.scatterplot_io_port) > + scatterplot_vs_time(h->exit_tsc, P.now - h->exit_tsc); > +} > + > +void hvm_io_assist_process(struct record_info *ri, struct hvm_data *h) > +{ > + union { > + struct { > + unsigned int port; > + unsigned int data; > + } x32; > + } *r = (typeof(r))h->d; > + > + union { > + unsigned event; > + struct { > + unsigned minor:8, > + x64:1, > + write:2; > + }; > + } mevt = { .event = ri->event }; > + > + if(mevt.x64) { > + fprintf(stderr, "FATAL: Unexpected 64-bit PIO\n"); > + error(ERR_RECORD, ri); > + return; > + } > + > + h->inflight.io.port = r->x32.port; > + h->inflight.io.val = r->x32.data; > + > + if(mevt.write) { > + h->inflight.io.is_write = 1; > + if ( hvm_set_postprocess(h, hvm_io_write_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > + } else { > + h->inflight.io.is_write = 0; > + if ( hvm_set_postprocess(h, hvm_io_read_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > + } > + > + if(opt.dump_all) > + { > + printf(" %s io %s port %x val %x\n", > + ri->dump_header, > + mevt.write?"write":"read", > + r->x32.port, > + r->x32.data); > + } > +} > + > +/* cr_write */ > +/* CR3 list */ > +void cr3_switch(unsigned long long val, struct hvm_data *h) { > + struct vcpu_data *v = h->v; > + /* Really only need absolute tsc here. Later change to global time. */ > + unsigned long long now = P.now; > + unsigned long long gmfn = val >> 12; > + > + if ( !h->init ) > + return; > + > + if(opt.with_cr3_enumeration) { > + if(v->cr3.data) { > + struct cr3_value_struct *cur = v->cr3.data; > + unsigned long long cycles = now - v->cr3.start_time; > + > + if(opt.summary_info) > + update_cycles(&cur->total_time, cycles); > + > + cur->last_time = now; > + } > + > + if(gmfn) { > + struct cr3_value_struct *p, **last=&v->d->cr3_value_head; > + > + /* Always add to tail, so that we get consistent interval > + ouptut as the number of cr3s grow */ > + for(p=*last; p; last = (&p->next), p=p->next) > + if(p->gmfn == gmfn) > + break; > + > + if(!p) { > + if((p=malloc(sizeof(*p)))==NULL) { > + fprintf(stderr, "malloc() failed.\n"); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(p, sizeof(*p)); > + > + p->gmfn = gmfn; > + p->cr3_id = P.cr3.id; > + p->first_time = now; > + > + p->next=*last; > + *last=p; > + > + p->gnext = NULL; > + if(P.cr3.head) > + *P.cr3.tail = p; > + else > + P.cr3.head = p; > + P.cr3.tail = &p->gnext; > + > + P.cr3.id++; > + > + /* Add to the interval list if appropriate */ > + if(opt.interval.check == INTERVAL_CHECK_CR3 > + && v->d->did != DEFAULT_DOMAIN) > + interval_cr3_value_check(p); > + } > + > + if(p->prealloc_unpin.now) { > + fprintf(warn, "Re-promoting previously unpinned cr3 %llx!\n", > + p->gmfn); > + p->prealloc_unpin.now = 0; > + h->inflight.cr_write.repromote = 1; > + } > + > + /* Accounting for new toplevel */ > + v->cr3.start_time = now; > + p->switch_count++; > + if(p->destroy.callback) > + p->destroy.switch_count++; > + v->cr3.data = p; > + } else { > + v->cr3.data = NULL; > + } > + > + if (opt.scatterplot_cr3_switch) { > + scatterplot_vs_time(h->exit_tsc, > + v->cr3.data ? (v->cr3.data->cr3_id) : 0); > + } > + } else { > + if (opt.scatterplot_cr3_switch) > + scatterplot_vs_time(h->exit_tsc, gmfn); > + } > + > + v->cr3.val = val; > +}; > + > +void cr3_prealloc_unpin(struct vcpu_data *v, unsigned long long gmfn) { > + struct cr3_value_struct *cr3; > + > + /* Look for it in the list */ > + for(cr3 = v->d->cr3_value_head; cr3; cr3=cr3->next) > + if(cr3->gmfn == gmfn) > + break; > + > + if(!cr3) > + return; > + > + if(cr3->prealloc_unpin.now) > + fprintf(warn, "Strange, gmfn %llx multiple unpins w/o access!\n", > + gmfn); > + > + cr3->prealloc_unpin.now = 1; > + cr3->prealloc_unpin.count++; > + > + if(opt.dump_all) > + printf(" cr3 %llx unpinned %d times\n", > + gmfn, cr3->prealloc_unpin.count); > +} > + > +void cr3_dump_list(struct cr3_value_struct *head){ > + struct cr3_value_struct *p; > + struct cr3_value_struct **qsort_array; > + int i, N=0; > + > + int cr3_compare_total(const void *_a, const void *_b) { > + struct cr3_value_struct *a=*(typeof(&a))_a; > + struct cr3_value_struct *b=*(typeof(&a))_b; > + > + if(a->total_time.cycles < b->total_time.cycles) > + return 1; > + else if(b->total_time.cycles == a->total_time.cycles) { > + if(a->total_time.count < b->total_time.count) > + return 1; > + else if(a->total_time.count == b->total_time.count) > + return 0; > + else > + return -1; > + } else > + return -1; > + } > + > + int cr3_compare_start(const void *_a, const void *_b) { > + struct cr3_value_struct *a=*(typeof(&a))_a; > + struct cr3_value_struct *b=*(typeof(&a))_b; > + > + if(a->first_time > b->first_time) > + return 1; > + else if(b->first_time == a->first_time) > + return 0; > + else > + return -1; > + } > + > + if(!head) > + return; > + > + /* Count the number of elements */ > + for(p=head; p; p=p->next) > + N++; > + > + if(!N) > + return; > + > + /* Alloc a struct of the right size */ > + qsort_array = malloc(N * sizeof(struct eip_list_struct *)); > + > + /* Point the array into it */ > + for(i=0, p=head; p; p=p->next, i++) > + qsort_array[i]=p; > + > + /* Sort the array by time */ > + qsort(qsort_array, N, sizeof(struct eip_list_struct *), > + cr3_compare_start); > + > + /* WARNING: don't use N after this point unless you copy this variable */ > +#if 0 > + if(opt.summary_eip_limit && opt.summary_eip_limit < N) > + N=opt.summary_eip_limit; > +#endif > + > + /* Now print the results */ > + printf(" cr3 values:\n"); > + for(i=0; i<N; i++) { > + char desc[30]; > + struct time_struct first, last; > + > + p = qsort_array[i]; > + > + abs_cycles_to_time(p->first_time, &first); > + abs_cycles_to_time(p->last_time, &last); > + > + > + snprintf(desc, 30, " %8llx (id %d)", p->gmfn, p->cr3_id); > + print_cycle_summary(&p->total_time, desc); > + snprintf(desc, 30, " guest"); > + print_cycle_percent_summary(&p->guest_time, p->run_time, desc); > + snprintf(desc, 30, " hv "); > + print_cycle_percent_summary(&p->hv_time, p->run_time, desc); > + > + hvm_short_summary(&p->hvm, p->run_time, " + "); > + printf(" Seen: %4u.%09u-%4u.%09u switch %d flush %d\n", > + first.s, first.ns, > + last.s, last.ns, > + p->switch_count, p->flush_count); > + if(p->destroy.callback) > + printf(" destroy: flush %u switch %u fixup %u emulate %u\n", > + p->destroy.flush_count, > + p->destroy.switch_count, > + p->destroy.fixup_user, > + p->destroy.emulate_corr_user); > + } > + > + free(qsort_array); > +} > + > +void hvm_cr3_write_summary(struct hvm_data *h) { > + int j; > + > + for(j=0; j<RESYNCS_MAX; j++) > + PRINT_SUMMARY(h->summary.cr3_write_resyncs[j], > + " *[%3d] ", j); > + PRINT_SUMMARY(h->summary.cr3_write_resyncs[j], > + " *[MAX] "); > +} > + > +void hvm_cr_write_summary(struct hvm_data *h, void *data) > +{ > + long cr=(long)data; > + > + PRINT_SUMMARY(h->summary.cr_write[cr], > + " cr%ld ", cr); > + if ( cr==3 ) > + hvm_cr3_write_summary(h); > +} > + > +void hvm_cr_write_postprocess(struct hvm_data *h) > +{ > + if(h->inflight.cr_write.cr == 3) { > + struct vcpu_data *v = h->v; > + unsigned long long new_val = h->inflight.cr_write.val; > + unsigned long long oval; > + int flush=0; > + > + if(v->cr3.val) { > + oval = v->cr3.val; > + > + if(new_val == oval) { > + if(v->cr3.data) { > + v->cr3.data->flush_count++; > + if(v->cr3.data->destroy.callback) > + v->cr3.data->destroy.flush_count++; > + } > + flush=1; > + } > + } > + > + if(opt.summary_info) { > + int resyncs = h->resyncs; > + > + if(resyncs > RESYNCS_MAX) > + resyncs = RESYNCS_MAX; > + > + update_summary(&h->summary.cr3_write_resyncs[resyncs], > + h->arc_cycles); > + > + update_summary(&h->summary.cr_write[3], > + h->arc_cycles); > + > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_CR3); > + } > + > + if(!flush) > + cr3_switch(new_val, h); > + } else { > + if(opt.summary_info) > + { > + if(h->inflight.cr_write.cr < CR_MAX) > + update_summary(&h->summary.cr_write[h->inflight.cr_write.cr], > + h->arc_cycles); > + > + } > + } > + > + /* Set summary handler */ > + /* FIXME - deal with cr_read_summary */ > + if(h->exit_reason < h->exit_reason_max) > + { > + /* Want a different "set" for each cr */ > + switch(h->inflight.cr_write.cr) > + { > +#define case_cr(_x) \ > + case (_x): \ > + hvm_set_summary_handler(h, hvm_cr_write_summary, (void *)(_x)); \ > + break > + case_cr(0); > + case_cr(1); > + case_cr(2); > + case_cr(3); > + case_cr(4); > + case_cr(5); > + case_cr(6); > + case_cr(7); > + case_cr(8); > + case_cr(9); > + case_cr(10); > + case_cr(11); > + case_cr(12); > + case_cr(13); > + case_cr(14); > + case_cr(15); > +#undef case_cr > + default: > + fprintf(stderr, "Unexpected cr: %d\n", h->inflight.cr_write.cr); > + error(ERR_SANITY, NULL); > + break; > + } > + } > +} > + > +void hvm_cr_write_process(struct record_info *ri, struct hvm_data *h) > +{ > + union { > + struct { > + unsigned cr; > + unsigned int val; > + } x32; > + struct { > + unsigned cr; > + unsigned long long val; > + } __attribute__((packed)) x64; > + } *r = (typeof(r))h->d; > + unsigned cr; > + unsigned long long val; > + > + if(ri->event & TRC_64_FLAG) { > + h->inflight.cr_write.cr = cr = r->x64.cr; > + h->inflight.cr_write.val = val = r->x64.val; > + } else { > + h->inflight.cr_write.cr = cr = r->x32.cr; > + h->inflight.cr_write.val = val = r->x32.val; > + } > + > + /* In vmx, in real mode, cr accesses may cause EXNMI vmexits. > + * Account them under that heading; otherwise, complain */ > + if ( hvm_set_postprocess(h, hvm_cr_write_postprocess) ) > + fprintf(warn, "%s: Strange, h->postprocess already set!\n", > + __func__); > + > + if(opt.dump_all) > + { > + if(cr == 3 && h->v->cr3.val) { > + printf("]%s cr_write cr3 val %llx oval %llx %s\n", > + ri->dump_header, > + val, > + h->v->cr3.val, > + (h->v->cr3.val == val)?"flush":"switch"); > + } else { > + printf(" %s cr_write cr%d val %llx\n", > + ri->dump_header, > + cr, val); > + > + } > + } > + > +} > + > +/* msr_write */ > +void hvm_msr_write_summary(struct hvm_data *h, void *d) > +{ > +} > + > +void hvm_msr_write_postprocess(struct hvm_data *h) > +{ > + if(opt.summary_info) { > + } > + > + /* Set summary handler */ > + hvm_set_summary_handler(h, hvm_msr_write_summary, NULL); > +} > + > +void hvm_msr_write_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned int addr; > + unsigned long long val; > + } __attribute__((packed)) *r = (typeof(r))h->d; > + > + if(check_extra_words(ri, sizeof(*r), "msr_write")) > + return; > + > + h->inflight.msr.addr = r->addr; > + h->inflight.msr.val = r->val; > + > + if(opt.dump_all) > + { > + printf(" %s msr_write addr %x val %llx\n", > + ri->dump_header, > + r->addr, r->val); > + } > + > + if ( hvm_set_postprocess(h, hvm_msr_write_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +/* msr_read */ > +void hvm_msr_read_summary(struct hvm_data *h, void *d) > +{ > +} > + > +void hvm_msr_read_postprocess(struct hvm_data *h) > +{ > + if(opt.summary_info) { > + } > + > + /* Set summary handler */ > + hvm_set_summary_handler(h, hvm_msr_read_summary, NULL); > +} > + > +void hvm_msr_read_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned int addr; > + unsigned long long val; > + } __attribute__((packed)) *r = (typeof(r))h->d; > + > + if(check_extra_words(ri, sizeof(*r), "msr_read")) > + return; > + > + h->inflight.msr.addr = r->addr; > + h->inflight.msr.val = r->val; > + > + if(opt.dump_all) > + { > + printf(" %s msr_read addr %x val %llx\n", > + ri->dump_header, > + r->addr, r->val); > + } > + > + if ( hvm_set_postprocess(h, hvm_msr_read_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void hvm_vmcall_summary(struct hvm_data *h, void *d) > +{ > + int i; > + > + for ( i=0; i<HYPERCALL_MAX ; i++) > + { > + PRINT_SUMMARY(h->summary.vmcall[i], > + " [%10s] ", hypercall_name[i]); > + } > + PRINT_SUMMARY(h->summary.vmcall[HYPERCALL_MAX], > + " [%10s] ", "max"); > +} > + > +void hvm_vmcall_postprocess(struct hvm_data *h) > +{ > + unsigned eax = h->inflight.vmcall.eax ; > + > + if(opt.summary) > + { > + if ( eax < HYPERCALL_MAX ) > + update_summary(&h->summary.vmcall[eax], > + h->arc_cycles); > + else > + update_summary(&h->summary.vmcall[HYPERCALL_MAX], > + h->arc_cycles); > + hvm_set_summary_handler(h, hvm_vmcall_summary, NULL); > + } > +} > + > +void hvm_vmcall_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned int eax; > + } *r = (typeof(r))h->d; > + > + if(opt.dump_all) { > + if(r->eax < HYPERCALL_MAX) > + printf(" %s vmcall %2x (%s)\n", > + ri->dump_header, > + r->eax, > + hypercall_name[r->eax]); > + else > + printf(" %s vmcall %2x\n", > + ri->dump_header, > + r->eax); > + } > + > + h->inflight.vmcall.eax = r->eax; > + > + if ( hvm_set_postprocess(h, hvm_vmcall_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void hvm_inj_exc_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned vec, ec; > + } *r = (typeof(r))h->d; > + > + if ( opt.dump_all ) > + { > + if(r->vec < HVM_TRAP_MAX) > + printf(" %3u.%09u %s inj_exc trap %s ec %x\n", > + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), > + hvm_trap_name[r->vec], r->ec); > + else > + printf(" %3u.%09u %s inj_exc trap %u ec %x\n", > + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), > + r->vec, r->ec); > + } > + > +} > + > +void hvm_intr_summary(struct hvm_data *h, void *d) > +{ > + int i; > + > + for(i=0; i<EXTERNAL_INTERRUPT_MAX; i++) > + if(h->summary.extint[i]) > + { > + if(hvm_extint_vector_name[i]) > + printf(" %10s(%3d): %d\n", > + hvm_extint_vector_name[i], > + i, > + h->summary.extint[i]); > + else > + printf(" [%3d]: %d\n", > + i, > + h->summary.extint[i]); > + } > + if(h->summary.extint[EXTERNAL_INTERRUPT_MAX]) > + printf(" Other: : %d\n", > + h->summary.extint[EXTERNAL_INTERRUPT_MAX]); > +} > + > + > +void hvm_intr_process(struct record_info *ri, struct hvm_data *h) > +{ > + unsigned vec = *(unsigned *)h->d; > + > + /* Vector is difficult to get in SVM mode */ > + if ( opt.svm_mode ) > + vec = 0; > + > + if( (h->rip >> ADDR_SPACE_BITS) != 00 > + && (h->rip >> ADDR_SPACE_BITS) != ((0ULL-1)>> ADDR_SPACE_BITS) ) { > + fprintf(stderr, "Unexpected rip %llx (shift %llx)\n", > + h->rip, > + h->rip >> ADDR_SPACE_BITS); > + error(ERR_RECORD, NULL); > + /* Can process with strange rip */ > + } > + > + h->inflight.intr.vec = vec; > + > + if ( opt.dump_all ) > + { > + if ( vec < EXTERNAL_INTERRUPT_MAX && > + hvm_extint_vector_name[vec] ) > + printf(" %s intr vec %s(%x)\n", > + ri->dump_header, > + hvm_extint_vector_name[vec], > + vec); > + else > + printf(" %s intr vec %x\n", > + ri->dump_header, vec); > + } > + > + if(opt.scatterplot_interrupt_eip > + && vec == opt.scatterplot_interrupt_vector) > + { > + struct time_struct t; > + /* Truncate to 40 bits */ > + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); > + > + /* Want absolute tsc to global tsc */ > + abs_cycles_to_time(h->exit_tsc, &t); > + printf("d%dv%d %u.%09u %lld\n", > + h->v->d->did, h->v->vid, > + t.s, t.ns, > + rip); > + } > + > + if(opt.histogram_interrupt_eip > + && vec == opt.histogram_interrupt_vector) > + { > + /* Truncate to 40 bits */ > + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); > + unsigned index = rip / opt.histogram_interrupt_increment; > + > + h->summary.extint_histogram[index]++; > + } > + > + if(opt.with_interrupt_eip_enumeration > + && vec == opt.interrupt_eip_enumeration_vector) > + { > + /* Truncate to 40 bits */ > + unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); > + > + /* Want absolute tsc to global tsc */ > + update_eip(&h->v->d->interrupt_eip_list, rip, 0, 0, NULL); > + } > + > + /* Disable generic postprocessing */ > + /* FIXME: Do the summary stuff in a post-processor */ > + h->post_process = NULL; > + > + if(opt.summary_info) { > + if(opt.summary) > + hvm_set_summary_handler(h, hvm_intr_summary, NULL); > + > + if(vec < EXTERNAL_INTERRUPT_MAX) > + h->summary.extint[vec]++; > + else > + h->summary.extint[EXTERNAL_INTERRUPT_MAX]++; > + } > +} > + > + > +void hvm_intr_window_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + uint32_t vector; > + uint32_t source; > + int32_t intr; > + } *r = (typeof(r))h->d; > + > + char *intsrc_name[] = { > + "none", > + "pic", > + "lapic", > + "nmi", > + "mce", > + "vector" > + }; > + > + if ( opt.dump_all ) > + { > + printf(" %s intr_window vec %u src %u(%s) ", > + ri->dump_header, > + (unsigned)r->vector, > + (unsigned)r->source, > + r->source < 6 ? intsrc_name[r->source]: "?"); > + > + if ( r->intr > 0 ) > + printf("intr %x\n", > + (unsigned)r->intr); > + else > + printf("intr #\n"); > + } > +} > + > +void hvm_pf_inject_process(struct record_info *ri, struct hvm_data *h) > +{ > + union { > + struct { > + unsigned ec; > + unsigned int cr2; > + } x32; > + struct { > + unsigned ec; > + unsigned long long cr2; > + } __attribute__((packed)) x64; > + } *r = (typeof(r))h->d; > + unsigned int ec; > + unsigned long long cr2; > + int is_64 = 0; > + > + if(ri->event & TRC_64_FLAG) { > + is_64 = 1; > + cr2 = r->x64.cr2; > + ec = r->x64.ec; > + } else { > + cr2 = r->x32.cr2; > + ec = r->x32.ec; > + } > + > + if ( opt.dump_all ) > + { > + printf(" %3u.%09u %s pf_inject%s guest_cr2 %llx guest_ec %x\n", > + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), > + is_64?"64":"", > + cr2, ec); > + } > +} > + > +void hvm_generic_postprocess_init(struct record_info *ri, struct hvm_data *h); > + > +void hvm_npf_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + uint64_t gpa; > + uint64_t mfn; > + uint32_t qualification; > + uint32_t p2mt; > + } *r = (typeof(r))h->d; > + > + if ( opt.dump_all ) > + printf(" %s npf gpa %llx q %x mfn %llx t %d\n", > + ri->dump_header, > + (unsigned long long)r->gpa, r->qualification, > + (unsigned long long)r->mfn, r->p2mt); > + > + if ( opt.summary_info ) > + hvm_generic_postprocess_init(ri, h); > +} > + > +void hvm_rdtsc_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned long long tsc; > + } *r = (typeof(r))h->d; > + > + if ( opt.dump_all ) > + printf(" %s rdtsc %llx %lld %s\n", > + ri->dump_header, > + (unsigned long long)r->tsc, > + (unsigned long long)r->tsc, > + h->last_rdtsc > r->tsc ? "BACKWARDS" : ""); > + > + if ( opt.scatterplot_rdtsc ) > + { > + struct time_struct t; > + > + abs_cycles_to_time(ri->tsc, &t); > + > + printf("%dv%d %u.%09u %llu\n", > + h->v->d->did, h->v->vid, > + t.s, t.ns, > + r->tsc); > + } > + > + h->last_rdtsc = r->tsc; > +} > + > +void hvm_generic_summary(struct hvm_data *h, void *data) > +{ > + long evt = (long)data; > + > + assert(evt < HVM_EVENT_HANDLER_MAX); > + > + PRINT_SUMMARY(h->summary.generic[evt], > + " %s ", hvm_event_handler_name[evt]); > + > +} > + > +void hvm_generic_postprocess_init(struct record_info *ri, struct hvm_data *h) > +{ > + if ( h->post_process != hvm_generic_postprocess ) > + fprintf(warn, "%s: Strange, h->postprocess set!\n", > + __func__); > + h->inflight.generic.event = ri->event; > + bcopy(h->d, h->inflight.generic.d, sizeof(unsigned int) * 4); > +} > + > +void hvm_generic_postprocess(struct hvm_data *h) > +{ > + long evt = 0; > + static unsigned registered[HVM_EVENT_HANDLER_MAX] = { 0 }; > + > + if ( h->inflight.generic.event ) > + evt = (h->inflight.generic.event - TRC_HVM_HANDLER) > + & ~(TRC_64_FLAG|HVM_IO_ASSIST_WRITE); > + else { > + static unsigned warned[HVM_EXIT_REASON_MAX] = { 0 }; > + /* Some exits we don't expect a handler; just return */ > + if(opt.svm_mode) > + { > + } > + else > + { > + switch(h->exit_reason) > + { > + /* These just need us to go through the return path */ > + case EXIT_REASON_PENDING_INTERRUPT: > + case EXIT_REASON_TPR_BELOW_THRESHOLD: > + /* Not much to log now; may need later */ > + case EXIT_REASON_WBINVD: > + return; > + default: > + break; > + } > + } > + if ( !warned[h->exit_reason] ) > + { > + /* If we aren't a known exception, warn and log results */ > + fprintf(warn, "%s: Strange, exit %x(%s) missing a handler\n", > + __func__, h->exit_reason, > + (h->exit_reason > h->exit_reason_max) > + ? "[clipped]" > + : h->exit_reason_name[h->exit_reason]); > + warned[h->exit_reason]=1; > + } > + } > + > + if ( evt >= HVM_EVENT_HANDLER_MAX || evt < 0) > + { > + fprintf(warn, "%s: invalid hvm event %lx(%x)\n", > + __func__, evt, h->inflight.generic.event); > + error(ERR_RECORD, NULL); > + return; > + } > + > + if(opt.summary_info) { > + update_summary(&h->summary.generic[evt], > + h->arc_cycles); > + > + /* NB that h->exit_reason may be 0, so we offset by 1 */ > + if ( registered[evt] ) > + { > + static unsigned warned[HVM_EXIT_REASON_MAX] = { 0 }; > + if ( registered[evt] != h->exit_reason+1 && !warned[h->exit_reason]) > + { > + fprintf(warn, "%s: HVM evt %lx in %x and %x!\n", > + __func__, evt, registered[evt]-1, h->exit_reason); > + warned[h->exit_reason]=1; > + } > + } > + else > + { > + int ret; > + if((ret=__hvm_set_summary_handler(h, hvm_generic_summary, (void *)evt))) > + fprintf(stderr, "%s: hvm_set_summary_handler returned %d\n", > + __func__, ret); > + registered[evt]=h->exit_reason+1; > + } > + /* HLT checked at hvm_vmexit_close() */ > + } > +} > + > +void hvm_generic_dump(struct record_info *ri, char * prefix) > +{ > + struct { > + unsigned vcpu:16, domain:16; > + unsigned d[4]; > + } *cr = (typeof(cr))ri->d; > + > + char *evt_string, evt_number[256]; > + int i, evt, is_64 = 0; > + > + evt = ri->event - TRC_HVM_HANDLER; > + > + if(evt & TRC_64_FLAG) { > + evt &= ~(TRC_64_FLAG); > + is_64=1; > + } > + > + if(evt < HVM_EVENT_HANDLER_MAX) > + { > + evt_string = hvm_event_handler_name[evt]; > + } > + else > + { > + snprintf(evt_number, 256, "hvm_handler %d", evt); > + evt_string = evt_number; > + } > + > + printf("%s%s %s%s [", > + prefix, > + ri->dump_header, > + evt_string, > + is_64?"64":""); > + > + for(i=0; i<ri->extra_words; i++) { > + printf(" %x", ri->d[i]); > + } > + > + printf(" ]\n"); > +} > + > +void hvm_handler_process(struct record_info *ri, struct hvm_data *h) { > + /* Wait for first vmexit to initialize */ > + if(!h->init) > + { > + if(opt.dump_all) > + hvm_generic_dump(ri,"!"); > + return; > + } > + > + h->d = ri->d; > + > + /* Handle things that don't need a vmexit */ > + switch(ri->event) { > + default: > + goto needs_vmexit; > + /* Records about changing guest state */ > + case TRC_HVM_PF_INJECT: > + case TRC_HVM_PF_INJECT64: > + hvm_pf_inject_process(ri, h); > + break; > + case TRC_HVM_REINJ_VIRQ: > + if ( opt.dump_all ) > + { > + printf(" %3u.%09u %s inj_virq vec %u\n", > + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), > + *(unsigned*)h->d); > + } > + break; > + case TRC_HVM_INJ_EXC: > + hvm_inj_exc_process(ri, h); > + break; > + case TRC_HVM_INJ_VIRQ: > + hvm_inj_virq_process(ri, h); > + break; > + case TRC_HVM_INTR_WINDOW: > + hvm_intr_window_process(ri, h); > + break; > + case TRC_HVM_OP_DESTROY_PROC: > + if(h->v->cr3.data) { > + struct cr3_value_struct *cur = h->v->cr3.data; > + if(cur->destroy.callback) > + fprintf(warn, "Strange, double callback for cr3 gmfn %llx!\n", > + cur->gmfn); > + cur->destroy.callback = 1; > + } else if(opt.with_cr3_enumeration) { > + fprintf(warn, "Warning: destroy_proc: don't know current cr3\n"); > + } > + if ( opt.dump_all ) > + { > + printf(" %3u.%09u %s destroy_proc cur_cr3 %llx\n", > + ri->t.s, ri->t.ns, pcpu_string(ri->cpu), h->v->cr3.val); > + } > + break; > + } > + > + return; > + > +needs_vmexit: > + /* Wait for the next vmexit */ > + if(!h->vmexit_valid) > + { > + if(opt.dump_all) > + hvm_generic_dump(ri,"!"); > + return; > + } > + > + /* Keep generic "event handler" info */ > + h->event_handler = ri->event - TRC_HVM_HANDLER; > + > + switch(ri->event) { > + /* Records adding to the vmexit reason */ > + case TRC_HVM_INTR: > + hvm_intr_process(ri, h); > + break; > + case TRC_HVM_PF_XEN: > + case TRC_HVM_PF_XEN64: > + hvm_pf_xen_process(ri, h); > + break; > + case TRC_HVM_IOPORT_READ: > + case TRC_HVM_IOPORT_WRITE: > + hvm_io_assist_process(ri, h); > + break; > + case TRC_HVM_IOMEM_READ: > + case TRC_HVM_IOMEM_WRITE: > + case TRC_HVM_IOMEM_READ|TRC_64_FLAG: > + case TRC_HVM_IOMEM_WRITE|TRC_64_FLAG: > + hvm_mmio_assist_process(ri, h); > + break; > + case TRC_HVM_CR_WRITE: > + case TRC_HVM_CR_WRITE64: > + hvm_cr_write_process(ri, h); > + break; > + case TRC_HVM_MSR_WRITE: > + hvm_msr_write_process(ri, h); > + break; > + case TRC_HVM_MSR_READ: > + hvm_msr_read_process(ri, h); > + break; > + case TRC_HVM_VMMCALL: > + hvm_vmcall_process(ri, h); > + break; > + case TRC_HVM_NPF: > + hvm_npf_process(ri, h); > + break; > + case TRC_HVM_RDTSC: > + hvm_rdtsc_process(ri, h); > + break; > + case TRC_HVM_DR_READ: > + case TRC_HVM_DR_WRITE: > + case TRC_HVM_CPUID: > + case TRC_HVM_SMI: > + case TRC_HVM_HLT: > + case TRC_HVM_INVLPG: > + case TRC_HVM_INVLPG64: > + case TRC_HVM_MCE: > + case TRC_HVM_CLTS: > + case TRC_HVM_LMSW: > + case TRC_HVM_LMSW64: > + case TRC_HVM_NMI: > + case TRC_HVM_REALMODE_EMULATE: > + case TRC_HVM_TRAP: > + case TRC_HVM_TRAP_DEBUG: > + case TRC_HVM_CR_READ: > + case TRC_HVM_CR_READ64: > + default: > + if(opt.dump_all) > + hvm_generic_dump(ri, "]"); > + if(opt.summary_info) > + hvm_generic_postprocess_init(ri, h); > + break; > + } > +} > + > +void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc); > +void vcpu_prev_update(struct pcpu_info *p, struct vcpu_data *prev, > + tsc_t tsc, int new_runstate); > +struct vcpu_data * vcpu_find(int did, int vid); > +void lose_vcpu(struct vcpu_data *v, tsc_t tsc); > + > +int domain_runstate(struct domain_data *d) { > + int i; > + int runstates[RUNSTATE_MAX]; > + int ret=-1; > + int max_vcpus = 0; > + > + if(d->did == DEFAULT_DOMAIN) > + return 0; > + > + for(i=0; i<RUNSTATE_MAX; i++) > + runstates[i]=0; > + > + for(i=0; i<=d->max_vid; i++) > + if(d->vcpu[i] && d->vcpu[i]->runstate.state != RUNSTATE_INIT) { > + max_vcpus++; > + runstates[d->vcpu[i]->runstate.state]++; > + } > + > + if(runstates[RUNSTATE_LOST] == max_vcpus) > + ret=DOMAIN_RUNSTATE_LOST; > + else if(runstates[RUNSTATE_RUNNING]) > + { > + if(runstates[RUNSTATE_RUNNABLE]) > + ret=DOMAIN_RUNSTATE_CONCURRENCY_HAZARD; > + else if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) > + ret= DOMAIN_RUNSTATE_PARTIAL_RUN; > + else > + ret= DOMAIN_RUNSTATE_FULL_RUN; > + } > + else if(runstates[RUNSTATE_RUNNABLE]) > + { > + if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) > + ret= DOMAIN_RUNSTATE_PARTIAL_CONTENTION; > + else > + ret= DOMAIN_RUNSTATE_FULL_CONTENTION; > + } > + else if(runstates[RUNSTATE_BLOCKED]||runstates[RUNSTATE_OFFLINE]) > + { > + ret= DOMAIN_RUNSTATE_BLOCKED; > + } else { > + fprintf(warn, "Strange, no meaningful runstates for d%d!\n", > + d->did); > + } > + > + if ( ret < 0 ) > + { > + printf(" Max vid: %d (max_vcpus %d)\n", d->max_vid, max_vcpus); > + for(i=0; i<=d->max_vid; i++) > + if(d->vcpu[i]) > + fprintf(warn, " v%d: %s\n", > + i, runstate_name[d->vcpu[i]->runstate.state]); > + > + for(i=0; i<RUNSTATE_MAX; i++) > + fprintf(warn, " %s: %d\n", > + runstate_name[i], runstates[i]); > + } > + > + if(ret >= 0) > + return ret; > + > + error(ERR_ASSERT, NULL); > + return -1; /* Never happens */ > +} > + > +static inline void runstate_update(struct vcpu_data *v, int new_runstate, > + tsc_t tsc) > +{ > + struct domain_data *d = v->d; > + > + if ( opt.scatterplot_runstate ) > + { > + struct time_struct t; > + > + abs_cycles_to_time(tsc, &t); > + > + printf("%dv%d %u.%09u %d\n", > + d->did, v->vid, > + t.s, t.ns, > + runstate_graph[v->runstate.state]); > + printf("%dv%d %u.%09u %d\n", > + d->did, v->vid, > + t.s, t.ns, > + runstate_graph[new_runstate]); > + } > + > + if(v->runstate.tsc > 0 && v->runstate.tsc < tsc) { > + update_cycles(v->runstates + v->runstate.state, tsc - v->runstate.tsc); > + > + if ( opt.scatterplot_runstate_time ) > + { > + struct time_struct t, dt; > + > + abs_cycles_to_time(tsc, &t); > + cycles_to_time(tsc - v->runstate.tsc, &dt); > + > + printf("%dv%d %u.%09u %u.%09u\n", > + d->did, v->vid, > + t.s, t.ns, > + dt.s, dt.ns); > + } > + > + if(v->runstate.state == RUNSTATE_RUNNING) > + update_cycles(&v->d->total_time, tsc - v->runstate.tsc); > + > + if(v->runstate.state == RUNSTATE_RUNNABLE) > + update_cycles(v->runnable_states + v->runstate.runnable_state, tsc - v->runstate.tsc); > + > + /* How much did dom0 run this buffer? */ > + if(v->d->did == 0) { > + int i; > + for(i=0; i<MAX_CPUS; i++) { > + struct pcpu_info * p = P.pcpu + i; > + tsc_t start_tsc; > + if(!p->active) > + continue; > + start_tsc = (p->volume.buffer_first_tsc > v->runstate.tsc) ? > + p->volume.buffer_first_tsc : > + v->runstate.tsc; > + p->volume.buffer_dom0_runstate_cycles[v->runstate.state] > + += tsc - start_tsc; > +#if 0 > + printf(" - updated p%d dom0_runstate %s to %lld cycles (+%lld)\n", > + p->pid, runstate_name[v->runstate.state], > + p->volume.buffer_dom0_runstate_cycles[v->runstate.state], > + tsc - start_tsc); > +#endif > + p->volume.buffer_dom0_runstate = new_runstate; > + p->volume.buffer_dom0_runstate_tsc = tsc; > + } > + } > + } > + > + /* Detect "runnable" states */ > + if ( new_runstate == RUNSTATE_RUNNABLE ) > + { > + switch(v->runstate.state) > + { > + case RUNSTATE_RUNNING: > + v->runstate.runnable_state=RUNNABLE_STATE_PREEMPT; > + break; > + case RUNSTATE_BLOCKED: > + case RUNSTATE_OFFLINE: > + v->runstate.runnable_state=RUNNABLE_STATE_WAKE; > + break; > + default: > + v->runstate.runnable_state=RUNNABLE_STATE_OTHER; > + break; > + } > + } else > + v->runstate.runnable_state=RUNNABLE_STATE_INVALID; > + > + v->runstate.state = new_runstate; > + v->runstate.tsc = tsc; > + > + /* Determine the domain runstate */ > + if(d->runstate_tsc > 0 && d->runstate_tsc < tsc) > + update_cycles(d->runstates + d->runstate, tsc - d->runstate_tsc); > + > + d->runstate = domain_runstate(d); > + > + d->runstate_tsc = tsc; > +} > + > +void hvm_vmexit_process(struct record_info *ri, struct hvm_data *h, > + struct vcpu_data *v) { > + struct { > + union { > + struct { > + unsigned int exit_reason; > + unsigned long long rip; > + } __attribute__((packed)) x64; > + struct { > + unsigned int exit_reason; > + unsigned int eip; > + } x32; > + }; > + } *r; > + > + if ( ri->event & TRC_64_FLAG ) > + { > + if (check_extra_words(ri, sizeof(r->x64), "vmexit")) > + return; > + } > + else > + { > + if (check_extra_words(ri, sizeof(r->x32), "vmexit")) > + return; > + } > + > + r = (typeof(r))ri->d; > + > + if(!h->init) > + init_hvm_data(h, v); > + > + h->vmexit_valid=1; > + bzero(&h->inflight, sizeof(h->inflight)); > + > + if(ri->event == TRC_HVM_VMEXIT64) { > + if(v->guest_paging_levels != 4) > + { > + if ( verbosity >= 6 ) > + fprintf(warn, "%s: VMEXIT64, but guest_paging_levels %d. Switching to 4.\n", > + __func__, v->guest_paging_levels); > + v->guest_paging_levels = 4; > + } > + if(!is_valid_addr64(r->x64.rip)) > + fprintf(warn, "%s: invalid va %llx\n", > + __func__, r->x64.rip); > + h->rip = r->x64.rip; > + h->exit_reason = r->x64.exit_reason; > + } else { > + if(v->guest_paging_levels == 4) > + { > + int new_paging_levels = opt.default_guest_paging_levels; > + > + if(new_paging_levels == 4) > + new_paging_levels = 2; /* Wild guess */ > + > + if ( verbosity >= 6 ) > + fprintf(warn, "%s: VMEXIT, but guest_paging_levels %d. Switching to %d(default).\n", > + __func__, v->guest_paging_levels, new_paging_levels); > + > + v->guest_paging_levels = new_paging_levels; > + } > + h->rip = r->x32.eip; > + h->exit_reason = r->x32.exit_reason; > + } > + > + if(opt.scatterplot_vmexit_eip) > + scatterplot_vs_time(ri->tsc, h->rip); > + > + if(h->exit_reason > h->exit_reason_max) > + { > + fprintf(warn, "h->exit_reason %x > exit_reason_max %x!\n", > + (unsigned int)h->exit_reason, > + (unsigned int)h->exit_reason_max); > + error(ERR_RECORD, ri); > + return; > + } > + > + if(opt.dump_all) { > + if ( h->exit_reason < h->exit_reason_max > + && h->exit_reason_name[h->exit_reason] != NULL) > + printf("]%s vmexit exit_reason %s eip %llx%s\n", > + ri->dump_header, > + h->exit_reason_name[h->exit_reason], > + h->rip, > + find_symbol(h->rip)); > + else > + printf("]%s vmexit exit_reason %x eip %llx%s\n", > + ri->dump_header, > + h->exit_reason, > + h->rip, > + find_symbol(h->rip)); > + } > + > + if(h->v->cr3.data && h->entry_tsc) { > + update_cycles(&h->v->cr3.data->guest_time, > + ri->tsc - h->entry_tsc); > + h->v->cr3.data->run_time += (ri->tsc - h->entry_tsc); > + } > + > + h->exit_tsc = ri->tsc; > + h->entry_tsc = 0; > + h->resyncs = 0; > + h->prealloc_unpin = 0; > + h->wrmap_bf = 0; > + h->short_summary_done = 0; > + > + h->post_process = hvm_generic_postprocess; > + h->inflight.generic.event = 0; > +} > + > +void hvm_close_vmexit(struct hvm_data *h, tsc_t tsc) { > + > + if(h->exit_tsc) { > + if(h->exit_tsc > tsc) > + h->arc_cycles = 0; > + else { > + h->arc_cycles = tsc - h->exit_tsc; > + > + if(opt.summary_info) { > + update_summary(&h->summary.exit_reason[h->exit_reason], > + h->arc_cycles); > + h->summary_info = 1; > + } > + > + if ( opt.scatterplot_extint_cycles > + && h->exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT > + && h->inflight.intr.vec == opt.scatterplot_extint_cycles_vector ) > + { > + struct time_struct t; > + > + abs_cycles_to_time(tsc, &t); > + > + printf("d%dv%d %u.%09u %lld\n", > + h->v->d->did, > + h->v->vid, > + t.s, t.ns, > + h->arc_cycles); > + } > + } > + } > + > + if(h->post_process) > + (h->post_process)(h); > + > + if(h->arc_cycles) { > + if(opt.summary_info && !h->short_summary_done) { > + switch(h->event_handler) { > + case HVM_EVENT_HANDLER_VMCALL: > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_VMCALL); > + break; > + case HVM_EVENT_HANDLER_INTR: > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_INTERRUPT); > + break; > + case HVM_EVENT_HANDLER_HLT: > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_HLT); > + break; > + default: > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_OTHER); > + break; > + } > + } > + > + > + if(h->v->cr3.data) { > + h->v->cr3.data->run_time += h->arc_cycles; > + > + if(opt.summary_info) > + update_cycles(&h->v->cr3.data->hv_time, > + h->arc_cycles); > + } > + } > + > + h->exit_tsc = 0; > + h->vmexit_valid = 0; > + h->post_process = NULL; > + > +} > + > +void hvm_vmentry_process(struct record_info *ri, struct hvm_data *h) { > + if(!h->init) > + { > + if(opt.dump_all) > + printf("!%s vmentry\n", > + ri->dump_header); > + return; > + } > + > + /* Vista bug > + * This has to be done here because irqs are injected on the path out > + * to vmexit. */ > + hvm_vlapic_vmentry_cleanup(h->v, ri->tsc); > + > + if(h->w2h.waking && opt.dump_all) > + printf(" [w2h] d%dv%d Finishing waking\n", > + h->v->d->did, h->v->vid); > + > + h->w2h.waking = 0; > + > + if ( h->w2h.interrupts_wanting_tsc ) { > + int i; > + for(i=0; i<GUEST_INTERRUPT_MAX; i++) > + { > + if ( h->summary.guest_interrupt[i].start_tsc == 1 ) > + { > + if(opt.dump_all) > + printf(" [w2h] d%dv%d Setting vec %d tsc to %lld\n", > + h->v->d->did, h->v->vid, i, ri->tsc); > + h->summary.guest_interrupt[i].start_tsc = ri->tsc; > + h->w2h.interrupts_wanting_tsc--; > + if ( h->w2h.interrupts_wanting_tsc == 0 ) > + break; > + } > + } > + } > + > + if(!h->vmexit_valid) > + { > + if(opt.dump_all) > + printf("!%s vmentry\n", > + ri->dump_header); > + return; > + } > + > + if(opt.dump_all) { > + unsigned long long arc_cycles = ri->tsc - h->exit_tsc; > + printf("]%s vmentry cycles %lld %s\n", > + ri->dump_header, arc_cycles, (arc_cycles>10000)?"!":""); > + } > + > + hvm_close_vmexit(h, ri->tsc); > + h->entry_tsc = ri->tsc; > +} > + > +void hvm_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + struct vcpu_data *v = p->current; > + struct hvm_data *h = &v->hvm; > + > + assert(p->current); > + > + if(vcpu_set_data_type(p->current, VCPU_DATA_HVM)) > + return; > + > + if(ri->evt.sub == 2) > + { > + UPDATE_VOLUME(p, hvm[HVM_VOL_HANDLER], ri->size); > + hvm_handler_process(ri, h); > + } > + else > + { > + switch(ri->event) { > + /* HVM */ > + case TRC_HVM_VMEXIT: > + case TRC_HVM_VMEXIT64: > + UPDATE_VOLUME(p, hvm[HVM_VOL_VMEXIT], ri->size); > + hvm_vmexit_process(ri, h, v); > + break; > + case TRC_HVM_VMENTRY: > + UPDATE_VOLUME(p, hvm[HVM_VOL_VMENTRY], ri->size); > + hvm_vmentry_process(ri, &p->current->hvm); > + break; > + default: > + fprintf(warn, "Unknown hvm event: %x", ri->event); > + } > + } > +} > + > +void hvm_summary(struct hvm_data *h) { > + int i; > + > + if(!h->summary_info) > + return; > + > + printf("Exit reasons:\n"); > + for(i=0; i<h->exit_reason_max; i++) { > + struct hvm_summary_handler_node *p; > + > + if ( h->exit_reason_name[i] ) > + PRINT_SUMMARY(h->summary.exit_reason[i], > + " %-20s ", h->exit_reason_name[i]); > + else > + PRINT_SUMMARY(h->summary.exit_reason[i], > + " %20d ", i); > + > + p=h->exit_reason_summary_handler_list[i]; > + while(p) > + { > + p->handler(h, p->data); > + p=p->next; > + } > + } > + > + printf("Guest interrupt counts:\n"); > + for(i=0; i<GUEST_INTERRUPT_MAX; i++) > + if(h->summary.guest_interrupt[i].count) { > + int j; > + printf(" [%3d] %d\n", > + i, h->summary.guest_interrupt[i].count); > + for(j=1; j<GUEST_INTERRUPT_CASE_MAX; j++) { > + char desc[80]; > + snprintf(desc, 80, " * %s", guest_interrupt_case_name[j]); > + print_cycle_summary(h->summary.guest_interrupt[i].runtime+j, desc); > + } > + } > + if(h->summary.guest_interrupt[i].count) > + printf(" [%d+] %d\n", > + i, h->summary.guest_interrupt[i].count); > + > + if(opt.histogram_interrupt_eip) > + { > + unsigned max = ((1ULL<<ADDR_SPACE_BITS)/opt.histogram_interrupt_increment); > + printf("Interrupt eip histogram:\n"); > + for(i=0; i<max; i++) > + if(h->summary.extint_histogram[i]) > + { > + printf("[%llx-%llx]: %d\n", > + opt.histogram_interrupt_increment * i, > + (opt.histogram_interrupt_increment * (i+1)) - 1, > + h->summary.extint_histogram[i]); > + } > + } > + > + PRINT_SUMMARY(h->summary.ipi_latency, > + "IPI latency \n"); > + for(i=0; i<256; i++) > + if(h->summary.ipi_count[i]) > + printf(" [%3d] %10d\n", > + i, h->summary.ipi_count[i]); > + hvm_io_address_summary(h->summary.io.pio, "IO address summary:"); > + hvm_io_address_summary(h->summary.io.mmio, "MMIO address summary:"); > +} > + > +/* ---- Shadow records ---- */ > +union shadow_event > +{ > + unsigned event; > + struct { > + unsigned minor:8, > + paging_levels:4; > + }; > +}; > + > +/* WARNING - not thread safe */ > +#define FLAGSTRING(_name, _char) \ > + if(e->flag_ ## _name) \ > + flagstring[i] = _char; \ > + i++; > + > +char * flag_string(struct pf_xen_extra *e) > +{ > + static char flagstring[32]; > + int i=0; > + > + for(i=0; i<32; i++) > + flagstring[i]='-'; > + > + i=0; > + > + if(e->flag_set_ad) > + flagstring[i]='d'; > + else if(e->flag_set_a) > + flagstring[i]='a'; > + i++; > + > + FLAGSTRING(shadow_l1_get_ref, 'g'); > + FLAGSTRING(shadow_l1_put_ref, 'p'); > + //FLAGSTRING(l2_propagate, '2'); > + FLAGSTRING(demote, 'D'); > + FLAGSTRING(promote, 'P'); > + FLAGSTRING(wrmap, 'w'); > + FLAGSTRING(wrmap_guess_found, 'G'); > + //FLAGSTRING(wrmap_brute_force, 'b'); > + FLAGSTRING(early_unshadow, 'e'); > + FLAGSTRING(prealloc_unhook, 'H'); > + FLAGSTRING(unsync, 'u'); > + FLAGSTRING(oos_fixup_add, 'a'); > + FLAGSTRING(oos_fixup_evict, 'x'); > + > + flagstring[i]=0; > + > + return flagstring; > +} > + > +void shadow_emulate_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if ( opt.summary_info ) > + { > + update_eip(&h->v->d->emulate_eip_list, > + h->rip, > + h->arc_cycles, > + 0, NULL); > + update_summary(&h->summary.pf_xen[PF_XEN_EMULATE], h->arc_cycles); > + update_summary(&h->summary.pf_xen_emul[e->pt_level], h->arc_cycles); > + if(h->prealloc_unpin) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PREALLOC_UNPIN], h->arc_cycles); > + if(e->flag_prealloc_unhook) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PREALLOC_UNHOOK], h->arc_cycles); > + if(e->flag_early_unshadow) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_EARLY_UNSHADOW], h->arc_cycles); > + if(e->flag_set_changed) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_CHANGED], h->arc_cycles); > + else > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_UNCHANGED], h->arc_cycles); > + if(e->flag_set_flush) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_FLUSH], h->arc_cycles); > + if(e->flag_set_error) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_SET_ERROR], h->arc_cycles); > + if(e->flag_promote) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_PROMOTE], h->arc_cycles); > + if(e->flag_demote) > + update_summary(&h->summary.pf_xen_emul[PF_XEN_EMUL_DEMOTE], h->arc_cycles); > + /* more summary info */ > + > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_EMULATE); > + } > + > + if(opt.scatterplot_unpin_promote) { > + if(e->flag_early_unshadow) > + scatterplot_vs_time(h->exit_tsc, -10); > + if(h->prealloc_unpin) > + scatterplot_vs_time(h->exit_tsc, 0); > + if(e->flag_promote) { > + if(opt.with_cr3_enumeration) { > + if(h->v->cr3.data) > + scatterplot_vs_time(h->exit_tsc, h->v->cr3.data->cr3_id); > + } else > + scatterplot_vs_time(h->exit_tsc, 2); > + } > + } > + > + > +} > + > +void shadow_emulate_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + union { > + /* for PAE, guest_l1e may be 64 while guest_va may be 32; > + so put it first for alignment sake. */ > + struct { > + unsigned gl1e, write_val; > + unsigned va; > + unsigned flags:29, emulation_count:3; > + } gpl2; > + struct { > + unsigned long long gl1e, write_val; > + unsigned va; > + unsigned flags:29, emulation_count:3; > + } gpl3; > + struct { > + unsigned long long gl1e, write_val; > + unsigned long long va; > + unsigned flags:29, emulation_count:3; > + } gpl4; > + } *r = (typeof(r))ri->d; > + > + union shadow_event sevt = { .event = ri->event }; > + int rec_gpl = sevt.paging_levels + 2; > + > + if ( rec_gpl != h->v->guest_paging_levels ) > + { > + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", > + __func__, rec_gpl, h->v->guest_paging_levels); > + h->v->guest_paging_levels = rec_gpl; > + } > + > + /* Fill in extended information */ > + switch(rec_gpl) > + { > + case 2: > + if(sizeof(r->gpl2) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, > + ri->extra_words * 4); > + > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl2.va; > + e->flags = r->gpl2.flags; > + e->gl1e = r->gpl2.gl1e; > + e->wval = r->gpl2.write_val; > + break; > + case 3: > + if(sizeof(r->gpl3) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl3.va; > + e->flags = r->gpl3.flags; > + e->gl1e = r->gpl3.gl1e; > + e->wval = r->gpl3.write_val; > + break; > + case 4: > + if(sizeof(r->gpl4) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl4.va; > + e->flags = r->gpl4.flags; > + e->gl1e = r->gpl4.gl1e; > + e->wval = r->gpl4.write_val; > + break; > + } > + > + pf_preprocess(e,rec_gpl); > + > + if(opt.dump_all) > + printf("]%s emulate va %llx gl1e %8llx wval %8llx flags %s(%x) pt_level %d corr %8llx\n", > + ri->dump_header, > + e->va, > + e->gl1e, e->wval, > + flag_string(e), e->flags, > + e->pt_level, e->corresponding_va); > + > + if ( hvm_set_postprocess(h, shadow_emulate_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +struct shadow_emulate_other { > + unsigned long long gfn, va; > +}; > + > +#define SHADOW_OTHER_LOGS_GFN_NOT_GMFN 1 > + > +void shadow_parse_other(struct record_info *ri, > + struct shadow_emulate_other *o, > + struct hvm_data *h) { > + union { > + /* for PAE, guest_l1e may be 64 while guest_va may be 32; > + so put it first for alignment sake. */ > +#if SHADOW_OTHER_LOGS_GFN_NOT_GMFN > + /* D'OH! Accidentally used mfn_t in the struct, so gmfns are always > + 64-bit... :-/ */ > + struct { > + unsigned int gfn, va; > + } gpl2; > +#endif > + struct { > + unsigned long long gfn; > + unsigned int va; > + } gpl3; > + struct { > + unsigned long long gfn, va; > + } gpl4; > + } *r = (typeof(r))ri->d; > + > + > + union shadow_event sevt = { .event = ri->event }; > + int rec_gpl = sevt.paging_levels + 2; > + > + if ( rec_gpl != h->v->guest_paging_levels ) > + { > + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", > + __func__, rec_gpl, h->v->guest_paging_levels); > + h->v->guest_paging_levels = rec_gpl; > + } > + > + switch(rec_gpl) > + { > +#if SHADOW_OTHER_LOGS_GFN_NOT_GMFN > + case 2: > + if(sizeof(r->gpl2) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl2), rec_gpl, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + o->va = r->gpl2.va; > + o->gfn = r->gpl2.gfn; > + break; > +#else > + case 2: > + /* FALLTHRU */ > +#endif > + case 3: > + if(sizeof(r->gpl3) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl3), rec_gpl, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + o->va = r->gpl3.va; > + o->gfn = r->gpl3.gfn; > + break; > + case 4: > + if(sizeof(r->gpl4) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl4), rec_gpl, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + o->va = r->gpl4.va; > + o->gfn = r->gpl4.gfn; > + break; > + } > +} > + > +#if 0 > +void shadow_unsync_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if(h->resyncs > 1) > + fprintf(warn, "Strange, %d resyncs for an unsync!\n", > + h->resyncs); > + > + if(opt.summary_info) { > + update_summary(&h->summary.pf_xen[PF_XEN_EMULATE_UNSYNC], > + h->arc_cycles); > + if(h->resyncs <= 1) > + update_summary(&h->summary.pf_xen_unsync[h->resyncs], > + h->arc_cycles); > + } > +} > + > + > +void shadow_unsync_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + struct shadow_emulate_other r; > + > + shadow_parse_other(ri, &r, h); > + > + e->gmfn = r.gmfn; > + e->va = r.va; > + > + pf_preprocess(e, h->v->guest_paging_levels); > + > + if(opt.dump_all) > + printf("]%s shadow unsync gmfn %llx va %llx pt_level %d corr %llx\n", > + ri->dump_header, > + e->gmfn, > + e->va, > + e->pt_level, > + e->corresponding_va); > + > + if ( hvm_set_postprocess(h, shadow_unsync_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > +#endif > + > +void shadow_fault_generic_postprocess(struct hvm_data *h); > + > +void shadow_emulate_other_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + struct shadow_emulate_other r; > + union shadow_event sevt = { .event = ri->event }; > + > + shadow_parse_other(ri, &r, h); > + > + e->gfn = r.gfn; > + e->va = r.va; > + e->pf_case = sevt.minor; > + > + pf_preprocess(e, h->v->guest_paging_levels); > + > + if(opt.dump_all) > + printf("]%s shadow %s gfn %llx va %llx\n", > + ri->dump_header, > + pf_xen_name[sevt.minor], > + e->gfn, > + e->va); > + > + if ( hvm_set_postprocess(h, shadow_fault_generic_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void shadow_fixup_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if ( opt.summary_info ) > + { > + update_summary(&h->summary.pf_xen[PF_XEN_FIXUP], h->arc_cycles); > + if(h->prealloc_unpin) { > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_PREALLOC_UNPIN], h->arc_cycles); > + } > + if(e->flag_unsync) { > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_UNSYNC], h->arc_cycles); > + if(h->resyncs < PF_XEN_FIXUP_UNSYNC_RESYNC_MAX) > + update_summary(&h->summary.pf_xen_fixup_unsync_resync[h->resyncs], > + h->arc_cycles); > + else > + update_summary(&h->summary.pf_xen_fixup_unsync_resync[PF_XEN_FIXUP_UNSYNC_RESYNC_MAX], > + h->arc_cycles); > + } > + if(e->flag_oos_fixup_add) > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_OOS_ADD], h->arc_cycles); > + if(e->flag_oos_fixup_evict) > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_OOS_EVICT], h->arc_cycles); > + if(e->flag_promote) > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_PROMOTE], h->arc_cycles); > + if(e->flag_wrmap) { > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_WRMAP], h->arc_cycles); > + if(e->flag_wrmap_brute_force || h->wrmap_bf) > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_BRUTE_FORCE], h->arc_cycles); > + } else if(e->flag_wrmap_brute_force || h->wrmap_bf) { > + fprintf(warn, "Strange: wrmap_bf but not wrmap!\n"); > + } > + > + > + if(!(e->flag_promote || h->prealloc_unpin || e->flag_unsync)) > + update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_UPDATE_ONLY], h->arc_cycles); > + /* more summary info */ > + > + if(e->flag_unsync) > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_UNSYNC); > + else > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_FIXUP); > + } > + > + if(opt.scatterplot_unpin_promote) { > + if(h->prealloc_unpin) > + scatterplot_vs_time(h->exit_tsc, 0); > + if(e->flag_promote) { > + if(opt.with_cr3_enumeration) { > + if(h->v->cr3.data) > + scatterplot_vs_time(h->exit_tsc, h->v->cr3.data->cr3_id); > + } else > + scatterplot_vs_time(h->exit_tsc, 2); > + } > + } > +} > + > +void shadow_fixup_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + union { > + /* for PAE, guest_l1e may be 64 while guest_va may be 32; > + so put it first for alignment sake. */ > + struct { > + unsigned int gl1e, va, flags; > + } gpl2; > + struct { > + unsigned long long gl1e; > + unsigned int va, flags; > + } gpl3; > + struct { > + unsigned long long gl1e, va; > + unsigned int flags; > + } gpl4; > + } *r = (typeof(r))ri->d; > + union shadow_event sevt = { .event = ri->event }; > + int rec_gpl = sevt.paging_levels + 2; > + > + if ( rec_gpl != h->v->guest_paging_levels ) > + { > + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", > + __func__, rec_gpl, h->v->guest_paging_levels); > + h->v->guest_paging_levels = rec_gpl; > + } > + > + switch(rec_gpl) > + { > + case 2: > + if(sizeof(r->gpl2) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl2.va; > + e->flags = r->gpl2.flags; > + e->gl1e = r->gpl2.gl1e; > + break; > + case 3: > + if(sizeof(r->gpl3) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl3.va; > + e->flags = r->gpl3.flags; > + e->gl1e = r->gpl3.gl1e; > + break; > + case 4: > + if(sizeof(r->gpl4) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl4.va; > + e->flags = r->gpl4.flags; > + e->gl1e = r->gpl4.gl1e; > + break; > + } > + > + pf_preprocess(e,rec_gpl); > + > + if(opt.dump_all) > + { > + if ( e->flag_unsync ) > + printf("]%s fixup:unsync va %llx gl1e %llx corr %llx flags (%x)%s\n", > + ri->dump_header, > + e->va, e->gl1e, > + e->corresponding_va, > + e->flags, > + flag_string(e)); > + else > + printf("]%s fixup va %llx gl1e %llx flags (%x)%s\n", > + ri->dump_header, > + e->va, e->gl1e, e->flags, > + flag_string(e)); > + } > + > + if ( hvm_set_postprocess(h, shadow_fixup_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void shadow_mmio_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + if ( opt.summary_info ) > + { > + if(e->pf_case) > + update_summary(&h->summary.pf_xen[e->pf_case], > + h->arc_cycles); > + else > + fprintf(warn, "Strange, pf_case 0!\n"); > + > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_MMIO); > + } > + > + if(opt.with_mmio_enumeration) > + enumerate_mmio(h); > +} > + > +void shadow_mmio_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + struct mmio_info *m = &h->inflight.mmio; > + union { > + /* for PAE, guest_l1e may be 64 while guest_va may be 32; > + so put it first for alignment sake. */ > + struct { > + unsigned int va; > + } gpl2; > + struct { > + unsigned long long va; > + } gpl4; > + } *r = (typeof(r))ri->d; > + union shadow_event sevt = { .event = ri->event }; > + int rec_gpl = sevt.paging_levels + 2; > + > + if ( rec_gpl != h->v->guest_paging_levels ) > + { > + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", > + __func__, rec_gpl, h->v->guest_paging_levels); > + h->v->guest_paging_levels = rec_gpl; > + } > + > + switch(rec_gpl) > + { > + case 2: > + case 3: > + if(sizeof(r->gpl2) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = m->va = r->gpl2.va; > + break; > + case 4: > + if(sizeof(r->gpl4) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = m->va = r->gpl4.va; > + break; > + } > + > + if(opt.dump_all) > + printf("]%s %smmio va %llx\n", > + ri->dump_header, > + (e->pf_case==PF_XEN_FAST_MMIO)?"fast ":"", > + e->va); > + > + if ( hvm_set_postprocess(h, shadow_mmio_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void shadow_propagate_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + > + if ( opt.summary_info ) > + { > + if(e->pf_case) > + update_summary(&h->summary.pf_xen[e->pf_case], > + h->arc_cycles); > + else > + fprintf(warn, "Strange, pf_case 0!\n"); > + > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_PROPAGATE); > + } > +} > + > +void shadow_propagate_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + union { > + /* for PAE, guest_l1e may be 64 while guest_va may be 32; > + so put it first for alignment sake. */ > + struct { > + unsigned int gl1e, va, flags; > + } gpl2; > + struct { > + unsigned long long gl1e; > + unsigned int va, flags; > + } gpl3; > + struct { > + unsigned long long gl1e, va; > + unsigned int flags; > + } gpl4; > + } *r = (typeof(r))ri->d; > + union shadow_event sevt = { .event = ri->event }; > + int rec_gpl = sevt.paging_levels + 2; > + > + if ( rec_gpl != h->v->guest_paging_levels ) > + { > + fprintf(warn, "%s: record paging levels %d, guest paging levels %d. Switching.\n", > + __func__, rec_gpl, h->v->guest_paging_levels); > + h->v->guest_paging_levels = rec_gpl; > + } > + > + switch(rec_gpl) > + { > + case 2: > + if(sizeof(r->gpl2) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl2), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl2.va; > + e->flags = r->gpl2.flags; > + e->gl1e = r->gpl2.gl1e; > + break; > + case 3: > + if(sizeof(r->gpl3) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl3), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl3.va; > + e->flags = r->gpl3.flags; > + e->gl1e = r->gpl3.gl1e; > + break; > + case 4: > + if(sizeof(r->gpl4) != ri->extra_words * 4) > + { > + fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", > + __func__, sizeof(r->gpl4), h->v->guest_paging_levels, > + ri->extra_words * 4); > + error(ERR_RECORD, ri); > + return; > + } > + e->va = r->gpl4.va; > + e->flags = r->gpl4.flags; > + e->gl1e = r->gpl4.gl1e; > + break; > + } > + > + if(opt.dump_all) > + printf("]%s propagate va %llx gl1e %llx flags (%x)%s\n", > + ri->dump_header, > + e->va, e->gl1e, e->flags, > + flag_string(e)); > + > + if ( hvm_set_postprocess(h, shadow_propagate_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void shadow_fault_generic_dump(unsigned int event, uint32_t *d, char *prefix, > + char * dump_header) > +{ > + char *evt_string, evt_number[10]; > + union shadow_event sevt = { .event = event }; > + int i; > + > + if(sevt.minor < PF_XEN_MAX && pf_xen_name[sevt.minor]) > + { > + evt_string = pf_xen_name[sevt.minor]; > + } > + else > + { > + snprintf(evt_number, 10, "%d", sevt.minor); > + evt_string = evt_number; > + } > + > + printf("%s%s shadow %s gl %d [", > + prefix, > + dump_header, > + evt_string, > + sevt.paging_levels); > + > + for(i=0; i<4; i++) > + { > + printf(" %x", d[i]); > + } > + > + printf(" ]\n"); > +} > + > +void shadow_fault_generic_postprocess(struct hvm_data *h) > +{ > + struct pf_xen_extra *e = &h->inflight.pf_xen; > + if ( e->pf_case < PF_XEN_NOT_SHADOW || e->pf_case > PF_XEN_LAST_FAULT ) > + { > + fprintf(warn, "%s: Strange, unexpected case %d\n", > + __func__, e->pf_case); > + return; > + } > + > + if(opt.summary_info) { > + update_summary(&h->summary.pf_xen[e->pf_case], > + h->arc_cycles); > + > + hvm_update_short_summary(h, HVM_SHORT_SUMMARY_PROPAGATE); > + } > +} > + > +void shadow_fault_generic_process(struct record_info *ri, struct hvm_data *h) > +{ > + union shadow_event sevt = { .event = ri->event }; > + > + /* pf-case traces, vs others */ > + h->inflight.generic.event = ri->event; > + bcopy(ri->d, h->inflight.generic.d, sizeof(unsigned int) * 4); > + > + if(opt.dump_all) > + shadow_fault_generic_dump(h->inflight.generic.event, > + h->inflight.generic.d, > + "]", ri->dump_header); > + > + h->inflight.pf_xen.pf_case = sevt.minor; > + if ( hvm_set_postprocess(h, shadow_fault_generic_postprocess) ) > + fprintf(warn, "%s: Strange, postprocess already set\n", __func__); > +} > + > +void shadow_resync_process(struct record_info *ri, struct hvm_data *h) > +{ > + struct { > + unsigned long long gfn; > + } *r = (typeof(r))ri->d; > + > + if(opt.dump_all) > + printf(" %s oos resync %s gfn %llx\n", > + ri->dump_header, > + (ri->event == TRC_SHADOW_RESYNC_FULL)?"full":"only", > + r->gfn); > + > + h->resyncs++; > +} > + > +void shadow_prealloc_unpin_process(struct record_info *ri, struct hvm_data *h) { > + struct { > + unsigned long long gfn; > + } *r = (typeof(r))ri->d; > + > + if(opt.dump_all) > + printf(" %s prealloc-unpin gfn %llx\n", > + ri->dump_header, r->gfn); > + > + if(h->prealloc_unpin) > + fprintf(warn, "Strange, more than one prealloc_unpin per arc!\n"); > + > + h->prealloc_unpin = 1; > + > + if(opt.with_cr3_enumeration) > + cr3_prealloc_unpin(h->v, r->gfn); > +} > + > +void shadow_wrmap_bf_process(struct record_info *ri, struct hvm_data *h) { > + struct { > + unsigned long long gfn; > + } *r = (typeof(r))ri->d; > + > + if(opt.dump_all) > + printf(" %s wrmap-bf gfn %llx\n", > + ri->dump_header, r->gfn); > + > + h->wrmap_bf = 1; > +} > + > +void shadow_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + struct hvm_data *h; > + > + union shadow_event sevt = { .event = ri->event }; > + > + int gpl = sevt.paging_levels + 2; > + > + assert(p->current); > + if(vcpu_set_data_type(p->current, VCPU_DATA_HVM)) > + return; > + > + h = &p->current->hvm; > + > + if(!h->init || !h->vmexit_valid) > + { > + if(opt.dump_all) > + shadow_fault_generic_dump(ri->event, > + ri->d, > + "!", ri->dump_header); > + return; > + } > + > + if(sevt.minor <= PF_XEN_NOT_SHADOW) { > + if(p->current->guest_paging_levels != gpl) > + { > + fprintf(warn, "%s: Changing guest paging levels to %d\n", > + __func__, gpl); > + p->current->guest_paging_levels = gpl; > + } > + } > + > + if(sevt.minor <= PF_XEN_LAST_FAULT) { > + h->inflight.pf_xen.pf_case = sevt.minor; > + if(opt.summary) { > + hvm_set_summary_handler(h, hvm_pf_xen_summary, NULL); > + } > + } > + > + /* FIXME - mask out paging levels */ > + switch(sevt.minor) > + { > + case PF_XEN_NOT_SHADOW: > + shadow_propagate_process(ri, h); > + break; > + case PF_XEN_EMULATE: > + shadow_emulate_process(ri, h); > + break; > + case PF_XEN_FIXUP: > + shadow_fixup_process(ri, h); > + break; > + case PF_XEN_MMIO: > + case PF_XEN_FAST_MMIO: > + shadow_mmio_process(ri, h); > + break; > + case PF_XEN_EMULATE_UNSHADOW_USER: > + case PF_XEN_EMULATE_UNSHADOW_EVTINJ: > + case PF_XEN_EMULATE_UNSHADOW_UNHANDLED: > + shadow_emulate_other_process(ri, h); > + break; > +#if 0 > + case PF_XEN_EMULATE_UNSYNC: > + shadow_unsync_process(ri, h); > + break; > +#endif > + case SHADOW_RESYNC_FULL: > + case SHADOW_RESYNC_ONLY: > + shadow_resync_process(ri, h); > + break; > + case SHADOW_PREALLOC_UNPIN: > + shadow_prealloc_unpin_process(ri, h); > + break; > + case SHADOW_WRMAP_BF: > + shadow_wrmap_bf_process(ri, h); > + break; > + default: > + if(sevt.minor <= PF_XEN_LAST_FAULT) { > + shadow_fault_generic_process(ri, h); > + } else { > + warn_once("Warning: processing shadow as generic\n"); > + process_generic(ri); > + } > + break; > + } > +} > + > +/* ---- PV guests ---- */ > +union pv_event { > + unsigned event; > + struct { > + unsigned minor:8, > + x64:1, > + unused1:3, > + sub:4, > + main:12, > + unused:4; > + }; > +}; > + > +void pv_hypercall_process(struct record_info *ri, struct pv_data *pv) { > + union { > + struct { > + uint32_t eip, eax; > + } x32; > + struct { > + uint64_t eip; > + uint32_t eax; > + } x64; > + } * r = (typeof(r)) ri->d; > + union pv_event pevt = { .event = ri->event }; > + unsigned long long eip; > + unsigned int eax; > + > + if(pevt.x64) { > + eip = r->x64.eip; > + eax = r->x64.eax; > + } else { > + eip = r->x32.eip; > + eax = r->x32.eax; > + } > + > + if(opt.summary_info) { > + if(eax < PV_HYPERCALL_MAX) > + pv->hypercall_count[eax]++; > + } > + > + if(opt.dump_all) { > + if(eax < HYPERCALL_MAX) > + printf(" %s hypercall %2x (%s) eip %llx\n", > + ri->dump_header, eax, > + hypercall_name[eax], eip); > + else > + printf(" %s hypercall %x eip %llx\n", > + ri->dump_header, eax, eip); > + } > +} > + > +void pv_trap_process(struct record_info *ri, struct pv_data *pv) { > + union { > + struct { > + unsigned int eip; > + unsigned trapnr:15, > + use_error_code:1, > + error_code:16; > + } x32; > + struct { > + unsigned long long eip; > + unsigned trapnr:15, > + use_error_code:1, > + error_code:16; > + } x64; > + } * r = (typeof(r)) ri->d; > + union pv_event pevt = { .event = ri->event }; > + unsigned long long eip; > + unsigned trapnr, use_ec, ec; > + > + if(pevt.x64) { > + eip = r->x64.eip; > + trapnr = r->x64.trapnr; > + use_ec = r->x64.use_error_code; > + ec = r->x64.error_code; > + } else { > + eip = r->x32.eip; > + trapnr = r->x32.trapnr; > + use_ec = r->x32.use_error_code; > + ec = r->x32.error_code; > + } > + > + if(opt.summary_info) { > + if(trapnr < PV_TRAP_MAX) > + pv->trap_count[trapnr]++; > + } > + > + if(opt.dump_all) { > + printf(" %s trap %x eip %llx", > + ri->dump_header, trapnr, eip); > + if(use_ec) > + printf(" ec %x\n", ec); > + else > + printf("\n"); > + } > +} > + > +void pv_ptwr_emulation_process(struct record_info *ri, struct pv_data *pv) { > + union pv_event pevt = { .event = ri->event }; > + union { > + /* gpl2 is deprecated */ > + struct { > + unsigned long long pte; > + unsigned int addr, eip; > + } gpl3; > + struct { > + unsigned long long pte; > + unsigned long long addr, eip; > + } gpl4; > + } *r = (typeof(r))ri->d; > + struct { > + unsigned long long pte, addr, eip; > + } e; > + > + switch ( pevt.minor ) { > + case PV_PTWR_EMULATION_PAE: > + if ( pevt.x64 ) > + { > + fprintf(warn, "Strange: PV_PTWR_EMULATION, but x64! %x\n", > + ri->event); > + error(ERR_RECORD, ri); > + } > + e.pte = r->gpl3.pte; > + e.addr = r->gpl3.addr; > + e.eip = r->gpl3.eip; > + break; > + case PV_PTWR_EMULATION: > + if ( !pevt.x64 ) > + { > + fprintf(warn, "Strange: PV_PTWR_EMULATION, but !x64! %x\n", > + ri->event); > + error(ERR_RECORD, ri); > + } > + e.pte = r->gpl4.pte; > + e.addr = r->gpl4.addr; > + e.eip = r->gpl4.eip; > + break; > + default: > + fprintf(warn, "ERROR: Unknown PV_PTRW minor type %d!\n", > + pevt.minor); > + error(ERR_RECORD, ri); > + return; > + } > + > + if ( opt.dump_all ) > + { > + printf(" %s ptwr l1e %llx eip %llx addr %llx\n", > + ri->dump_header, > + e.pte, e.eip, e.addr); > + } > +} > + > +void pv_generic_process(struct record_info *ri, struct pv_data *pv) { > + union pv_event pevt = { .event = ri->event }; > + if ( opt.dump_all ) { > + if(pevt.minor < PV_MAX && pv_name[pevt.minor]) > + printf(" %s %s", > + ri->dump_header, > + pv_name[pevt.minor]); > + else > + printf(" %s PV-%d ", > + ri->dump_header, pevt.minor); > + if (ri->extra_words) { > + int i; > + printf("[ "); > + for(i=0; i<ri->extra_words; i++) { > + printf("%x ", (unsigned)ri->d[i]); > + } > + printf("]"); > + > + } > + printf("\n"); > + } > +} > + > +void pv_summary(struct pv_data *pv) { > + int i, j; > + > + if(!pv->summary_info) > + return; > + > + printf("PV events:\n"); > + for(i=0; i<PV_MAX; i++) { > + int count; > + > + count = pv->count[i]; > + if (i == PV_HYPERCALL_V2) > + count += pv->count[PV_HYPERCALL_SUBCALL]; > + > + if (count == 0) > + continue; > + > + printf(" %s %d\n", pv_name[i], count); > + > + switch(i) { > + case PV_HYPERCALL: > + case PV_HYPERCALL_V2: > + for(j=0; j<PV_HYPERCALL_MAX; j++) { > + if(pv->hypercall_count[j]) > + printf(" %-29s[%2d]: %6d\n", > + hypercall_name[j], > + j, > + pv->hypercall_count[j]); > + } > + break; > + case PV_TRAP: > + for(j=0; j<PV_TRAP_MAX; j++) { > + if(pv->trap_count[j]) > + printf(" [%d] %d\n", > + j, pv->trap_count[j]); > + } > + break; > + } > + } > +} > + > +static const char *grant_table_op_str[] = { > + "map_grant_ref", "unmap_grant_ref", "setup_table", "dump_table", > + "transfer", "copy", "query_size", "unmap_and_replace", > + "set_version", "get_status_frames", "get_version", "swap_grant_ref", > +}; > + > +static const char *vcpu_op_str[] = { > + "initialise", "up", "down", "is_up", "get_runstate_info", > + "register_runstate_memory_area", "set_periodic_timer", > + "stop_periodic_timer", "set_singleshot_timer", "stop_singleshot_timer", > + "register_vcpu_info", "send_nmi", "get_physid", > + "register_vcpu_time_memory_area", > +}; > + > +static const char *sched_op_str[] = { > + "yield", "block", "shutdown", "poll", "remote_shutdown", "shutdown_code", > + "watchdog", > +}; > + > +static const char *cmd_to_str(const char *strings[], size_t n, uint32_t cmd) > +{ > + static char buf[32]; > + > + if (cmd < n) > + return strings[cmd]; > + > + snprintf(buf, sizeof(buf), "unknown (%d)", cmd); > + return buf; > +} > + > +#define CMD_TO_STR(op) \ > + static const char * op ## _to_str(uint32_t cmd) { \ > + return cmd_to_str(op ## _str, ARRAY_SIZE(op ## _str), cmd); \ > + } > + > +CMD_TO_STR(grant_table_op); > +CMD_TO_STR(vcpu_op); > +CMD_TO_STR(sched_op); > + > +void pv_hypercall_gather_args(const struct record_info *ri, uint64_t *args) > +{ > + int i, word; > + > + /* Missing arguments are zeroed. */ > + memset(args, 0, 6 * sizeof(uint64_t)); > + > + for (i = 0, word = 1; i < 6 && word < ri->extra_words; i++) { > + int present = pv_hypercall_arg_present(ri, i); > + > + switch (present) { > + case ARG_32BIT: > + args[i] = ri->d[word]; > + break; > + case ARG_64BIT: > + args[i] = ((uint64_t)ri->d[word + 1] << 32) | ri->d[word]; > + break; > + } > + > + /* Skip over any words for this argument. */ > + word += present; > + } > +} > + > +static void pv_hypercall_print_args(const struct record_info *ri) > +{ > + int i, word; > + > + for (i = 0, word = 1; i < 6 && word < ri->extra_words; i++) { > + int present = pv_hypercall_arg_present(ri, i); > + > + switch (present) { > + case ARG_MISSING: > + printf(" ??"); > + break; > + case ARG_32BIT: > + printf(" %08x", ri->d[word]); > + break; > + case ARG_64BIT: > + printf(" %016"PRIu64"", ((uint64_t)ri->d[word + 1] << 32) | ri->d[word]); > + break; > + } > + > + word += present; > + } > +} > + > +void pv_hypercall_v2_process(struct record_info *ri, struct pv_data *pv, > + const char *indent) > +{ > + int op = pv_hypercall_op(ri); > + > + if(opt.summary_info) { > + if(op < PV_HYPERCALL_MAX) > + pv->hypercall_count[op]++; > + } > + > + if(opt.dump_all) { > + uint64_t args[6]; > + > + if(op < HYPERCALL_MAX) > + printf(" %s%s hypercall %2x (%s)", > + ri->dump_header, indent, op, hypercall_name[op]); > + else > + printf(" %s%s hypercall %2x", > + ri->dump_header, indent, op); > + > + switch(op) { > + case HYPERCALL_mmu_update: > + pv_hypercall_gather_args(ri, args); > + printf(" %d updates%s", (uint32_t)args[1] & ~MMU_UPDATE_PREEMPTED, > + (args[1] & MMU_UPDATE_PREEMPTED) ? " (preempted)" : ""); > + break; > + case HYPERCALL_multicall: > + pv_hypercall_gather_args(ri, args); > + printf(" %d calls", (uint32_t)args[1]); > + break; > + case HYPERCALL_grant_table_op: > + pv_hypercall_gather_args(ri, args); > + printf(" %s %d ops", grant_table_op_to_str(args[0]), (uint32_t)args[2]); > + break; > + case HYPERCALL_vcpu_op: > + pv_hypercall_gather_args(ri, args); > + printf(" %s vcpu %d", vcpu_op_to_str(args[0]), (uint32_t)args[1]); > + break; > + case HYPERCALL_mmuext_op: > + pv_hypercall_gather_args(ri, args); > + printf(" %d ops", (uint32_t)args[1]); > + break; > + case HYPERCALL_sched_op: > + pv_hypercall_gather_args(ri, args); > + printf(" %s", sched_op_to_str(args[0])); > + break; > + default: > + pv_hypercall_print_args(ri); > + break; > + } > + printf("\n"); > + } > +} > + > +void pv_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + struct vcpu_data *v = p->current; > + struct pv_data *pv = &v->pv; > + > + union pv_event pevt = { .event = ri->event }; > + > + if(vcpu_set_data_type(p->current, VCPU_DATA_PV)) > + return; > + > + if(opt.summary_info) { > + pv->summary_info=1; > + > + if(pevt.minor == PV_PTWR_EMULATION_PAE) > + pv->count[PV_PTWR_EMULATION]++; > + else > + pv->count[pevt.minor]++; > + } > + > + switch(pevt.minor) > + { > + case PV_HYPERCALL: > + pv_hypercall_process(ri, pv); > + break; > + case PV_TRAP: > + pv_trap_process(ri, pv); > + break; > + case PV_PTWR_EMULATION: > + case PV_PTWR_EMULATION_PAE: > + pv_ptwr_emulation_process(ri, pv); > + break; > + case PV_HYPERCALL_V2: > + pv_hypercall_v2_process(ri, pv, ""); > + break; > + case PV_HYPERCALL_SUBCALL: > + pv_hypercall_v2_process(ri, pv, " "); > + break; > + default: > + pv_generic_process(ri, pv); > + break; > + } > +} > + > +/* ---- Schedule ---- */ > +struct vcpu_data * vcpu_create(struct domain_data *d, int vid) > +{ > + struct vcpu_data *v; > + > + assert(d->vcpu[vid] == NULL); > + > + fprintf(warn, "Creating vcpu %d for dom %d\n", vid, d->did); > + > + if((v=malloc(sizeof(*v)))==NULL) > + { > + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*d)); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(v, sizeof(*v)); > + > + v->vid = vid; > + v->d = d; > + v->p = NULL; > + v->runstate.state = RUNSTATE_INIT; > + v->runstate.last_oldstate.wrong = RUNSTATE_INIT; > + > + d->vcpu[vid] = v; > + > + assert(v == v->d->vcpu[v->vid]); > + > + if(vid > d->max_vid) > + d->max_vid = vid; > + > + return v; > +} > + > +/* Called by both domain_create and sched_default_domain_init */ > +void domain_init(struct domain_data *d, int did) > +{ > + bzero(d, sizeof(*d)); > + > + d->did = did; > + d->next = NULL; > + > + if(opt.interval.check == INTERVAL_CHECK_DOMAIN) > + interval_domain_value_check(d); > +} > + > +struct domain_data * domain_create(int did) > +{ > + struct domain_data *d; > + > + fprintf(warn, "Creating domain %d\n", did); > + > + if((d=malloc(sizeof(*d)))==NULL) > + { > + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*d)); > + error(ERR_SYSTEM, NULL); > + } > + > + /* Initialize domain & vcpus */ > + domain_init(d, did); > + > + return d; > + } > + > +struct domain_data * domain_find(int did) > +{ > + struct domain_data *d, *n, **q; > + > + /* Look for domain, keeping track of the last pointer so we can add > + a domain if we need to. */ > + for ( d = domain_list, q=&domain_list ; > + d && (d->did < did) ; > + q = &d->next, d=d->next ) ; > + > + if(d && d->did == did) > + return d; > + > + /* Make a new domain */ > + n = domain_create(did); > + > + /* Insert it into the list */ > + n->next = d; > + *q = n; > + > + return n; > +} > + > +struct vcpu_data * vcpu_find(int did, int vid) > +{ > + struct domain_data *d; > + struct vcpu_data *v; > + > + d = domain_find(did); > + > + v = d->vcpu[vid]; > + > + if(!v) > + v = vcpu_create(d, vid); > + > + return v; > +} > + > +void pcpu_runstate_update(struct pcpu_info *p, tsc_t tsc) > +{ > + if ( p->time.tsc ) > + { > + if ( p->current->d->did == IDLE_DOMAIN ) > + update_cycles(&p->time.idle, tsc - p->time.tsc); > + else > + update_cycles(&p->time.running, tsc - p->time.tsc); > + p->time.tsc = 0; > + } > +} > + > +void vcpu_prev_update(struct pcpu_info *p, struct vcpu_data *prev, > + tsc_t tsc, int new_runstate) > +{ > + assert(prev == prev->d->vcpu[prev->vid]); > + > + if(prev->p != p) > + { > + fprintf(warn, "Strange, sched_switch on pcpu %d, prev->pcpu %d!\n", > + p->pid, prev->p->pid); > + prev->runstate.tsc = 0; > + goto set; > + } > + > + //assert(p->current); > + > + if ( !p->current ) > + { > + fprintf(warn, "%s: FATAL: p->current NULL!\n", __func__); > + error(ERR_ASSERT, NULL); > + } > + > + if(p->current != prev) > + { > + fprintf(warn, "Strange, sched_switch prev d%dv%d, pcpu %d current d%dv%d!\n", > + prev->d->did, prev->vid, > + p->pid, p->current->d->did, p->current->vid); > + prev->runstate.tsc = 0; > + goto set; > + } > + > + if(prev->runstate.state != RUNSTATE_RUNNING) > + { > + fprintf(warn, "Strange, prev d%dv%d not running!\n", > + prev->d->did, prev->vid); > + prev->runstate.tsc = 0; > + goto set; > + } > + > +set: > + pcpu_runstate_update(p, tsc); > + p->current = NULL; > + pcpu_string_draw(p); > + runstate_update(prev, new_runstate, tsc); > +} > + > +void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc) > +{ > + assert(next == next->d->vcpu[next->vid]); > + //assert(p->current == NULL); > + > + if ( p->current != NULL ) > + { > + if ( p->lost_record.seen_valid_schedule == 0 ) > + { > + fprintf(warn, "%s: p->current non-NULL, but seen_valid_schedule 0. Ignoring.\n", > + __func__); > + runstate_update(p->current, RUNSTATE_LOST, tsc); > + p->current = NULL; > + } > + else > + { > + fprintf(warn, "%s: FATAL: p->current not NULL! (d%dv%d, runstate %s)\n", > + __func__, > + p->current->d->did, > + p->current->vid, > + runstate_name[p->current->runstate.state]); > + error(ERR_ASSERT, NULL); > + } > + } > + > + if(next->activated) > + { > + /* We may get lost records at start-of-day, so ignore > + setting runstate of default vcpus */ > + if(next->runstate.state == RUNSTATE_RUNNING > + && next->d->did != DEFAULT_DOMAIN) > + { > + fprintf(warn, "Strange, next d%dv%d already running on proc %d!\n", > + next->d->did, next->vid, > + next->p->pid); > + next->runstate.tsc = 0; > + } > + > + /* If we're moving from one pcpu to another, record change & update tsc */ > + if(next->p != p) { > + if(next->pcpu_tsc) > + { > + update_cycles(&next->cpu_affinity_all, tsc - next->pcpu_tsc); > + update_cycles(&next->cpu_affinity_pcpu[p->pid], tsc - next->pcpu_tsc); > + } > + next->pcpu_tsc = tsc; > + } > + } > + else > + { > + next->guest_paging_levels = opt.default_guest_paging_levels; > + next->activated = 1; > + next->pcpu_tsc = tsc; > + } > + > + runstate_update(next, RUNSTATE_RUNNING, tsc); > + > + if ( opt.scatterplot_pcpu > + && next->d->did != IDLE_DOMAIN > + && next->d->did != DEFAULT_DOMAIN ) > + { > + struct time_struct t; > + > + abs_cycles_to_time(tsc, &t); > + > + if ( next->p ) > + printf("%dv%d %u.%09u %d\n", > + next->d->did, next->vid, > + t.s, t.ns, > + next->p->pid); > + printf("%dv%d %u.%09u %d\n", > + next->d->did, next->vid, > + t.s, t.ns, > + p->pid); > + } > + > + next->p = p; > + p->current = next; > + pcpu_string_draw(p); > + p->time.tsc = tsc; > + p->lost_record.seen_valid_schedule = 1; > +} > + > +/* If current is the default domain, we're fixing up from something > + * like start-of-day. Update what we can. */ > +void vcpu_start(struct pcpu_info *p, struct vcpu_data *v) { > + /* If vcpus are created, or first show up, in a "dead zone", this will > + * fail. */ > + if( !p->current || p->current->d->did != DEFAULT_DOMAIN) { > + fprintf(stderr, "Strange, p->current not default domain!\n"); > + error(ERR_FILE, NULL); > + return; > + } > + > + if(!p->first_tsc) { > + fprintf(stderr, "Strange, p%d first_tsc 0!\n", p->pid); > + error(ERR_FILE, NULL); > + } > + > + if(p->first_tsc <= p->current->runstate.tsc) { > + fprintf(stderr, "Strange, first_tsc %llx < default_domain runstate tsc %llx!\n", > + p->first_tsc, > + p->current->runstate.tsc); > + error(ERR_FILE, NULL); > + } > + > + /* Change default domain to 'queued' */ > + runstate_update(p->current, RUNSTATE_QUEUED, p->first_tsc); > + > + /* FIXME: Copy over data from the default domain this interval */ > + fprintf(warn, "Using first_tsc for d%dv%d (%lld cycles)\n", > + v->d->did, v->vid, p->last_tsc - p->first_tsc); > + > + /* Simulate the time since the first tsc */ > + runstate_update(v, RUNSTATE_RUNNING, p->first_tsc); > + p->time.tsc = p->first_tsc; > + p->current = v; > + pcpu_string_draw(p); > + v->p = p; > +} > + > +void sched_runstate_process(struct pcpu_info *p) > +{ > + enum { > + CHANGE=0, > + CONTINUE > + } type; > + struct vcpu_data *v; > + struct record_info *ri = &p->ri; > + struct { > + unsigned vcpu:16, dom:16; > + unsigned long long p1, p2; > + } __attribute__((packed)) * r = (typeof(r))ri->d; > + union { > + unsigned int event; > + struct { > + unsigned lo:4, > + new_runstate:4, > + old_runstate:4, > + sub:4, > + main:12, > + unused:4; > + }; > + } _sevt = { .event = ri->event }; > + struct { > + int new_runstate, old_runstate; > + } sevt; > + int perfctrs; > + struct last_oldstate_struct last_oldstate; > + > + switch(_sevt.lo) > + { > + case 1: > + type = CHANGE; > + sevt.new_runstate = _sevt.new_runstate; > + sevt.old_runstate = _sevt.old_runstate; > + break; > + case 2: > + type = CONTINUE; > + sevt.new_runstate = sevt.old_runstate = RUNSTATE_RUNNING; > + break; > + default: > + fprintf(warn, "FATAL: Unexpected runstate change type %d!\n", > + _sevt.lo); > + error(ERR_RECORD, NULL); > + return; > + } > + > + perfctrs = (ri->extra_words == 5); > + > + if(opt.dump_all) { > + if( perfctrs ) { > + printf(" %s %s {%lld,%lld} d%uv%u %s->%s\n", > + ri->dump_header, > + type?"runstate_continue":"runstate_change", > + r->p1, r->p2, > + r->dom, r->vcpu, > + runstate_name[sevt.old_runstate], > + runstate_name[sevt.new_runstate]); > + } else { > + printf(" %s %s d%uv%u %s->%s\n", > + ri->dump_header, > + type?"runstate_continue":"runstate_change", > + r->dom, r->vcpu, > + runstate_name[sevt.old_runstate], > + runstate_name[sevt.new_runstate]); > + } > + } > + > + /* Sanity check: expected transitions */ > + if ( type == CHANGE ) > + { > + if( (sevt.new_runstate == RUNSTATE_RUNNING > + && sevt.old_runstate != RUNSTATE_RUNNABLE) > + || (sevt.new_runstate == RUNSTATE_BLOCKED > + && sevt.old_runstate == RUNSTATE_RUNNABLE ) ) > + { > + fprintf(warn, "Strange, d%dv%d unexpected runstate transition %s->%s\n", > + r->dom, r->vcpu, > + runstate_name[sevt.old_runstate], > + runstate_name[sevt.new_runstate]); > + } > + } > + > + if(r->vcpu > MAX_CPUS) > + { > + fprintf(warn, "%s: vcpu %u > MAX_VCPUS %d!\n", > + __func__, r->vcpu, MAX_CPUS); > + return; > + } > + > + v = vcpu_find(r->dom, r->vcpu); > + > + /* We want last_oldstate reset every time; so copy the last one and use > + * that locally, clobbering the one in the vcpu struct. If it needs to > + * be reset, it will be reset below. */ > + last_oldstate = v->runstate.last_oldstate; > + v->runstate.last_oldstate.wrong = RUNSTATE_INIT; > + > + /* Close vmexits when the putative reason for blocking / &c stops. > + * This way, we don't account cpu contention to some other overhead. */ > + if(sevt.new_runstate == RUNSTATE_RUNNABLE > + && v->data_type == VCPU_DATA_HVM > + && v->hvm.vmexit_valid) { > + hvm_close_vmexit(&v->hvm, ri->tsc); > + } > + > + /* Track waking state */ > + if ( v->data_type == VCPU_DATA_HVM && v->runstate.state != RUNSTATE_LOST ) { > + if ( sevt.new_runstate == RUNSTATE_RUNNABLE > + && sevt.old_runstate == RUNSTATE_BLOCKED ) > + { > + /* Hmm... want to make sure we're not in some weird > + vmexit state... have to look later. */ > + if(opt.dump_all) > + printf(" [w2h] d%dv%d Setting waking\n", v->d->did, v->vid); > + v->hvm.w2h.waking = 1; > + } > + else if ( sevt.new_runstate != RUNSTATE_RUNNING > + || sevt.old_runstate != RUNSTATE_RUNNABLE ) > + { > + if( v->hvm.w2h.waking > + && sevt.old_runstate == RUNSTATE_RUNNING > + && sevt.new_runstate != RUNSTATE_OFFLINE ) > + { > + /* NB: This is printed a lot unnecessairly when there is TSC skew */ > + if ( sevt.old_runstate != v->runstate.state ) > + fprintf(warn, "Strange, unexpected waking transition for d%dv%d: %s -> %s\n", > + v->d->did, v->vid, > + runstate_name[sevt.old_runstate], > + runstate_name[sevt.new_runstate]); > + v->hvm.w2h.waking = 0; > + } > + > + /* Close wake-to-halt summary */ > + /* FIXME: Need to think about handling preemption. */ > + if (sevt.new_runstate == RUNSTATE_BLOCKED > + && sevt.old_runstate == RUNSTATE_RUNNING > + && v->hvm.w2h.interrupts ) { > + int i; > + for(i=0; i<GUEST_INTERRUPT_MAX; i++) { > + struct hvm_gi_struct *g=v->hvm.summary.guest_interrupt + i; > + tsc_t start_tsc = g->start_tsc; > + if(start_tsc) { > + tsc_t t = (start_tsc == 1) ? 0 : ri->tsc - start_tsc; > + if(opt.dump_all) > + printf(" [w2h] Halting vec %d is_wake %d time %lld\n", > + i, > + g->is_wake, > + t); > + > + if(opt.scatterplot_wake_to_halt > + && t > + && g->is_wake) > + scatterplot_vs_time(ri->tsc, t); > + > + if(opt.summary && t) { > + if(g->is_wake) { > + if(v->hvm.w2h.interrupts==1) > + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ALONE], > + t); > + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_WAKE_TO_HALT_ANY], > + t); > + } else { > + update_cycles(&g->runtime[GUEST_INTERRUPT_CASE_INTERRUPT_TO_HALT], > + t); > + } > + } > + g->start_tsc = 0; > + g->is_wake = 0; > + } > + } > + v->hvm.w2h.interrupts = 0; > + v->hvm.w2h.vector = 0; > + } > + } > + } > + > + /* Sanity checks / tsc skew detection */ > + if( v->runstate.state != sevt.old_runstate > + && v->runstate.state != RUNSTATE_INIT ) > + { > + if(v->runstate.state == RUNSTATE_LOST) { > + if( sevt.new_runstate == RUNSTATE_RUNNING ) > + goto update; > + else if(opt.dump_all) > + fprintf(warn, "%s: d%dv%d in runstate lost, not updating to %s\n", > + __func__, v->d->did, v->vid, > + runstate_name[sevt.new_runstate]); > + goto no_update; > + } else if (last_oldstate.wrong == sevt.new_runstate > + && last_oldstate.actual == sevt.old_runstate) { > + tsc_t lag, old_offset; > + struct pcpu_info *p2; > + > + if(ri->tsc < last_oldstate.tsc) { > + fprintf(warn, "WARNING: new tsc %lld < detected runstate tsc %lld! Not updating\n", > + ri->tsc, last_oldstate.tsc); > + goto no_update; > + } > + > + p2 = P.pcpu + last_oldstate.pid; > + > + lag = ri->tsc > + - last_oldstate.tsc; > + > + old_offset = p2->tsc_skew.offset; > + > + cpumask_union(&p2->tsc_skew.downstream, &p->tsc_skew.downstream); > + cpumask_set(&p2->tsc_skew.downstream, p->pid); > + > + if(cpumask_isset(&p2->tsc_skew.downstream, p2->pid)) { > + if ( opt.tsc_loop_fatal ) > + { > + fprintf(stderr, "FATAL: tsc skew dependency loop detected!\n"); > + error(ERR_FILE, NULL); > + } > + else > + { > + int i; > + fprintf(warn, "Tsc skew dependency loop detected! Resetting...\n"); > + for ( i=0; i<=P.max_active_pcpu; i++) > + { > + struct pcpu_info *p = P.pcpu + i; > + > + p->tsc_skew.offset = 0; > + cpumask_init(&p->tsc_skew.downstream); > + } > + goto no_update; > + } > + } > + > + p2->tsc_skew.offset += lag * 2; > + > + fprintf(warn, "TSC skew detected p%d->p%d, %lld cycles. Changing p%d offset from %lld to %lld\n", > + p->pid, p2->pid, lag, > + p2->pid, > + old_offset, > + p2->tsc_skew.offset); > + > + goto no_update; > + } else { > + fprintf(warn, "runstate_change old_runstate %s, d%dv%d runstate %s. Possible tsc skew.\n", > + runstate_name[sevt.old_runstate], > + v->d->did, v->vid, > + runstate_name[v->runstate.state]); > + > + v->runstate.last_oldstate.wrong = sevt.old_runstate; > + v->runstate.last_oldstate.actual = v->runstate.state; > + v->runstate.last_oldstate.tsc = ri->tsc; > + v->runstate.last_oldstate.pid = p->pid; > + > + if ( v->runstate.state == RUNSTATE_RUNNING ) > + { > + fprintf(warn, " Not updating.\n"); > + goto no_update; > + } > + goto update; > + } > + fprintf(stderr, "FATAL: Logic hole in %s\n", __func__); > + error(ERR_ASSERT, NULL); > + } > + > +update: > + /* Actually update the runstate. Special things to do if we're starting > + * or stopping actually running on a physical cpu. */ > + if ( type == CONTINUE ) > + { > + if( v->runstate.state == RUNSTATE_INIT ) { > + /* Start-of-day; account first tsc -> now to v */ > + vcpu_start(p, v); > + } else { > + /* Continue running. First, do some sanity checks */ > + if ( v->runstate.state == RUNSTATE_LOST ) { > + fprintf(warn, "WARNING: continue with d%dv%d in RUNSTATE_LOST. Resetting current.\n", > + v->d->did, v->vid); > + if ( p->current ) > + vcpu_prev_update(p, p->current, ri->tsc, RUNSTATE_LOST); > + vcpu_next_update(p, v, ri->tsc); > + } > + else if( v->runstate.state != RUNSTATE_RUNNING ) { > + /* This should never happen. */ > + fprintf(warn, "FATAL: sevt.old_runstate running, but d%dv%d runstate %s!\n", > + v->d->did, v->vid, runstate_name[v->runstate.state]); > + error(ERR_FILE, NULL); > + } else if ( v->p != p ) { > + fprintf(warn, "FATAL: continue on p%d, but d%dv%d p%d!\n", > + p->pid, v->d->did, v->vid, > + v->p ? v->p->pid : -1); > + error(ERR_FILE, NULL); > + } > + > + runstate_update(v, RUNSTATE_RUNNING, ri->tsc); > + } > + } > + else if ( sevt.old_runstate == RUNSTATE_RUNNING > + || v->runstate.state == RUNSTATE_RUNNING ) > + { > +#if 0 > + /* A lot of traces include cpi that shouldn't... */ > + if(perfctrs && v->runstate.tsc) { > + unsigned long long run_cycles, run_instr; > + double cpi; > + > + //run_cycles = r->p1 - v->runstate_p1_start; > + run_cycles = ri->tsc - v->runstate.tsc; > + run_instr = r->p2 - v->runstate.p2_start; > + > + cpi = ((double)run_cycles) / run_instr; > + > + if(opt.dump_all) { > + printf(" cpi: %2.2lf ( %lld / %lld )\n", > + cpi, run_cycles, run_instr); > + } > + > + if(opt.scatterplot_cpi && v->d->did == 1) > + printf("%lld,%2.2lf\n", > + ri->tsc, cpi); > + > + if(opt.summary_info) > + update_cpi(&v->cpi, run_instr, run_cycles); > + } > +#endif > + /* > + * Cases: > + * old running, v running: > + * normal (prev update p, lost record check) > + * v running, old ! running: > + * tsc skew (prev update v->p, lost record check) > + * old running, v init: > + start-of-day (fake update, prev p, lost record) > + * old running, v !{running,init}: > + * # (should never happen) > + */ > + if( sevt.old_runstate == RUNSTATE_RUNNING ) { > + if( v->runstate.state == RUNSTATE_INIT ) { > + /* Start-of-day; account first tsc -> now to v */ > + vcpu_start(p, v); > + } else if( v->runstate.state != RUNSTATE_RUNNING > + && v->runstate.state != RUNSTATE_LOST ) { > + /* This should never happen. */ > + fprintf(warn, "FATAL: sevt.old_runstate running, but d%dv%d runstate %s!\n", > + v->d->did, v->vid, runstate_name[v->runstate.state]); > + error(ERR_FILE, NULL); > + } > + > + vcpu_prev_update(p, v, ri->tsc, sevt.new_runstate); > + } else { > + vcpu_prev_update(v->p, v, ri->tsc, sevt.new_runstate); > + } > + > + if(P.lost_cpus && v->d->did != IDLE_DOMAIN) { > + if(opt.dump_all) > + fprintf(warn, "%s: %d lost cpus, setting d%dv%d runstate to RUNSTATE_LOST\n", > + __func__, P.lost_cpus, v->d->did, v->vid); > + lose_vcpu(v, ri->tsc); > + } > + } > + else if ( sevt.new_runstate == RUNSTATE_RUNNING ) > + { > + if(perfctrs) { > + v->runstate.p1_start = r->p1; > + v->runstate.p2_start = r->p2; > + } > + > + vcpu_next_update(p, v, ri->tsc); > + } > + else if ( v->runstate.state != RUNSTATE_INIT ) > + { > + /* TSC skew at start-of-day is hard to deal with. Don't > + * bring a vcpu out of INIT until it's seen to be actually > + * running somewhere. */ > + runstate_update(v, sevt.new_runstate, ri->tsc); > + } > + > +no_update: > + return; > +} > + > +void sched_switch_process(struct pcpu_info *p) > +{ > + struct vcpu_data *prev, *next; > + struct record_info *ri = &p->ri; > + struct { > + unsigned int prev_dom, prev_vcpu, next_dom, next_vcpu; > + } * r = (typeof(r))ri->d; > + > + if(opt.dump_all) > + printf("%s sched_switch prev d%uv%u next d%uv%u\n", > + ri->dump_header, > + r->prev_dom, r->prev_vcpu, > + r->next_dom, r->next_vcpu); > + > + if(r->prev_vcpu > MAX_CPUS) > + { > + fprintf(warn, "%s: prev_vcpu %u > MAX_VCPUS %d!\n", > + __func__, r->prev_vcpu, MAX_CPUS); > + return; > + } > + > + if(r->next_vcpu > MAX_CPUS) > + { > + fprintf(warn, "%s: next_vcpu %u > MAX_VCPUS %d!\n", > + __func__, r->next_vcpu, MAX_CPUS); > + return; > + } > + > + prev = vcpu_find(r->prev_dom, r->prev_vcpu); > + next = vcpu_find(r->next_dom, r->next_vcpu); > + > + vcpu_prev_update(p, prev, ri->tsc, RUNSTATE_QUEUED); /* FIXME */ > + > + vcpu_next_update(p, next, ri->tsc); > +} > + > +void sched_default_vcpu_activate(struct pcpu_info *p) > +{ > + struct vcpu_data *v = default_domain.vcpu[p->pid]; > + > + if(!v) > + v = vcpu_create(&default_domain, p->pid); > + > + assert(v == v->d->vcpu[v->vid]); > + > + v->activated = 1; > + v->guest_paging_levels = opt.default_guest_paging_levels; > + v->p = p; > + v->runstate.state = RUNSTATE_RUNNING; > + > + p->current = v; > + pcpu_string_draw(p); > +} > + > +void sched_default_domain_init(void) > +{ > + struct domain_data *d = &default_domain; > + > + domain_init(d, DEFAULT_DOMAIN); > +} > + > +void runstate_clear(tsc_t * runstate_cycles) > +{ > + int i; > + for(i=0; i<RUNSTATE_MAX; i++) > + runstate_cycles[i]=0; > +} > + > +void runstate_summary(tsc_t * runstate_cycles) > +{ > + int i; > + for(i=0; i<RUNSTATE_MAX; i++) > + if(runstate_cycles[i]) { > + struct time_struct t; > + cycles_to_time(runstate_cycles[i], &t); > + printf(" %s: %u.%09u s\n", > + runstate_name[i], t.s, t.ns); > + } > +} > + > +void sched_summary_vcpu(struct vcpu_data *v) > +{ > + int i; > + char desc[30]; > + > + /* FIXME: Update all records like this */ > + if ( v->pcpu_tsc ) > + { > + update_cycles(&v->cpu_affinity_all, P.f.last_tsc - v->pcpu_tsc); > + update_cycles(&v->cpu_affinity_pcpu[v->p->pid], P.f.last_tsc - v->pcpu_tsc); > + } > + > + printf(" Runstates:\n"); > + for(i=0; i<RUNSTATE_MAX; i++) { > + snprintf(desc,30, " %8s", runstate_name[i]); > + print_cycle_summary(v->runstates+i, desc); > + if ( i==RUNSTATE_RUNNABLE ) > + { > + int j; > + for(j=0; j<RUNNABLE_STATE_MAX; j++) { > + if ( j == RUNNABLE_STATE_INVALID ) > + continue; > + snprintf(desc,30, " %8s", runnable_state_name[j]); > + print_cycle_summary(v->runnable_states+j, desc); > + } > + } > + } > + print_cpi_summary(&v->cpi); > + print_cpu_affinity(&v->cpu_affinity_all, " cpu affinity"); > + for ( i = 0; i < MAX_CPUS ; i++) > + { > + snprintf(desc,30, " [%d]", i); > + print_cpu_affinity(v->cpu_affinity_pcpu+i, desc); > + } > +} > + > +void sched_summary_domain(struct domain_data *d) > +{ > + int i; > + char desc[30]; > + > + printf(" Runstates:\n"); > + for(i=0; i<DOMAIN_RUNSTATE_MAX; i++) { > + snprintf(desc,30, " %8s", domain_runstate_name[i]); > + print_cycle_summary(d->runstates+i, desc); > + } > +} > + > + > +void sched_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + if(ri->evt.sub == 0xf) { > + switch(ri->event) > + { > + case TRC_SCHED_SWITCH: > + sched_switch_process(p); > + break; > + default: > + process_generic(&p->ri); > + } > + } else { > + if(ri->evt.sub == 1) > + sched_runstate_process(p); > + else { > + UPDATE_VOLUME(p, sched_verbose, ri->size); > + process_generic(&p->ri); > + } > + } > +} > + > +/* ---- Memory ---- */ > +void mem_summary_domain(struct domain_data *d) { > + int i, j; > + > + printf(" Grant table ops:\n"); > + > + printf(" Done by:\n"); > + for(i=0; i<MEM_MAX; i++) > + if(d->memops.done[i]) > + printf(" %-14s: %d\n", > + mem_name[i], > + d->memops.done[i]); > + > + printf(" Done for:\n"); > + for(i=0; i<MEM_MAX; i++) > + if(d->memops.done_for[i]) > + printf(" %-14s: %d\n", > + mem_name[i], > + d->memops.done_for[i]); > + > + printf(" Populate-on-demand:\n"); > + printf(" Populated:\n"); > + for(i=0; i<4; i++) > + { > + if ( d->pod.populate_order[i] ) > + printf(" [%d] %d\n", i, > + d->pod.populate_order[i]); > + } > + printf(" Reclaim order:\n"); > + for(i=0; i<4; i++) > + { > + if ( d->pod.reclaim_order[i] ) > + printf(" [%d] %d\n", i, > + d->pod.reclaim_order[i]); > + } > + printf(" Reclaim contexts:\n"); > + for(j=0; j<POD_RECLAIM_CONTEXT_MAX; j++) > + { > + if ( d->pod.reclaim_context[j] ) > + { > + printf(" * [%s] %d\n", > + pod_reclaim_context_name[j], > + d->pod.reclaim_context[j]); > + for(i=0; i<4; i++) > + { > + if ( d->pod.reclaim_context_order[j][i] ) > + printf(" [%d] %d\n", i, > + d->pod.reclaim_context_order[j][i]); > + } > + } > + } > +} > + > +int p2m_canonical_order(int order) > +{ > + if ( order % 9 > + || (order / 9) > 2 ) > + { > + fprintf(warn, "%s: Strange, non-canonical order %d\n", > + __func__, order); > + order = 4; > + } else { > + order /= 9; > + } > + return order; > +} > + > +void mem_pod_zero_reclaim_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + int context = POD_RECLAIM_CONTEXT_UNKNOWN; > + struct vcpu_data *v = p->current; > + > + struct { > + uint64_t gfn, mfn; > + int d:16,order:16; > + } *r = (typeof(r))ri->d; > + > + if ( v && v->hvm.vmexit_valid ) > + { > + switch(v->hvm.exit_reason) > + { > + case EXIT_REASON_EPT_VIOLATION: > + case EXIT_REASON_EXCEPTION_NMI: > + context = POD_RECLAIM_CONTEXT_FAULT; > + break; > + case EXIT_REASON_VMCALL: > + context = POD_RECLAIM_CONTEXT_BALLOON; > + break; > + } > + } > + > + if ( opt.dump_all ) > + { > + printf(" %s pod_zero_reclaim d%d o%d g %llx m %llx ctx %s\n", > + ri->dump_header, > + r->d, r->order, > + (unsigned long long)r->gfn, (unsigned long long)r->mfn, > + pod_reclaim_context_name[context]); > + > + } > + > + if ( opt.summary_info ) > + { > + struct domain_data *d; > + > + if ( v && (d=v->d) ) > + { > + int order; > + > + order = p2m_canonical_order(r->order); > + > + d->pod.reclaim_order[order]++; > + d->pod.reclaim_context[context]++; > + d->pod.reclaim_context_order[context][order]++; > + } > + } > +} > + > +void mem_pod_populate_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + struct { > + uint64_t gfn, mfn; > + int d:16,order:16; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s pod_populate d%d o%d g %llx m %llx\n", > + ri->dump_header, > + r->d, r->order, > + (unsigned long long)r->gfn, (unsigned long long)r->mfn); > + } > + > + if ( opt.summary_info ) > + { > + struct vcpu_data *v = p->current; > + struct domain_data *d; > + > + if ( v && (d=v->d) ) > + { > + int order; > + > + order = p2m_canonical_order(r->order); > + > + d->pod.populate_order[order]++; > + } > + } > +} > + > +void mem_pod_superpage_splinter_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + struct { > + uint64_t gfn; > + int d:16; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s pod_spage_splinter d%d g %llx\n", > + ri->dump_header, > + r->d, (unsigned long long)r->gfn); > + } > +} > + > +void mem_page_grant(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + struct { > + unsigned domain; > + } *r = (typeof(r))ri->d; > + union pv_event pevt = { .event = ri->event }; > + > + if ( opt.dump_all ) > + { > + printf(" %s %s domain %u\n", ri->dump_header, mem_name[pevt.minor], r->domain); > + } > +} > +void mem_set_p2m_entry_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + struct { > + uint64_t gfn, mfn; > + int p2mt; > + int d:16,order:16; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s set_p2m_entry d%d o%d t %d g %llx m %llx\n", > + ri->dump_header, > + r->d, r->order, > + r->p2mt, > + (unsigned long long)r->gfn, (unsigned long long)r->mfn); > + } > +} > + > +void mem_decrease_reservation_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + struct { > + uint64_t gfn; > + int d:16,order:16; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s decrease_reservation d%d o%d g %llx\n", > + ri->dump_header, > + r->d, r->order, > + (unsigned long long)r->gfn); > + } > +} > + > +void mem_process(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + struct { > + int dom; > + } *r = (typeof(r))ri->d; > + > + int minor = ri->evt.minor; > + > + switch ( minor ) > + { > + case MEM_PAGE_GRANT_MAP: > + case MEM_PAGE_GRANT_UNMAP: > + case MEM_PAGE_GRANT_TRANSFER: > + mem_page_grant(p); > + break; > + case MEM_SET_P2M_ENTRY: > + mem_set_p2m_entry_process(p); > + break; > + case MEM_DECREASE_RESERVATION: > + mem_decrease_reservation_process(p); > + break; > + case MEM_POD_POPULATE: > + mem_pod_populate_process(p); > + break; > + case MEM_POD_ZERO_RECLAIM: > + mem_pod_zero_reclaim_process(p); > + break; > + case MEM_POD_SUPERPAGE_SPLINTER: > + mem_pod_superpage_splinter_process(p); > + break; > + default: > + if(opt.dump_all) { > + dump_generic(stdout, ri); > + } > + > + if(opt.summary_info && minor < MEM_MAX) { > + struct domain_data *d; > + > + if(p->current) { > + if (p->current->d) { > + p->current->d->memops.done[minor]++; > + p->current->d->memops.done_interval[minor]++; > + } > + if((d=domain_find(r->dom))) { > + d->memops.done_for[minor]++; > + d->memops.done_for_interval[minor]++; > + } > + } > + } > + break; > + } > + > +} > + > +/* ---- PM ---- */ > +#define CSTATE_MAX 5 > +#define CSTATE_INVALID ((CSTATE_MAX)+1) > +void pm_process(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + > + switch ( ri->event ) > + { > + case TRC_PM_FREQ_CHANGE: > + if (opt.dump_all ) > + printf(" %s pm_freq_change o%d n%d\n", > + ri->dump_header, > + ri->d[0], > + ri->d[1]); > + break; > + case TRC_PM_IDLE_ENTRY: > + if (opt.dump_all ) > + printf(" %s pm_idle_start c%d\n", > + ri->dump_header, > + ri->d[0]); > + if ( ri->d[0] <= CSTATE_MAX ) > + { > + p->power_state=ri->d[0]; > + pcpu_string_draw(p); > + } > + break; > + case TRC_PM_IDLE_EXIT: > + if (opt.dump_all ) > + printf(" %s pm_idle_end c%d\n", > + ri->dump_header, > + ri->d[0]); > + if ( p->power_state != ri->d[0] > + && p->power_state != CSTATE_INVALID ) > + printf("Strange, pm_idle_end %d, power_state %d!\n", > + ri->d[0], p->power_state); > + p->power_state = 0; > + pcpu_string_draw(p); > + break; > + default: > + if(opt.dump_all) { > + dump_generic(stdout, ri); > + } > + break; > + } > + > +} > + > +/* > + * IRQ related stuff > + */ > + > +#define MAX_VECTOR 256 > +int global_vector_used[256] = {0}; > +struct pci_dev { > + uint8_t bus; > + uint8_t devfn; > + int vector_used[MAX_VECTOR]; > + struct pci_dev *next; > +} *pdev_list; > + > +#define MAX_IRQ 512 > +struct irq_desc { > + enum { > + IRQ_NONE, > + IRQ_MSI, > + IRQ_GSI > + } type; > + struct pci_dev *dev; > +} irq_table[MAX_IRQ]; > + > +struct pci_dev * pdev_find(uint8_t bus, uint8_t devfn) > +{ > + struct pci_dev *d, *n, **q; > + > + /* Look for domain, keeping track of the last pointer so we can add > + a domain if we need to. */ > + for ( d = pdev_list, q=&pdev_list ; > + d && ( (d->bus < bus) > + || (d->bus == bus && d->devfn < devfn) ) ; > + q = &d->next, d=d->next ) ; > + > + if(d && d->bus == bus && d->devfn == devfn) > + return d; > + > + /* Make a new domain */ > + fprintf(warn, "Creating pdev %02x:%02x.%x\n", bus, devfn>>4, devfn&3); > + > + if((n=malloc(sizeof(*n)))==NULL) > + { > + fprintf(stderr, "%s: malloc %zd failed!\n", __func__, sizeof(*n)); > + error(ERR_SYSTEM, NULL); > + } > + > + bzero(n, sizeof(*n)); > + > + n->bus=bus; > + n->devfn=devfn; > + > + /* Insert it into the list */ > + n->next = d; > + *q = n; > + > + return n; > +} > + > +void irq_process(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + > + switch ( ri->event ) > + { > + case TRC_HW_IRQ_BIND_VECTOR: > + { > + struct { > + int irq, vec; > + unsigned mask[4]; > + } *r = (typeof(r))ri->d; > + if ( opt.dump_all ) > + { > + printf(" %s irq_bind_vector irq %x vec %x mask %04x %04x %04x %04x\n", > + ri->dump_header, > + r->irq, r->vec, > + r->mask[3], > + r->mask[2], > + r->mask[1], > + r->mask[0]); > + } > + break; > + } > + case TRC_HW_IRQ_HANDLED: > + { > + struct { > + int irq, start_tsc, end_tsc; > + } *r = (typeof(r))ri->d; > + int arctime; > + > + arctime = r->end_tsc - r->start_tsc; > + if ( opt.dump_all ) > + { > + printf(" %s irq_handled irq %x %d (%d,%d)\n", > + ri->dump_header, > + r->irq, arctime, r->start_tsc, r->end_tsc); > + } > + if ( opt.scatterplot_irq ) > + { > + struct time_struct t; > + > + abs_cycles_to_time(ri->tsc, &t); > + > + printf("i%x %u.%09u %d\n", > + (unsigned)r->irq, > + t.s, t.ns, > + p->pid); > + } > + break; > + } > + case TRC_HW_IRQ_ASSIGN_VECTOR: > + { > + struct { > + int irq, vec; > + unsigned mask[4]; > + } *r = (typeof(r))ri->d; > + if ( opt.dump_all ) > + { > + printf(" %s irq_assign_vector irq %x vec %x mask %04x %04x %04x %04x\n", > + ri->dump_header, > + r->irq, r->vec, > + r->mask[3], > + r->mask[2], > + r->mask[1], > + r->mask[0]); > + } > + if ( r->irq < MAX_IRQ > + && r->vec < MAX_VECTOR ) > + { > + if ( irq_table[r->irq].type == IRQ_MSI ) > + { > + if(global_vector_used[r->vec]) > + fprintf(warn, " Vector collision on global table!\n"); > + global_vector_used[r->vec]=1; > + } > + if( irq_table[r->irq].dev ) > + { > + struct pci_dev * pdev=irq_table[r->irq].dev; > + > + if(pdev->vector_used[r->vec]) > + fprintf(warn, " Vector collision on %02x.%02x!\n", > + pdev->bus, pdev->devfn); > + pdev->vector_used[r->vec]=1; > + } > + } > + break; > + } > + case TRC_HW_IRQ_MOVE_CLEANUP_DELAY: > + { > + struct { > + int irq, vec, cpu; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s irq_move_cleanup_delay irq %x vec %x cpu %d\n", > + ri->dump_header, > + r->irq, r->vec, r->cpu); > + } > + break; > + } > + case TRC_HW_IRQ_MOVE_CLEANUP: > + { > + struct { > + int irq; > + int vec; > + int cpu; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s irq_move_cleanup irq %x vec %x cpu %d\n", > + ri->dump_header, > + r->irq, r->vec, r->cpu); > + } > + if ( r->irq < MAX_IRQ > + && r->vec < MAX_VECTOR ) > + { > + if ( irq_table[r->irq].type == IRQ_MSI ) > + { > + if(!global_vector_used[r->vec]) > + fprintf(warn," Strange, cleanup on non-used vector\n"); > + global_vector_used[r->vec]=0; > + } > + if ( irq_table[r->irq].dev ) > + { > + struct pci_dev * pdev=irq_table[r->irq].dev; > + > + if(!pdev->vector_used[r->vec]) > + fprintf(warn," Strange, cleanup on non-used vector\n"); > + pdev->vector_used[r->vec]=0; > + } > + } > + break; > + } > + case TRC_HW_IRQ_UNMAPPED_VECTOR: > + { > + struct { > + int vec; > + } *r = (typeof(r))ri->d; > + > + if ( opt.dump_all ) > + { > + printf(" %s irq_unmapped_vector vec %x\n", > + ri->dump_header, > + r->vec); > + } > + break; > + } > + case TRC_HW_IRQ_CLEAR_VECTOR: > + case TRC_HW_IRQ_MOVE_FINISH : > + default: > + if(opt.dump_all) { > + dump_generic(stdout, ri); > + } > + break; > + } > +} > + > +#define TRC_HW_SUB_PM 1 > +#define TRC_HW_SUB_IRQ 2 > +void hw_process(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + > + switch(ri->evt.sub) > + { > + case TRC_HW_SUB_PM: > + pm_process(p); > + break; > + case TRC_HW_SUB_IRQ: > + irq_process(p); > + break; > + } > + > +} > +/* ---- Base ----- */ > +void dump_generic(FILE * f, struct record_info *ri) > +{ > + int i; > + > + fprintf(f, "]%s %7x(%x:%x:%x) %u [", > + ri->dump_header, > + ri->event, > + ri->evt.main, > + ri->evt.sub, > + ri->evt.minor, > + ri->extra_words); > + > + for(i=0; i<ri->extra_words; i++) { > + fprintf(f, " %x", ri->d[i]); > + } > + > + fprintf(f, " ]\n"); > +} > + > +void dump_raw(char * s, struct record_info *ri) > +{ > + int i; > + > + if(ri->rec.cycle_flag) > + printf("%s %7x %d %14lld [", > + s, ri->event, ri->extra_words, ri->tsc); > + else > + printf("%s %7x %d %14s [", > + s, ri->event, ri->extra_words, "-"); > + > + for(i=0; i<7; i++) { > + if ( i < ri->extra_words ) > + printf(" %8x", ri->d[i]); > + else > + printf(" "); > + } > + > + printf(" ] | "); > + > + for (i=0; i<8; i++) { > + printf(" %08x", ri->rec.raw[i]); > + } > + > + printf(" |\n"); > +} > + > +void error(enum error_level l, struct record_info *ri) > +{ > + if ( l > opt.tolerance ) > + { > + if ( ri ) > + dump_generic(warn, ri); > + exit(1); > + } > +} > + > +int check_extra_words(struct record_info *ri, > + int expected_size, > + const char *record) > +{ > + static int off_by_one = 0; > + int expected_extra = expected_size / sizeof(unsigned int); > + > + if(ri->extra_words != expected_extra > + && !(off_by_one && ri->extra_words == expected_extra + 1) ) > + { > + if ( !off_by_one && ri->extra_words == expected_extra + 1 ) > + { > + fprintf(warn, "Detected off-by-one bug; relaxing expectations\n"); > + off_by_one=1; > + } > + else { > + fprintf(warn, "ERROR: %s extra_words %d, expected %d!\n", > + record, > + ri->extra_words, expected_extra); > + error(ERR_RECORD, ri); > + return 1; > + } > + } > + return 0; > +} > + > +void process_generic(struct record_info *ri) { > + > + error(ERR_STRICT, ri); > + > + if(opt.dump_all) { > + dump_generic(stdout, ri); > + } > +} > + > +int vcpu_set_data_type(struct vcpu_data *v, int type) > +{ > + if (v->data_type == VCPU_DATA_NONE ) > + { > + v->data_type = type; > + switch(type) > + { > + case VCPU_DATA_HVM: > + init_hvm_data(&v->hvm, v); > + break; > + default: > + break; > + } > + } > + else > + assert(v->data_type == type); > + return 0; > +} > + > + > +void lose_vcpu(struct vcpu_data *v, tsc_t tsc) > +{ > + if(v->data_type == VCPU_DATA_HVM) > + v->hvm.vmexit_valid=0; > + runstate_update(v, RUNSTATE_LOST, tsc); > + hvm_vlapic_clear(&v->vlapic); > + > + if(v->data_type == VCPU_DATA_HVM) { > + int i; > + if(opt.dump_all) > + printf(" [w2h] Clearing w2h state for d%dv%d\n", > + v->d->did, v->vid); > + v->hvm.w2h.interrupts=0; > + v->hvm.w2h.vector=0; > + v->hvm.w2h.waking = 0; > + for(i=0; i<GUEST_INTERRUPT_MAX; i++) { > + if(opt.dump_all && v->hvm.summary.guest_interrupt[i].start_tsc) { > + printf(" Interrupt %d clearing start_tsc %lld\n", > + i, v->hvm.summary.guest_interrupt[i].start_tsc); > + } > + v->hvm.summary.guest_interrupt[i].start_tsc = 0; > + } > + } > +} > + > +struct lost_record_struct { > + int lost_records; > + unsigned did:16,vid:16; > + tsc_t first_tsc; > +}; > + > +void process_lost_records(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + struct lost_record_struct *r = (typeof(r))ri->d; > + tsc_t first_tsc; /* TSC of first record that was lost */ > + > + /* Sanity checks */ > + if(ri->extra_words != 4) > + { > + fprintf(warn, "FATAL: Lost record has unexpected extra words %d!\n", > + ri->extra_words); > + error(ERR_RECORD, ri); > + return; > + } > + > + first_tsc = r->first_tsc; > + > + if(opt.dump_all) > + { > + if(p->current) > + printf(" %s lost_records count %d d%uv%u (cur d%dv%d) first_tsc %lld\n", > + ri->dump_header, r->lost_records, > + r->did, r->vid, > + p->current->d->did, p->current->vid, > + r->first_tsc); > + else > + printf(" %s lost_records count %d d%uv%u (cur X) first_tsc %lld\n", > + ri->dump_header, r->lost_records, > + r->did, r->vid, > + r->first_tsc); > + } > + > +#if 0 > + if(opt.dump_trace_volume_on_lost_record) > + volume_summary(&p->volume.last_buffer); > +#endif > + > + if ( p->current ) { > + > + hvm_vlapic_clear(&p->current->vlapic); > + if(p->current->data_type == VCPU_DATA_HVM) { > + p->current->hvm.vmexit_valid=0; > + cr3_switch(0, &p->current->hvm); > + } > + > + /* We may lose scheduling records; so we need to: > + * - Point all records until now to the next schedule in the > + * "default" domain > + * - Make sure there are no warnings / strangeness with the > + * current vcpu (if it gets scheduled elsewhere). > + */ > + vcpu_prev_update(p, p->current, first_tsc, RUNSTATE_LOST); > + } > +#if 0 > + vcpu_next_update(p, default_domain.vcpu[p->pid], first_tsc); > + if(p->current->data_type == VCPU_DATA_HVM) { > + p->current->hvm.vmexit_valid=0; > + } > +#endif > + > + /* The lost record trace is processed early -- i.e., > + * After the last good record, rather than when the next > + * record is processed. Between the time it's processed and > + * the time it actually went in, the vcpu may be scheduled on > + * other processors. So we can't switch vcpus until the first > + * TSC'd record after the lost record. */ > + if(!p->lost_record.active) { > + P.lost_cpus++; > + if(P.lost_cpus > P.max_active_pcpu + 1) { > + fprintf(warn, "ERROR: P.lost_cpus %d > P.max_active_pcpu + 1 %d!\n", > + P.lost_cpus, P.max_active_pcpu + 1); > + error(ERR_ASSERT, NULL); > + } > + } else > + fprintf(warn, "Strange, lost record for pcpu %d, but lost_record still active!\n", > + p->pid); > + > + p->lost_record.active = 1; > + p->lost_record.tsc = first_tsc; > + pcpu_string_draw(p); > + > + { > + /* Any vcpu which is not actively running may be scheduled on the > + * lost cpu. To avoid mis-accounting, we need to reset */ > + struct domain_data *d; > + int i; > + for(d=domain_list ; d; d=d->next) > + { > + if(d->did != DEFAULT_DOMAIN) { > + for(i=0; i<MAX_CPUS; i++) > + if(d->vcpu[i] && > + d->vcpu[i]->runstate.state != RUNSTATE_RUNNING) { > + if(opt.dump_all) > + fprintf(warn, "%s: setting d%dv%d to RUNSTATE_LOST\n", > + __func__, d->did, i); > + lose_vcpu(d->vcpu[i], first_tsc); > + } > + } > + } > + } > + > + p->lost_record.domain_valid=1; > + p->lost_record.did=r->did; > + p->lost_record.vid=r->vid; > +} > + > + > +void process_lost_records_end(struct pcpu_info *p) > +{ > + struct record_info *ri = &p->ri; > + struct lost_record_struct *r = (typeof(r))ri->d; > + > + if(!p->lost_record.active) { > + fprintf(warn, "FATAL: lost_records_end but pid %d not lost!\n", > + p->pid); > + error(ERR_FILE, NULL); > + return; > + } > + > + /* Lost records. If this is the first record on a pcpu after the loss, > + * Update the information. */ > + if(ri->tsc > p->lost_record.tsc) > + { > + if(opt.dump_all) > + printf(" %s lost_records end ---\n", > + pcpu_string(p->pid)); > + > + update_cycles(&p->time.lost, ri->tsc - p->lost_record.tsc); > + > + if(p->lost_record.domain_valid) { > + int did = p->lost_record.did, > + vid = p->lost_record.vid; > + > + if(opt.dump_all) > + printf(" %s lost_records end d%dv%d---\n", > + pcpu_string(p->pid), > + did, vid); > + if(p->current) > + { > + fprintf(warn, "FATAL: lost_record valid (d%dv%d), but current d%dv%d!\n", > + did, vid, > + p->current->d->did, p->current->vid); > + error(ERR_FILE, NULL); > + return; > + } > + > + if(opt.dump_all) > + fprintf(warn, "Changing p%d current to d%dv%d\n", > + p->pid, did, vid); > + vcpu_next_update(p, > + vcpu_find(did, vid), > + ri->tsc); > + p->lost_record.domain_valid=0; > + p->lost_record.seen_valid_schedule=0; /* Let next vcpu_next_update know that > + this one was inferred */ > + } else { > + if(opt.dump_all) > + printf(" %s lost_records end (domain invalid)---\n", > + pcpu_string(p->pid)); > + } > + > + > + p->lost_record.active = 0; > + pcpu_string_draw(p); > + P.lost_cpus--; > + if(P.lost_cpus < 0) { > + fprintf(warn, "ERROR: lost_cpus fell below 0 for pcpu %d!\n", > + p->pid); > + error(ERR_ASSERT, NULL); > + } > + } > +} > + > +void base_process(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + switch(ri->event) > + { > + case TRC_LOST_RECORDS: > + process_lost_records(p); > + break; > + case TRC_LOST_RECORDS_END: > + process_lost_records_end(p); > + break; > + default: > + process_generic(ri); > + } > + } > + > + > + > +/* Non-compat only */ > +void record_order_insert(struct pcpu_info *new); > +void record_order_remove(struct pcpu_info *rem); > +void record_order_bubble(struct pcpu_info *last); > + > +struct cpu_change_data { > + int cpu; > + unsigned window_size; > +}; > + > +void activate_early_eof(void) { > + struct pcpu_info *p; > + int i; > + > + fprintf(warn, "Short cpu_change window, activating early_eof\n"); > + > + P.early_eof = 1; > + > + for(i=0; i<=P.max_active_pcpu; i++) { > + p = P.pcpu + i; > + if(p->active && p->file_offset > P.last_epoch_offset) { > + fprintf(warn, " deactivating pid %d\n", > + p->pid); > + p->active = 0; > + } > + } > +} > + > +loff_t scan_for_new_pcpu(loff_t offset) { > + ssize_t r; > + struct trace_record rec; > + struct cpu_change_data *cd; > + > + r=__read_record(&rec, offset); > + > + if(r==0) > + return 0; > + > + if(rec.event != TRC_TRACE_CPU_CHANGE > + || rec.cycle_flag) > + { > + fprintf(stderr, "%s: Unexpected record event %x!\n", > + __func__, rec.event); > + error(ERR_ASSERT, NULL); /* Actually file, but can't recover */ > + } > + > + cd = (typeof(cd))rec.u.notsc.data; > + > + if ( cd->cpu > MAX_CPUS ) > + { > + fprintf(stderr, "%s: cpu %d exceeds MAX_CPU %d!\n", > + __func__, cd->cpu, MAX_CPUS); > + /* FIXME: Figure out if we could handle this more gracefully */ > + error(ERR_ASSERT, NULL); > + } > + > + if(cd->cpu > P.max_active_pcpu || !P.pcpu[cd->cpu].active) { > + struct pcpu_info *p = P.pcpu + cd->cpu; > + > + fprintf(warn, "%s: Activating pcpu %d at offset %lld\n", > + __func__, cd->cpu, (unsigned long long)offset); > + > + p->active = 1; > + /* Process this cpu_change record first */ > + p->ri.rec = rec; > + p->ri.size = r; > + __fill_in_record_info(p); > + > + p->file_offset = offset; > + p->next_cpu_change_offset = offset; > + > + record_order_insert(p); > + > + offset += r + cd->window_size; > + > + sched_default_vcpu_activate(p); > + > + if ( cd->cpu > P.max_active_pcpu ) > + P.max_active_pcpu = cd->cpu; > + > + return offset; > + } else { > + return 0; > + } > +} > + > +/* > + * Conceptually, when we reach a cpu_change record that's not for our pcpu, > + * we want to scan forward through the file until we reach one that's for us. > + * However, looping through involves reading the file, which we'd rather > + * do in one place. Because cpu_change records don't include a tsc, > + * the same pcpu will be processed repeatedly until the cpu_change > + * equals p->pid. > + * > + * There are two additional things we need to do in this algorithm: > + * + Detect new pcpus as they come online > + * + De-activate pcpus which don't have any more records > + * > + * Detecting new pcpus which are less than P.max_active_pcpu is straight- > + * forward: when max_active_pcpu is searching for its next cpu window, > + * it will pass by the new cpu's window, and can activate it then. > + * > + * Detecting new pcpus greater than P.max_active_pcpu is a little harder; > + * When max_active_pcpu is scanning for its next cpu window, after it's found > + * it, we need to scan one more window forward to see if its' an already-active > + * pcpu; if not, activate it. > + * > + * We also need to deal with truncated files, where records from one pcpu may > + * be present but not from another pcpu due to lack of disk space. The best > + * thing to do is to find the last "epoch" and essentially truncate the file > + * to that. > + */ > +void deactivate_pcpu(struct pcpu_info *p) > +{ > + if ( p->current ) > + { > + pcpu_runstate_update(p, p->last_tsc); > + > + fprintf(warn, "%s: setting d%dv%d to state LOST\n", > + __func__, p->current->d->did, > + p->current->vid); > + lose_vcpu(p->current, p->last_tsc); > + } > + p->active = 0; > + > + record_order_remove(p); > + > + if ( p->pid == P.max_active_pcpu ) > + { > + int i, max_active_pcpu = -1; > + for(i=0; i<=P.max_active_pcpu; i++) > + { > + if(!P.pcpu[i].active) > + continue; > + > + max_active_pcpu = i; > + } > + P.max_active_pcpu = max_active_pcpu; > + fprintf(warn, "%s: Setting max_active_pcpu to %d\n", > + __func__, max_active_pcpu); > + } > + > +} > + > +/* Helper function to process tsc-related record info */ > +void process_record_tsc(tsc_t order_tsc, struct record_info *ri) > +{ > + /* Find the first tsc set */ > + if(ri->tsc && ri->tsc >= P.f.first_tsc) { > + /* We use the order_tsc to account for the second processing of > + * a lost record. */ > + tsc_t tsc = order_tsc; > + > + if(P.f.first_tsc == 0) { > + P.f.first_tsc = tsc; > + if ( opt.interval_mode ) { > + P.interval.start_tsc = tsc; > + } > + } else { > + if ( opt.interval_mode ) { > + if(P.interval.start_tsc > tsc) { > + fprintf(warn, "FATAL: order_tsc %lld < interval.start_tsc %lld!\n", > + tsc, P.interval.start_tsc); > + error(ERR_FILE, NULL); > + } else { > + while ( tsc - P.interval.start_tsc > opt.interval.cycles ) { > + interval_callback(); > + P.interval.start_tsc += opt.interval.cycles; > + } > + } > + } > + } > + > + P.f.last_tsc=tsc; > + > + P.f.total_cycles = P.f.last_tsc - P.f.first_tsc; > + > + P.now = tsc; > + } > +} > + > +/* Standardized part of dump output */ > +void create_dump_header(struct record_info *ri, struct pcpu_info *p) > +{ > + char * c; > + int len, r; > + > + len = DUMP_HEADER_MAX; > + c = ri->dump_header; > + > + abs_cycles_to_time(ri->tsc, &ri->t); > + > + if ( ri->t.time ) > + { > + r=snprintf(c, len, "%3u.%09u", ri->t.s, ri->t.ns); > + c+=r; > + len-=r; > + } > + else > + { > + r=snprintf(c, > + len, > + " "); > + c+=r; > + len-=r; > + } > + > + r = snprintf(c, len, " %s", pcpu_string(ri->cpu)); > + c+=r; > + len-=r; > + > + if ( p->current ) > + { > + r = snprintf(c, len, " d%dv%d", p->current->d->did, p->current->vid); > + c+=r; > + len-=r; > + } > + else > + { > + r = snprintf(c, len, " d?v?"); > + c+=r; > + len-=r; > + } > +} > + > +int find_toplevel_event(struct record_info *ri) > +{ > + int toplevel=0, i, count; > + > + for(i=0, count=0; i<TOPLEVEL_MAX; i++) > + if(ri->evt.main & (1UL<<i)) > + { > + toplevel=i; > + count++; > + } > + > + /* Sanity check: One and only one bit should be set */ > + if(count != 1) > + { > + fprintf(warn, "FATAL: unexpected number bits(%d) in evt.main! event %x main %x sub %x minor %x\n", > + count, > + ri->event, > + ri->evt.main, ri->evt.sub, ri->evt.minor); > + error(ERR_RECORD, NULL); > + return -1; > + } > + > + return toplevel; > +} > + > + > +void process_cpu_change(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + struct cpu_change_data *r = (typeof(r))ri->d; > + > + if(opt.dump_all && verbosity >= 6) { > + printf("]%s cpu_change this-cpu %u record-cpu %u window_size %u(0x%08x)\n", > + ri->dump_header, p->pid, r->cpu, r->window_size, > + r->window_size); > + } > + > + /* File sanity check */ > + if(p->file_offset != p->next_cpu_change_offset) { > + fprintf(warn, "Strange, pcpu %d expected offet %llx, actual %llx!\n", > + p->pid, (unsigned long long)p->next_cpu_change_offset, > + (unsigned long long)p->file_offset); > + } > + > + if(r->cpu > MAX_CPUS) > + { > + fprintf(stderr, "FATAL: cpu %d > MAX_CPUS %d.\n", > + r->cpu, MAX_CPUS); > + /* Actually file, but takes some work to skip */ > + error(ERR_ASSERT, NULL); > + } > + > + /* Detect beginning of new "epoch" while scanning thru file */ > + if((p->last_cpu_change_pid > r->cpu) > + && (p->file_offset > P.last_epoch_offset)) { > + P.last_epoch_offset = p->file_offset; > + } > + > + /* If that pcpu has never been activated, activate it. */ > + if(!P.pcpu[r->cpu].active && P.pcpu[r->cpu].file_offset == 0) > + { > + struct pcpu_info * p2 = P.pcpu + r->cpu; > + > + p2->active = 1; > + if(r->cpu > P.max_active_pcpu) > + P.max_active_pcpu = r->cpu; > + > + /* Taking this record as the first record should make everything > + * run swimmingly. */ > + p2->ri = *ri; > + p2->ri.cpu = r->cpu; > + p2->ri.d = p2->ri.rec.u.notsc.data; > + p2->file_offset = p->file_offset; > + p2->next_cpu_change_offset = p->file_offset; > + > + fprintf(warn, "%s: Activating pcpu %d at offset %lld\n", > + __func__, r->cpu, (unsigned long long)p->file_offset); > + > + record_order_insert(p2); > + > + sched_default_vcpu_activate(p2); > + } > + > + p->last_cpu_change_pid = r->cpu; > + > + /* If this isn't the cpu we're looking for, skip the whole bunch */ > + if(p->pid != r->cpu) > + { > + p->file_offset += ri->size + r->window_size; > + p->next_cpu_change_offset = p->file_offset; > + > + if(p->file_offset > G.file_size) { > + activate_early_eof(); > + } else if(P.early_eof && p->file_offset > P.last_epoch_offset) { > + fprintf(warn, "%s: early_eof activated, pcpu %d past last_epoch_offset %llx, deactivating.\n", > + __func__, p->pid, (unsigned long long)P.last_epoch_offset); > + deactivate_pcpu(p); > + } > + } > + else > + { > + /* Track information about dom0 scheduling and records */ > + if(opt.dump_trace_volume_on_lost_record) { > + tsc_t cycles; > + struct time_struct t; > + > + /* Update dom0 runstates */ > + cycles = (p->volume.buffer_first_tsc > p->volume.buffer_dom0_runstate_tsc) ? > + p->volume.buffer_first_tsc : > + p->volume.buffer_dom0_runstate_tsc; > + p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate] > + += ri->tsc - cycles; > + > + printf(" - updated p%d dom0_runstate %s to %lld cycles (+%lld)\n", > + p->pid, runstate_name[p->volume.buffer_dom0_runstate], > + p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate], > + ri->tsc - cycles); > + > + /* print info */ > + cycles = ri->tsc - p->volume.buffer_first_tsc; > + cycles_to_time(cycles, &t); > + printf("Buffer time: %u.%09u (%lld cycles)\n", > + t.s, t.ns, cycles); > + if(p->volume.buffer_size) > + printf("Rate: %lld cycles / byte\n", > + cycles / p->volume.buffer_size); > + if(P.buffer_trace_virq_tsc) > + { > + cycles = ri->tsc - P.buffer_trace_virq_tsc; > + cycles_to_time(cycles, &t); > + printf("trace_virq latency: %u.%09u (%lld cycles)\n", > + t.s, t.ns, cycles); > + P.buffer_trace_virq_tsc = 0; > + } > + else > + { > + printf("No trace_virq record found.\n"); > + } > + printf("Dom0 runstates this buffer:\n"); > + runstate_summary(p->volume.buffer_dom0_runstate_cycles); > + volume_summary(&p->volume.last_buffer); > + > + /* reset info */ > + p->volume.buffer_first_tsc = 0; > + p->volume.buffer_size = r->window_size; > + runstate_clear(p->volume.buffer_dom0_runstate_cycles); > + volume_clear(&p->volume.last_buffer); > + } > + > + p->file_offset += ri->size; > + p->next_cpu_change_offset = p->file_offset + r->window_size; > + > + if(p->next_cpu_change_offset > G.file_size) > + activate_early_eof(); > + else if(p->pid == P.max_active_pcpu) > + scan_for_new_pcpu(p->next_cpu_change_offset); > + > + } > +} > + > +struct tl_assert_mask { > + unsigned p_current:1, > + not_idle_domain:1; > + int vcpu_data_mode; > +}; > +static struct tl_assert_mask tl_assert_checks[TOPLEVEL_MAX] = { > + [TRC_HVM_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_HVM }, > + [TRC_SHADOW_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_HVM }, > + [TRC_PV_MAIN]={ .p_current=1, .not_idle_domain=1, .vcpu_data_mode=VCPU_DATA_PV }, > +}; > + > +/* There are a lot of common assumptions for the various processing > + * routines. Check them all in one place, doing something else if > + * they don't pass. */ > +int toplevel_assert_check(int toplevel, struct pcpu_info *p) > +{ > + struct tl_assert_mask mask; > + > + mask = tl_assert_checks[toplevel]; > + > + if (mask.p_current && p->current == NULL) > + { > + fprintf(warn, "WARNING: p->current null! Not processing\n"); > + goto fail; > + } > + > + if( mask.not_idle_domain ) > + { > + /* Can't do this check w/o first doing above check */ > + assert(mask.p_current); > + > + if ( p->current->d->did == IDLE_DOMAIN) { > + fprintf(warn, "WARNING: Unexpected record for idle domain! Not processing\n"); > + goto fail; > + } > + } > + > + if ( mask.vcpu_data_mode ) > + { > + struct vcpu_data *v; > + assert(mask.p_current); > + > + v = p->current; > + > + if ( ! (v->data_type == VCPU_DATA_NONE > + || v->data_type == mask.vcpu_data_mode) ) > + { > + /* This may happen for track_dirty_vram, which causes a SHADOW_WRMAP_BF trace f/ dom0 */ > + fprintf(warn, "WARNING: Unexpected vcpu data type for d%dv%d on proc %d! Expected %d got %d. Not processing\n", > + v->d->did, v->vid, p->pid, > + mask.vcpu_data_mode, > + v->data_type); > + goto fail; > + } > + } > + > + return 1; > + > +fail: > + dump_generic(warn, &p->ri); > + return 0; > +} > + > +void process_record(struct pcpu_info *p) { > + struct record_info *ri = &p->ri; > + int toplevel; > + > + /* Process only TRC_TRACE_CPU_CHANGE */ > + if(ri->event == TRC_TRACE_CPU_CHANGE) { > + process_cpu_change(p); > + return; > + } > + > + if ( opt.dump_no_processing ) > + goto out; > + > + p->summary = 1; > + > + if( opt.dump_raw_process ) > + dump_raw("* ", ri); > + > + process_record_tsc(p->order_tsc, ri); > + > + if(opt.dump_all) > + create_dump_header(ri, p); > + > + > + toplevel = find_toplevel_event(ri); > + if ( toplevel < 0 ) > + return; > + > + /* Unify toplevel assertions */ > + if ( toplevel_assert_check(toplevel, p) ) > + { > + switch(toplevel) { > + case TRC_GEN_MAIN: > + base_process(p); > + break; > + case TRC_SCHED_MAIN: > + sched_process(p); > + break; > + case TRC_HVM_MAIN: > + hvm_process(p); > + break; > + case TRC_SHADOW_MAIN: > + shadow_process(p); > + break; > + case TRC_PV_MAIN: > + pv_process(p); > + break; > + case TRC_MEM_MAIN: > + mem_process(p); > + break; > + case TRC_HW_MAIN: > + hw_process(p); > + break; > + case TRC_DOM0OP_MAIN: > + default: > + process_generic(ri); > + } > + } > + > + UPDATE_VOLUME(p, toplevel[toplevel], ri->size); > + > + if(!p->volume.buffer_first_tsc) > + p->volume.buffer_first_tsc = ri->tsc; > + > + out: > + /* Lost records gets processed twice */ > + if(ri->event != TRC_LOST_RECORDS) > + p->file_offset += ri->size; > +} > + > +static inline ssize_t get_rec_size(struct trace_record *rec) { > + ssize_t s; > + > + s = sizeof(uint32_t); > + > + if(rec->cycle_flag) > + s += sizeof(tsc_t); > + > + s += rec->extra_words * sizeof(uint32_t); > + > + return s; > +} > + > +#define STDIN 0 > + > +void progress_child_exec(void) { > + fclose(stdin); > + dup2(G.progress.pipe[0], STDIN); > + > + execlp("zenity", "zenity", "--progress", "--auto-close", "--title", > + "Analyzing", "--text", G.trace_file, "--auto-kill", NULL); > +} > + > +void progress_init(void) { > + int pid; > + > + if (pipe(G.progress.pipe) < 0) > + perror("pipe"); > + > + if(!(pid = fork())) { > + progress_child_exec(); > + > + fprintf(stderr, "%s: exec failed (%s), disabling progress bar\n", > + __func__, strerror(errno)); > + opt.progress = 0; > + exit(1); > + } else if( pid < 0 ) { > + fprintf(stderr, "%s: could not fork: %s, disabling progress bar\n", > + __func__, strerror(errno)); > + opt.progress = 0; > + } > + > + if( (G.progress.out = fdopen(G.progress.pipe[1], "w")) < 0 ) { > + fprintf(stderr, "%s: could not fdopen pipe: %s, disabling progress bar\n", > + __func__, strerror(errno)); > + opt.progress = 0; > + } > + > +} > + > +void progress_update(loff_t offset) { > + long long p; > + > + p = ( offset * 100 ) / G.file_size; > + > + fprintf(G.progress.out, "%lld\n", p); > + fflush(G.progress.out); > + > + p += 1; > + > + G.progress.update_offset = ( G.file_size * p ) / 100; > + > +#if 0 > + fprintf(stderr, "Progress: %lld %% Next update_offset: %lld\n", > + p-1, > + G.progress.update_offset); > +#endif > +} > + > +void progress_finish(void) { > + int pid; > + > + fprintf(G.progress.out, "100\n"); > + fflush(G.progress.out); > + fclose(G.progress.out); > + > + wait(NULL); > + > + if(!(pid = fork())) { > + /* Child */ > + char text[128]; > + > + snprintf(text, 128, "Finished analyzing %s", > + G.trace_file); > + execlp("zenity", "zenity", "--info", "--text", text, NULL); > + } > +} > + > +ssize_t __read_record(struct trace_record *rec, loff_t offset) > +{ > + ssize_t r, rsize; > + > + r=mread64(G.mh, rec, sizeof(*rec), offset); > + > + if(r < 0) { > + /* Read error */ > + perror("read"); > + fprintf(stderr, "offset %llx\n", (unsigned long long)offset); > + return 0; > + } else if(r==0) { > + /* End-of-file */ > + return 0; > + } else if(r < sizeof(uint32_t)) { > + /* Full header not read */ > + fprintf(stderr, "%s: short read (%zd bytes)\n", > + __func__, r); > + error(ERR_SYSTEM, NULL); > + } > + > + rsize=get_rec_size(rec); > + > + if(r < rsize) { > + /* Full record not read */ > + fprintf(stderr, "%s: short read (%zd, expected %zd)\n", > + __func__, r, rsize); > + return 0; > + } > + > + return rsize; > +} > + > +void __fill_in_record_info(struct pcpu_info *p) > +{ > + struct record_info *ri; > + tsc_t tsc=0; > + > + ri = &p->ri; > + > + ri->event = ri->rec.event; > + ri->extra_words = ri->rec.extra_words; > + > + if(ri->rec.cycle_flag) { > + tsc = (((tsc_t)ri->rec.u.tsc.tsc_hi) << 32) > + | ri->rec.u.tsc.tsc_lo; > + > + tsc += p->tsc_skew.offset; > + > + ri->tsc = tsc; > + ri->d = ri->rec.u.tsc.data; > + > + if(p->first_tsc == 0) > + p->first_tsc = tsc; > + > + /* We process lost record twice: once at the first_tsc, > + once at the time it was placed in the log */ > + if(ri->event == TRC_LOST_RECORDS && ri->extra_words == 4) { > + struct lost_record_struct *r = (typeof(r))ri->d; > + p->order_tsc = r->first_tsc + p->tsc_skew.offset; > + } else > + p->order_tsc = tsc; > + > + p->last_tsc = tsc; > + } else { > + ri->tsc = p->last_tsc; > + ri->d = ri->rec.u.notsc.data; > + } > + > + if ( opt.dump_raw_reads ) { > + char s[256]; > + snprintf(s, 256, "R p%2d o%016llx ", > + p->pid, (unsigned long long)p->file_offset); > + dump_raw(s, ri); > + } > + > + /* Updated tracing uses CPU_CHANGE. If we hit one of these, > + * it will process very next (since the tsc isn't updated), and > + * we'll skip forward appropriately. */ > + ri->cpu = p->pid; > +} > + > +ssize_t read_record(struct pcpu_info * p) { > + loff_t * offset; > + struct record_info *ri; > + > + offset = &p->file_offset; > + ri = &p->ri; > + > + ri->size = __read_record(&ri->rec, *offset); > + if(ri->size) > + { > + __fill_in_record_info(p); > + } > + else > + { > + fprintf(warn, "%s: read returned zero, deactivating pcpu %d\n", > + __func__, p->pid); > + deactivate_pcpu(p); > + } > + > + return ri->size; > +} > + > +/* > + * This funciton gets called for every record when doing dump. Try to > + * make it efficient by changing the minimum amount from the last > + * call. Do this by: > + * - Keeping track of the last pcpu called, so we can just set that to - > + * - Keeping track of how many pcpus we've "drawn", and only "drawing" new ones > + * - Updating the current one > + * > + * FIXME: Need to deal with pcpu states changing... > + * > + * WARNING not thread-safe > + */ > + > +char __pcpu_string[MAX_CPUS+1] = { 0 }; > +void pcpu_string_draw(struct pcpu_info *p) > +{ > + char *s = __pcpu_string; > + int i=p->pid; > + > + if(p->lost_record.active) > + s[i]='l'; > + else if (!p->current) > + s[i]=' '; > + else if (p->current->d->did == DEFAULT_DOMAIN) > + s[i]='.'; > + else if (p->current->d->did == IDLE_DOMAIN) > + { > + if ( opt.dump_show_power_states ) > + s[i]=p->power_state+'0'; > + else > + s[i]='-'; > + } > + else > + s[i]='|'; > +} > + > +char * pcpu_string(int pcpu) > +{ > + char *s = __pcpu_string; > + static int max_active_pcpu=-1, last_pcpu=-1; > + > + assert(P.max_active_pcpu < MAX_CPUS); > + assert(pcpu <= P.max_active_pcpu); > + > + if(last_pcpu >= 0) > + pcpu_string_draw(P.pcpu+last_pcpu); > + > + if(P.max_active_pcpu > max_active_pcpu) > + { > + int i; > + for(i=max_active_pcpu + 1; i<= P.max_active_pcpu; i++) > + pcpu_string_draw(P.pcpu+i); > + max_active_pcpu=P.max_active_pcpu; > + } > + > + s[pcpu]='x'; > + last_pcpu = pcpu; > + > + return s; > +} > + > +/* Null terminated */ > +struct pcpu_info *record_order[MAX_CPUS+1] = { 0 }; > + > +/* In the case of identical tsc values, the old algorithm would favor the > + * pcpu with the lowest number. By default the new algorithm favors the > + * pcpu which has been processed most recently. > + * > + * I think the second way is better; but it's good to be able to use the > + * old ordering, at very lest to verify that there are no (other) ordering > + * differences. Enabling the below flag will cause the insertion / bubble > + * routines to order by pcpu id as well as tsc, preserving the old order. */ > +//#define PRESERVE_PCPU_ORDERING > + > +/* Steady state: > + * + Entire list is in order, except (potentially) for the first entry > + * + last is pointing to the first entry. > + */ > +void record_order_bubble(struct pcpu_info *last) > +{ > + int i; > + > + /* Find the pcpu to "bubble". This is usually the > + * first one, but if other pcpus have been activated, it may > + * not be. */ > + for(i=0; record_order[i] && record_order[i]!=last; i++); > + > + assert(record_order[i]); > + > + /* Now bubble it down */ > + for( ; > + record_order[i+1] > + && ( record_order[i+1]->order_tsc < last->order_tsc > +#ifdef PRESERVE_PCPU_ORDERING > + || ( record_order[i+1]->order_tsc == last->order_tsc > + && record_order[i+1]->pid < last->pid ) > +#endif > + ) ; > + i++) > + record_order[i]=record_order[i+1]; > + record_order[i]=last; > +} > + > +void record_order_insert(struct pcpu_info *new) > +{ > + int i; > + struct pcpu_info *p=NULL, *t=NULL; > + > + /* Sanity check: Make sure it's not already in there */ > + for(i=0; record_order[i]; i++) > + assert(record_order[i]!=new); > + > + /* Find where to insert it */ > + for(i=0; > + record_order[i] > + && ( record_order[i]->order_tsc < new->order_tsc > +#ifdef PRESERVE_PCPU_ORDERING > + || ( record_order[i]->order_tsc == new->order_tsc > + && record_order[i]->pid < new->pid ) > +#endif > + ) ; > + i++) > + ; > + > + /* And insert it */ > + for( p=new; p ; i++) > + { > + t=record_order[i]; > + record_order[i]=p; > + p=t; > + } > +} > + > +void record_order_remove(struct pcpu_info *rem) > +{ > + int i; > + > + /* Find where the record is */ > + for(i=0; record_order[i] && record_order[i]!=rem; i++) > + ; > + > + /* Sanity check: Make sure it's actually there! */ > + assert(record_order[i]); > + > + /* And move everyone forward */ > + for(; (record_order[i]=record_order[i+1]); i++) > + ; > +} > + > +struct pcpu_info * choose_next_record(void) > +{ > + struct pcpu_info *min_p=NULL; > + > + min_p=record_order[0]; > + > + if(opt.progress && min_p && min_p->file_offset >= G.progress.update_offset) > + progress_update(min_p->file_offset); > + > + /* If there are active pcpus, make sure we chose one */ > + assert(min_p || (P.max_active_pcpu==-1)); > + > + return min_p; > +} > + > +void process_records(void) { > + while(1) { > + struct pcpu_info *p = NULL; > + > + if(!(p=choose_next_record())) > + return; > + > + process_record(p); > + > + /* Lost records gets processed twice. */ > + if(p->ri.event == TRC_LOST_RECORDS) { > + p->ri.event = TRC_LOST_RECORDS_END; > + if(p->ri.tsc > p->order_tsc) > + p->order_tsc = p->ri.tsc; > + else { > + fprintf(warn, "Strange, lost_record ri->tsc %lld !> p->order_tsc %lld!\n", > + p->ri.tsc, p->order_tsc); > + error(ERR_FILE, NULL); > + } > + } > + else > + read_record(p); > + > + /* Update this pcpu in the processing order */ > + if ( p->active ) > + record_order_bubble(p); > + } > +} > + > +void vcpu_summary(struct vcpu_data *v) > +{ > + printf("-- v%d --\n", v->vid); > + sched_summary_vcpu(v); > + switch(v->data_type) { > + case VCPU_DATA_HVM: > + hvm_summary(&v->hvm); > + break; > + case VCPU_DATA_PV: > + pv_summary(&v->pv); > + break; > + default: > + break; > + } > +} > + > +void domain_summary(void) > +{ > + struct domain_data * d; > + int i; > + > + if(opt.show_default_domain_summary) { > + d = &default_domain; > + printf("|-- Default domain --|\n"); > + > + for( i = 0; i < MAX_CPUS ; i++ ) > + { > + if(d->vcpu[i]) > + vcpu_summary(d->vcpu[i]); > + } > + } > + > + for ( d = domain_list ; d ; d=d->next ) > + { > + int i; > + printf("|-- Domain %d --|\n", d->did); > + > + sched_summary_domain(d); > + > + mem_summary_domain(d); > + > + for( i = 0; i < MAX_CPUS ; i++ ) > + { > + if(d->vcpu[i]) > + vcpu_summary(d->vcpu[i]); > + } > + > + printf("Emulate eip list\n"); > + dump_eip(d->emulate_eip_list); > + > + if ( opt.with_interrupt_eip_enumeration ) > + { > + printf("Interrupt eip list (vector %d)\n", > + opt.interrupt_eip_enumeration_vector); > + dump_eip(d->interrupt_eip_list); > + } > + > + cr3_dump_list(d->cr3_value_head); > + } > +} > + > +char * stringify_cpu_hz(long long cpu_hz); > + > +void summary(void) { > + int i; > + printf("Total time: %.2lf seconds (using cpu speed %s)\n", > + ((double)(P.f.total_cycles))/opt.cpu_hz, > + stringify_cpu_hz(opt.cpu_hz)); > + printf("--- Log volume summary ---\n"); > + for(i=0; i<MAX_CPUS; i++) > + { > + struct pcpu_info *p = P.pcpu+i; > + if(!p->summary) > + continue; > + printf(" - cpu %d -\n", i); > + volume_summary(&p->volume.total); > + } > + domain_summary(); > +} > + > +void report_pcpu(void) { > + int i, active=0; > + > + for(i=0; i<MAX_CPUS; i++) > + { > + struct pcpu_info *p = P.pcpu+i; > + if(!p->summary) > + continue; > + printf("pcpu %d\n", i); > + > + print_cycle_summary(&p->time.running, " running"); > + print_cycle_summary(&p->time.idle, " idle"); > + print_cycle_summary(&p->time.lost, " lost"); > + > + if ( p->time.running.count ) > + active++; > + } > + printf("Total active cpus: %d\n", active); > + > +} > + > +void init_pcpus(void) { > + int i=0; > + loff_t offset = 0; > + > + for(i=0; i<MAX_CPUS; i++) > + { > + P.pcpu[i].pid=i; > + P.pcpu[i].lost_record.seen_valid_schedule=1; > + P.pcpu[i].power_state=CSTATE_INVALID; > + } > + > + P.max_active_pcpu = -1; > + > + sched_default_domain_init(); > + > + /* Scan through the cpu_change recs until we see a duplicate */ > + do { > + offset = scan_for_new_pcpu(offset); > + > + if(!offset) { > + fprintf(warn, "%s: through first trace write, done for now.\n", > + __func__); > + } > + } while(offset); > + > +} > + > +enum { > + OPT_NULL=0, > + /* Dumping info */ > + OPT_DUMP_RAW_READS, > + OPT_DUMP_RAW_PROCESS, > + OPT_DUMP_NO_PROCESSING, > + OPT_DUMP_IPI_LATENCY, > + OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD, > + OPT_DUMP_SHOW_POWER_STATES, > + /* Extra tracking functionality */ > + OPT_WITH_CR3_ENUMERATION, > + OPT_WITH_PIO_ENUMERATION, > + OPT_WITH_MMIO_ENUMERATION, > + OPT_WITH_INTERRUPT_EIP_ENUMERATION, > + OPT_SCATTERPLOT_INTERRUPT_EIP, > + OPT_SCATTERPLOT_CPI, > + OPT_SCATTERPLOT_UNPIN_PROMOTE, > + OPT_SCATTERPLOT_CR3_SWITCH, > + OPT_SCATTERPLOT_WAKE_TO_HALT, > + OPT_SCATTERPLOT_IO, > + OPT_SCATTERPLOT_VMEXIT_EIP, > + OPT_SCATTERPLOT_RUNSTATE, > + OPT_SCATTERPLOT_RUNSTATE_TIME, > + OPT_SCATTERPLOT_PCPU, > + OPT_SCATTERPLOT_EXTINT_CYCLES, > + OPT_SCATTERPLOT_RDTSC, > + OPT_SCATTERPLOT_IRQ, > + OPT_HISTOGRAM_INTERRUPT_EIP, > + /* Interval options */ > + OPT_INTERVAL_CR3_SCHEDULE_TIME, > + OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL, > + OPT_INTERVAL_CR3_SCHEDULE_ORDERED, > + OPT_INTERVAL_CR3_SHORT_SUMMARY, > + OPT_INTERVAL_DOMAIN_TOTAL_TIME, > + OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL, > + OPT_INTERVAL_DOMAIN_SHORT_SUMMARY, > + OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT, > + OPT_INTERVAL_DOMAIN_GRANT_MAPS, > + /* Summary info */ > + OPT_SHOW_DEFAULT_DOMAIN_SUMMARY, > + OPT_MMIO_ENUMERATION_SKIP_VGA, > + OPT_SAMPLE_SIZE, > + OPT_REPORT_PCPU, > + /* Guest info */ > + OPT_DEFAULT_GUEST_PAGING_LEVELS, > + OPT_SYMBOL_FILE, > + /* Hardware info */ > + OPT_SVM_MODE, > + OPT_CPU_HZ, > + /* Misc */ > + OPT_PROGRESS, > + OPT_TOLERANCE, > + OPT_TSC_LOOP_FATAL, > + /* Specific letters */ > + OPT_DUMP_ALL='a', > + OPT_INTERVAL_LENGTH='i', > + OPT_SUMMARY='s', > +}; > + > +enum { > + OPT_GROUP_SUMMARY=1, > + OPT_GROUP_DUMP, > + OPT_GROUP_INTERVAL, > + OPT_GROUP_EXTRA, > + OPT_GROUP_GUEST, > + OPT_GROUP_HARDWARE > +}; > + > +#define xstr(x) str(x) > +#define str(x) #x > + > +#define GHZ 1000000000LL > +#define MHZ 1000000LL > +#define KHZ 1000LL > + > +void parse_cpu_hz(char * arg) { > + float hz_base; > + char * next_ptr; > + > + hz_base=strtof(arg, &next_ptr); > + if(next_ptr == arg) { > + fprintf(stderr, "Invalid cpu_hz %s\n", arg); > + exit(1); > + } > + switch(*next_ptr) { > + case '\0': > + opt.cpu_hz=(long long)hz_base; > + break; > + case 'G': > + opt.cpu_hz= hz_base * GHZ; > + break; > + case 'M': > + opt.cpu_hz=hz_base * MHZ; > + break; > + case 'K': > + opt.cpu_hz=hz_base * KHZ; > + break; > + default: > + fprintf(stderr, "Unknown suffix %c\n", *next_ptr); > + exit(1); > + } > + /* Just a convenient pre-calculation */ > + opt.cpu_qhz = QHZ_FROM_HZ(opt.cpu_hz); > +} > + > +/* WARNING not thread-safe */ > +char * stringify_cpu_hz(long long cpu_hz) { > + static char cpu_string[20], suffix; > + float hz; > + > + if(cpu_hz > GHZ) { > + hz = (float)cpu_hz / GHZ; > + suffix = 'G'; > + } else if(cpu_hz > MHZ) { > + hz = (float)cpu_hz / MHZ; > + suffix = 'M'; > + } else if(cpu_hz > KHZ) { > + hz = (float)cpu_hz / KHZ; > + suffix = 'k'; > + } else { > + hz = cpu_hz; > + suffix = ' '; > + } > + > + snprintf(cpu_string, 20, "%1.2lf %cHz", hz, suffix); > + > + return cpu_string; > +} > + > +int parse_array(char *arg, struct array_struct *a) { > + char *p, *q; > + int n=1, i; > + > + /* Count the number of commas (and thus the number of elements) */ > + for(p=arg; *p; p++) > + if(*p == ',') > + n++; > + > + fprintf(warn, "%s: Found %d elements\n", __func__, n); > + fflush(warn); > + a->count = n; > + a->values = malloc(n * sizeof(unsigned long long)); > + > + if(!a->values) { > + fprintf(stderr, "Malloc failed!\n"); > + error(ERR_SYSTEM, NULL); > + } > + > + /* Now parse the elements */ > + p = q = arg; > + for(i=0; i<n; i++) { > + a->values[i] = strtoull(p, &q, 0); > + if(p == q) { > + fprintf(stderr, "Bad format: %s\n", q); > + return -1; > + } > + fprintf(warn, "%s: Found element 0x%llx (%lld)\n", > + __func__, a->values[i], > + a->values[i]); > + fflush(warn); > + if(*q == ',') > + q++; > + else if(*q != '\0') { > + fprintf(stderr, "Bad format: %s\n", q); > + return -1; > + } > + p=q; > + } > + > + return n; > +} > + > +error_t cmd_parser(int key, char *arg, struct argp_state *state) > +{ > + switch (key) > + { > + /* Dump group */ > + case OPT_DUMP_ALL: > + opt.dump_all = 1; > + G.output_defined = 1; > + break; > + case OPT_DUMP_RAW_READS: > + opt.dump_raw_reads = 1; > + G.output_defined = 1; > + break; > + case OPT_DUMP_NO_PROCESSING: > + opt.dump_no_processing = 1; > + opt.dump_raw_reads = 1; > + G.output_defined = 1; > + break; > + case OPT_DUMP_RAW_PROCESS: > + opt.dump_raw_process = 1; > + G.output_defined = 1; > + break; > + case OPT_DUMP_IPI_LATENCY: > + opt.dump_ipi_latency = 1; > + break; > + case OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD: > + opt.dump_trace_volume_on_lost_record = 1; > + break; > + case OPT_DUMP_SHOW_POWER_STATES: > + opt.dump_show_power_states = 1; > + break; > + /* Extra group */ > + case OPT_WITH_CR3_ENUMERATION: > + opt.with_cr3_enumeration=1; > + break; > + case OPT_WITH_PIO_ENUMERATION: > + opt.with_pio_enumeration=1; > + break; > + case OPT_WITH_MMIO_ENUMERATION: > + opt.with_mmio_enumeration=1; > + break; > + case OPT_SHOW_DEFAULT_DOMAIN_SUMMARY: > + opt.show_default_domain_summary=1; > + break; > + case OPT_SAMPLE_SIZE: > + { > + char * inval; > + opt.sample_size = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + break; > + } > + case OPT_MMIO_ENUMERATION_SKIP_VGA: > + { > + char * inval; > + opt.mmio_enumeration_skip_vga = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + break; > + } > + case OPT_SCATTERPLOT_INTERRUPT_EIP: > + { > + char * inval; > + G.output_defined = 1; > + opt.scatterplot_interrupt_eip=1; > + opt.scatterplot_interrupt_vector = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + } > + break; > + case OPT_WITH_INTERRUPT_EIP_ENUMERATION: > + { > + char * inval; > + opt.with_interrupt_eip_enumeration=1; > + opt.interrupt_eip_enumeration_vector = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + } > + break; > + case OPT_SCATTERPLOT_CPI: > + G.output_defined = 1; > + opt.scatterplot_cpi=1; > + break; > + case OPT_SCATTERPLOT_UNPIN_PROMOTE: > + G.output_defined = 1; > + opt.scatterplot_unpin_promote=1; > + break; > + case OPT_SCATTERPLOT_CR3_SWITCH: > + G.output_defined = 1; > + opt.scatterplot_cr3_switch=1; > + break; > + case OPT_SCATTERPLOT_WAKE_TO_HALT: > + G.output_defined = 1; > + opt.scatterplot_wake_to_halt=1; > + break; > + case OPT_SCATTERPLOT_VMEXIT_EIP: > + G.output_defined = 1; > + opt.scatterplot_vmexit_eip=1; > + break; > + case OPT_SCATTERPLOT_EXTINT_CYCLES: > + { > + char * inval; > + G.output_defined = 1; > + opt.scatterplot_extint_cycles=1; > + opt.scatterplot_extint_cycles_vector = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + } > + break; > + case OPT_SCATTERPLOT_RDTSC: > + G.output_defined = 1; > + opt.scatterplot_rdtsc=1; > + break; > + case OPT_SCATTERPLOT_IRQ: > + G.output_defined = 1; > + opt.scatterplot_irq=1; > + break; > + case OPT_SCATTERPLOT_IO: > + { > + char * inval; > + G.output_defined = 1; > + opt.scatterplot_io=1; > + opt.scatterplot_io_port = (int)strtol(arg, &inval, 0); > + if( inval == arg ) > + argp_usage(state); > + } > + break; > + case OPT_SCATTERPLOT_RUNSTATE: > + G.output_defined = 1; > + opt.scatterplot_runstate=1; > + break; > + case OPT_SCATTERPLOT_RUNSTATE_TIME: > + G.output_defined = 1; > + opt.scatterplot_runstate_time=1; > + break; > + case OPT_SCATTERPLOT_PCPU: > + G.output_defined = 1; > + opt.scatterplot_pcpu=1; > + break; > + case OPT_HISTOGRAM_INTERRUPT_EIP: > + { > + char * inval, *p; > + > + opt.histogram_interrupt_eip=1; > + opt.histogram_interrupt_vector = (int)strtol(arg, &inval, 0); > + > + if( inval == arg ) > + argp_usage(state); > + > + p = inval; > + > + if(*p == ',') > + opt.histogram_interrupt_increment = (unsigned long long)strtoull(p+1, &inval, 0); > + else > + opt.histogram_interrupt_increment = 0x1000000; > + > + printf("Making histogram of eips at interrupt %d, increment %llx\n", > + opt.histogram_interrupt_vector, > + opt.histogram_interrupt_increment); > + } > + break; > + > + case OPT_INTERVAL_LENGTH: > + { > + char * inval; > + > + opt.interval.msec = (unsigned) (strtof(arg, &inval) * 1000); > + > + if ( inval == arg ) > + argp_usage(state); > + > + break; > + } > + > + case OPT_INTERVAL_CR3_SCHEDULE_TIME: > + { > + if(parse_array(arg, &opt.interval.array) < 0) > + goto usage; > + interval_table_alloc(opt.interval.array.count); > + opt.interval.output = INTERVAL_CR3_SCHEDULE_TIME; > + opt.interval.check = INTERVAL_CHECK_CR3; > + opt.interval.mode = INTERVAL_MODE_ARRAY; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + opt.with_cr3_enumeration = 1; > + G.output_defined = 1; > + break; > + usage: > + fprintf(stderr, "Invalid input for cr3_schedule_time\n"); > + argp_usage(state); > + break; > + } > + > + case OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL: > + opt.interval.output = INTERVAL_CR3_SCHEDULE_TIME; > + opt.interval.check = INTERVAL_CHECK_CR3; > + opt.interval.mode = INTERVAL_MODE_LIST; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + opt.with_cr3_enumeration = 1; > + G.output_defined = 1; > + break; > + > + case OPT_INTERVAL_CR3_SCHEDULE_ORDERED: > + opt.interval.output = INTERVAL_CR3_SCHEDULE_ORDERED; > + opt.interval.check = INTERVAL_CHECK_CR3; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + opt.with_cr3_enumeration = 1; > + G.output_defined = 1; > + break; > + > + case OPT_INTERVAL_CR3_SHORT_SUMMARY: > + { > + if(parse_array(arg, &opt.interval.array) < 0 > + || opt.interval.array.count != 1) > + goto usage; > + opt.interval.output = INTERVAL_CR3_SHORT_SUMMARY; > + opt.interval.check = INTERVAL_CHECK_CR3; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + opt.with_cr3_enumeration = 1; > + G.output_defined = 1; > + break; > + } > + > + case OPT_INTERVAL_DOMAIN_TOTAL_TIME: > + { > + if(parse_array(arg, &opt.interval.array) < 0) > + goto idtt_usage; > + interval_table_alloc(opt.interval.array.count); > + opt.interval.output = INTERVAL_DOMAIN_TOTAL_TIME; > + opt.interval.check = INTERVAL_CHECK_DOMAIN; > + opt.interval.mode = INTERVAL_MODE_ARRAY; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + idtt_usage: > + fprintf(stderr, "Invalid input for domain_total_time\n"); > + argp_usage(state); > + break; > + } > + > + case OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL: > + opt.interval.output = INTERVAL_DOMAIN_TOTAL_TIME; > + opt.interval.check = INTERVAL_CHECK_DOMAIN; > + opt.interval.mode = INTERVAL_MODE_LIST; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + > + case OPT_INTERVAL_DOMAIN_SHORT_SUMMARY: > + { > + if((parse_array(arg, &opt.interval.array) < 0) > + || opt.interval.array.count != 1) > + argp_usage(state); > + > + opt.interval.output = INTERVAL_DOMAIN_SHORT_SUMMARY; > + opt.interval.check = INTERVAL_CHECK_DOMAIN; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + } > + > + case OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT: > + { > + if((parse_array(arg, &opt.interval.array) < 0) > + || opt.interval.array.count != 1) > + argp_usage(state); > + > + opt.interval.output = INTERVAL_DOMAIN_GUEST_INTERRUPT; > + opt.interval.check = INTERVAL_CHECK_DOMAIN; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + } > + > + case OPT_INTERVAL_DOMAIN_GRANT_MAPS: > + { > + if((parse_array(arg, &opt.interval.array) < 0) > + || opt.interval.array.count != 1) > + argp_usage(state); > + > + opt.interval.output = INTERVAL_DOMAIN_GRANT_MAPS; > + opt.interval.check = INTERVAL_CHECK_DOMAIN; > + opt.interval_mode = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + } > + > + /* Summary group */ > + case OPT_SUMMARY: > + opt.summary = 1; > + opt.summary_info = 1; > + G.output_defined = 1; > + break; > + case OPT_REPORT_PCPU: > + opt.report_pcpu = 1; > + //opt.summary_info = 1; > + G.output_defined = 1; > + break; > + /* Guest info group */ > + case OPT_DEFAULT_GUEST_PAGING_LEVELS: > + { > + char *inval; > + opt.default_guest_paging_levels = (int)strtol(arg, &inval, 0); > + if ( inval == arg ) > + argp_usage(state); > + } > + break; > + case OPT_SYMBOL_FILE: > + /* FIXME - strcpy */ > + G.symbol_file = arg; > + break; > + /* Hardware info group */ > + case OPT_SVM_MODE: > + opt.svm_mode = 1; > + break; > + case OPT_CPU_HZ: > + parse_cpu_hz(arg); > + break; > + break; > + > + case OPT_TOLERANCE: > + { > + char * inval; > + > + opt.tolerance = (int)strtol(arg, &inval, 0); > + > + if( inval == arg ) > + argp_usage(state); > + > + if ( opt.tolerance > ERR_MAX_TOLERABLE ) > + { > + fprintf(stderr, "ERROR: Max tolerable error %d\n", > + ERR_MAX_TOLERABLE); > + exit(1); > + } > + > + printf("Tolerating errors at or below %d\n", > + opt.tolerance); > + } > + break; > + > + case OPT_PROGRESS: > + opt.progress = 1; > + break; > + > + case OPT_TSC_LOOP_FATAL: > + opt.tsc_loop_fatal = 1; > + break; > + > + case ARGP_KEY_ARG: > + { > + /* FIXME - strcpy */ > + if (state->arg_num == 0) > + G.trace_file = arg; > + else > + argp_usage(state); > + } > + break; > + case ARGP_KEY_END: > + { > + if(opt.interval_mode) { > + opt.interval.cycles = ( opt.interval.msec * opt.cpu_hz ) / 1000 ; > + interval_header(); > + } > + > + if(!G.output_defined) > + { > + fprintf(stderr, "No output defined, using summary.\n"); > + opt.summary = 1; > + opt.summary_info = 1; > + } > + fprintf(stderr, "Using %s hardware-assisted virtualization.\n", > + opt.svm_mode?"SVM":"VMX"); > + } > + break; > + > + default: > + return ARGP_ERR_UNKNOWN; > + } > + > + return 0; > +} > + > +const struct argp_option cmd_opts[] = { > + /* Dump group */ > + { .name = "dump-all", > + .key = OPT_DUMP_ALL, > + .group = OPT_GROUP_DUMP, > + .doc = "Dump all records as they come in.", }, > + > + { .name = "dump-raw-reads", > + .key = OPT_DUMP_RAW_READS, > + .group = OPT_GROUP_DUMP, > + .doc = "Dump raw data as it's read from disk. Useful mainly for debugging the analysis tool.", }, > + > + { .name = "dump-no-processing", > + .key = OPT_DUMP_NO_PROCESSING, > + .group = OPT_GROUP_DUMP, > + .doc = "Don't do any processing on records other than cpu changes. Implies dump-raw-reads (or you wouldn't get anything).", }, > + > + { .name = "dump-raw-process", > + .key = OPT_DUMP_RAW_PROCESS, > + .group = OPT_GROUP_DUMP, > + .doc = "Dump raw data as it's processed. Useful mainly for debugging the analysis tool.", }, > + > + { .name = "dump-ipi-latency", > + .key = OPT_DUMP_IPI_LATENCY, > + .group = OPT_GROUP_DUMP, > + .doc = "Dump IPI latency info as IPIs are delivered (vector 0xd1 only).", }, > + > + { .name = "dump-trace-volume-on-lost-record", > + .key = OPT_DUMP_TRACE_VOLUME_ON_LOST_RECORD, > + .group = OPT_GROUP_DUMP, > + .doc = "Dump the volume of trace types in the previous cpu buffer when a lost record is created.", }, > + > + { .name = "dump-show-power-states", > + .key = OPT_DUMP_SHOW_POWER_STATES, > + .group = OPT_GROUP_DUMP, > + .doc = "Show the power-state of the physical cpu when dumping output.", }, > + > + /* Extra processing group */ > + { .name = "with-cr3-enumeration", > + .key = OPT_WITH_CR3_ENUMERATION, > + .group = OPT_GROUP_EXTRA, > + .doc = "Keep track of per-cr3 values", }, > + > + { .name = "with-pio-enumeration", > + .key = OPT_WITH_PIO_ENUMERATION, > + .group = OPT_GROUP_EXTRA, > + .doc = "Report summary info on indiviaul IO addresses", }, > + > + { .name = "with-mmio-enumeration", > + .key = OPT_WITH_MMIO_ENUMERATION, > + .group = OPT_GROUP_EXTRA, > + .doc = "Report summary info on indiviaul MMIO addresses.", }, > + > + { .name = "with-interrupt-eip-enumeration", > + .key = OPT_WITH_INTERRUPT_EIP_ENUMERATION, > + .arg = "vector", > + .group = OPT_GROUP_EXTRA, > + .doc = "Report a summary on eips interrupted by specified vector.", }, > + > + { .name = "scatterplot-interrupt-eip", > + .key = OPT_SCATTERPLOT_INTERRUPT_EIP, > + .arg = "vector", > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of eips as a function of time.", }, > + > + { .name = "scatterplot-extint-cycles", > + .key = OPT_SCATTERPLOT_EXTINT_CYCLES, > + .arg = "vector", > + .group = OPT_GROUP_EXTRA, > + .doc = "Output a scatterplot of vmexit cycles for external interrupts of the given vector as a funciton of time.", }, > + > + { .name = "scatterplot-cpi", > + .key = OPT_SCATTERPLOT_CPI, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of cpi.", }, > + > + { .name = "scatterplot-unpin-promote", > + .key = OPT_SCATTERPLOT_UNPIN_PROMOTE, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of unpins and promotions. If " \ > + "--with-cr3-enumeration is included, promotions include current cr3.", }, > + > + { .name = "scatterplot-cr3-switch", > + .key = OPT_SCATTERPLOT_CR3_SWITCH, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of cr3 switches.", }, > + > + { .name = "scatterplot-wake-to-halt", > + .key = OPT_SCATTERPLOT_WAKE_TO_HALT, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of wake-to-halt.", }, > + > + { .name = "scatterplot-vmexit-eip", > + .key = OPT_SCATTERPLOT_VMEXIT_EIP, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of vmexit eips.", }, > + > + { .name = "scatterplot-io", > + .key = OPT_SCATTERPLOT_IO, > + .arg = "port", > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of io latencies for givein address as a function of time.", }, > + > + { .name = "scatterplot-runstate", > + .key = OPT_SCATTERPLOT_RUNSTATE, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of runstate.", }, > + > + { .name = "scatterplot-runstate-time", > + .key = OPT_SCATTERPLOT_RUNSTATE_TIME, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of time in a runstate.", }, > + > + { .name = "scatterplot-pcpu", > + .key = OPT_SCATTERPLOT_PCPU, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of which pcpu vcpus are run on.", }, > + > + { .name = "scatterplot-rdtsc", > + .key = OPT_SCATTERPLOT_RDTSC, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of rdtsc values.", }, > + > + { .name = "scatterplot-irq", > + .key = OPT_SCATTERPLOT_IRQ, > + .group = OPT_GROUP_EXTRA, > + .doc = "Output scatterplot of irqs on pcpus.", }, > + > + { .name = "histogram-interrupt-eip", > + .key = OPT_HISTOGRAM_INTERRUPT_EIP, > + .arg = "vector[,increment]", > + .group = OPT_GROUP_EXTRA, > + .doc = "Output histograms of eips.", }, > + > + { .name = "interval", > + .key = OPT_INTERVAL_LENGTH, > + .arg = "sec", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Interval length to do time-based graphs, in seconds", }, > + > + { .name = "interval-cr3-schedule-time", > + .key = OPT_INTERVAL_CR3_SCHEDULE_TIME, > + .arg = "gmfn[,gmfn...]", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the listed cr3 value(s) every interval.", }, > + > + { .name = "interval-cr3-schedule-time-all", > + .key = OPT_INTERVAL_CR3_SCHEDULE_TIME_ALL, > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with all cr3 values every interval.", }, > + > + { .name = "interval-cr3-schedule-ordered", > + .key = OPT_INTERVAL_CR3_SCHEDULE_ORDERED, > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print summary with the top 10 cr3 values every interval.", }, > + > + { .name = "interval-cr3-short-summary", > + .key = OPT_INTERVAL_CR3_SHORT_SUMMARY, > + .arg = "gmfn", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the hvm short summary of cr3 value every interval.", }, > + > + { .name = "interval-domain-total-time", > + .key = OPT_INTERVAL_DOMAIN_TOTAL_TIME, > + .arg = "domain[,domain...]", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the listed domain(s) total runtime every interval.", }, > + > + { .name = "interval-domain-total-time-all", > + .key = OPT_INTERVAL_DOMAIN_TOTAL_TIME_ALL, > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with all domains every interval.", }, > + > + { .name = "interval-domain-short-summary", > + .key = OPT_INTERVAL_DOMAIN_SHORT_SUMMARY, > + .arg = "domain-id", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the hvm short summary of given domain every interval.", }, > + > + { .name = "interval-domain-guest-interrupt", > + .key = OPT_INTERVAL_DOMAIN_GUEST_INTERRUPT, > + .arg = "domain-id", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the guest interrupt count of given domain every interval.", }, > + > + { .name = "interval-domain-grant-maps", > + .key = OPT_INTERVAL_DOMAIN_GRANT_MAPS, > + .arg = "domain-id", > + .group = OPT_GROUP_INTERVAL, > + .doc = "Print a csv with the grant maps done on behalf of a given domain every interval.", }, > + > + /* Summary group */ > + { .name = "show-default-domain-summary", > + .key = OPT_SHOW_DEFAULT_DOMAIN_SUMMARY, > + .group = OPT_GROUP_SUMMARY, > + .doc = "Show default domain information on summary", }, > + > + { .name = "mmio-enumeration-skip-vga", > + .key = OPT_MMIO_ENUMERATION_SKIP_VGA, > + .arg = "[0|1]", > + .group = OPT_GROUP_SUMMARY, > + .doc = "Control whether we enumerate MMIO accesses to the VGA area, which can be extremly high during boot. Default: 0", }, > + > + { .name = "sample-size", > + .key = OPT_SAMPLE_SIZE, > + .arg = "size", > + .group = OPT_GROUP_SUMMARY, > + .doc = "Keep [size] samples for percentile purposes. Enter 0 to " \ > + "disable. Default 10240.", }, > + > + { .name = "summary", > + .key = OPT_SUMMARY, > + .group = OPT_GROUP_SUMMARY, > + .doc = "Output a summary", }, > + > + { .name = "report-pcpu", > + .key = OPT_REPORT_PCPU, > + .group = OPT_GROUP_SUMMARY, > + .doc = "Report utilization for pcpus", }, > + > + /* Guest info */ > + { .name = "default-guest-paging-levels", > + .key = OPT_DEFAULT_GUEST_PAGING_LEVELS, > + .group = OPT_GROUP_GUEST, > + .arg = "L", > + .doc = "Default guest paging levels. Mainly necessary for Rio, as Miami traces include guest paging levels where appropriate.", }, > + > + { .name = "symbol-file", > + .key = OPT_SYMBOL_FILE, > + .group = OPT_GROUP_GUEST, > + .arg = "filename", > + .doc = "A symbol file for interpreting guest eips.", }, > + > + /* Hardware info */ > + { .name = "cpu-hz", > + .key = OPT_CPU_HZ, > + .group = OPT_GROUP_HARDWARE, > + .arg = "HZ", > + .doc = "Cpu speed of the tracing host, used to convert tsc into seconds.", }, > + > + { .name = "svm-mode", > + .key = OPT_SVM_MODE, > + .group = OPT_GROUP_HARDWARE, > + .doc = "Assume AMD SVM-style vmexit error codes. (Default is Intel VMX.)", }, > + > + { .name = "progress", > + .key = OPT_PROGRESS, > + .doc = "Progress dialog. Requires the zenity (GTK+) executable.", }, > + > + { .name = "tsc-loop-fatal", > + .key = OPT_TSC_LOOP_FATAL, > + .doc = "Stop processing and exit if tsc skew tracking detects a dependency loop.", }, > + > + { .name = "tolerance", > + .key = OPT_TOLERANCE, > + .arg = "errlevel", > + .doc = "Sets tolerance for errors found in the file. Default is 3; max is 6.", }, > + > + > + { 0 }, > +}; > + > +const struct argp parser_def = { > + .options = cmd_opts, > + .parser = cmd_parser, > + .args_doc = "[trace file]", > + .doc = "", > +}; > + > +const char *argp_program_version = "xenalyze - Open-source xen-unstable (3.4)"; > +const char *argp_program_bug_address = "George Dunlap <george.dunlap@eu.citrix.com>"; > + > + > +int main(int argc, char *argv[]) { > + /* Start with warn at stderr. */ > + warn = stderr; > + > + argp_parse(&parser_def, argc, argv, 0, NULL, NULL); > + > + if (G.trace_file == NULL) > + exit(1); > + > + if ( (G.fd = open(G.trace_file, O_RDONLY|O_LARGEFILE)) < 0) { > + perror("open"); > + error(ERR_SYSTEM, NULL); > + } else { > + struct stat64 s; > + fstat64(G.fd, &s); > + G.file_size = s.st_size; > + } > + > + if ( (G.mh = mread_init(G.fd)) == NULL ) > + perror("mread"); > + > + if (G.symbol_file != NULL) > + parse_symbol_file(G.symbol_file); > + > + if(opt.dump_all) > + warn = stdout; > + > + init_pcpus(); > + > + if(opt.progress) > + progress_init(); > + > + process_records(); > + > + if(opt.interval_mode) > + interval_tail(); > + > + if(opt.summary) > + summary(); > + > + if(opt.report_pcpu) > + report_pcpu(); > + > + if(opt.progress) > + progress_finish(); > + > + return 0; > +} > +/* > + * Local variables: > + * mode: C > + * c-set-style: "BSD" > + * c-basic-offset: 4 > + * tab-width: 4 > + * indent-tabs-mode: nil > + * End: > + */ > > _______________________________________________ > Xen-devel mailing list > Xen-devel@lists.xen.org > http://lists.xen.org/xen-devel ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 1/8] xenalyze: add to tools/xentrace/ 2015-06-11 15:23 ` George Dunlap @ 2015-06-11 16:04 ` Olaf Hering 0 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-11 16:04 UTC (permalink / raw) To: George Dunlap Cc: Ian Jackson, Stefano Stabellini, Wei Liu, Ian Campbell, xen-devel On Thu, Jun 11, George Dunlap wrote: > First, it looks like maybe this wasn't based on 24308507be1d, but on > 8083183a7238? At least there seems to be changes in it that aren't in > the other one. Where is 8083183a7238? I have this as HEAD: # changeset: 150:24308507be1d # tag: tip # user: David Vrabel <david.vrabel@citrix.com> # date: Mon Jul 22 17:25:51 2013 +0100 # files: xenalyze.c > Secondly, it's not identical to what's checked in there, but has a > handful of changes; namely: > * Use <public/trace.h> rather than "trace.h", both in xenalyze.c and pv.h. Thats the main point of the merge. I will mention it. > * Remove __atribute__((packed)) from various structures. This must be another non-public change. I made just #include changes. Olaf ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering 2015-06-09 11:23 ` [PATCH v5 1/8] xenalyze: add to tools/xentrace/ Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-10 20:29 ` Julien Grall 2015-06-09 11:23 ` [PATCH v5 3/8] xenalyze: print newline after unknown hvm events Olaf Hering ` (5 subsequent siblings) 7 siblings, 1 reply; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini To match the hypervisor default which was introduced in 9da0c5b63933b9912e3903190601661813954d0d, bump the limit. Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/analyze.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/xentrace/analyze.h b/tools/xentrace/analyze.h index 40ee551..64b1911 100644 --- a/tools/xentrace/analyze.h +++ b/tools/xentrace/analyze.h @@ -16,7 +16,7 @@ #define TRC_LOST_RECORDS_END (TRC_GEN + 50) -#define NR_CPUS 128 +#define NR_CPUS 256 #if __x86_64__ # define BITS_PER_LONG 64 #else ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-09 11:23 ` [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 Olaf Hering @ 2015-06-10 20:29 ` Julien Grall 2015-06-11 6:12 ` Olaf Hering 0 siblings, 1 reply; 20+ messages in thread From: Julien Grall @ 2015-06-10 20:29 UTC (permalink / raw) To: Olaf Hering, xen-devel, George Dunlap Cc: Ian Jackson, Wei Liu, Ian Campbell, Stefano Stabellini Hi Olaf, On 09/06/2015 07:23, Olaf Hering wrote: > To match the hypervisor default which was introduced in > 9da0c5b63933b9912e3903190601661813954d0d, bump the limit. > > Signed-off-by: Olaf Hering <olaf@aepfle.de> > Acked-by: George Dunlap <george.dunlap@eu.citrix.com> > Acked-by: Wei Liu <wei.liu2@citrix.com> > Cc: Ian Jackson <ian.jackson@eu.citrix.com> > Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> > Cc: Ian Campbell <ian.campbell@citrix.com> > Cc: Wei Liu <wei.liu2@citrix.com> > --- > tools/xentrace/analyze.h | 2 +- > 1 file changed, 1 insertion(+), 1 deletion(-) > > diff --git a/tools/xentrace/analyze.h b/tools/xentrace/analyze.h > index 40ee551..64b1911 100644 > --- a/tools/xentrace/analyze.h > +++ b/tools/xentrace/analyze.h > @@ -16,7 +16,7 @@ > > #define TRC_LOST_RECORDS_END (TRC_GEN + 50) > > -#define NR_CPUS 128 > +#define NR_CPUS 256 You are updating NR_CPUS but this is only used for cpumask_t which is never used within xenalyze. Only cpu_mask_t is used and alias to a uint32_t. Or did I miss something? There is also a variable MAX_CPUS defined to 256. which is used every. Regards, -- Julien Grall ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-10 20:29 ` Julien Grall @ 2015-06-11 6:12 ` Olaf Hering 2015-06-11 11:03 ` Julien Grall 0 siblings, 1 reply; 20+ messages in thread From: Olaf Hering @ 2015-06-11 6:12 UTC (permalink / raw) To: Julien Grall Cc: Wei Liu, Ian Campbell, Stefano Stabellini, George Dunlap, Ian Jackson, xen-devel On Wed, Jun 10, Julien Grall wrote: > There is also a variable MAX_CPUS defined to 256. which is used every. You are right, while forwarding an old patch (from memory) I changed the wrong place. MAX_CPUS is already at 256 so no change is strictly neccessary. I suggest to drop that patch from this series while applying. Thanks for the review. Olaf ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-11 6:12 ` Olaf Hering @ 2015-06-11 11:03 ` Julien Grall 2015-06-11 14:35 ` George Dunlap 0 siblings, 1 reply; 20+ messages in thread From: Julien Grall @ 2015-06-11 11:03 UTC (permalink / raw) To: Olaf Hering Cc: Wei Liu, Ian Campbell, Stefano Stabellini, George Dunlap, Ian Jackson, xen-devel On 11/06/2015 02:12, Olaf Hering wrote: > On Wed, Jun 10, Julien Grall wrote: > >> There is also a variable MAX_CPUS defined to 256. which is used every. > > You are right, while forwarding an old patch (from memory) I changed the > wrong place. MAX_CPUS is already at 256 so no change is strictly > neccessary. > > I suggest to drop that patch from this series while applying. > Thanks for the review. I would suggest some refactoring to remove NR_CPUS and associated code in order to avoid mis-usage later. Also, cpu_mask_t is a uint32_t, is it intentional? Regards, -- Julien Grall ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-11 11:03 ` Julien Grall @ 2015-06-11 14:35 ` George Dunlap 2015-06-15 16:14 ` Olaf Hering 0 siblings, 1 reply; 20+ messages in thread From: George Dunlap @ 2015-06-11 14:35 UTC (permalink / raw) To: Julien Grall, Olaf Hering Cc: Ian Jackson, Stefano Stabellini, Wei Liu, Ian Campbell, xen-devel On 06/11/2015 12:03 PM, Julien Grall wrote: > > > On 11/06/2015 02:12, Olaf Hering wrote: >> On Wed, Jun 10, Julien Grall wrote: >> >>> There is also a variable MAX_CPUS defined to 256. which is used every. >> >> You are right, while forwarding an old patch (from memory) I changed the >> wrong place. MAX_CPUS is already at 256 so no change is strictly >> neccessary. >> >> I suggest to drop that patch from this series while applying. >> Thanks for the review. > > I would suggest some refactoring to remove NR_CPUS and associated code > in order to avoid mis-usage later. > > Also, cpu_mask_t is a uint32_t, is it intentional? When xenalyze was originally written back in 2006, I think that's probably how it was defined in Xen. I just haven't used it on a system with more than 32 cpus. :-) That certainly should be addressed at some point. I'd be in favor of checking this in and fixing it up later; or, for the time being, just disabling the skew detection functionality (which is the only place that uses it, AFAICT). -George ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-11 14:35 ` George Dunlap @ 2015-06-15 16:14 ` Olaf Hering 2015-06-15 17:19 ` Andrew Cooper 0 siblings, 1 reply; 20+ messages in thread From: Olaf Hering @ 2015-06-15 16:14 UTC (permalink / raw) To: George Dunlap Cc: Wei Liu, Ian Campbell, Stefano Stabellini, Ian Jackson, xen-devel, Julien Grall On Thu, Jun 11, George Dunlap wrote: > On 06/11/2015 12:03 PM, Julien Grall wrote: > > I would suggest some refactoring to remove NR_CPUS and associated code > > in order to avoid mis-usage later. > > > > Also, cpu_mask_t is a uint32_t, is it intentional? > > When xenalyze was originally written back in 2006, I think that's > probably how it was defined in Xen. I just haven't used it on a system > with more than 32 cpus. :-) > > That certainly should be addressed at some point. I'd be in favor of > checking this in and fixing it up later; or, for the time being, just > disabling the skew detection functionality (which is the only place that > uses it, AFAICT). Today I looked at this part: In v6 I have added a patch to remove cpumask_t. Now I see xenalyze.c has a cpu_mask_t with just 32 bits. Easy change would be to change that to uin64_t. To really support MAX_CPUS the code can either include xen/include/xen/cpumask.h, or just the few required functions can be pasted into xenalyze.c. What do you prefer? Olaf ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-15 16:14 ` Olaf Hering @ 2015-06-15 17:19 ` Andrew Cooper 2015-06-15 17:58 ` Olaf Hering 0 siblings, 1 reply; 20+ messages in thread From: Andrew Cooper @ 2015-06-15 17:19 UTC (permalink / raw) To: Olaf Hering, George Dunlap Cc: Wei Liu, Ian Campbell, Stefano Stabellini, Ian Jackson, xen-devel, Julien Grall On 15/06/15 17:14, Olaf Hering wrote: > On Thu, Jun 11, George Dunlap wrote: > >> On 06/11/2015 12:03 PM, Julien Grall wrote: >>> I would suggest some refactoring to remove NR_CPUS and associated code >>> in order to avoid mis-usage later. >>> >>> Also, cpu_mask_t is a uint32_t, is it intentional? >> When xenalyze was originally written back in 2006, I think that's >> probably how it was defined in Xen. I just haven't used it on a system >> with more than 32 cpus. :-) >> >> That certainly should be addressed at some point. I'd be in favor of >> checking this in and fixing it up later; or, for the time being, just >> disabling the skew detection functionality (which is the only place that >> uses it, AFAICT). > Today I looked at this part: > > In v6 I have added a patch to remove cpumask_t. Now I see xenalyze.c has > a cpu_mask_t with just 32 bits. Easy change would be to change that to > uin64_t. > > To really support MAX_CPUS the code can either include > xen/include/xen/cpumask.h, or just the few required functions can be > pasted into xenalyze.c. > > What do you prefer? In an ideal world, userspace tools like this should not really be tied to NR_CPUS or MAX_CPUS. They should get max_cpu_id from Xen and dynamically allocate a bitmap of sufficient size. Whether this is a yak worth shaving now is a different matter. ~Andrew ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-15 17:19 ` Andrew Cooper @ 2015-06-15 17:58 ` Olaf Hering 2015-06-16 8:33 ` Ian Campbell 0 siblings, 1 reply; 20+ messages in thread From: Olaf Hering @ 2015-06-15 17:58 UTC (permalink / raw) To: Andrew Cooper Cc: Wei Liu, Ian Campbell, Stefano Stabellini, George Dunlap, Ian Jackson, xen-devel, Julien Grall On Mon, Jun 15, Andrew Cooper wrote: > In an ideal world, userspace tools like this should not really be tied > to NR_CPUS or MAX_CPUS. They should get max_cpu_id from Xen and > dynamically allocate a bitmap of sufficient size. The dumps are taken on one machine and get inspected on another, which may not even be a dom0. I like the idea with dynamically allocate the array size, based on a cmdline option. Once I find the time I will implement it. Olaf ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-15 17:58 ` Olaf Hering @ 2015-06-16 8:33 ` Ian Campbell 2015-06-16 8:35 ` Olaf Hering 0 siblings, 1 reply; 20+ messages in thread From: Ian Campbell @ 2015-06-16 8:33 UTC (permalink / raw) To: Olaf Hering Cc: Wei Liu, Stefano Stabellini, George Dunlap, Andrew Cooper, Ian Jackson, xen-devel, Julien Grall On Mon, 2015-06-15 at 19:58 +0200, Olaf Hering wrote: > On Mon, Jun 15, Andrew Cooper wrote: > > > In an ideal world, userspace tools like this should not really be tied > > to NR_CPUS or MAX_CPUS. They should get max_cpu_id from Xen and > > dynamically allocate a bitmap of sufficient size. > > The dumps are taken on one machine and get inspected on another, which > may not even be a dom0. I like the idea with dynamically allocate the > array size, based on a cmdline option. Once I find the time I will > implement it. Perhaps we should split out "get xenalyze in tree" out from actual improvements and development work? The former ought to be pretty easy to achieve, no? Ian. ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 2015-06-16 8:33 ` Ian Campbell @ 2015-06-16 8:35 ` Olaf Hering 0 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-16 8:35 UTC (permalink / raw) To: Ian Campbell Cc: Wei Liu, Stefano Stabellini, George Dunlap, Andrew Cooper, Ian Jackson, xen-devel, Julien Grall On Tue, Jun 16, Ian Campbell wrote: > On Mon, 2015-06-15 at 19:58 +0200, Olaf Hering wrote: > > On Mon, Jun 15, Andrew Cooper wrote: > > > > > In an ideal world, userspace tools like this should not really be tied > > > to NR_CPUS or MAX_CPUS. They should get max_cpu_id from Xen and > > > dynamically allocate a bitmap of sufficient size. > > > > The dumps are taken on one machine and get inspected on another, which > > may not even be a dom0. I like the idea with dynamically allocate the > > array size, based on a cmdline option. Once I find the time I will > > implement it. > > Perhaps we should split out "get xenalyze in tree" out from actual > improvements and development work? The former ought to be pretty easy to > achieve, no? Yes, v6 of my series is ready to merge from my POV. Olaf ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v5 3/8] xenalyze: print newline after unknown hvm events 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering 2015-06-09 11:23 ` [PATCH v5 1/8] xenalyze: add to tools/xentrace/ Olaf Hering 2015-06-09 11:23 ` [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 4/8] xenalyze: include odd mmio states in default output Olaf Hering ` (4 subsequent siblings) 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index a0a3ac1..8b5e1dc 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -5435,7 +5435,7 @@ void hvm_process(struct pcpu_info *p) hvm_vmentry_process(ri, &p->current->hvm); break; default: - fprintf(warn, "Unknown hvm event: %x", ri->event); + fprintf(warn, "Unknown hvm event: %x\n", ri->event); } } } ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v5 4/8] xenalyze: include odd mmio states in default output 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering ` (2 preceding siblings ...) 2015-06-09 11:23 ` [PATCH v5 3/8] xenalyze: print newline after unknown hvm events Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 5/8] xenalyze: handle TRC_TRACE_WRAP_BUFFER Olaf Hering ` (3 subsequent siblings) 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index 8b5e1dc..fef8aea 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -3740,7 +3740,7 @@ void hvm_mmio_assist_postprocess(struct hvm_data *h) static int warned = 0; if (!warned) { - fprintf(stderr, "%s: Strange, MMIO with unexpected exit reason %d\n", + fprintf(warn, "%s: Strange, MMIO with unexpected exit reason %d\n", __func__, h->exit_reason); warned=1; } ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v5 5/8] xenalyze: handle TRC_TRACE_WRAP_BUFFER 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering ` (3 preceding siblings ...) 2015-06-09 11:23 ` [PATCH v5 4/8] xenalyze: include odd mmio states in default output Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 6/8] xenalyze: handle more events in sched_process Olaf Hering ` (2 subsequent siblings) 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index fef8aea..15c51d9 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -8469,6 +8469,8 @@ void base_process(struct pcpu_info *p) { struct record_info *ri = &p->ri; switch(ri->event) { + case TRC_TRACE_WRAP_BUFFER: + break; case TRC_LOST_RECORDS: process_lost_records(p); break; ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v5 6/8] xenalyze: handle more events in sched_process 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering ` (4 preceding siblings ...) 2015-06-09 11:23 ` [PATCH v5 5/8] xenalyze: handle TRC_TRACE_WRAP_BUFFER Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 7/8] xenalyze: remove trailing whitespaces Olaf Hering 2015-06-09 11:23 ` [PATCH v5 8/8] xenalyze: remove argp_program_version Olaf Hering 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Signed-off-by: Olaf Hering <olaf@aepfle.de> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 73 ++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index 15c51d9..aa6d033 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -30,6 +30,7 @@ #include <fcntl.h> #include <unistd.h> #include <xen/trace.h> +#include <xen/sched.h> #include "analyze.h" #include "mread.h" #include "pv.h" @@ -7569,24 +7570,82 @@ void sched_summary_domain(struct domain_data *d) } } +void sched_class(struct record_info *ri) +{ + /* Just a stub for now */ +} void sched_process(struct pcpu_info *p) { struct record_info *ri = &p->ri; - if(ri->evt.sub == 0xf) { + if (ri->evt.sub == 1) { + sched_runstate_process(p); + } else if (ri->evt.sub == 2) { + sched_class(ri); + } else { switch(ri->event) { + case TRC_SCHED_DOM_ADD: + printf(" %s sched_add_domain d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_DOM_REM: + printf(" %s sched_rem_domain d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_SLEEP: + printf(" %s domain_sleep d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_WAKE: + printf(" %s domain_wake d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_YIELD: + printf(" %s do_yield d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_BLOCK: + printf(" %s do_block d%uv%u\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_SHUTDOWN: + { + static const char *reason[] = { + [SHUTDOWN_poweroff] = "poweroff", + [SHUTDOWN_reboot] = "reboot", + [SHUTDOWN_suspend] = "suspend", + [SHUTDOWN_crash] = "crash", + [SHUTDOWN_watchdog] = "watchdog", + }; + printf(" %s domain_shutdown d%uv%u reason %x (%s)\n", + ri->dump_header, ri->d[0], ri->d[1], ri->d[2], + ri->d[2] > SHUTDOWN_MAX ? "unknown" : reason[ri->d[2]]); + break; + } + case TRC_SCHED_SHUTDOWN_CODE: + { + printf(" %s domain_shutdown_code d%uv%u reason %x\n", + ri->dump_header, ri->d[0], ri->d[1], ri->d[2]); + break; + } + case TRC_SCHED_ADJDOM: + printf(" %s sched_adjdom domid d%u\n", + ri->dump_header, ri->d[0]); + break; case TRC_SCHED_SWITCH: sched_switch_process(p); break; + case TRC_SCHED_SWITCH_INFPREV: + printf(" %s switch_infprev old_domid %x runtime %d\n", + ri->dump_header, ri->d[0], ri->d[1]); + break; + case TRC_SCHED_SWITCH_INFNEXT: + printf(" %s switch_infnext new_domid %x time %d r_time %d\n", + ri->dump_header, ri->d[0], ri->d[1], ri->d[2]); + break; default: - process_generic(&p->ri); - } - } else { - if(ri->evt.sub == 1) - sched_runstate_process(p); - else { UPDATE_VOLUME(p, sched_verbose, ri->size); process_generic(&p->ri); } ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v5 7/8] xenalyze: remove trailing whitespaces 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering ` (5 preceding siblings ...) 2015-06-09 11:23 ` [PATCH v5 6/8] xenalyze: handle more events in sched_process Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 8/8] xenalyze: remove argp_program_version Olaf Hering 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Result of "sed -i 's@[[:blank:]]\+$@@' tools/xentrace/xenalyze.c" Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 350 +++++++++++++++++++++++----------------------- 1 file changed, 175 insertions(+), 175 deletions(-) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index aa6d033..4525e36 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -2,7 +2,7 @@ * xenalyze.c: Analyzing xentrace output * * Written by George Dunlap. - * + * * Copyright (c) 2006-2007, XenSource Inc. * Copyright (c) 2007-2008, Citrix Systems R&D Ltd, UK * @@ -62,7 +62,7 @@ struct array_struct { fprintf(warn, ##_x); \ } \ } while(0) \ - + /* -- Global variables -- */ struct { int fd; @@ -88,7 +88,7 @@ struct { .progress = { .update_offset = 0 }, }; -/* +/* Kinds of errors: Unexpected values - RIP with information in high bits (not all 0 or 1) @@ -116,7 +116,7 @@ struct { - domain runstates - runstate / tsc skew - vcpu_{prev,next}_update p->current{==,!=}null - - vcpu start conditions + - vcpu start conditions - lost_cpu count higher than # of seen cpus / < 0 - lost cpu has non-null p->current Symbol file @@ -147,7 +147,7 @@ enum error_level { int verbosity = 5; struct { - unsigned + unsigned scatterplot_interrupt_eip:1, scatterplot_cpi:1, scatterplot_unpin_promote:1, @@ -226,7 +226,7 @@ struct { } opt = { .scatterplot_interrupt_eip=0, .scatterplot_cpi=0, - .scatterplot_unpin_promote=0, + .scatterplot_unpin_promote=0, .scatterplot_cr3_switch=0, .scatterplot_wake_to_halt=0, .scatterplot_vmexit_eip=0, @@ -356,7 +356,7 @@ void parse_symbol_file(char *fn) { error(ERR_ASSERT, NULL); } else last_addr = (*p)->symbols[(*p)->count].addr; - + (*p)->count++; /* If this struct is full, point to the next. It will be allocated @@ -419,7 +419,7 @@ struct { void (*dump)(struct eip_list_struct *); } eip_list_type[EIP_LIST_TYPE_MAX] = { [EIP_LIST_TYPE_NONE] = { - .update=NULL, + .update=NULL, .new=NULL, .dump=NULL }, }; @@ -428,7 +428,7 @@ struct { /* --- HVM class of events --- */ /* - * -- Algorithms -- + * -- Algorithms -- * * Interrupt Wake-to-halt detection * @@ -451,7 +451,7 @@ struct { * * The "waking" interrupts we want to sub-classify into * "wake-only" (when interrupt was the only interrupt from wake to halt) and - * "wake-all" (whether this was the only interrupt or not). + * "wake-all" (whether this was the only interrupt or not). */ /* VMX data */ @@ -969,7 +969,7 @@ char * hvm_event_handler_name[HVM_EVENT_HANDLER_MAX] = { "pf_inject", "inj_exc", "inj_virq", - "reinj_virq", + "reinj_virq", "io_read", "io_write", "cr_read", /* 8 */ @@ -1470,7 +1470,7 @@ void init_hvm_data(struct hvm_data *h, struct vcpu_data *v) { size); error(ERR_SYSTEM, NULL); } - + } for(i=0; i<GUEST_INTERRUPT_MAX+1; i++) h->summary.guest_interrupt[i].count=0; @@ -1758,7 +1758,7 @@ struct domain_data { struct cr3_value_struct *cr3_value_head; struct eip_list_struct *emulate_eip_list; struct eip_list_struct *interrupt_eip_list; - + int guest_interrupt[GUEST_INTERRUPT_MAX+1]; struct hvm_short_summary_struct hvm_short; struct { @@ -1841,7 +1841,7 @@ void volume_summary(struct trace_volume *vol) printf(" +-%-7s: %10lld\n", hvm_vol_name[k], vol->hvm[k]); } - + break; } } @@ -2050,7 +2050,7 @@ long long percentile(long long * A, int N, int ple) { I++; J--; } } while (I <= J); /* Keep going until our pointers meet or pass */ - + /* Re-adjust L and R, based on which element we're looking for */ if(J<K) L=I; @@ -2134,9 +2134,9 @@ float weighted_percentile(float * A, /* values */ } while (I <= J); /* Keep going until our pointers meet or pass */ /* Re-adjust L and R, based on which element we're looking for */ - if(J_weight<K_weight) + if(J_weight<K_weight) L=I; L_weight = I_weight; - if(K_weight<I_weight) + if(K_weight<I_weight) R=J; R_weight = J_weight; } @@ -2365,7 +2365,7 @@ static inline void clear_interval_cpi(struct weighted_cpi_summary *s) { static inline void print_cpu_affinity(struct cycle_summary *s, char *p) { if(s->count) { long long avg; - + avg = s->cycles / s->count; if ( opt.sample_size ) { @@ -2442,7 +2442,7 @@ static inline void print_cycle_percent_summary(struct cycle_summary *s, avg, p5, p50, p95); } else { printf("%s: %7d %5.2lfs %5.2lf%% %6lld\n", - p, s->count, + p, s->count, seconds, percent, avg); @@ -2455,7 +2455,7 @@ static inline void print_cycle_summary(struct cycle_summary *s, char *p) { long long avg; avg = s->cycles / s->count; - + if ( opt.sample_size ) { long long p5, p50, p95; int data_size = s->count; @@ -2579,9 +2579,9 @@ void interval_list_add(struct interval_element *e, char *desc) { struct interval_list *p; fprintf(warn, "%s: Adding element '%s'\n", __func__, desc); - + if((p=malloc(sizeof(*p)))==NULL) { - fprintf(stderr, "malloc() failed.\n"); + fprintf(stderr, "malloc() failed.\n"); error(ERR_SYSTEM, NULL); } @@ -2628,7 +2628,7 @@ void interval_cr3_value_check(struct cr3_value_struct *cr3) { __func__, cr3->gmfn); P.interval.array.values[i] = &cr3->total_time.interval; - } + } } } else if(opt.interval.mode == INTERVAL_MODE_LIST) { char desc[32]; @@ -2714,14 +2714,14 @@ void interval_cr3_short_summary_output(void) { struct cr3_value_struct *p = P.interval.cr3; interval_time_output(); - + hss_array = p->hvm.s; printf(" %.02lf", __cycles_percent(p->total_time.interval.cycles, opt.interval.cycles)); - for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) __interval_cycle_percent_output(&hss_array[i].interval, p->total_time.interval.cycles); @@ -2744,7 +2744,7 @@ void interval_domain_value_check(struct domain_data *d) { } P.interval.array.values[i] = &d->total_time.interval; - } + } } } else if(opt.interval.mode == INTERVAL_MODE_LIST) { char desc[32]; @@ -2777,7 +2777,7 @@ void interval_domain_short_summary_output(void) { interval_cycle_percent_output(&d->total_time.interval); - for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) + for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) interval_cycle_percent_output(&d->hvm_short.s[i].interval); printf("\n"); @@ -2842,7 +2842,7 @@ void interval_domain_guest_interrupt_output(void) { printf("\n"); } - + } void interval_domain_grant_maps_output(void) { @@ -2861,7 +2861,7 @@ void interval_domain_grant_maps_output(void) { printf("\n"); } } - + /* General interval gateways */ void interval_callback(void) { @@ -2929,11 +2929,11 @@ void interval_tail(void) { void update_eip(struct eip_list_struct **head, unsigned long long eip, unsigned long long cycles, int type, void * extra) { struct eip_list_struct *p, **last=head; - + for(p=*head; p; last = (&p->next), p=p->next) if(p->eip >= eip) break; - + if(!p || p->eip != eip) { p=malloc(sizeof(*p)); if(!p) { @@ -3009,7 +3009,7 @@ void dump_eip(struct eip_list_struct *head) { #endif printf(" Total samples: %d\n", total); - + for(i=0; i<N; i++) { p = qsort_array[i]; if ( p->summary.cycles ) @@ -3026,7 +3026,7 @@ void dump_eip(struct eip_list_struct *head) { ((double)p->summary.count*100)/total); } - + if(eip_list_type[p->type].dump) { eip_list_type[p->type].dump(p); } @@ -3053,7 +3053,7 @@ struct hvm_pf_xen_record { void hvm_update_short_summary(struct hvm_data *h, int element) { struct vcpu_data *v = h->v; - if(v->cr3.data) + if(v->cr3.data) update_cycles(&v->cr3.data->hvm.s[element], h->arc_cycles); update_cycles(&v->d->hvm_short.s[element], h->arc_cycles); @@ -3251,7 +3251,7 @@ void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) e->corresponding_va = CORR_VA_INVALID; e->pt_level = 0; - + /* Detect accesses to Windows linear pagetables */ switch(guest_paging_levels) { @@ -3270,7 +3270,7 @@ void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) | e->pt_index[1]<<22 | e->pt_index[0]<<12; } - } + } break; case 3: if(e->pt_index[3]==3 && (e->pt_index[2]>>2==0)) @@ -3299,7 +3299,7 @@ void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) | e->pt_index[1]<<21 | e->pt_index[2]<<30; } - } + } break; case 4: if(e->pt_index[4] == 0x1ed) @@ -3323,7 +3323,7 @@ void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) } } else - { + { e->pt_level = 2; e->corresponding_va = ((1ULL<<21)-1) | (unsigned long long)e->pt_index[0]<<21 @@ -3340,7 +3340,7 @@ void pf_preprocess(struct pf_xen_extra *e, int guest_paging_levels) | (unsigned long long)e->pt_index[2]<<30 | (unsigned long long)e->pt_index[3]<<39; } - + if(HIGH_BIT(e->corresponding_va)) e->corresponding_va |= SIGN_EXTENDED_BITS; } @@ -3454,7 +3454,7 @@ void hvm_pf_xen_process(struct record_info *ri, struct hvm_data *h) { h->v->guest_paging_levels); hvm_pf_xen_preprocess(ri->event, h); - + if(opt.dump_all) { if(e->pf_case == PF_XEN_EMULATE) @@ -3483,7 +3483,7 @@ char * hvm_vlapic_icr_dest_shorthand_name[4] = { void hvm_vlapic_vmentry_cleanup(struct vcpu_data *v, tsc_t tsc) { int i; - + struct vlapic_struct *vla = &v->vlapic; for(i=0; i<MAX_VLAPIC_LIST; i++) @@ -3592,7 +3592,7 @@ void hvm_vlapic_icr_handler(struct hvm_data *h) return; } - if(!o->first_tsc) + if(!o->first_tsc) o->first_tsc = P.now; if(opt.dump_all && o->count == 0 && o->injected) @@ -3603,7 +3603,7 @@ void hvm_vlapic_icr_handler(struct hvm_data *h) if((opt.dump_all) #if 0 && (ov->runstate.state != RUNSTATE_RUNNING - || ov->hvm.vmexit_valid) + || ov->hvm.vmexit_valid) #endif ) printf(" [vla] d%dv%d vec %d state %s (outstanding ipis %d)\n", @@ -3829,7 +3829,7 @@ void hvm_inj_virq_process(struct record_info *ri, struct hvm_data *h) { ri->dump_header, r->vector, r->fake?"fake":"real"); } - + if(opt.summary_info) { int vector = r->vector; @@ -3868,7 +3868,7 @@ void hvm_inj_virq_process(struct record_info *ri, struct hvm_data *h) { h->w2h.vector = vector; h->summary.guest_interrupt[vector].is_wake = 1; } - + if( h->summary.guest_interrupt[vector].start_tsc == 0 ) { /* Note that we want start_tsc set at the next vmentry */ h->summary.guest_interrupt[vector].start_tsc = 1; @@ -3898,19 +3898,19 @@ void update_io_address(struct io_address ** list, unsigned int pa, int dir, /* Keep list in order */ for(p=*list; p && (p->pa != pa) && (p->pa < pa); q=p, p=p->next); - + /* If we didn't find it, make a new element. */ if(!p || (p->pa != pa)) { if((p=malloc(sizeof(*p)))==NULL) { fprintf(stderr, "malloc() failed.\n"); error(ERR_SYSTEM, NULL); } - + bzero(p, sizeof(*p)); p->pa=pa; p->va=va; - + /* If we stopped in the middle or at the end, add it in */ if(q) { p->next=q->next; @@ -4029,7 +4029,7 @@ void cr3_switch(unsigned long long val, struct hvm_data *h) { if(gmfn) { struct cr3_value_struct *p, **last=&v->d->cr3_value_head; - + /* Always add to tail, so that we get consistent interval ouptut as the number of cr3s grow */ for(p=*last; p; last = (&p->next), p=p->next) @@ -4057,7 +4057,7 @@ void cr3_switch(unsigned long long val, struct hvm_data *h) { else P.cr3.head = p; P.cr3.tail = &p->gnext; - + P.cr3.id++; /* Add to the interval list if appropriate */ @@ -4099,20 +4099,20 @@ void cr3_prealloc_unpin(struct vcpu_data *v, unsigned long long gmfn) { struct cr3_value_struct *cr3; /* Look for it in the list */ - for(cr3 = v->d->cr3_value_head; cr3; cr3=cr3->next) + for(cr3 = v->d->cr3_value_head; cr3; cr3=cr3->next) if(cr3->gmfn == gmfn) break; if(!cr3) return; - if(cr3->prealloc_unpin.now) + if(cr3->prealloc_unpin.now) fprintf(warn, "Strange, gmfn %llx multiple unpins w/o access!\n", gmfn); cr3->prealloc_unpin.now = 1; cr3->prealloc_unpin.count++; - + if(opt.dump_all) printf(" cr3 %llx unpinned %d times\n", gmfn, cr3->prealloc_unpin.count); @@ -4190,7 +4190,7 @@ void cr3_dump_list(struct cr3_value_struct *head){ abs_cycles_to_time(p->first_time, &first); abs_cycles_to_time(p->last_time, &last); - + snprintf(desc, 30, " %8llx (id %d)", p->gmfn, p->cr3_id); print_cycle_summary(&p->total_time, desc); snprintf(desc, 30, " guest"); @@ -4243,7 +4243,7 @@ void hvm_cr_write_postprocess(struct hvm_data *h) int flush=0; if(v->cr3.val) { - oval = v->cr3.val; + oval = v->cr3.val; if(new_val == oval) { if(v->cr3.data) { @@ -4292,7 +4292,7 @@ void hvm_cr_write_postprocess(struct hvm_data *h) #define case_cr(_x) \ case (_x): \ hvm_set_summary_handler(h, hvm_cr_write_summary, (void *)(_x)); \ - break + break case_cr(0); case_cr(1); case_cr(2); @@ -4351,13 +4351,13 @@ void hvm_cr_write_process(struct record_info *ri, struct hvm_data *h) { if(cr == 3 && h->v->cr3.val) { printf("]%s cr_write cr3 val %llx oval %llx %s\n", - ri->dump_header, + ri->dump_header, val, h->v->cr3.val, (h->v->cr3.val == val)?"flush":"switch"); } else { printf(" %s cr_write cr%d val %llx\n", - ri->dump_header, + ri->dump_header, cr, val); } @@ -4511,7 +4511,7 @@ void hvm_inj_exc_process(struct record_info *ri, struct hvm_data *h) ri->t.s, ri->t.ns, pcpu_string(ri->cpu), r->vec, r->ec); } - + } void hvm_intr_summary(struct hvm_data *h, void *d) @@ -4578,9 +4578,9 @@ void hvm_intr_process(struct record_info *ri, struct hvm_data *h) /* Want absolute tsc to global tsc */ abs_cycles_to_time(h->exit_tsc, &t); - printf("d%dv%d %u.%09u %lld\n", + printf("d%dv%d %u.%09u %lld\n", h->v->d->did, h->v->vid, - t.s, t.ns, + t.s, t.ns, rip); } @@ -4590,7 +4590,7 @@ void hvm_intr_process(struct record_info *ri, struct hvm_data *h) /* Truncate to 40 bits */ unsigned long long rip = h->rip & ((1ULL << ADDR_SPACE_BITS)-1); unsigned index = rip / opt.histogram_interrupt_increment; - + h->summary.extint_histogram[index]++; } @@ -4753,7 +4753,7 @@ void hvm_generic_postprocess_init(struct record_info *ri, struct hvm_data *h) fprintf(warn, "%s: Strange, h->postprocess set!\n", __func__); h->inflight.generic.event = ri->event; - bcopy(h->d, h->inflight.generic.d, sizeof(unsigned int) * 4); + bcopy(h->d, h->inflight.generic.d, sizeof(unsigned int) * 4); } void hvm_generic_postprocess(struct hvm_data *h) @@ -4863,7 +4863,7 @@ void hvm_generic_dump(struct record_info *ri, char * prefix) ri->dump_header, evt_string, is_64?"64":""); - + for(i=0; i<ri->extra_words; i++) { printf(" %x", ri->d[i]); } @@ -4928,7 +4928,7 @@ void hvm_handler_process(struct record_info *ri, struct hvm_data *h) { return; -needs_vmexit: +needs_vmexit: /* Wait for the next vmexit */ if(!h->vmexit_valid) { @@ -5015,7 +5015,7 @@ int domain_runstate(struct domain_data *d) { int runstates[RUNSTATE_MAX]; int ret=-1; int max_vcpus = 0; - + if(d->did == DEFAULT_DOMAIN) return 0; @@ -5066,7 +5066,7 @@ int domain_runstate(struct domain_data *d) { fprintf(warn, " %s: %d\n", runstate_name[i], runstates[i]); } - + if(ret >= 0) return ret; @@ -5094,17 +5094,17 @@ static inline void runstate_update(struct vcpu_data *v, int new_runstate, t.s, t.ns, runstate_graph[new_runstate]); } - + if(v->runstate.tsc > 0 && v->runstate.tsc < tsc) { update_cycles(v->runstates + v->runstate.state, tsc - v->runstate.tsc); if ( opt.scatterplot_runstate_time ) { struct time_struct t, dt; - + abs_cycles_to_time(tsc, &t); cycles_to_time(tsc - v->runstate.tsc, &dt); - + printf("%dv%d %u.%09u %u.%09u\n", d->did, v->vid, t.s, t.ns, @@ -5165,7 +5165,7 @@ static inline void runstate_update(struct vcpu_data *v, int new_runstate, v->runstate.tsc = tsc; /* Determine the domain runstate */ - if(d->runstate_tsc > 0 && d->runstate_tsc < tsc) + if(d->runstate_tsc > 0 && d->runstate_tsc < tsc) update_cycles(d->runstates + d->runstate, tsc - d->runstate_tsc); d->runstate = domain_runstate(d); @@ -5252,7 +5252,7 @@ void hvm_vmexit_process(struct record_info *ri, struct hvm_data *h, if(opt.dump_all) { if ( h->exit_reason < h->exit_reason_max - && h->exit_reason_name[h->exit_reason] != NULL) + && h->exit_reason_name[h->exit_reason] != NULL) printf("]%s vmexit exit_reason %s eip %llx%s\n", ri->dump_header, h->exit_reason_name[h->exit_reason], @@ -5334,12 +5334,12 @@ void hvm_close_vmexit(struct hvm_data *h, tsc_t tsc) { break; } } - + if(h->v->cr3.data) { h->v->cr3.data->run_time += h->arc_cycles; - if(opt.summary_info) + if(opt.summary_info) update_cycles(&h->v->cr3.data->hv_time, h->arc_cycles); } @@ -5360,12 +5360,12 @@ void hvm_vmentry_process(struct record_info *ri, struct hvm_data *h) { return; } - /* Vista bug + /* Vista bug * This has to be done here because irqs are injected on the path out * to vmexit. */ hvm_vlapic_vmentry_cleanup(h->v, ri->tsc); - if(h->w2h.waking && opt.dump_all) + if(h->w2h.waking && opt.dump_all) printf(" [w2h] d%dv%d Finishing waking\n", h->v->d->did, h->v->vid); @@ -5507,7 +5507,7 @@ void hvm_summary(struct hvm_data *h) { } /* ---- Shadow records ---- */ -union shadow_event +union shadow_event { unsigned event; struct { @@ -5531,7 +5531,7 @@ char * flag_string(struct pf_xen_extra *e) flagstring[i]='-'; i=0; - + if(e->flag_set_ad) flagstring[i]='d'; else if(e->flag_set_a) @@ -5631,7 +5631,7 @@ void shadow_emulate_process(struct record_info *ri, struct hvm_data *h) unsigned flags:29, emulation_count:3; } gpl4; } *r = (typeof(r))ri->d; - + union shadow_event sevt = { .event = ri->event }; int rec_gpl = sevt.paging_levels + 2; @@ -5651,7 +5651,7 @@ void shadow_emulate_process(struct record_info *ri, struct hvm_data *h) fprintf(warn, "%s: expected %zd bytes for %d-level guest, got %d!\n", __func__, sizeof(r->gpl2), h->v->guest_paging_levels, ri->extra_words * 4); - + error(ERR_RECORD, ri); return; } @@ -5793,7 +5793,7 @@ void shadow_parse_other(struct record_info *ri, void shadow_unsync_postprocess(struct hvm_data *h) { struct pf_xen_extra *e = &h->inflight.pf_xen; - + if(h->resyncs > 1) fprintf(warn, "Strange, %d resyncs for an unsync!\n", h->resyncs); @@ -5894,7 +5894,7 @@ void shadow_fixup_postprocess(struct hvm_data *h) } - if(!(e->flag_promote || h->prealloc_unpin || e->flag_unsync)) + if(!(e->flag_promote || h->prealloc_unpin || e->flag_unsync)) update_summary(&h->summary.pf_xen_fixup[PF_XEN_FIXUP_UPDATE_ONLY], h->arc_cycles); /* more summary info */ @@ -6208,8 +6208,8 @@ void shadow_fault_generic_dump(unsigned int event, uint32_t *d, char *prefix, dump_header, evt_string, sevt.paging_levels); - - for(i=0; i<4; i++) + + for(i=0; i<4; i++) { printf(" %x", d[i]); } @@ -6241,7 +6241,7 @@ void shadow_fault_generic_process(struct record_info *ri, struct hvm_data *h) /* pf-case traces, vs others */ h->inflight.generic.event = ri->event; - bcopy(ri->d, h->inflight.generic.d, sizeof(unsigned int) * 4); + bcopy(ri->d, h->inflight.generic.d, sizeof(unsigned int) * 4); if(opt.dump_all) shadow_fault_generic_dump(h->inflight.generic.event, @@ -6312,7 +6312,7 @@ void shadow_process(struct pcpu_info *p) return; h = &p->current->hvm; - + if(!h->init || !h->vmexit_valid) { if(opt.dump_all) @@ -6421,7 +6421,7 @@ void pv_hypercall_process(struct record_info *ri, struct pv_data *pv) { } if(opt.summary_info) { - if(eax < PV_HYPERCALL_MAX) + if(eax < PV_HYPERCALL_MAX) pv->hypercall_count[eax]++; } @@ -6468,7 +6468,7 @@ void pv_trap_process(struct record_info *ri, struct pv_data *pv) { } if(opt.summary_info) { - if(trapnr < PV_TRAP_MAX) + if(trapnr < PV_TRAP_MAX) pv->trap_count[trapnr]++; } @@ -6498,7 +6498,7 @@ void pv_ptwr_emulation_process(struct record_info *ri, struct pv_data *pv) { struct { unsigned long long pte, addr, eip; } e; - + switch ( pevt.minor ) { case PV_PTWR_EMULATION_PAE: if ( pevt.x64 ) @@ -6554,7 +6554,7 @@ void pv_generic_process(struct record_info *ri, struct pv_data *pv) { printf("%x ", (unsigned)ri->d[i]); } printf("]"); - + } printf("\n"); } @@ -6616,7 +6616,7 @@ static const char *vcpu_op_str[] = { }; static const char *sched_op_str[] = { - "yield", "block", "shutdown", "poll", "remote_shutdown", "shutdown_code", + "yield", "block", "shutdown", "poll", "remote_shutdown", "shutdown_code", "watchdog", }; @@ -6649,7 +6649,7 @@ void pv_hypercall_gather_args(const struct record_info *ri, uint64_t *args) for (i = 0, word = 1; i < 6 && word < ri->extra_words; i++) { int present = pv_hypercall_arg_present(ri, i); - + switch (present) { case ARG_32BIT: args[i] = ri->d[word]; @@ -6693,7 +6693,7 @@ void pv_hypercall_v2_process(struct record_info *ri, struct pv_data *pv, int op = pv_hypercall_op(ri); if(opt.summary_info) { - if(op < PV_HYPERCALL_MAX) + if(op < PV_HYPERCALL_MAX) pv->hypercall_count[op]++; } @@ -6746,12 +6746,12 @@ void pv_process(struct pcpu_info *p) struct record_info *ri = &p->ri; struct vcpu_data *v = p->current; struct pv_data *pv = &v->pv; - + union pv_event pevt = { .event = ri->event }; if(vcpu_set_data_type(p->current, VCPU_DATA_PV)) return; - + if(opt.summary_info) { pv->summary_info=1; @@ -6833,7 +6833,7 @@ void domain_init(struct domain_data *d, int did) struct domain_data * domain_create(int did) { struct domain_data *d; - + fprintf(warn, "Creating domain %d\n", did); if((d=malloc(sizeof(*d)))==NULL) @@ -6863,7 +6863,7 @@ struct domain_data * domain_find(int did) /* Make a new domain */ n = domain_create(did); - + /* Insert it into the list */ n->next = d; *q = n; @@ -6927,7 +6927,7 @@ void vcpu_prev_update(struct pcpu_info *p, struct vcpu_data *prev, prev->runstate.tsc = 0; goto set; } - + if(prev->runstate.state != RUNSTATE_RUNNING) { fprintf(warn, "Strange, prev d%dv%d not running!\n", @@ -6960,7 +6960,7 @@ void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc) else { fprintf(warn, "%s: FATAL: p->current not NULL! (d%dv%d, runstate %s)\n", - __func__, + __func__, p->current->d->did, p->current->vid, runstate_name[p->current->runstate.state]); @@ -6987,9 +6987,9 @@ void vcpu_next_update(struct pcpu_info *p, struct vcpu_data *next, tsc_t tsc) { update_cycles(&next->cpu_affinity_all, tsc - next->pcpu_tsc); update_cycles(&next->cpu_affinity_pcpu[p->pid], tsc - next->pcpu_tsc); - } + } next->pcpu_tsc = tsc; - } + } } else { @@ -7051,7 +7051,7 @@ void vcpu_start(struct pcpu_info *p, struct vcpu_data *v) { /* Change default domain to 'queued' */ runstate_update(p->current, RUNSTATE_QUEUED, p->first_tsc); - + /* FIXME: Copy over data from the default domain this interval */ fprintf(warn, "Using first_tsc for d%dv%d (%lld cycles)\n", v->d->did, v->vid, p->last_tsc - p->first_tsc); @@ -7146,7 +7146,7 @@ void sched_runstate_process(struct pcpu_info *p) runstate_name[sevt.new_runstate]); } } - + if(r->vcpu > MAX_CPUS) { fprintf(warn, "%s: vcpu %u > MAX_VCPUS %d!\n", @@ -7169,7 +7169,7 @@ void sched_runstate_process(struct pcpu_info *p) && v->hvm.vmexit_valid) { hvm_close_vmexit(&v->hvm, ri->tsc); } - + /* Track waking state */ if ( v->data_type == VCPU_DATA_HVM && v->runstate.state != RUNSTATE_LOST ) { if ( sevt.new_runstate == RUNSTATE_RUNNABLE @@ -7213,12 +7213,12 @@ void sched_runstate_process(struct pcpu_info *p) i, g->is_wake, t); - + if(opt.scatterplot_wake_to_halt && t && g->is_wake) scatterplot_vs_time(ri->tsc, t); - + if(opt.summary && t) { if(g->is_wake) { if(v->hvm.w2h.interrupts==1) @@ -7257,23 +7257,23 @@ void sched_runstate_process(struct pcpu_info *p) && last_oldstate.actual == sevt.old_runstate) { tsc_t lag, old_offset; struct pcpu_info *p2; - + if(ri->tsc < last_oldstate.tsc) { fprintf(warn, "WARNING: new tsc %lld < detected runstate tsc %lld! Not updating\n", ri->tsc, last_oldstate.tsc); goto no_update; } - + p2 = P.pcpu + last_oldstate.pid; - + lag = ri->tsc - last_oldstate.tsc; - + old_offset = p2->tsc_skew.offset; - + cpumask_union(&p2->tsc_skew.downstream, &p->tsc_skew.downstream); cpumask_set(&p2->tsc_skew.downstream, p->pid); - + if(cpumask_isset(&p2->tsc_skew.downstream, p2->pid)) { if ( opt.tsc_loop_fatal ) { @@ -7294,22 +7294,22 @@ void sched_runstate_process(struct pcpu_info *p) goto no_update; } } - + p2->tsc_skew.offset += lag * 2; - + fprintf(warn, "TSC skew detected p%d->p%d, %lld cycles. Changing p%d offset from %lld to %lld\n", p->pid, p2->pid, lag, p2->pid, old_offset, p2->tsc_skew.offset); - + goto no_update; } else { fprintf(warn, "runstate_change old_runstate %s, d%dv%d runstate %s. Possible tsc skew.\n", runstate_name[sevt.old_runstate], v->d->did, v->vid, runstate_name[v->runstate.state]); - + v->runstate.last_oldstate.wrong = sevt.old_runstate; v->runstate.last_oldstate.actual = v->runstate.state; v->runstate.last_oldstate.tsc = ri->tsc; @@ -7325,7 +7325,7 @@ void sched_runstate_process(struct pcpu_info *p) fprintf(stderr, "FATAL: Logic hole in %s\n", __func__); error(ERR_ASSERT, NULL); } - + update: /* Actually update the runstate. Special things to do if we're starting * or stopping actually running on a physical cpu. */ @@ -7354,7 +7354,7 @@ update: v->p ? v->p->pid : -1); error(ERR_FILE, NULL); } - + runstate_update(v, RUNSTATE_RUNNING, ri->tsc); } } @@ -7366,10 +7366,10 @@ update: if(perfctrs && v->runstate.tsc) { unsigned long long run_cycles, run_instr; double cpi; - + //run_cycles = r->p1 - v->runstate_p1_start; run_cycles = ri->tsc - v->runstate.tsc; - run_instr = r->p2 - v->runstate.p2_start; + run_instr = r->p2 - v->runstate.p2_start; cpi = ((double)run_cycles) / run_instr; @@ -7377,12 +7377,12 @@ update: printf(" cpi: %2.2lf ( %lld / %lld )\n", cpi, run_cycles, run_instr); } - + if(opt.scatterplot_cpi && v->d->did == 1) printf("%lld,%2.2lf\n", ri->tsc, cpi); - if(opt.summary_info) + if(opt.summary_info) update_cpi(&v->cpi, run_instr, run_cycles); } #endif @@ -7413,7 +7413,7 @@ update: } else { vcpu_prev_update(v->p, v, ri->tsc, sevt.new_runstate); } - + if(P.lost_cpus && v->d->did != IDLE_DOMAIN) { if(opt.dump_all) fprintf(warn, "%s: %d lost cpus, setting d%dv%d runstate to RUNSTATE_LOST\n", @@ -7536,7 +7536,7 @@ void sched_summary_vcpu(struct vcpu_data *v) printf(" Runstates:\n"); for(i=0; i<RUNSTATE_MAX; i++) { - snprintf(desc,30, " %8s", runstate_name[i]); + snprintf(desc,30, " %8s", runstate_name[i]); print_cycle_summary(v->runstates+i, desc); if ( i==RUNSTATE_RUNNABLE ) { @@ -7544,7 +7544,7 @@ void sched_summary_vcpu(struct vcpu_data *v) for(j=0; j<RUNNABLE_STATE_MAX; j++) { if ( j == RUNNABLE_STATE_INVALID ) continue; - snprintf(desc,30, " %8s", runnable_state_name[j]); + snprintf(desc,30, " %8s", runnable_state_name[j]); print_cycle_summary(v->runnable_states+j, desc); } } @@ -7565,7 +7565,7 @@ void sched_summary_domain(struct domain_data *d) printf(" Runstates:\n"); for(i=0; i<DOMAIN_RUNSTATE_MAX; i++) { - snprintf(desc,30, " %8s", domain_runstate_name[i]); + snprintf(desc,30, " %8s", domain_runstate_name[i]); print_cycle_summary(d->runstates+i, desc); } } @@ -7716,7 +7716,7 @@ int p2m_canonical_order(int order) } else { order /= 9; } - return order; + return order; } void mem_pod_zero_reclaim_process(struct pcpu_info *p) @@ -7800,7 +7800,7 @@ void mem_pod_populate_process(struct pcpu_info *p) order = p2m_canonical_order(r->order); d->pod.populate_order[order]++; - } + } } } @@ -7850,7 +7850,7 @@ void mem_set_p2m_entry_process(struct pcpu_info *p) printf(" %s set_p2m_entry d%d o%d t %d g %llx m %llx\n", ri->dump_header, r->d, r->order, - r->p2mt, + r->p2mt, (unsigned long long)r->gfn, (unsigned long long)r->mfn); } } @@ -7924,7 +7924,7 @@ void mem_process(struct pcpu_info *p) { } break; } - + } /* ---- PM ---- */ @@ -7971,7 +7971,7 @@ void pm_process(struct pcpu_info *p) { } break; } - + } /* @@ -8024,7 +8024,7 @@ struct pci_dev * pdev_find(uint8_t bus, uint8_t devfn) n->bus=bus; n->devfn=devfn; - + /* Insert it into the list */ n->next = d; *q = n; @@ -8072,9 +8072,9 @@ void irq_process(struct pcpu_info *p) { if ( opt.scatterplot_irq ) { struct time_struct t; - + abs_cycles_to_time(ri->tsc, &t); - + printf("i%x %u.%09u %d\n", (unsigned)r->irq, t.s, t.ns, @@ -8110,7 +8110,7 @@ void irq_process(struct pcpu_info *p) { if( irq_table[r->irq].dev ) { struct pci_dev * pdev=irq_table[r->irq].dev; - + if(pdev->vector_used[r->vec]) fprintf(warn, " Vector collision on %02x.%02x!\n", pdev->bus, pdev->devfn); @@ -8147,7 +8147,7 @@ void irq_process(struct pcpu_info *p) { ri->dump_header, r->irq, r->vec, r->cpu); } - if ( r->irq < MAX_IRQ + if ( r->irq < MAX_IRQ && r->vec < MAX_VECTOR ) { if ( irq_table[r->irq].type == IRQ_MSI ) @@ -8159,7 +8159,7 @@ void irq_process(struct pcpu_info *p) { if ( irq_table[r->irq].dev ) { struct pci_dev * pdev=irq_table[r->irq].dev; - + if(!pdev->vector_used[r->vec]) fprintf(warn," Strange, cleanup on non-used vector\n"); pdev->vector_used[r->vec]=0; @@ -8218,7 +8218,7 @@ void dump_generic(FILE * f, struct record_info *ri) ri->event, ri->evt.main, ri->evt.sub, - ri->evt.minor, + ri->evt.minor, ri->extra_words); for(i=0; i<ri->extra_words; i++) { @@ -8245,7 +8245,7 @@ void dump_raw(char * s, struct record_info *ri) else printf(" "); } - + printf(" ] | "); for (i=0; i<8; i++) { @@ -8271,7 +8271,7 @@ int check_extra_words(struct record_info *ri, { static int off_by_one = 0; int expected_extra = expected_size / sizeof(unsigned int); - + if(ri->extra_words != expected_extra && !(off_by_one && ri->extra_words == expected_extra + 1) ) { @@ -8287,7 +8287,7 @@ int check_extra_words(struct record_info *ri, error(ERR_RECORD, ri); return 1; } - } + } return 0; } @@ -8389,7 +8389,7 @@ void process_lost_records(struct pcpu_info *p) #endif if ( p->current ) { - + hvm_vlapic_clear(&p->current->vlapic); if(p->current->data_type == VCPU_DATA_HVM) { p->current->hvm.vmexit_valid=0; @@ -8431,7 +8431,7 @@ void process_lost_records(struct pcpu_info *p) p->lost_record.active = 1; p->lost_record.tsc = first_tsc; pcpu_string_draw(p); - + { /* Any vcpu which is not actively running may be scheduled on the * lost cpu. To avoid mis-accounting, we need to reset */ @@ -8511,8 +8511,8 @@ void process_lost_records_end(struct pcpu_info *p) printf(" %s lost_records end (domain invalid)---\n", pcpu_string(p->pid)); } - - + + p->lost_record.active = 0; pcpu_string_draw(p); P.lost_cpus--; @@ -8575,7 +8575,7 @@ loff_t scan_for_new_pcpu(loff_t offset) { ssize_t r; struct trace_record rec; struct cpu_change_data *cd; - + r=__read_record(&rec, offset); if(r==0) @@ -8598,7 +8598,7 @@ loff_t scan_for_new_pcpu(loff_t offset) { /* FIXME: Figure out if we could handle this more gracefully */ error(ERR_ASSERT, NULL); } - + if(cd->cpu > P.max_active_pcpu || !P.pcpu[cd->cpu].active) { struct pcpu_info *p = P.pcpu + cd->cpu; @@ -8629,7 +8629,7 @@ loff_t scan_for_new_pcpu(loff_t offset) { } } -/* +/* * Conceptually, when we reach a cpu_change record that's not for our pcpu, * we want to scan forward through the file until we reach one that's for us. * However, looping through involves reading the file, which we'd rather @@ -8684,7 +8684,7 @@ void deactivate_pcpu(struct pcpu_info *p) fprintf(warn, "%s: Setting max_active_pcpu to %d\n", __func__, max_active_pcpu); } - + } /* Helper function to process tsc-related record info */ @@ -8749,11 +8749,11 @@ void create_dump_header(struct record_info *ri, struct pcpu_info *p) c+=r; len-=r; } - + r = snprintf(c, len, " %s", pcpu_string(ri->cpu)); c+=r; len-=r; - + if ( p->current ) { r = snprintf(c, len, " d%dv%d", p->current->d->did, p->current->vid); @@ -8792,7 +8792,7 @@ int find_toplevel_event(struct record_info *ri) return toplevel; } - + void process_cpu_change(struct pcpu_info *p) { struct record_info *ri = &p->ri; @@ -8844,7 +8844,7 @@ void process_cpu_change(struct pcpu_info *p) { fprintf(warn, "%s: Activating pcpu %d at offset %lld\n", __func__, r->cpu, (unsigned long long)p->file_offset); - + record_order_insert(p2); sched_default_vcpu_activate(p2); @@ -8865,7 +8865,7 @@ void process_cpu_change(struct pcpu_info *p) { __func__, p->pid, (unsigned long long)P.last_epoch_offset); deactivate_pcpu(p); } - } + } else { /* Track information about dom0 scheduling and records */ @@ -8879,7 +8879,7 @@ void process_cpu_change(struct pcpu_info *p) { p->volume.buffer_dom0_runstate_tsc; p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate] += ri->tsc - cycles; - + printf(" - updated p%d dom0_runstate %s to %lld cycles (+%lld)\n", p->pid, runstate_name[p->volume.buffer_dom0_runstate], p->volume.buffer_dom0_runstate_cycles[p->volume.buffer_dom0_runstate], @@ -9010,7 +9010,7 @@ void process_record(struct pcpu_info *p) { process_record_tsc(p->order_tsc, ri); - if(opt.dump_all) + if(opt.dump_all) create_dump_header(ri, p); @@ -9062,9 +9062,9 @@ void process_record(struct pcpu_info *p) { static inline ssize_t get_rec_size(struct trace_record *rec) { ssize_t s; - + s = sizeof(uint32_t); - + if(rec->cycle_flag) s += sizeof(tsc_t); @@ -9091,7 +9091,7 @@ void progress_init(void) { if(!(pid = fork())) { progress_child_exec(); - + fprintf(stderr, "%s: exec failed (%s), disabling progress bar\n", __func__, strerror(errno)); opt.progress = 0; @@ -9261,7 +9261,7 @@ ssize_t read_record(struct pcpu_info * p) { * - Updating the current one * * FIXME: Need to deal with pcpu states changing... - * + * * WARNING not thread-safe */ @@ -9292,7 +9292,7 @@ char * pcpu_string(int pcpu) { char *s = __pcpu_string; static int max_active_pcpu=-1, last_pcpu=-1; - + assert(P.max_active_pcpu < MAX_CPUS); assert(pcpu <= P.max_active_pcpu); @@ -9302,7 +9302,7 @@ char * pcpu_string(int pcpu) if(P.max_active_pcpu > max_active_pcpu) { int i; - for(i=max_active_pcpu + 1; i<= P.max_active_pcpu; i++) + for(i=max_active_pcpu + 1; i<= P.max_active_pcpu; i++) pcpu_string_draw(P.pcpu+i); max_active_pcpu=P.max_active_pcpu; } @@ -9397,7 +9397,7 @@ void record_order_remove(struct pcpu_info *rem) assert(record_order[i]); /* And move everyone forward */ - for(; (record_order[i]=record_order[i+1]); i++) + for(; (record_order[i]=record_order[i+1]); i++) ; } @@ -9469,7 +9469,7 @@ void domain_summary(void) if(opt.show_default_domain_summary) { d = &default_domain; printf("|-- Default domain --|\n"); - + for( i = 0; i < MAX_CPUS ; i++ ) { if(d->vcpu[i]) @@ -9534,7 +9534,7 @@ void report_pcpu(void) { if(!p->summary) continue; printf("pcpu %d\n", i); - + print_cycle_summary(&p->time.running, " running"); print_cycle_summary(&p->time.idle, " idle"); print_cycle_summary(&p->time.lost, " lost"); @@ -9543,7 +9543,7 @@ void report_pcpu(void) { active++; } printf("Total active cpus: %d\n", active); - + } void init_pcpus(void) { @@ -9651,7 +9651,7 @@ enum { void parse_cpu_hz(char * arg) { float hz_base; char * next_ptr; - + hz_base=strtof(arg, &next_ptr); if(next_ptr == arg) { fprintf(stderr, "Invalid cpu_hz %s\n", arg); @@ -9947,7 +9947,7 @@ error_t cmd_parser(int key, char *arg, struct argp_state *state) opt.with_cr3_enumeration = 1; G.output_defined = 1; break; - + case OPT_INTERVAL_CR3_SCHEDULE_ORDERED: opt.interval.output = INTERVAL_CR3_SCHEDULE_ORDERED; opt.interval.check = INTERVAL_CHECK_CR3; @@ -9997,7 +9997,7 @@ error_t cmd_parser(int key, char *arg, struct argp_state *state) opt.summary_info = 1; G.output_defined = 1; break; - + case OPT_INTERVAL_DOMAIN_SHORT_SUMMARY: { if((parse_array(arg, &opt.interval.array) < 0) @@ -10057,7 +10057,7 @@ error_t cmd_parser(int key, char *arg, struct argp_state *state) char *inval; opt.default_guest_paging_levels = (int)strtol(arg, &inval, 0); if ( inval == arg ) - argp_usage(state); + argp_usage(state); } break; case OPT_SYMBOL_FILE: @@ -10350,19 +10350,19 @@ const struct argp_option cmd_opts[] = { .key = OPT_SUMMARY, .group = OPT_GROUP_SUMMARY, .doc = "Output a summary", }, - + { .name = "report-pcpu", .key = OPT_REPORT_PCPU, .group = OPT_GROUP_SUMMARY, .doc = "Report utilization for pcpus", }, - + /* Guest info */ { .name = "default-guest-paging-levels", .key = OPT_DEFAULT_GUEST_PAGING_LEVELS, .group = OPT_GROUP_GUEST, .arg = "L", .doc = "Default guest paging levels. Mainly necessary for Rio, as Miami traces include guest paging levels where appropriate.", }, - + { .name = "symbol-file", .key = OPT_SYMBOL_FILE, .group = OPT_GROUP_GUEST, @@ -10435,7 +10435,7 @@ int main(int argc, char *argv[]) { if(opt.dump_all) warn = stdout; - + init_pcpus(); if(opt.progress) @@ -10454,7 +10454,7 @@ int main(int argc, char *argv[]) { if(opt.progress) progress_finish(); - + return 0; } /* ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v5 8/8] xenalyze: remove argp_program_version 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering ` (6 preceding siblings ...) 2015-06-09 11:23 ` [PATCH v5 7/8] xenalyze: remove trailing whitespaces Olaf Hering @ 2015-06-09 11:23 ` Olaf Hering 7 siblings, 0 replies; 20+ messages in thread From: Olaf Hering @ 2015-06-09 11:23 UTC (permalink / raw) To: xen-devel, George Dunlap Cc: Wei Liu, Olaf Hering, Ian Jackson, Ian Campbell, Stefano Stabellini Since xenalyze is now upstream its Open Source and part of the given release. Signed-off-by: Olaf Hering <olaf@aepfle.de> Acked-by: George Dunlap <george.dunlap@eu.citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> Cc: Ian Jackson <ian.jackson@eu.citrix.com> Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Cc: Ian Campbell <ian.campbell@citrix.com> Cc: Wei Liu <wei.liu2@citrix.com> --- tools/xentrace/xenalyze.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/xentrace/xenalyze.c b/tools/xentrace/xenalyze.c index 4525e36..52764fe 100644 --- a/tools/xentrace/xenalyze.c +++ b/tools/xentrace/xenalyze.c @@ -10405,7 +10405,6 @@ const struct argp parser_def = { .doc = "", }; -const char *argp_program_version = "xenalyze - Open-source xen-unstable (3.4)"; const char *argp_program_bug_address = "George Dunlap <george.dunlap@eu.citrix.com>"; ^ permalink raw reply related [flat|nested] 20+ messages in thread
end of thread, other threads:[~2015-06-16 8:35 UTC | newest] Thread overview: 20+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2015-06-09 11:23 [PATCH v5 0/8] add xenalyze to staging Olaf Hering 2015-06-09 11:23 ` [PATCH v5 1/8] xenalyze: add to tools/xentrace/ Olaf Hering 2015-06-11 15:23 ` George Dunlap 2015-06-11 16:04 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 2/8] xenalyze: increase NR_CPUS to 256 Olaf Hering 2015-06-10 20:29 ` Julien Grall 2015-06-11 6:12 ` Olaf Hering 2015-06-11 11:03 ` Julien Grall 2015-06-11 14:35 ` George Dunlap 2015-06-15 16:14 ` Olaf Hering 2015-06-15 17:19 ` Andrew Cooper 2015-06-15 17:58 ` Olaf Hering 2015-06-16 8:33 ` Ian Campbell 2015-06-16 8:35 ` Olaf Hering 2015-06-09 11:23 ` [PATCH v5 3/8] xenalyze: print newline after unknown hvm events Olaf Hering 2015-06-09 11:23 ` [PATCH v5 4/8] xenalyze: include odd mmio states in default output Olaf Hering 2015-06-09 11:23 ` [PATCH v5 5/8] xenalyze: handle TRC_TRACE_WRAP_BUFFER Olaf Hering 2015-06-09 11:23 ` [PATCH v5 6/8] xenalyze: handle more events in sched_process Olaf Hering 2015-06-09 11:23 ` [PATCH v5 7/8] xenalyze: remove trailing whitespaces Olaf Hering 2015-06-09 11:23 ` [PATCH v5 8/8] xenalyze: remove argp_program_version Olaf Hering
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.