/*
* xen_hyper_dump_tables.c
*
* Portions Copyright (C) 2006-2007 Fujitsu Limited
* Portions Copyright (C) 2006-2007 VA Linux Systems Japan K.K.
*
* Authors: Itsuro Oda <oda@valinux.co.jp>
* Fumihiko Kakuma <kakuma@valinux.co.jp>
*
* This file is part of Xencrash.
*
* Xencrash is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Xencrash is distributed in the hope that 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 Xencrash; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "defs.h"
#ifdef XEN_HYPERVISOR_ARCH
#include "xen_hyper_defs.h"
static void xen_hyper_dump_xen_hyper_table(int verbose);
static void xen_hyper_dump_xen_hyper_dumpinfo_table(int verbose);
static void xen_hyper_dump_xen_hyper_domain_table(int verbose);
static void xen_hyper_dump_xen_hyper_vcpu_table(int verbose);
static void xen_hyper_dump_xen_hyper_pcpu_table(int verbose);
static void xen_hyper_dump_xen_hyper_sched_table(int verbose);
static void xen_hyper_dump_xen_hyper_size_table(char *spec, ulong makestruct);
static void xen_hyper_dump_xen_hyper_offset_table(char *spec, ulong makestruct);
static void xen_hyper_dump_mem(void *mem, ulong len, int dsz);
/*
* Get help for a command, to dump an internal table, or the GNU public
* license copying/warranty information.
*/
void
xen_hyper_cmd_help(void)
{
int c;
int oflag;
oflag = 0;
while ((c = getopt(argcnt, args,
"aBbcDgHhM:mnOopszX:")) != EOF) {
switch(c)
{
case 'a':
dump_alias_data();
return;
case 'b':
dump_shared_bufs();
return;
case 'B':
dump_build_data();
return;
case 'c':
dump_numargs_cache();
return;
case 'n':
case 'D':
dumpfile_memory(DUMPFILE_MEM_DUMP);
return;
case 'g':
dump_gdb_data();
return;
case 'H':
dump_hash_table(VERBOSE);
return;
case 'h':
dump_hash_table(!VERBOSE);
return;
case 'M':
dump_machdep_table(stol(optarg, FAULT_ON_ERROR, NULL));
return;
case 'm':
dump_machdep_table(0);
return;
case 'O':
dump_offset_table(NULL, TRUE);
return;
case 'o':
oflag = TRUE;
break;
case 'p':
dump_program_context();
return;
case 's':
dump_symbol_table();
return;
case 'X':
if (strlen(optarg) != 3) {
argerrs++;
break;
}
if (!strncmp("Xen", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_table(VERBOSE);
else if (!strncmp("xen", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_table(!VERBOSE);
else if (!strncmp("Dmp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_dumpinfo_table(VERBOSE);
else if (!strncmp("dmp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_dumpinfo_table(!VERBOSE);
else if (!strncmp("Dom", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_domain_table(VERBOSE);
else if (!strncmp("dom", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_domain_table(!VERBOSE);
else if (!strncmp("Vcp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_vcpu_table(VERBOSE);
else if (!strncmp("vcp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_vcpu_table(!VERBOSE);
else if (!strncmp("Pcp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_pcpu_table(VERBOSE);
else if (!strncmp("pcp", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_pcpu_table(!VERBOSE);
else if (!strncmp("Sch", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_sched_table(VERBOSE);
else if (!strncmp("sch", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_sched_table(!VERBOSE);
else if (!strncmp("siz", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_size_table(NULL, TRUE);
else if (!strncmp("ofs", optarg, strlen(optarg)))
xen_hyper_dump_xen_hyper_offset_table(NULL, TRUE);
else {
argerrs++;
break;
}
return;
case 'z':
fprintf(fp, "help options:\n");
fprintf(fp, " -a - alias data\n");
fprintf(fp, " -b - shared buffer data\n");
fprintf(fp, " -B - build data\n");
fprintf(fp, " -c - numargs cache\n");
fprintf(fp, " -M <num> machine specific\n");
fprintf(fp, " -m - machdep_table\n");
fprintf(fp, " -s - symbol table data\n");
fprintf(fp, " -o - offset_table and size_table\n");
fprintf(fp, " -p - program_context\n");
fprintf(fp, " -h - hash_table data\n");
fprintf(fp, " -H - hash_table data (verbose)\n");
fprintf(fp, " -X Xen - xen table data (verbose)\n");
fprintf(fp, " -X xen - xen table data\n");
fprintf(fp, " -X Dmp - dumpinfo table data (verbose)\n");
fprintf(fp, " -X dmp - dumpinfo table data\n");
fprintf(fp, " -X Dom - domain table data (verbose)\n");
fprintf(fp, " -X dom - domain table data\n");
fprintf(fp, " -X Vcp - vcpu table data (verbose)\n");
fprintf(fp, " -X vcp - vcpu table data\n");
fprintf(fp, " -X Pcp - pcpu table data (verbose)\n");
fprintf(fp, " -X pcp - pcpu table data\n");
fprintf(fp, " -X Sch - schedule table data (verbose)\n");
fprintf(fp, " -X sch - schedule table data\n");
fprintf(fp, " -X siz - size table data\n");
fprintf(fp, " -X ofs - offset table data\n");
return;
default:
argerrs++;
break;
}
}
if (argerrs)
cmd_usage(pc->curcmd, COMPLETE_HELP);
if (!args[optind]) {
if (oflag)
dump_offset_table(NULL, FALSE);
else
display_help_screen("");
return;
}
do {
if (oflag)
dump_offset_table(args[optind], FALSE);
else
cmd_usage(args[optind], COMPLETE_HELP);
optind++;
} while (args[optind]);
}
/*
* "help -x xen" output
*/
static void
xen_hyper_dump_xen_hyper_table(int verbose)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
uint cpuid;
int len, flag, i;
len = 14;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "cpu_data_address: ", buf, flag,
(buf, "%lu\n", xht->cpu_data_address));
XEN_HYPER_PRI(fp, len, "cpu_curr: ", buf, flag,
(buf, "%u\n", xht->cpu_curr));
XEN_HYPER_PRI(fp, len, "max_cpus: ", buf, flag,
(buf, "%u\n", xht->max_cpus));
XEN_HYPER_PRI(fp, len, "cores: ", buf, flag,
(buf, "%d\n", xht->cores));
XEN_HYPER_PRI(fp, len, "pcpus: ", buf, flag,
(buf, "%d\n", xht->pcpus));
XEN_HYPER_PRI(fp, len, "vcpus: ", buf, flag,
(buf, "%d\n", xht->vcpus));
XEN_HYPER_PRI(fp, len, "domains: ", buf, flag,
(buf, "%d\n", xht->domains));
XEN_HYPER_PRI(fp, len, "sys_pages: ", buf, flag,
(buf, "%lu\n", xht->sys_pages));
XEN_HYPER_PRI(fp, len, "crashing_cpu: ", buf, flag,
(buf, "%d\n", xht->crashing_cpu));
XEN_HYPER_PRI(fp, len, "crashing_vcc: ", buf, flag,
(buf, "%p\n", xht->crashing_vcc));
XEN_HYPER_PRI(fp, len, "max_page: ", buf, flag,
(buf, "%lu\n", xht->max_page));
XEN_HYPER_PRI(fp, len, "total_pages: ", buf, flag,
(buf, "%lu\n", xht->total_pages));
XEN_HYPER_PRI(fp, len, "cpumask: ", buf, flag,
(buf, "%p\n", xht->cpumask));
if (verbose && xht->cpumask) {
xen_hyper_dump_mem(xht->cpumask,
XEN_HYPER_SIZE(cpumask_t), sizeof(long));
}
XEN_HYPER_PRI(fp, len, "cpu_idxs: ", buf, flag,
(buf, "%p\n", xht->cpu_idxs));
if (verbose) {
for_cpu_indexes(i, cpuid)
fprintf(fp, "%03d : %d\n", i, cpuid);
}
}
/*
* "help -x dmp" output
*/
static void
xen_hyper_dump_xen_hyper_dumpinfo_table(int verbose)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
int len, flag;
len = 25;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "note_ver: ", buf, flag,
(buf, "%u\n", xhdit->note_ver));
XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
(buf, "%p\n", xhdit->context_array));
if (verbose && xhdit->context_array) {
xen_hyper_dump_mem((long *)xhdit->context_array,
sizeof(struct xen_hyper_dumpinfo_context) *
XEN_HYPER_MAX_CPUS(), sizeof(long));
}
XEN_HYPER_PRI(fp, len, "context_xen_core_array: ", buf, flag,
(buf, "%p\n", xhdit->context_xen_core_array));
if (verbose && xhdit->context_xen_core_array) {
xen_hyper_dump_mem((long *)xhdit->context_xen_core_array,
sizeof(struct xen_hyper_dumpinfo_context_xen_core) *
XEN_HYPER_MAX_CPUS(), sizeof(long));
}
XEN_HYPER_PRI_CONST(fp, len, "context_xen_info: ", flag|XEN_HYPER_PRI_LF);
XEN_HYPER_PRI(fp, len, "note: ", buf, flag,
(buf, "%lx\n", xhdit->context_xen_info.note));
XEN_HYPER_PRI(fp, len, "pcpu_id: ", buf, flag,
(buf, "%u\n", xhdit->context_xen_info.pcpu_id));
XEN_HYPER_PRI(fp, len, "crash_xen_info_ptr: ", buf, flag,
(buf, "%p\n", xhdit->context_xen_info.crash_xen_info_ptr));
XEN_HYPER_PRI(fp, len, "crash_note_core_array: ", buf, flag,
(buf, "%p\n", xhdit->crash_note_core_array));
if (verbose && xhdit->crash_note_core_array) {
xen_hyper_dump_mem((long *)xhdit->crash_note_core_array,
xhdit->core_size * XEN_HYPER_NR_PCPUS(),
sizeof(long));
}
XEN_HYPER_PRI(fp, len, "crash_note_xen_core_array: ", buf, flag,
(buf, "%p\n", xhdit->crash_note_xen_core_array));
if (verbose && xhdit->crash_note_xen_core_array) {
xen_hyper_dump_mem(
xhdit->crash_note_xen_core_array,
xhdit->xen_core_size * XEN_HYPER_NR_PCPUS(),
sizeof(long));
}
XEN_HYPER_PRI(fp, len, "crash_note_xen_info_ptr: ", buf, flag,
(buf, "%p\n", xhdit->crash_note_xen_info_ptr));
if (verbose && xhdit->crash_note_xen_info_ptr) {
xen_hyper_dump_mem(
xhdit->crash_note_xen_info_ptr,
xhdit->xen_info_size, sizeof(long));
}
XEN_HYPER_PRI(fp, len, "xen_info_cpu: ", buf, flag,
(buf, "%u\n", xhdit->xen_info_cpu));
XEN_HYPER_PRI(fp, len, "note_size: ", buf, flag,
(buf, "%u\n", xhdit->note_size));
XEN_HYPER_PRI(fp, len, "core_offset: ", buf, flag,
(buf, "%u\n", xhdit->core_offset));
XEN_HYPER_PRI(fp, len, "core_size: ", buf, flag,
(buf, "%u\n", xhdit->core_size));
XEN_HYPER_PRI(fp, len, "xen_core_offset: ", buf, flag,
(buf, "%u\n", xhdit->xen_core_offset));
XEN_HYPER_PRI(fp, len, "xen_core_size: ", buf, flag,
(buf, "%u\n", xhdit->xen_core_size));
XEN_HYPER_PRI(fp, len, "xen_info_offset: ", buf, flag,
(buf, "%u\n", xhdit->xen_info_offset));
XEN_HYPER_PRI(fp, len, "xen_info_size: ", buf, flag,
(buf, "%u\n", xhdit->xen_info_size));
}
/*
* "help -x dom" output
*/
static void
xen_hyper_dump_xen_hyper_domain_table(int verbose)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
struct xen_hyper_domain_context *dcca;
int len, flag, i;
len = 22;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
(buf, "%p\n", xhdt->context_array));
if (verbose) {
char buf1[XEN_HYPER_CMD_BUFSIZE];
int j;
for (i = 0, dcca = xhdt->context_array;
i < xhdt->context_array_cnt; i++, dcca++) {
snprintf(buf, XEN_HYPER_CMD_BUFSIZE, "context_array[%d]: ", i);
XEN_HYPER_PRI_CONST(fp, len, buf, flag|XEN_HYPER_PRI_LF);
XEN_HYPER_PRI(fp, len, "domain: ", buf, flag,
(buf, "%lx\n", dcca->domain));
XEN_HYPER_PRI(fp, len, "domain_id: ", buf, flag,
(buf, "%d\n", dcca->domain_id));
XEN_HYPER_PRI(fp, len, "tot_pages: ", buf, flag,
(buf, "%x\n", dcca->tot_pages));
XEN_HYPER_PRI(fp, len, "max_pages: ", buf, flag,
(buf, "%x\n", dcca->max_pages));
XEN_HYPER_PRI(fp, len, "xenheap_pages: ", buf, flag,
(buf, "%x\n", dcca->xenheap_pages));
XEN_HYPER_PRI(fp, len, "shared_info: ", buf, flag,
(buf, "%lx\n", dcca->shared_info));
XEN_HYPER_PRI(fp, len, "sched_priv: ", buf, flag,
(buf, "%lx\n", dcca->sched_priv));
XEN_HYPER_PRI(fp, len, "next_in_list: ", buf, flag,
(buf, "%lx\n", dcca->next_in_list));
XEN_HYPER_PRI(fp, len, "domain_flags: ", buf, flag,
(buf, "%lx\n", dcca->domain_flags));
XEN_HYPER_PRI(fp, len, "evtchn: ", buf, flag,
(buf, "%lx\n", dcca->evtchn));
XEN_HYPER_PRI(fp, len, "vcpu_cnt: ", buf, flag,
(buf, "%d\n", dcca->vcpu_cnt));
for (j = 0; j < XEN_HYPER_MAX_VIRT_CPUS; j++) {
snprintf(buf1, XEN_HYPER_CMD_BUFSIZE, "vcpu[%d]: ", j);
XEN_HYPER_PRI(fp, len, buf1, buf, flag,
(buf, "%lx\n", dcca->vcpu[j]));
}
XEN_HYPER_PRI(fp, len, "vcpu_context_array: ", buf, flag,
(buf, "%p\n", dcca->vcpu_context_array));
}
}
XEN_HYPER_PRI(fp, len, "context_array_cnt: ", buf, flag,
(buf, "%d\n", xhdt->context_array_cnt));
XEN_HYPER_PRI(fp, len, "running_domains: ", buf, flag,
(buf, "%lu\n", xhdt->running_domains));
XEN_HYPER_PRI(fp, len, "dom_io: ", buf, flag,
(buf, "%p\n", xhdt->dom_io));
XEN_HYPER_PRI(fp, len, "dom_xen: ", buf, flag,
(buf, "%p\n", xhdt->dom_xen));
XEN_HYPER_PRI(fp, len, "dom0: ", buf, flag,
(buf, "%p\n", xhdt->dom0));
XEN_HYPER_PRI(fp, len, "idle_domain: ", buf, flag,
(buf, "%p\n", xhdt->idle_domain));
XEN_HYPER_PRI(fp, len, "curr_domain: ", buf, flag,
(buf, "%p\n", xhdt->curr_domain));
XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
(buf, "%p\n", xhdt->last));
XEN_HYPER_PRI(fp, len, "domain_struct: ", buf, flag,
(buf, "%p\n", xhdt->domain_struct));
XEN_HYPER_PRI(fp, len, "domain_struct_verify: ", buf, flag,
(buf, "%p\n", xhdt->domain_struct_verify));
}
/*
* "help -x vcp" output
*/
static void
xen_hyper_dump_xen_hyper_vcpu_table(int verbose)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
int len, flag;
len = 25;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "vcpu_context_arrays: ", buf, flag,
(buf, "%p\n", xhvct->vcpu_context_arrays));
XEN_HYPER_PRI(fp, len, "vcpu_context_arrays_cnt: ", buf, flag,
(buf, "%d\n", xhvct->vcpu_context_arrays_cnt));
if (verbose) {
struct xen_hyper_vcpu_context_array *vcca;
struct xen_hyper_vcpu_context *vca;
int i, j;
for (i = 0, vcca = xhvct->vcpu_context_arrays;
i < xhvct->vcpu_context_arrays_cnt; i++, vcca++) {
snprintf(buf, XEN_HYPER_CMD_BUFSIZE, "vcpu_context_arrays[%d]: ", i);
XEN_HYPER_PRI_CONST(fp, len, buf, flag|XEN_HYPER_PRI_LF);
if (vcca->context_array) {
XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
(buf, "%p\n", vcca->context_array));
} else {
XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
(buf, "NULL\n"));
}
XEN_HYPER_PRI(fp, len, "context_array_cnt: ", buf, flag,
(buf, "%d\n", vcca->context_array_cnt));
XEN_HYPER_PRI(fp, len, "context_array_valid: ", buf, flag,
(buf, "%d\n", vcca->context_array_valid));
for (j = 0, vca = vcca->context_array;
j < vcca->context_array_cnt; j++, vca++) {
snprintf(buf, XEN_HYPER_CMD_BUFSIZE, "context_array[%d]: ", j);
XEN_HYPER_PRI_CONST(fp, len, buf, flag|XEN_HYPER_PRI_LF);
XEN_HYPER_PRI(fp, len, "vcpu: ", buf, flag,
(buf, "%lx\n", vca->vcpu));
XEN_HYPER_PRI(fp, len, "vcpu_id: ", buf, flag,
(buf, "%d\n", vca->vcpu_id));
XEN_HYPER_PRI(fp, len, "processor: ", buf, flag,
(buf, "%d\n", vca->processor));
XEN_HYPER_PRI(fp, len, "vcpu_info: ", buf, flag,
(buf, "%lx\n", vca->vcpu_info));
XEN_HYPER_PRI(fp, len, "domain: ", buf, flag,
(buf, "%lx\n", vca->domain));
XEN_HYPER_PRI(fp, len, "next_in_list: ", buf, flag,
(buf, "%lx\n", vca->next_in_list));
XEN_HYPER_PRI(fp, len, "sleep_tick: ", buf, flag,
(buf, "%lx\n", vca->sleep_tick));
XEN_HYPER_PRI(fp, len, "sched_priv: ", buf, flag,
(buf, "%lx\n", vca->sched_priv));
XEN_HYPER_PRI(fp, len, "state: ", buf, flag,
(buf, "%d\n", vca->state));
XEN_HYPER_PRI(fp, len, "state_entry_time: ", buf, flag,
(buf, "%llux\n", (unsigned long long)(vca->state_entry_time)));
XEN_HYPER_PRI(fp, len, "runstate_guest: ", buf, flag,
(buf, "%lx\n", vca->runstate_guest));
XEN_HYPER_PRI(fp, len, "vcpu_flags: ", buf, flag,
(buf, "%lx\n", vca->vcpu_flags));
}
}
}
XEN_HYPER_PRI(fp, len, "idle_vcpu: ", buf, flag,
(buf, "%lx\n", xhvct->idle_vcpu));
XEN_HYPER_PRI(fp, len, "idle_vcpu_context_array: ", buf, flag,
(buf, "%p\n", xhvct->idle_vcpu_context_array));
XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
(buf, "%p\n", xhvct->last));
XEN_HYPER_PRI(fp, len, "vcpu_struct: ", buf, flag,
(buf, "%p\n", xhvct->vcpu_struct));
XEN_HYPER_PRI(fp, len, "vcpu_struct_verify: ", buf, flag,
(buf, "%p\n", xhvct->vcpu_struct_verify));
}
/*
* "help -x pcp" output
*/
static void
xen_hyper_dump_xen_hyper_pcpu_table(int verbose)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
struct xen_hyper_pcpu_context *pcca;
int len, flag, i;
#ifdef X86_64
uint64_t *ist_p;
int j;
#endif
len = 21;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
(buf, "%p\n", xhpct->context_array));
if (verbose) {
for (i = 0, pcca = xhpct->context_array;
i < XEN_HYPER_MAX_CPUS(); i++, pcca++) {
snprintf(buf, XEN_HYPER_CMD_BUFSIZE, "context_array %d: ", i);
XEN_HYPER_PRI_CONST(fp, len, buf, flag|XEN_HYPER_PRI_LF);
XEN_HYPER_PRI(fp, len, "pcpu: ", buf, flag,
(buf, "%lx\n", pcca->pcpu));
XEN_HYPER_PRI(fp, len, "processor_id: ", buf, flag,
(buf, "%u\n", pcca->processor_id));
XEN_HYPER_PRI(fp, len, "guest_cpu_user_regs: ", buf, flag,
(buf, "%lx\n", pcca->guest_cpu_user_regs));
XEN_HYPER_PRI(fp, len, "current_vcpu: ", buf, flag,
(buf, "%lx\n", pcca->current_vcpu));
XEN_HYPER_PRI(fp, len, "init_tss: ", buf, flag,
(buf, "%lx\n", pcca->init_tss));
#ifdef X86
XEN_HYPER_PRI(fp, len, "sp.esp0: ", buf, flag,
(buf, "%x\n", pcca->sp.esp0));
#endif
#ifdef X86_64
XEN_HYPER_PRI(fp, len, "sp.rsp0: ", buf, flag,
(buf, "%lx\n", pcca->sp.rsp0));
for (j = 0, ist_p = pcca->ist;
j < XEN_HYPER_TSS_IST_MAX; j++, ist_p++) {
XEN_HYPER_PRI(fp, len, "ist: ", buf, flag,
(buf, "%lx\n", *ist_p));
}
#endif
}
}
XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
(buf, "%p\n", xhpct->last));
XEN_HYPER_PRI(fp, len, "pcpu_struct: ", buf, flag,
(buf, "%p\n", xhpct->pcpu_struct));
}
/*
* "help -x sch" output
*/
static void
xen_hyper_dump_xen_hyper_sched_table(int verbose)
{
struct xen_hyper_sched_context *schc;
char buf[XEN_HYPER_CMD_BUFSIZE];
int len, flag, i;
len = 21;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "name: ", buf, flag,
(buf, "%s\n", xhscht->name));
XEN_HYPER_PRI(fp, len, "opt_sched: ", buf, flag,
(buf, "%s\n", xhscht->opt_sched));
XEN_HYPER_PRI(fp, len, "sched_id: ", buf, flag,
(buf, "%d\n", xhscht->sched_id));
XEN_HYPER_PRI(fp, len, "scheduler: ", buf, flag,
(buf, "%lx\n", xhscht->scheduler));
XEN_HYPER_PRI(fp, len, "scheduler_struct: ", buf, flag,
(buf, "%p\n", xhscht->scheduler_struct));
XEN_HYPER_PRI(fp, len, "sched_context_array: ", buf, flag,
(buf, "%p\n", xhscht->sched_context_array));
if (verbose) {
for (i = 0, schc = xhscht->sched_context_array;
i < xht->pcpus; i++, schc++) {
XEN_HYPER_PRI(fp, len, "sched_context_array[", buf,
flag, (buf, "%d]\n", i));
XEN_HYPER_PRI(fp, len, "schedule_data: ", buf, flag,
(buf, "%lx\n", schc->schedule_data));
XEN_HYPER_PRI(fp, len, "curr: ", buf, flag,
(buf, "%lx\n", schc->curr));
XEN_HYPER_PRI(fp, len, "idle: ", buf, flag,
(buf, "%lx\n", schc->idle));
XEN_HYPER_PRI(fp, len, "sched_priv: ", buf, flag,
(buf, "%lx\n", schc->sched_priv));
XEN_HYPER_PRI(fp, len, "tick: ", buf, flag,
(buf, "%lx\n", schc->tick));
}
}
}
/*
* "help -x siz" output
*/
static void
xen_hyper_dump_xen_hyper_size_table(char *spec, ulong makestruct)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
int len, flag;
len = 23;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "ELF_Prstatus: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.ELF_Prstatus));
XEN_HYPER_PRI(fp, len, "ELF_Signifo: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.ELF_Signifo));
XEN_HYPER_PRI(fp, len, "ELF_Gregset: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.ELF_Gregset));
XEN_HYPER_PRI(fp, len, "ELF_Timeval: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.ELF_Timeval));
XEN_HYPER_PRI(fp, len, "arch_domain: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.arch_domain));
XEN_HYPER_PRI(fp, len, "arch_shared_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.arch_shared_info));
XEN_HYPER_PRI(fp, len, "cpu_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpu_info));
XEN_HYPER_PRI(fp, len, "cpu_time: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpu_time));
XEN_HYPER_PRI(fp, len, "cpu_user_regs: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpu_user_regs));
XEN_HYPER_PRI(fp, len, "cpumask_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpumask_t));
XEN_HYPER_PRI(fp, len, "cpuinfo_ia64: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpuinfo_ia64));
XEN_HYPER_PRI(fp, len, "cpuinfo_x86: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.cpuinfo_x86));
XEN_HYPER_PRI(fp, len, "crash_note_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_note_t));
XEN_HYPER_PRI(fp, len, "crash_note_core_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_note_core_t));
XEN_HYPER_PRI(fp, len, "crash_note_xen_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_t));
XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_core_t));
XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_info_t));
XEN_HYPER_PRI(fp, len, "crash_xen_core_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_xen_core_t));
XEN_HYPER_PRI(fp, len, "crash_xen_info_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.crash_xen_info_t));
XEN_HYPER_PRI(fp, len, "domain: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.domain));
#ifdef IA64
XEN_HYPER_PRI(fp, len, "mm_struct: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.mm_struct));
#endif
XEN_HYPER_PRI(fp, len, "note_buf_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.note_buf_t));
XEN_HYPER_PRI(fp, len, "schedule_data: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.schedule_data));
XEN_HYPER_PRI(fp, len, "scheduler: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.scheduler));
XEN_HYPER_PRI(fp, len, "shared_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.shared_info));
XEN_HYPER_PRI(fp, len, "timer: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.timer));
XEN_HYPER_PRI(fp, len, "tss: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.tss));
XEN_HYPER_PRI(fp, len, "vcpu: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.vcpu));
XEN_HYPER_PRI(fp, len, "vcpu_runstate_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.vcpu_runstate_info));
XEN_HYPER_PRI(fp, len, "xen_crash_xen_regs_t: ", buf, flag,
(buf, "%ld\n", xen_hyper_size_table.xen_crash_xen_regs_t));
}
/*
* "help -x ofs" output
*/
static void
xen_hyper_dump_xen_hyper_offset_table(char *spec, ulong makestruct)
{
char buf[XEN_HYPER_CMD_BUFSIZE];
int len, flag;
len = 45;
flag = XEN_HYPER_PRI_R;
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_info));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cursig: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cursig));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sigpend: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sigpend));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sighold: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sighold));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_pid: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_pid));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_ppid: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_ppid));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_pgrp: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_pgrp));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sid: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sid));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_stime: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_stime));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cutime: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cutime));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cstime: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cstime));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_reg: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_reg));
XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_fpvalid: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_fpvalid));
XEN_HYPER_PRI(fp, len, "ELF_Timeval_tv_sec: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Timeval_tv_sec));
XEN_HYPER_PRI(fp, len, "ELF_Timeval_tv_usec: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.ELF_Timeval_tv_usec));
#ifdef IA64
XEN_HYPER_PRI(fp, len, "arch_domain_mm: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.arch_domain_mm));
#endif
XEN_HYPER_PRI(fp, len, "arch_shared_info_max_pfn: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.arch_shared_info_max_pfn));
XEN_HYPER_PRI(fp, len, "arch_shared_info_pfn_to_mfn_frame_list_list: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.arch_shared_info_pfn_to_mfn_frame_list_list));
XEN_HYPER_PRI(fp, len, "arch_shared_info_nmi_reason: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.arch_shared_info_nmi_reason));
XEN_HYPER_PRI(fp, len, "cpu_info_guest_cpu_user_regs: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_info_guest_cpu_user_regs));
XEN_HYPER_PRI(fp, len, "cpu_info_processor_id: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_info_processor_id));
XEN_HYPER_PRI(fp, len, "cpu_info_current_vcpu: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_info_current_vcpu));
XEN_HYPER_PRI(fp, len, "cpu_time_local_tsc_stamp: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_time_local_tsc_stamp));
XEN_HYPER_PRI(fp, len, "cpu_time_stime_local_stamp: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_time_stime_local_stamp));
XEN_HYPER_PRI(fp, len, "cpu_time_stime_master_stamp: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_time_stime_master_stamp));
XEN_HYPER_PRI(fp, len, "cpu_time_tsc_scale: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_time_tsc_scale));
XEN_HYPER_PRI(fp, len, "cpu_time_calibration_timer: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.cpu_time_calibration_timer));
XEN_HYPER_PRI(fp, len, "crash_note_t_core: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_core));
XEN_HYPER_PRI(fp, len, "crash_note_t_xen: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen));
XEN_HYPER_PRI(fp, len, "crash_note_t_xen_regs: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen_regs));
XEN_HYPER_PRI(fp, len, "crash_note_t_xen_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen_info));
XEN_HYPER_PRI(fp, len, "crash_note_core_t_note: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_core_t_note));
XEN_HYPER_PRI(fp, len, "crash_note_core_t_desc: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_core_t_desc));
XEN_HYPER_PRI(fp, len, "crash_note_xen_t_note: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_t_note));
XEN_HYPER_PRI(fp, len, "crash_note_xen_t_desc: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_t_desc));
XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t_note: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_core_t_note));
XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t_desc: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_core_t_desc));
XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t_note: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_info_t_note));
XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t_desc: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_info_t_desc));
XEN_HYPER_PRI(fp, len, "domain_page_list: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_page_list));
XEN_HYPER_PRI(fp, len, "domain_xenpage_list: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_xenpage_list));
XEN_HYPER_PRI(fp, len, "domain_domain_id: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_domain_id));
XEN_HYPER_PRI(fp, len, "domain_tot_pages: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_tot_pages));
XEN_HYPER_PRI(fp, len, "domain_max_pages: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_max_pages));
XEN_HYPER_PRI(fp, len, "domain_xenheap_pages: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_xenheap_pages));
XEN_HYPER_PRI(fp, len, "domain_shared_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_shared_info));
XEN_HYPER_PRI(fp, len, "domain_sched_priv: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_sched_priv));
XEN_HYPER_PRI(fp, len, "domain_next_in_list: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_next_in_list));
XEN_HYPER_PRI(fp, len, "domain_domain_flags: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_domain_flags));
XEN_HYPER_PRI(fp, len, "domain_evtchn: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_evtchn));
XEN_HYPER_PRI(fp, len, "domain_is_hvm: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_hvm));
XEN_HYPER_PRI(fp, len, "domain_guest_type: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_guest_type));
XEN_HYPER_PRI(fp, len, "domain_is_privileged: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_privileged));
XEN_HYPER_PRI(fp, len, "domain_debugger_attached: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_debugger_attached));
if (XEN_HYPER_VALID_MEMBER(domain_is_polling)) {
XEN_HYPER_PRI(fp, len, "domain_is_polling: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_polling));
}
XEN_HYPER_PRI(fp, len, "domain_is_dying: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_dying));
/* Only one of next both exists but print both, ones value is -1. */
XEN_HYPER_PRI(fp, len, "domain_is_paused_by_controller: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_paused_by_controller));
XEN_HYPER_PRI(fp, len, "domain_controller_pause_count: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_controller_pause_count));
XEN_HYPER_PRI(fp, len, "domain_is_shutting_down: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_shutting_down));
XEN_HYPER_PRI(fp, len, "domain_is_shut_down: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_is_shut_down));
XEN_HYPER_PRI(fp, len, "domain_vcpu: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_vcpu));
XEN_HYPER_PRI(fp, len, "domain_arch: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.domain_arch));
#ifdef IA64
XEN_HYPER_PRI(fp, len, "mm_struct_pgd: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.mm_struct_pgd));
#endif
XEN_HYPER_PRI(fp, len, "schedule_data_schedule_lock: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_schedule_lock));
XEN_HYPER_PRI(fp, len, "schedule_data_curr: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_curr));
XEN_HYPER_PRI(fp, len, "schedule_data_idle: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_idle));
XEN_HYPER_PRI(fp, len, "schedule_data_sched_priv: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_sched_priv));
XEN_HYPER_PRI(fp, len, "schedule_data_s_timer: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_s_timer));
XEN_HYPER_PRI(fp, len, "schedule_data_tick: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.schedule_data_tick));
XEN_HYPER_PRI(fp, len, "scheduler_name: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_name));
XEN_HYPER_PRI(fp, len, "scheduler_opt_name: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_opt_name));
XEN_HYPER_PRI(fp, len, "scheduler_sched_id: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_sched_id));
XEN_HYPER_PRI(fp, len, "scheduler_init: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_init));
XEN_HYPER_PRI(fp, len, "scheduler_tick: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_tick));
XEN_HYPER_PRI(fp, len, "scheduler_init_vcpu: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_init_vcpu));
XEN_HYPER_PRI(fp, len, "scheduler_destroy_domain: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_destroy_domain));
XEN_HYPER_PRI(fp, len, "scheduler_sleep: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_sleep));
XEN_HYPER_PRI(fp, len, "scheduler_wake: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_wake));
XEN_HYPER_PRI(fp, len, "scheduler_set_affinity: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_set_affinity));
XEN_HYPER_PRI(fp, len, "scheduler_do_schedule: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_do_schedule));
XEN_HYPER_PRI(fp, len, "scheduler_adjust: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_adjust));
XEN_HYPER_PRI(fp, len, "scheduler_dump_settings: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_dump_settings));
XEN_HYPER_PRI(fp, len, "scheduler_dump_cpu_state: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.scheduler_dump_cpu_state));
XEN_HYPER_PRI(fp, len, "shared_info_vcpu_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.shared_info_vcpu_info));
XEN_HYPER_PRI(fp, len, "shared_info_evtchn_pending: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.shared_info_evtchn_pending));
XEN_HYPER_PRI(fp, len, "shared_info_evtchn_mask: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.shared_info_evtchn_mask));
XEN_HYPER_PRI(fp, len, "shared_info_arch: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.shared_info_arch));
XEN_HYPER_PRI(fp, len, "timer_expires: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_expires));
XEN_HYPER_PRI(fp, len, "timer_cpu: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_cpu));
XEN_HYPER_PRI(fp, len, "timer_function: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_function));
XEN_HYPER_PRI(fp, len, "timer_data: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_data));
XEN_HYPER_PRI(fp, len, "timer_heap_offset: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_heap_offset));
XEN_HYPER_PRI(fp, len, "timer_killed: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.timer_killed));
XEN_HYPER_PRI(fp, len, "tss_struct_rsp0: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.tss_rsp0));
XEN_HYPER_PRI(fp, len, "tss_struct_esp0: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.tss_esp0));
XEN_HYPER_PRI(fp, len, "vcpu_vcpu_id: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_id));
XEN_HYPER_PRI(fp, len, "vcpu_processor: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_processor));
XEN_HYPER_PRI(fp, len, "vcpu_vcpu_info: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_info));
XEN_HYPER_PRI(fp, len, "vcpu_domain: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_domain));
XEN_HYPER_PRI(fp, len, "vcpu_next_in_list: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_next_in_list));
XEN_HYPER_PRI(fp, len, "vcpu_timer: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_timer));
XEN_HYPER_PRI(fp, len, "vcpu_sleep_tick: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_sleep_tick));
XEN_HYPER_PRI(fp, len, "vcpu_poll_timer: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_poll_timer));
XEN_HYPER_PRI(fp, len, "vcpu_sched_priv: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_sched_priv));
XEN_HYPER_PRI(fp, len, "vcpu_runstate: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate));
XEN_HYPER_PRI(fp, len, "vcpu_runstate_guest: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_guest));
XEN_HYPER_PRI(fp, len, "vcpu_vcpu_flags: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_flags));
XEN_HYPER_PRI(fp, len, "vcpu_pause_count: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_pause_count));
XEN_HYPER_PRI(fp, len, "vcpu_virq_to_evtchn: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_virq_to_evtchn));
XEN_HYPER_PRI(fp, len, "vcpu_cpu_affinity: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_cpu_affinity));
XEN_HYPER_PRI(fp, len, "vcpu_nmi_addr: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_nmi_addr));
XEN_HYPER_PRI(fp, len, "vcpu_vcpu_dirty_cpumask: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_dirty_cpumask));
XEN_HYPER_PRI(fp, len, "vcpu_arch: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_arch));
XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_state: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_state));
XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_state_entry_time: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_state_entry_time));
XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_time: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_time));
#ifdef IA64
XEN_HYPER_PRI(fp, len, "vcpu_thread_ksp: ", buf, flag,
(buf, "%ld\n", xen_hyper_offset_table.vcpu_thread_ksp));
#endif
}
/*
* dump specified memory with specified size.
*/
#define DSP_BYTE_SIZE 16
static void
xen_hyper_dump_mem(void *mem, ulong len, int dsz)
{
long i, max;
void *mem_w = mem;
if (!len ||
(dsz != SIZEOF_8BIT && dsz != SIZEOF_16BIT &&
dsz != SIZEOF_32BIT && dsz != SIZEOF_64BIT))
return;
max = len / dsz + (len % dsz ? 1 : 0);
for (i = 0; i < max; i++) {
if (i != 0 && !(i % (DSP_BYTE_SIZE / dsz)))
fprintf(fp, "\n");
if (i == 0 || !(i % (DSP_BYTE_SIZE / dsz)))
fprintf(fp, "%p : ", mem_w);
if (dsz == SIZEOF_8BIT)
fprintf(fp, "%02x ", *(uint8_t *)mem_w);
else if (dsz == SIZEOF_16BIT)
fprintf(fp, "%04x ", *(uint16_t *)mem_w);
else if (dsz == SIZEOF_32BIT)
fprintf(fp, "%08x ", *(uint32_t *)mem_w);
else if (dsz == SIZEOF_64BIT)
fprintf(fp, "%016llx ", *(unsigned long long *)mem_w);
mem_w = (char *)mem_w + dsz;
}
fprintf(fp, "\n");
}
#endif