/* * 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 * Fumihiko Kakuma * * 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 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