mirror of https://github.com/crash-utility/crash
961 lines
38 KiB
C
961 lines
38 KiB
C
/*
|
|
* 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, "sched_resource: ", buf, flag,
|
|
(buf, "%lx\n", schc->sched_resource));
|
|
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, "sched_resource: ", buf, flag,
|
|
(buf, "%ld\n", xen_hyper_size_table.sched_resource));
|
|
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
|