print_hw_residencies(cpu);
}
-static void dump_cx(unsigned char key)
+static void cf_check dump_cx(unsigned char key)
{
unsigned int cpu;
hvm_irq->callback_via_asserted ? "" : " not");
}
-static void dump_irq_info(unsigned char key)
+static void cf_check dump_irq_info(unsigned char key)
{
struct domain *d;
svm->vmcb = NULL;
}
-static void vmcb_dump(unsigned char ch)
+static void cf_check vmcb_dump(unsigned char ch)
{
struct domain *d;
struct vcpu *v;
vmx_vmcs_exit(v);
}
-static void vmcs_dump(unsigned char ch)
+static void cf_check vmcs_dump(unsigned char ch)
{
struct domain *d;
struct vcpu *v;
__print_IO_APIC(1);
}
-static void _print_IO_APIC_keyhandler(unsigned char key)
+static void cf_check _print_IO_APIC_keyhandler(unsigned char key)
{
__print_IO_APIC(0);
}
pcidevs_unlock();
}
-static void dump_irqs(unsigned char key)
+static void cf_check dump_irqs(unsigned char key)
{
int i, irq, pirq;
struct irq_desc *desc;
return memory_types[x][0] ? memory_types[x] : "?";
}
-static void ept_dump_p2m_table(unsigned char key)
+static void cf_check ept_dump_p2m_table(unsigned char key)
{
struct domain *d;
ept_entry_t *table, *ept_entry;
#if SHADOW_AUDIT
int shadow_audit_enable = 0;
-static void shadow_audit_key(unsigned char key)
+static void cf_check shadow_audit_key(unsigned char key)
{
shadow_audit_enable = !shadow_audit_enable;
printk("%s shadow_audit_enable=%d\n",
/* Blow all shadows of all shadowed domains: this can be used to cause the
* guest's pagetables to be re-shadowed if we suspect that the shadows
* have somehow got out of sync */
-static void shadow_blow_all_tables(unsigned char c)
+static void cf_check shadow_blow_all_tables(unsigned char c)
{
struct domain *d;
printk("'%c' pressed -> blowing all shadow tables\n", c);
return;
}
-static void dump_msi(unsigned char key)
+static void cf_check dump_msi(unsigned char key)
{
unsigned int irq;
local_irq_restore(flags);
}
-static void do_nmi_trigger(unsigned char key)
+static void cf_check do_nmi_trigger(unsigned char key)
{
printk("Triggering NMI on APIC ID %x\n", get_apic_id());
self_nmi();
}
-static void do_nmi_stats(unsigned char key)
+static void cf_check do_nmi_stats(unsigned char key)
{
const struct vcpu *v;
unsigned int cpu;
+ PAGE_SHIFT, 32);
}
-static void dump_numa(unsigned char key)
+static void cf_check dump_numa(unsigned char key)
{
s_time_t now = NOW();
unsigned int i, j, n;
}
/* vtsc may incur measurable performance degradation, diagnose with this */
-static void dump_softtsc(unsigned char key)
+static void cf_check dump_softtsc(unsigned char key)
{
struct domain *d;
int domcnt = 0;
spin_unlock_irqrestore(&debugtrace_lock, flags);
}
-static void debugtrace_key(unsigned char key)
+static void cf_check debugtrace_key(unsigned char key)
{
debugtrace_toggle();
}
spin_unlock(&d->event_lock);
}
-static void dump_evtchn_info(unsigned char key)
+static void cf_check dump_evtchn_info(unsigned char key)
{
struct domain *d;
printk("no active grant table entries\n");
}
-static void gnttab_usage_print_all(unsigned char key)
+static void cf_check gnttab_usage_print_all(unsigned char key)
{
struct domain *d;
return 0;
}
-static void do_crashdump_trigger(unsigned char key)
+static void cf_check do_crashdump_trigger(unsigned char key)
{
printk("'%c' pressed -> triggering crashdump\n", key);
kexec_crash(CRASHREASON_DEBUGKEY);
static unsigned char keypress_key;
static bool_t alt_key_handling;
-static keyhandler_fn_t show_handlers, dump_hwdom_registers,
- dump_domains, read_clocks;
-static irq_keyhandler_fn_t do_toggle_alt_key, dump_registers,
- reboot_machine, run_all_keyhandlers, do_debug_key;
+static keyhandler_fn_t cf_check show_handlers, cf_check dump_hwdom_registers,
+ cf_check dump_domains, cf_check read_clocks;
+static irq_keyhandler_fn_t cf_check do_toggle_alt_key, cf_check dump_registers,
+ cf_check reboot_machine, cf_check run_all_keyhandlers,
+ cf_check do_debug_key;
static struct keyhandler {
union {
} key_table[128] __read_mostly =
{
#define KEYHANDLER(k, f, desc, diag) \
- [k] = { { (f) }, desc, 0, diag }
+ [k] = { { .fn = (f) }, desc, 0, diag }
#define IRQ_KEYHANDLER(k, f, desc, diag) \
- [k] = { { (keyhandler_fn_t *)(f) }, desc, 1, diag }
+ [k] = { { .irq_fn = (f) }, desc, 1, diag }
IRQ_KEYHANDLER('A', do_toggle_alt_key, "toggle alternative key handling", 0),
IRQ_KEYHANDLER('d', dump_registers, "dump registers", 1),
key_table[key].diagnostic = diagnostic;
}
-static void show_handlers(unsigned char key)
+static void cf_check show_handlers(unsigned char key)
{
unsigned int i;
watchdog_enable();
}
-static void dump_registers(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check dump_registers(
+ unsigned char key, struct cpu_user_regs *regs)
{
unsigned int cpu;
}
}
-static void dump_hwdom_registers(unsigned char key)
+static void cf_check dump_hwdom_registers(unsigned char key)
{
struct vcpu *v;
}
}
-static void reboot_machine(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check reboot_machine(
+ unsigned char key, struct cpu_user_regs *regs)
{
printk("'%c' pressed -> rebooting machine\n", key);
machine_restart(0);
}
-static void dump_domains(unsigned char key)
+static void cf_check dump_domains(unsigned char key)
{
struct domain *d;
const struct sched_unit *unit;
local_irq_enable();
}
-static void read_clocks(unsigned char key)
+static void cf_check read_clocks(unsigned char key)
{
unsigned int cpu = smp_processor_id(), min_stime_cpu, max_stime_cpu;
unsigned int min_cycles_cpu, max_cycles_cpu;
static DECLARE_TASKLET(run_all_keyhandlers_tasklet,
run_all_nonirq_keyhandlers, NULL);
-static void run_all_keyhandlers(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check run_all_keyhandlers(
+ unsigned char key, struct cpu_user_regs *regs)
{
struct keyhandler *h;
unsigned int k;
barrier();
}
-static void do_debug_key(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check do_debug_key(unsigned char key, struct cpu_user_regs *regs)
{
printk("'%c' pressed -> trapping into debugger\n", key);
if ( regs )
run_in_exception_handler(do_debugger_trap_fatal);
}
-static void do_toggle_alt_key(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check do_toggle_alt_key(
+ unsigned char key, struct cpu_user_regs *regs)
{
alt_key_handling = !alt_key_handling;
printk("'%c' pressed -> using %s key handling\n", key,
return names[state];
}
-static void livepatch_printall(unsigned char key)
+static void cf_check livepatch_printall(unsigned char key)
{
struct payload *data;
const void *binary_id = NULL;
}
-static void pagealloc_info(unsigned char key)
+static void cf_check pagealloc_info(unsigned char key)
{
unsigned int zone = MEMZONE_XEN;
unsigned long n, total = 0;
#endif
}
-static void dump_heap(unsigned char key)
+static void cf_check dump_heap(unsigned char key)
{
s_time_t now = NOW();
int i, j;
DEFINE_PER_CPU(perfc_t[NUM_PERFCOUNTERS], perfcounters);
-void perfc_printall(unsigned char key)
+void cf_check perfc_printall(unsigned char key)
{
unsigned int i, j;
s_time_t now = NOW();
}
}
-void perfc_reset(unsigned char key)
+void cf_check perfc_reset(unsigned char key)
{
unsigned int i, j;
s_time_t now = NOW();
return pool->cpu_valid;
}
-void dump_runq(unsigned char key)
+void cf_check dump_runq(unsigned char key)
{
s_time_t now = NOW();
struct cpupool *c;
data->lock_cnt, data->time_hold, data->block_cnt, data->time_block);
}
-void spinlock_profile_printall(unsigned char key)
+void cf_check spinlock_profile_printall(unsigned char key)
{
s_time_t now = NOW();
s_time_t diff;
data->time_block = 0;
}
-void spinlock_profile_reset(unsigned char key)
+void cf_check spinlock_profile_reset(unsigned char key)
{
s_time_t now = NOW();
(t->expires - now) / 1000, t, t->function, t->data);
}
-static void dump_timerq(unsigned char key)
+static void cf_check dump_timerq(unsigned char key)
{
struct timer *t;
struct timers *ts;
static int *__read_mostly lower_thresh_adj = &xenlog_lower_thresh;
static const char *__read_mostly thresh_adj = "standard";
-static void do_toggle_guest(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check do_toggle_guest(unsigned char key, struct cpu_user_regs *regs)
{
if ( upper_thresh_adj == &xenlog_upper_thresh )
{
loglvl_str(*upper_thresh_adj));
}
-static void do_inc_thresh(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check do_inc_thresh(unsigned char key, struct cpu_user_regs *regs)
{
++*lower_thresh_adj;
do_adj_thresh(key);
}
-static void do_dec_thresh(unsigned char key, struct cpu_user_regs *regs)
+static void cf_check do_dec_thresh(unsigned char key, struct cpu_user_regs *regs)
{
if ( *lower_thresh_adj )
--*lower_thresh_adj;
pv_console_puts(s, nr);
}
-static void dump_console_ring_key(unsigned char key)
+static void cf_check dump_console_ring_key(unsigned char key)
{
uint32_t idx, len, sofar, c;
unsigned int order;
int amd_iommu_msi_msg_update_ire(
struct msi_desc *msi_desc, struct msi_msg *msg);
int amd_setup_hpet_msi(struct msi_desc *msi_desc);
-void amd_iommu_dump_intremap_tables(unsigned char key);
+void cf_check amd_iommu_dump_intremap_tables(unsigned char key);
extern struct ioapic_sbdf {
u16 bdf, seg;
return 0;
}
-void amd_iommu_dump_intremap_tables(unsigned char key)
+void cf_check amd_iommu_dump_intremap_tables(unsigned char key)
{
if ( !shared_intremap_table )
{
#include <xen/keyhandler.h>
#include <xsm/xsm.h>
-static void iommu_dump_page_tables(unsigned char key);
-
unsigned int __read_mostly iommu_dev_iotlb_timeout = 1000;
integer_param("iommu_dev_iotlb_timeout", iommu_dev_iotlb_timeout);
return 0;
}
+static void cf_check iommu_dump_page_tables(unsigned char key)
+{
+ struct domain *d;
+
+ ASSERT(iommu_enabled);
+
+ rcu_read_lock(&domlist_read_lock);
+
+ for_each_domain(d)
+ {
+ if ( is_hardware_domain(d) || !is_iommu_enabled(d) )
+ continue;
+
+ if ( iommu_use_hap_pt(d) )
+ {
+ printk("%pd sharing page tables\n", d);
+ continue;
+ }
+
+ iommu_vcall(dom_iommu(d)->platform_ops, dump_page_tables, d);
+ }
+
+ rcu_read_unlock(&domlist_read_lock);
+}
+
void __hwdom_init iommu_hwdom_init(struct domain *d)
{
struct domain_iommu *hd = dom_iommu(d);
return is_iommu_enabled(d) && test_bit(feature, dom_iommu(d)->features);
}
-static void iommu_dump_page_tables(unsigned char key)
-{
- struct domain *d;
-
- ASSERT(iommu_enabled);
-
- rcu_read_lock(&domlist_read_lock);
-
- for_each_domain(d)
- {
- if ( is_hardware_domain(d) || !is_iommu_enabled(d) )
- continue;
-
- if ( iommu_use_hap_pt(d) )
- {
- printk("%pd sharing page tables\n", d);
- continue;
- }
-
- iommu_vcall(dom_iommu(d)->platform_ops, dump_page_tables, d);
- }
-
- rcu_read_unlock(&domlist_read_lock);
-}
-
/*
* Local variables:
* mode: C
return 0;
}
-static void dump_pci_devices(unsigned char ch)
+static void cf_check dump_pci_devices(unsigned char ch)
{
printk("==== PCI devices ====\n");
pcidevs_lock();
void print_iommu_regs(struct acpi_drhd_unit *drhd);
void print_vtd_entries(struct vtd_iommu *iommu, int bus, int devfn, u64 gmfn);
-keyhandler_fn_t vtd_dump_iommu_info;
+keyhandler_fn_t cf_check vtd_dump_iommu_info;
bool intel_iommu_supports_eim(void);
int intel_iommu_enable_eim(void);
} while ( --level );
}
-void vtd_dump_iommu_info(unsigned char key)
+void cf_check vtd_dump_iommu_info(unsigned char key)
{
struct acpi_drhd_unit *drhd;
struct vtd_iommu *iommu;
struct xen_sysctl_perfc_op;
int perfc_control(struct xen_sysctl_perfc_op *);
-extern void perfc_printall(unsigned char key);
-extern void perfc_reset(unsigned char key);
+extern void cf_check perfc_printall(unsigned char key);
+extern void cf_check perfc_reset(unsigned char key);
#else /* CONFIG_PERF_COUNTERS */
int cpupool_do_sysctl(struct xen_sysctl_cpupool_op *op);
unsigned int cpupool_get_id(const struct domain *d);
const cpumask_t *cpupool_valid_cpus(const struct cpupool *pool);
-extern void dump_runq(unsigned char key);
+extern void cf_check dump_runq(unsigned char key);
void arch_do_physinfo(struct xen_sysctl_physinfo *pi);
_lock_profile_deregister_struct(type, &((ptr)->profile_head))
extern int spinlock_profile_control(struct xen_sysctl_lockprof_op *pc);
-extern void spinlock_profile_printall(unsigned char key);
-extern void spinlock_profile_reset(unsigned char key);
+extern void cf_check spinlock_profile_printall(unsigned char key);
+extern void cf_check spinlock_profile_reset(unsigned char key);
#else