/* SPDX-License-Identifier: MIT */
/******************************************************************************
* sysctl.h
*
* System management operations. For use by node control stack.
*
* Copyright (c) 2002-2006, K Fraser
*/
#ifndef __XEN_PUBLIC_SYSCTL_H__
#define __XEN_PUBLIC_SYSCTL_H__
#if !defined(__XEN__) && !defined(__XEN_TOOLS__)
#error "sysctl operations are intended for use by node control tools only"
#endif
#include "xen.h"
#include "domctl.h"
#include "physdev.h"
/*
* The interface version needs to be incremented by 1 in case the interface
* is modified in an incompatible way AND if the version hasn't been
* incremented in the current development cycle already.
* Pure additions (e.g. new sub-commands) or compatible interface changes
* (e.g. adding semantics to 0-checked input fields or data to zeroed output
* fields) don't require a change of the version.
*
* Last version bump: Xen 4.17
*/
#define XEN_SYSCTL_INTERFACE_VERSION 0x00000015
/*
* Read console content from Xen buffer ring.
*/
/* XEN_SYSCTL_readconsole */
struct xen_sysctl_readconsole {
/* IN: Non-zero -> clear after reading. */
uint8_t clear;
/* IN: Non-zero -> start index specified by @index field. */
uint8_t incremental;
uint8_t pad0, pad1;
/*
* IN: Start index for consuming from ring buffer (if @incremental);
* OUT: End index after consuming from ring buffer.
*/
uint32_t index;
/* IN: Virtual address to write console data. */
XEN_GUEST_HANDLE_64(char) buffer;
/* IN: Size of buffer; OUT: Bytes written to buffer. */
uint32_t count;
};
/* Get trace buffers machine base address */
/* XEN_SYSCTL_tbuf_op */
struct xen_sysctl_tbuf_op {
/* IN variables */
#define XEN_SYSCTL_TBUFOP_get_info 0
#define XEN_SYSCTL_TBUFOP_set_cpu_mask 1
#define XEN_SYSCTL_TBUFOP_set_evt_mask 2
#define XEN_SYSCTL_TBUFOP_set_size 3
#define XEN_SYSCTL_TBUFOP_enable 4
#define XEN_SYSCTL_TBUFOP_disable 5
uint32_t cmd;
/* IN/OUT variables */
struct xenctl_bitmap cpu_mask;
uint32_t evt_mask;
/* OUT variables */
uint64_aligned_t buffer_mfn;
uint32_t size; /* Also an IN variable! */
};
/*
* Get physical information about the host machine
*/
/* XEN_SYSCTL_physinfo */
/* The platform supports HVM guests. */
#define _XEN_SYSCTL_PHYSCAP_hvm 0
#define XEN_SYSCTL_PHYSCAP_hvm (1u<<_XEN_SYSCTL_PHYSCAP_hvm)
/* The platform supports PV guests. */
#define _XEN_SYSCTL_PHYSCAP_pv 1
#define XEN_SYSCTL_PHYSCAP_pv (1u<<_XEN_SYSCTL_PHYSCAP_pv)
/* The platform supports direct access to I/O devices with IOMMU. */
#define _XEN_SYSCTL_PHYSCAP_directio 2
#define XEN_SYSCTL_PHYSCAP_directio (1u<<_XEN_SYSCTL_PHYSCAP_directio)
/* The platform supports Hardware Assisted Paging. */
#define _XEN_SYSCTL_PHYSCAP_hap 3
#define XEN_SYSCTL_PHYSCAP_hap (1u<<_XEN_SYSCTL_PHYSCAP_hap)
/* The platform supports software paging. */
#define _XEN_SYSCTL_PHYSCAP_shadow 4
#define XEN_SYSCTL_PHYSCAP_shadow (1u<<_XEN_SYSCTL_PHYSCAP_shadow)
/* The platform supports sharing of HAP page tables with the IOMMU. */
#define _XEN_SYSCTL_PHYSCAP_iommu_hap_pt_share 5
#define XEN_SYSCTL_PHYSCAP_iommu_hap_pt_share \
(1u << _XEN_SYSCTL_PHYSCAP_iommu_hap_pt_share)
#define XEN_SYSCTL_PHYSCAP_vmtrace (1u << 6)
/* The platform supports vPMU. */
#define XEN_SYSCTL_PHYSCAP_vpmu (1u << 7)
/* Xen supports the Grant v1 and/or v2 ABIs. */
#define XEN_SYSCTL_PHYSCAP_gnttab_v1 (1u << 8)
#define XEN_SYSCTL_PHYSCAP_gnttab_v2 (1u << 9)
/* Max XEN_SYSCTL_PHYSCAP_* constant. Used for ABI checking. */
#define XEN_SYSCTL_PHYSCAP_MAX XEN_SYSCTL_PHYSCAP_gnttab_v2
#if defined(__arm__) || defined(__aarch64__)
#define XEN_SYSCTL_PHYSCAP_ARM_SVE_MASK (0x1FU)
#endif
struct xen_sysctl_physinfo {
uint32_t threads_per_core;
uint32_t cores_per_socket;
uint32_t nr_cpus; /* # CPUs currently online */
uint32_t max_cpu_id; /* Largest possible CPU ID on this host */
uint32_t nr_nodes; /* # nodes currently online */
uint32_t max_node_id; /* Largest possible node ID on this host */
uint32_t cpu_khz;
uint32_t capabilities;/* XEN_SYSCTL_PHYSCAP_??? */
uint32_t arch_capabilities;/* XEN_SYSCTL_PHYSCAP_{X86,ARM,...}_??? */
uint32_t pad;
uint64_aligned_t total_pages;
uint64_aligned_t free_pages;
uint64_aligned_t scrub_pages;
uint64_aligned_t outstanding_pages;
uint64_aligned_t max_mfn; /* Largest possible MFN on this host */
uint32_t hw_cap[8];
};
/*
* Get the ID of the current scheduler.
*/
/* XEN_SYSCTL_sched_id */
struct xen_sysctl_sched_id {
/* OUT variable */
uint32_t sched_id;
};
/* Interface for controlling Xen software performance counters. */
/* XEN_SYSCTL_perfc_op */
/* Sub-operations: */
#define XEN_SYSCTL_PERFCOP_reset 1 /* Reset all counters to zero. */
#define XEN_SYSCTL_PERFCOP_query 2 /* Get perfctr information. */
struct xen_sysctl_perfc_desc {
char name[80]; /* name of perf counter */
uint32_t nr_vals; /* number of values for this counter */
};
typedef struct xen_sysctl_perfc_desc xen_sysctl_perfc_desc_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_desc_t);
typedef uint32_t xen_sysctl_perfc_val_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_val_t);
struct xen_sysctl_perfc_op {
/* IN variables. */
uint32_t cmd; /* XEN_SYSCTL_PERFCOP_??? */
/* OUT variables. */
uint32_t nr_counters; /* number of counters description */
uint32_t nr_vals; /* number of values */
/* counter information (or NULL) */
XEN_GUEST_HANDLE_64(xen_sysctl_perfc_desc_t) desc;
/* counter values (or NULL) */
XEN_GUEST_HANDLE_64(xen_sysctl_perfc_val_t) val;
};
/* XEN_SYSCTL_getdomaininfolist */
struct xen_sysctl_getdomaininfolist {
/* IN variables. */
domid_t first_domain;
uint32_t max_domains;
XEN_GUEST_HANDLE_64(xen_domctl_getdomaininfo_t) buffer;
/* OUT variables. */
uint32_t num_domains;
};
/* Inject debug keys into Xen. */
/* XEN_SYSCTL_debug_keys */
struct xen_sysctl_debug_keys {
/* IN variables. */
XEN_GUEST_HANDLE_64(const_char) keys;
uint32_t nr_keys;
};
/* Get physical CPU information. */
/* XEN_SYSCTL_getcpuinfo */
struct xen_sysctl_cpuinfo {
uint64_aligned_t idletime;
};
typedef struct xen_sysctl_cpuinfo xen_sysctl_cpuinfo_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpuinfo_t);
struct xen_sysctl_getcpuinfo {
/* IN variables. */
uint32_t max_cpus;
XEN_GUEST_HANDLE_64(xen_sysctl_cpuinfo_t) info;
/* OUT variables. */
uint32_t nr_cpus;
};
/* XEN_SYSCTL_availheap */
struct xen_sysctl_availheap {
/* IN variables. */
uint32_t min_bitwidth; /* Smallest address width (zero if don't care). */
uint32_t max_bitwidth; /* Largest address width (zero if don't care). */
int32_t node; /* NUMA node of interest (-1 for all nodes). */
/* OUT variables. */
uint64_aligned_t avail_bytes;/* Bytes available in the specified region. */
};
/* XEN_SYSCTL_get_pmstat */
struct pm_px_val {
uint64_aligned_t freq; /* Px core frequency */
uint64_aligned_t residency; /* Px residency time */
uint64_aligned_t count; /* Px transition count */
};
typedef struct pm_px_val pm_px_val_t;
DEFINE_XEN_GUEST_HANDLE(pm_px_val_t);
struct pm_px_stat {
uint8_t total; /* total Px states */
uint8_t usable; /* usable Px states */
uint8_t last; /* last Px state */
uint8_t cur; /* current Px state */
XEN_GUEST_HANDLE_64(uint64) trans_pt; /* Px transition table */
XEN_GUEST_HANDLE_64(pm_px_val_t) pt;
};
struct pm_cx_stat {
uint32_t nr; /* entry nr in triggers & residencies, including C0 */
uint32_t last; /* last Cx state */
uint64_aligned_t idle_time; /* idle time from boot */
XEN_GUEST_HANDLE_64(uint64) triggers; /* Cx trigger counts */
XEN_GUEST_HANDLE_64(uint64) residencies; /* Cx residencies */
uint32_t nr_pc; /* entry nr in pc[] */
uint32_t nr_cc; /* entry nr in cc[] */
/*
* These two arrays may (and generally will) have unused slots; slots not
* having a corresponding hardware register will not be written by the
* hypervisor. It is therefore up to the caller to put a suitable sentinel
* into all slots before invoking the function.
* Indexing is 1-biased (PC1/CC1 being at index 0).
*/
XEN_GUEST_HANDLE_64(uint64) pc;
XEN_GUEST_HANDLE_64(uint64) cc;
};
struct xen_sysctl_get_pmstat {
#define PMSTAT_CATEGORY_MASK 0xf0
#define PMSTAT_PX 0x10
#define PMSTAT_CX 0x20
#define PMSTAT_get_max_px (PMSTAT_PX | 0x1)
#define PMSTAT_get_pxstat (PMSTAT_PX | 0x2)
#define PMSTAT_reset_pxstat (PMSTAT_PX | 0x3)
#define PMSTAT_get_max_cx (PMSTAT_CX | 0x1)
#define PMSTAT_get_cxstat (PMSTAT_CX | 0x2)
#define PMSTAT_reset_cxstat (PMSTAT_CX | 0x3)
uint32_t type;
uint32_t cpuid;
union {
struct pm_px_stat getpx;
struct pm_cx_stat getcx;
/* other struct for tx, etc */
} u;
};
/* XEN_SYSCTL_cpu_hotplug */
struct xen_sysctl_cpu_hotplug {
/* IN variables */
uint32_t cpu; /* Physical cpu. */
/* Single CPU enable/disable. */
#define XEN_SYSCTL_CPU_HOTPLUG_ONLINE 0
#define XEN_SYSCTL_CPU_HOTPLUG_OFFLINE 1
/*
* SMT enable/disable.
*
* These two ops loop over all present CPUs, and either online or offline
* every non-primary sibling thread (those with a thread id which is not
* 0). This behaviour is chosen to simplify the implementation.
*
* They are intended as a shorthand for identifying and feeding the cpu
* numbers individually to HOTPLUG_{ON,OFF}LINE.
*
* These are not expected to be used in conjunction with debugging options
* such as `maxcpus=` or when other manual configuration of offline cpus
* is in use.
*/
#define XEN_SYSCTL_CPU_HOTPLUG_SMT_ENABLE 2
#define XEN_SYSCTL_CPU_HOTPLUG_SMT_DISABLE 3
uint32_t op; /* hotplug opcode */
};
/*
* Get/set xen power management, include
* 1. cpufreq governors and related parameters
*/
/* XEN_SYSCTL_pm_op */
struct xen_userspace {
uint32_t scaling_setspeed;
};
struct xen_ondemand {
uint32_t sampling_rate_max;
uint32_t sampling_rate_min;
uint32_t sampling_rate;
uint32_t up_threshold;
};
struct xen_cppc_para {
/* OUT */
/* activity_window supported if set */
#define XEN_SYSCTL_CPPC_FEAT_ACT_WINDOW (1 << 0)
uint32_t features; /* bit flags for features */
/*
* See Intel SDM: HWP Performance Range and Dynamic Capabilities
*
* These four are 0-255 hardware-provided values. They're "continuous,
* abstract unit-less, performance" values. Smaller numbers are slower
* and larger ones are faster.
*/
uint32_t lowest;
uint32_t lowest_nonlinear; /* HWP: most_efficient */
uint32_t nominal; /* HWP: guaranteed */
uint32_t highest;
/*
* See Intel SDM: IA32_HWP_REQUEST MSR (Address: 774H Logical Processor
* Scope)
*
* These are all hints, and the processor may deviate outside of them.
* Values below are 0-255.
*
* minimum and maximum can be set to the above hardware values to constrain
* operation. The full range 0-255 is accepted and will be clipped by
* hardware.
*/
uint32_t minimum;
uint32_t maximum;
/*
* An explicit performance hint, disabling hardware selection.
* 0 lets the hardware decide.
*/
uint32_t desired;
/*
* Hint to hardware for energy/performance preference.
* 0: Performance
* 128: Balance (Default)
* 255: Powersaving
*/
uint32_t energy_perf;
/*
* Activity Window is a moving history window for the processor's operation
* calculations, controlling responsiveness. Measured in microseconds
* encoded as:
*
* bits 6:0 - 7bit mantissa
* bits 9:7 - 3bit base-10 exponent
* btis 15:10 - Unused - must be 0
*/
#define XEN_CPPC_ACT_WINDOW_MANTISSA_MASK 0x07f
#define XEN_CPPC_ACT_WINDOW_EXPONENT_MASK 0x380
uint32_t activity_window;
};
/*
* Set CPPC values.
*
* Configure the parameters for CPPC. Set bits in set_params control which
* values are applied. If a bit is not set in set_params, the field must be
* zero.
*
* For HWP specifically, values must be limited to 0-255 or within
* XEN_SYSCTL_CPPC_ACT_WINDOW_MASK for activity window. Set bits outside the
* range will be returned as -EINVAL.
*
* Activity Window may not be supported by the hardware. In that case, the
* returned set_params will clear XEN_SYSCTL_CPPC_SET_ACT_WINDOW to indicate
* that it was not applied - though the rest of the values will be applied.
*
* There are a set of presets along with individual fields. Presets are
* applied first, and then individual fields. This allows customizing
* a preset without having to specify every value.
*
* The preset options values are as follows:
*
* preset | minimum | maxium | energy_perf
* ------------+---------+---------+----------------
* powersave | lowest | lowest | powersave (255)
* ------------+---------+---------+----------------
* balance | lowest | highest | balance (128)
* ------------+---------+---------+----------------
* performance | highest | highest | performance (0)
*
* desired and activity_window are set to 0, hardware selected.
*/
struct xen_set_cppc_para {
#define XEN_SYSCTL_CPPC_SET_MINIMUM (1U << 0)
#define XEN_SYSCTL_CPPC_SET_MAXIMUM (1U << 1)
#define XEN_SYSCTL_CPPC_SET_DESIRED (1U << 2)
#define XEN_SYSCTL_CPPC_SET_ENERGY_PERF (1U << 3)
#define XEN_SYSCTL_CPPC_SET_ACT_WINDOW (1U << 4)
#define XEN_SYSCTL_CPPC_SET_PRESET_MASK 0xf0000000U
#define XEN_SYSCTL_CPPC_SET_PRESET_NONE 0x00000000U
#define XEN_SYSCTL_CPPC_SET_PRESET_BALANCE 0x10000000U
#define XEN_SYSCTL_CPPC_SET_PRESET_POWERSAVE 0x20000000U
#define XEN_SYSCTL_CPPC_SET_PRESET_PERFORMANCE 0x30000000U
#define XEN_SYSCTL_CPPC_SET_PARAM_MASK \
(XEN_SYSCTL_CPPC_SET_PRESET_MASK | \
XEN_SYSCTL_CPPC_SET_MINIMUM | \
XEN_SYSCTL_CPPC_SET_MAXIMUM | \
XEN_SYSCTL_CPPC_SET_DESIRED | \
XEN_SYSCTL_CPPC_SET_ENERGY_PERF | \
XEN_SYSCTL_CPPC_SET_ACT_WINDOW )
/* IN/OUT */
uint32_t set_params; /* bitflags for valid values */
/* See comments in struct xen_cppc_para. */
/* IN */
uint32_t minimum;
uint32_t maximum;
uint32_t desired;
uint32_t energy_perf;
#define XEN_SYSCTL_CPPC_ACT_WINDOW_MASK (XEN_CPPC_ACT_WINDOW_MANTISSA_MASK | \
XEN_CPPC_ACT_WINDOW_EXPONENT_MASK)
uint32_t activity_window;
};
#define XEN_HWP_DRIVER_NAME "hwp"
/*
* cpufreq para name of this structure named
* same as sysfs file name of native linux
*/
#define CPUFREQ_NAME_LEN 16
struct xen_get_cpufreq_para {
/* IN/OUT variable */
uint32_t cpu_num;
uint32_t freq_num;
uint32_t gov_num;
/* for all governors */
/* OUT variable */
XEN_GUEST_HANDLE_64(uint32) affected_cpus;
XEN_GUEST_HANDLE_64(uint32) scaling_available_frequencies;
XEN_GUEST_HANDLE_64(char) scaling_available_governors;
char scaling_driver[CPUFREQ_NAME_LEN];
uint32_t cpuinfo_cur_freq;
uint32_t cpuinfo_max_freq;
uint32_t cpuinfo_min_freq;
union {
struct {
uint32_t scaling_cur_freq;
char scaling_governor[CPUFREQ_NAME_LEN];
uint32_t scaling_max_freq;
uint32_t scaling_min_freq;
/* for specific governor */
union {
struct xen_userspace userspace;
struct xen_ondemand ondemand;
} u;
} s;
struct xen_cppc_para cppc_para;
} u;
int32_t turbo_enabled;
};
struct xen_set_cpufreq_gov {
char scaling_governor[CPUFREQ_NAME_LEN];
};
struct xen_set_cpufreq_para {
#define SCALING_MAX_FREQ 1
#define SCALING_MIN_FREQ 2
#define SCALING_SETSPEED 3
#define SAMPLING_RATE 4
#define UP_THRESHOLD 5
uint32_t ctrl_type;
uint32_t ctrl_value;
};
struct xen_sysctl_pm_op {
#define PM_PARA_CATEGORY_MASK 0xf0
#define CPUFREQ_PARA 0x10
/* cpufreq command type */
#define GET_CPUFREQ_PARA (CPUFREQ_PARA | 0x01)
#define SET_CPUFREQ_GOV (CPUFREQ_PARA | 0x02)
#define SET_CPUFREQ_PARA (CPUFREQ_PARA | 0x03)
#define GET_CPUFREQ_AVGFREQ (CPUFREQ_PARA | 0x04)
#define SET_CPUFREQ_CPPC (CPUFREQ_PARA | 0x05)
/* set/reset scheduler power saving option */
#define XEN_SYSCTL_pm_op_set_sched_opt_smt 0x21
/*
* cpuidle max C-state and max C-sub-state access command:
* Set cpuid to 0 for max C-state.
* Set cpuid to 1 for max C-sub-state.
*/
#define XEN_SYSCTL_pm_op_get_max_cstate 0x22
#define XEN_SYSCTL_pm_op_set_max_cstate 0x23
/* set scheduler migration cost value */
#define XEN_SYSCTL_pm_op_set_vcpu_migration_delay 0x24
#define XEN_SYSCTL_pm_op_get_vcpu_migration_delay 0x25
/* enable/disable turbo mode when in dbs governor */
#define XEN_SYSCTL_pm_op_enable_turbo 0x26
#define XEN_SYSCTL_pm_op_disable_turbo 0x27
uint32_t cmd;
uint32_t cpuid;
union {
struct xen_get_cpufreq_para get_para;
struct xen_set_cpufreq_gov set_gov;
struct xen_set_cpufreq_para set_para;
struct xen_set_cppc_para set_cppc;
uint64_aligned_t get_avgfreq;
uint32_t set_sched_opt_smt;
#define XEN_SYSCTL_CX_UNLIMITED 0xffffffffU
uint32_t get_max_cstate;
uint32_t set_max_cstate;
} u;
};
/* XEN_SYSCTL_page_offline_op */
struct xen_sysctl_page_offline_op {
/* IN: range of page to be offlined */
#define sysctl_page_offline 1
#define sysctl_page_online 2
#define sysctl_query_page_offline 3
uint32_t cmd;
uint32_t start;
uint32_t end;
/* OUT: result of page offline request */
/*
* bit 0~15: result flags
* bit 16~31: owner
*/
XEN_GUEST_HANDLE(uint32) status;
};
#define PG_OFFLINE_STATUS_MASK (0xFFUL)
/* The result is invalid, i.e. HV does not handle it */
#define PG_OFFLINE_INVALID (0x1UL << 0)
#define PG_OFFLINE_OFFLINED (0x1UL << 1)
#define PG_OFFLINE_PENDING (0x1UL << 2)
#define PG_OFFLINE_FAILED (0x1UL << 3)
#define PG_OFFLINE_AGAIN (0x1UL << 4)
#define PG_ONLINE_FAILED PG_OFFLINE_FAILED
#define PG_ONLINE_ONLINED PG_OFFLINE_OFFLINED
#define PG_OFFLINE_STATUS_OFFLINED (0x1UL << 1)
#define PG_OFFLINE_STATUS_ONLINE (0x1UL << 2)
#define PG_OFFLINE_STATUS_OFFLINE_PENDING (0x1UL << 3)
#define PG_OFFLINE_STATUS_BROKEN (0x1UL << 4)
#define PG_OFFLINE_MISC_MASK (0xFFUL << 4)
/* valid when PG_OFFLINE_FAILED or PG_OFFLINE_PENDING */
#define PG_OFFLINE_XENPAGE (0x1UL << 8)
#define PG_OFFLINE_DOM0PAGE (0x1UL << 9)
#define PG_OFFLINE_ANONYMOUS (0x1UL << 10)
#define PG_OFFLINE_NOT_CONV_RAM (0x1UL << 11)
#define PG_OFFLINE_OWNED (0x1UL << 12)
#define PG_OFFLINE_BROKEN (0x1UL << 13)
#define PG_ONLINE_BROKEN PG_OFFLINE_BROKEN
#define PG_OFFLINE_OWNER_SHIFT 16
/* XEN_SYSCTL_lockprof_op */
/* Sub-operations: */
#define XEN_SYSCTL_LOCKPROF_reset 1 /* Reset all profile data to zero. */
#define XEN_SYSCTL_LOCKPROF_query 2 /* Get lock profile information. */
/* Record-type: */
#define LOCKPROF_TYPE_GLOBAL 0 /* global lock, idx meaningless */
#define LOCKPROF_TYPE_PERDOM 1 /* per-domain lock, idx is domid */
#define LOCKPROF_TYPE_N 2 /* number of types */
struct xen_sysctl_lockprof_data {
char name[40]; /* lock name (may include up to 2 %d specifiers) */
int32_t type; /* LOCKPROF_TYPE_??? */
int32_t idx; /* index (e.g. domain id) */
uint64_aligned_t lock_cnt; /* # of locking succeeded */
uint64_aligned_t block_cnt; /* # of wait for lock */
uint64_aligned_t lock_time; /* nsecs lock held */
uint64_aligned_t block_time; /* nsecs waited for lock */
};
typedef struct xen_sysctl_lockprof_data xen_sysctl_lockprof_data_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_lockprof_data_t);
struct xen_sysctl_lockprof_op {
/* IN variables. */
uint32_t cmd; /* XEN_SYSCTL_LOCKPROF_??? */
uint32_t max_elem; /* size of output buffer */
/* OUT variables (query only). */
uint32_t nr_elem; /* number of elements available */
uint64_aligned_t time; /* nsecs of profile measurement */
/* profile information (or NULL) */
XEN_GUEST_HANDLE_64(xen_sysctl_lockprof_data_t) data;
};
/* XEN_SYSCTL_cputopoinfo */
#define XEN_INVALID_CORE_ID (~0U)
#define XEN_INVALID_SOCKET_ID (~0U)
#define XEN_INVALID_NODE_ID (~0U)
struct xen_sysctl_cputopo {
uint32_t core;
uint32_t socket;
uint32_t node;
};
typedef struct xen_sysctl_cputopo xen_sysctl_cputopo_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cputopo_t);
/*
* IN:
* - a NULL 'cputopo' handle is a request for maximun 'num_cpus'.
* - otherwise it's the number of entries in 'cputopo'
*
* OUT:
* - If 'num_cpus' is less than the number Xen wants to write but the handle
* handle is not a NULL one, partial data gets returned and 'num_cpus' gets
* updated to reflect the intended number.
* - Otherwise, 'num_cpus' shall indicate the number of entries written, which
* may be less than the input value.
*/
struct xen_sysctl_cputopoinfo {
uint32_t num_cpus;
XEN_GUEST_HANDLE_64(xen_sysctl_cputopo_t) cputopo;
};
/* XEN_SYSCTL_numainfo */
#define XEN_INVALID_MEM_SZ (~0U)
#define XEN_INVALID_NODE_DIST (~0U)
struct xen_sysctl_meminfo {
uint64_t memsize;
uint64_t memfree;
};
typedef struct xen_sysctl_meminfo xen_sysctl_meminfo_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_meminfo_t);
/*
* IN:
* - Both 'meminfo' and 'distance' handles being null is a request
* for maximum value of 'num_nodes'.
* - Otherwise it's the number of entries in 'meminfo' and square root
* of number of entries in 'distance' (when corresponding handle is
* non-null)
*
* OUT:
* - If 'num_nodes' is less than the number Xen wants to write but either
* handle is not a NULL one, partial data gets returned and 'num_nodes'
* gets updated to reflect the intended number.
* - Otherwise, 'num_nodes' shall indicate the number of entries written, which
* may be less than the input value.
*/
struct xen_sysctl_numainfo {
uint32_t num_nodes;
XEN_GUEST_HANDLE_64(xen_sysctl_meminfo_t) meminfo;
/*
* Distance between nodes 'i' and 'j' is stored in index 'i*N + j',
* where N is the number of nodes that will be returned in 'num_nodes'
* (i.e. not 'num_nodes' provided by the caller)
*/
XEN_GUEST_HANDLE_64(uint32) distance;
};
/* XEN_SYSCTL_cpupool_op */
#define XEN_SYSCTL_CPUPOOL_OP_CREATE 1 /* C */
#define XEN_SYSCTL_CPUPOOL_OP_DESTROY 2 /* D */
#define XEN_SYSCTL_CPUPOOL_OP_INFO 3 /* I */
#define XEN_SYSCTL_CPUPOOL_OP_ADDCPU 4 /* A */
#define XEN_SYSCTL_CPUPOOL_OP_RMCPU 5 /* R */
#define XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN 6 /* M */
#define XEN_SYSCTL_CPUPOOL_OP_FREEINFO 7 /* F */
#define XEN_SYSCTL_CPUPOOL_PAR_ANY 0xFFFFFFFFU
struct xen_sysctl_cpupool_op {
uint32_t op; /* IN */
uint32_t cpupool_id; /* IN: CDIARM OUT: CI */
uint32_t sched_id; /* IN: C OUT: I */
uint32_t domid; /* IN: M */
uint32_t cpu; /* IN: AR */
uint32_t n_dom; /* OUT: I */
struct xenctl_bitmap cpumap; /* OUT: IF */
};
/*
* Error return values of cpupool operations:
*
* -EADDRINUSE:
* XEN_SYSCTL_CPUPOOL_OP_RMCPU: A vcpu is temporarily pinned to the cpu
* which is to be removed from a cpupool.
* -EADDRNOTAVAIL:
* XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: A previous
* request to remove a cpu from a cpupool was terminated with -EAGAIN
* and has not been retried using the same parameters.
* -EAGAIN:
* XEN_SYSCTL_CPUPOOL_OP_RMCPU: The cpu can't be removed from the cpupool
* as it is active in the hypervisor. A retry will succeed soon.
* -EBUSY:
* XEN_SYSCTL_CPUPOOL_OP_DESTROY, XEN_SYSCTL_CPUPOOL_OP_RMCPU: A cpupool
* can't be destroyed or the last cpu can't be removed as there is still
* a running domain in that cpupool.
* -EEXIST:
* XEN_SYSCTL_CPUPOOL_OP_CREATE: A cpupool_id was specified and is already
* existing.
* -EINVAL:
* XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: An illegal
* cpu was specified (cpu does not exist).
* XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN: An illegal domain was specified
* (domain id illegal or not suitable for operation).
* -ENODEV:
* XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: The specified
* cpu is either not free (add) or not member of the specified cpupool
* (remove).
* -ENOENT:
* all: The cpupool with the specified cpupool_id doesn't exist.
*
* Some common error return values like -ENOMEM and -EFAULT are possible for
* all the operations.
*/
#define ARINC653_MAX_DOMAINS_PER_SCHEDULE 64
/*
* This structure is used to pass a new ARINC653 schedule from a
* privileged domain (ie dom0) to Xen.
*/
struct xen_sysctl_arinc653_schedule {
/* major_frame holds the time for the new schedule's major frame
* in nanoseconds. */
uint64_aligned_t major_frame;
/* num_sched_entries holds how many of the entries in the
* sched_entries[] array are valid. */
uint8_t num_sched_entries;
/* The sched_entries array holds the actual schedule entries. */
struct {
/* dom_handle must match a domain's UUID */
xen_domain_handle_t dom_handle;
/* If a domain has multiple VCPUs, vcpu_id specifies which one
* this schedule entry applies to. It should be set to 0 if
* there is only one VCPU for the domain. */
uint32_t vcpu_id;
/* runtime specifies the amount of time that should be allocated
* to this VCPU per major frame. It is specified in nanoseconds */
uint64_aligned_t runtime;
} sched_entries[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
};
typedef struct xen_sysctl_arinc653_schedule xen_sysctl_arinc653_schedule_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_arinc653_schedule_t);
/*
* Valid range for context switch rate limit (in microseconds).
* Applicable to Credit and Credit2 schedulers.
*/
#define XEN_SYSCTL_SCHED_RATELIMIT_MAX 500000
#define XEN_SYSCTL_SCHED_RATELIMIT_MIN 100
struct xen_sysctl_credit_schedule {
/* Length of timeslice in milliseconds */
#define XEN_SYSCTL_CSCHED_TSLICE_MAX 1000
#define XEN_SYSCTL_CSCHED_TSLICE_MIN 1
uint32_t tslice_ms;
uint32_t ratelimit_us;
/*
* How long we consider a vCPU to be cache-hot on the
* CPU where it has run (max 100ms, in microseconds)
*/
#define XEN_SYSCTL_CSCHED_MGR_DLY_MAX_US (100 * 1000)
uint32_t vcpu_migr_delay_us;
};
struct xen_sysctl_credit2_schedule {
uint32_t ratelimit_us;
};
/* XEN_SYSCTL_scheduler_op */
/* Set or get info? */
#define XEN_SYSCTL_SCHEDOP_putinfo 0
#define XEN_SYSCTL_SCHEDOP_getinfo 1
struct xen_sysctl_scheduler_op {
uint32_t cpupool_id; /* Cpupool whose scheduler is to be targetted. */
uint32_t sched_id; /* XEN_SCHEDULER_* (domctl.h) */
uint32_t cmd; /* XEN_SYSCTL_SCHEDOP_* */
union {
struct xen_sysctl_sched_arinc653 {
XEN_GUEST_HANDLE_64(xen_sysctl_arinc653_schedule_t) schedule;
} sched_arinc653;
struct xen_sysctl_credit_schedule sched_credit;
struct xen_sysctl_credit2_schedule sched_credit2;
} u;
};
/*
* Output format of gcov data:
*
* XEN_GCOV_FORMAT_MAGIC XEN_GCOV_RECORD ... XEN_GCOV_RECORD
*
* That is, one magic number followed by 0 or more record.
*
* The magic number is stored as an uint32_t field.
*
* The record is packed and variable in length. It has the form:
*
* filename: a NULL terminated path name extracted from gcov, used to
* create the name of gcda file.
* size: a uint32_t field indicating the size of the payload, the
* unit is byte.
* payload: the actual payload, length is `size' bytes.
*
* Userspace tool will split the record to different files.
*/
#define XEN_GCOV_FORMAT_MAGIC 0x58434f56 /* XCOV */
/*
* Ouput format of LLVM coverage data is just a raw stream, as would be
* written by the compiler_rt run time library into a .profraw file. There
* are no special Xen tags or delimiters because none are needed.
*/
#define XEN_SYSCTL_COVERAGE_get_size 0 /* Get total size of output data */
#define XEN_SYSCTL_COVERAGE_read 1 /* Read output data */
#define XEN_SYSCTL_COVERAGE_reset 2 /* Reset all counters */
struct xen_sysctl_coverage_op {
uint32_t cmd;
uint32_t size; /* IN/OUT: size of the buffer */
XEN_GUEST_HANDLE_64(char) buffer; /* OUT */
};
#define XEN_SYSCTL_PSR_CMT_get_total_rmid 0
#define XEN_SYSCTL_PSR_CMT_get_l3_upscaling_factor 1
/* The L3 cache size is returned in KB unit */
#define XEN_SYSCTL_PSR_CMT_get_l3_cache_size 2
#define XEN_SYSCTL_PSR_CMT_enabled 3
#define XEN_SYSCTL_PSR_CMT_get_l3_event_mask 4
struct xen_sysctl_psr_cmt_op {
uint32_t cmd; /* IN: XEN_SYSCTL_PSR_CMT_* */
uint32_t flags; /* padding variable, may be extended for future use */
union {
uint64_t data; /* OUT */
struct {
uint32_t cpu; /* IN */
uint32_t rsvd;
} l3_cache;
} u;
};
/* XEN_SYSCTL_pcitopoinfo */
#define XEN_INVALID_DEV (XEN_INVALID_NODE_ID - 1)
struct xen_sysctl_pcitopoinfo {
/*
* IN: Number of elements in 'devs' and 'nodes' arrays.
* OUT: Number of processed elements of those arrays.
*/
uint32_t num_devs;
/* IN: list of devices for which node IDs are requested. */
XEN_GUEST_HANDLE_64(physdev_pci_device_t) devs;
/*
* OUT: node identifier for each device.
* If information for a particular device is not available then
* corresponding entry will be set to XEN_INVALID_NODE_ID. If
* device is not known to the hypervisor then XEN_INVALID_DEV
* will be provided.
*/
XEN_GUEST_HANDLE_64(uint32) nodes;
};
#define XEN_SYSCTL_PSR_get_l3_info 0
#define XEN_SYSCTL_PSR_get_l2_info 1
#define XEN_SYSCTL_PSR_get_mba_info 2
struct xen_sysctl_psr_alloc {
uint32_t cmd; /* IN: XEN_SYSCTL_PSR_* */
uint32_t target; /* IN */
union {
struct {
uint32_t cbm_len; /* OUT: CBM length */
uint32_t cos_max; /* OUT: Maximum COS */
#define XEN_SYSCTL_PSR_CAT_L3_CDP (1u << 0)
uint32_t flags; /* OUT: CAT flags */
} cat_info;
struct {
uint32_t thrtl_max; /* OUT: Maximum throttle */
uint32_t cos_max; /* OUT: Maximum COS */
#define XEN_SYSCTL_PSR_MBA_LINEAR (1u << 0)
uint32_t flags; /* OUT: MBA flags */
} mba_info;
} u;
};
/*
* XEN_SYSCTL_get_cpu_levelling_caps (x86 specific)
*
* Return hardware capabilities concerning masking or faulting of the cpuid
* instruction for PV guests.
*/
struct xen_sysctl_cpu_levelling_caps {
#define XEN_SYSCTL_CPU_LEVELCAP_faulting (1UL << 0) /* CPUID faulting */
#define XEN_SYSCTL_CPU_LEVELCAP_ecx (1UL << 1) /* 0x00000001.ecx */
#define XEN_SYSCTL_CPU_LEVELCAP_edx (1UL << 2) /* 0x00000001.edx */
#define XEN_SYSCTL_CPU_LEVELCAP_extd_ecx (1UL << 3) /* 0x80000001.ecx */
#define XEN_SYSCTL_CPU_LEVELCAP_extd_edx (1UL << 4) /* 0x80000001.edx */
#define XEN_SYSCTL_CPU_LEVELCAP_xsave_eax (1UL << 5) /* 0x0000000D:1.eax */
#define XEN_SYSCTL_CPU_LEVELCAP_thermal_ecx (1UL << 6) /* 0x00000006.ecx */
#define XEN_SYSCTL_CPU_LEVELCAP_l7s0_eax (1UL << 7) /* 0x00000007:0.eax */
#define XEN_SYSCTL_CPU_LEVELCAP_l7s0_ebx (1UL << 8) /* 0x00000007:0.ebx */
uint32_t caps;
};
/*
* XEN_SYSCTL_get_cpu_featureset (x86 specific)
*
* Return information about featuresets available on this host.
* - Raw: The real cpuid values.
* - Host: The values Xen is using, (after command line overrides, etc).
* - PV: Maximum set of features which can be given to a PV guest.
* - HVM: Maximum set of features which can be given to a HVM guest.
* May fail with -EOPNOTSUPP if querying for PV or HVM data when support is
* compiled out of Xen.
*/
struct xen_sysctl_cpu_featureset {
#define XEN_SYSCTL_cpu_featureset_raw 0
#define XEN_SYSCTL_cpu_featureset_host 1
#define XEN_SYSCTL_cpu_featureset_pv 2
#define XEN_SYSCTL_cpu_featureset_hvm 3
#define XEN_SYSCTL_cpu_featureset_pv_max 4
#define XEN_SYSCTL_cpu_featureset_hvm_max 5
uint32_t index; /* IN: Which featureset to query? */
uint32_t nr_features; /* IN/OUT: Number of entries in/written to
* 'features', or the maximum number of features if
* the guest handle is NULL. NB. All featuresets
* come from the same numberspace, so have the same
* maximum length. */
XEN_GUEST_HANDLE_64(uint32) features; /* OUT: */
};
/*
* XEN_SYSCTL_LIVEPATCH_op
*
* Refer to the docs/unstable/misc/livepatch.markdown
* for the design details of this hypercall.
*
* There are four sub-ops:
* XEN_SYSCTL_LIVEPATCH_UPLOAD (0)
* XEN_SYSCTL_LIVEPATCH_GET (1)
* XEN_SYSCTL_LIVEPATCH_LIST (2)
* XEN_SYSCTL_LIVEPATCH_ACTION (3)
*
* The normal sequence of sub-ops is to:
* 1) XEN_SYSCTL_LIVEPATCH_UPLOAD to upload the payload. If errors STOP.
* 2) XEN_SYSCTL_LIVEPATCH_GET to check the `->rc`. If -XEN_EAGAIN spin.
* If zero go to next step.
* 3) XEN_SYSCTL_LIVEPATCH_ACTION with LIVEPATCH_ACTION_APPLY to apply the patch.
* 4) XEN_SYSCTL_LIVEPATCH_GET to check the `->rc`. If in -XEN_EAGAIN spin.
* If zero exit with success.
*/
#define LIVEPATCH_PAYLOAD_VERSION 2
/*
* .livepatch.funcs structure layout defined in the `Payload format`
* section in the Live Patch design document.
*
* We guard this with __XEN__ as toolstacks SHOULD not use it.
*/
#ifdef __XEN__
#define LIVEPATCH_OPAQUE_SIZE 31
struct livepatch_expectation {
uint8_t enabled : 1;
uint8_t len : 5; /* Length of data up to LIVEPATCH_OPAQUE_SIZE
(5 bits is enough for now) */
uint8_t rsv : 2; /* Reserved. Zero value */
uint8_t data[LIVEPATCH_OPAQUE_SIZE]; /* Same size as opaque[] buffer of
struct livepatch_func. This is the
max number of bytes to be patched */
};
typedef struct livepatch_expectation livepatch_expectation_t;
typedef enum livepatch_func_state {
LIVEPATCH_FUNC_NOT_APPLIED,
LIVEPATCH_FUNC_APPLIED
} livepatch_func_state_t;
struct livepatch_func {
const char *name; /* Name of function to be patched. */
void *new_addr;
void *old_addr;
uint32_t new_size;
uint32_t old_size;
uint8_t version; /* MUST be LIVEPATCH_PAYLOAD_VERSION. */
uint8_t _pad[39];
livepatch_expectation_t expect;
};
typedef struct livepatch_func livepatch_func_t;
#endif
/*
* Structure describing an ELF payload. Uniquely identifies the
* payload. Should be human readable.
* Recommended length is upto XEN_LIVEPATCH_NAME_SIZE.
* Includes the NUL terminator.
*/
#define XEN_LIVEPATCH_NAME_SIZE 128
struct xen_livepatch_name {
XEN_GUEST_HANDLE_64(char) name; /* IN: pointer to name. */
uint16_t size; /* IN: size of name. May be upto
XEN_LIVEPATCH_NAME_SIZE. */
uint16_t pad[3]; /* IN: MUST be zero. */
};
/*
* Upload a payload to the hypervisor. The payload is verified
* against basic checks and if there are any issues the proper return code
* will be returned. The payload is not applied at this time - that is
* controlled by XEN_SYSCTL_LIVEPATCH_ACTION.
*
* The return value is zero if the payload was succesfully uploaded.
* Otherwise an EXX return value is provided. Duplicate `name` are not
* supported.
*
* The payload at this point is verified against basic checks.
*
* The `payload` is the ELF payload as mentioned in the `Payload format`
* section in the Live Patch design document.
*/
#define XEN_SYSCTL_LIVEPATCH_UPLOAD 0
struct xen_sysctl_livepatch_upload {
struct xen_livepatch_name name; /* IN, name of the patch. */
uint64_t size; /* IN, size of the ELF file. */
XEN_GUEST_HANDLE_64(uint8) payload; /* IN, the ELF file. */
};
/*
* Retrieve an status of an specific payload.
*
* Upon completion the `struct xen_livepatch_status` is updated.
*
* The return value is zero on success and XEN_EXX on failure. This operation
* is synchronous and does not require preemption.
*/
#define XEN_SYSCTL_LIVEPATCH_GET 1
struct xen_livepatch_status {
#define LIVEPATCH_STATE_CHECKED 1
#define LIVEPATCH_STATE_APPLIED 2
uint32_t state; /* OUT: LIVEPATCH_STATE_*. */
int32_t rc; /* OUT: 0 if no error, otherwise -XEN_EXX. */
};
typedef struct xen_livepatch_status xen_livepatch_status_t;
DEFINE_XEN_GUEST_HANDLE(xen_livepatch_status_t);
struct xen_sysctl_livepatch_get {
struct xen_livepatch_name name; /* IN, name of the payload. */
struct xen_livepatch_status status; /* IN/OUT, state of it. */
};
/*
* Retrieve an array of abbreviated status, names and metadata of payloads that
* are loaded in the hypervisor.
*
* If the hypercall returns an positive number, it is the number (up to `nr`)
* of the payloads returned, along with `nr` updated with the number of remaining
* payloads, `version` updated (it may be the same across hypercalls. If it varies
* the data is stale and further calls could fail), `name_total_size` and
* `metadata_total_size` containing total sizes of transferred data for both the
* arrays.
* The `status`, `name`, `len`, `metadata` and `metadata_len` are updated at their
* designed index value (`idx`) with the returned value of data.
*
* If the hypercall returns E2BIG the `nr` is too big and should be
* lowered. The upper limit of `nr` is left to the implemention.
*
* Note that due to the asynchronous nature of hypercalls the domain might have
* added or removed the number of payloads making this information stale. It is
* the responsibility of the toolstack to use the `version` field to check
* between each invocation. if the version differs it should discard the stale
* data and start from scratch. It is OK for the toolstack to use the new
* `version` field.
*/
#define XEN_SYSCTL_LIVEPATCH_LIST 2
struct xen_sysctl_livepatch_list {
uint32_t version; /* OUT: Hypervisor stamps value.
If varies between calls, we are
* getting stale data. */
uint32_t idx; /* IN: Index into hypervisor list. */
uint32_t nr; /* IN: How many status, name, and len
should fill out. Can be zero to get
amount of payloads and version.
OUT: How many payloads left. */
uint32_t pad; /* IN: Must be zero. */
uint32_t name_total_size; /* OUT: Total size of all transfer names */
uint32_t metadata_total_size; /* OUT: Total size of all transfer metadata */
XEN_GUEST_HANDLE_64(xen_livepatch_status_t) status; /* OUT. Must have enough
space allocate for nr of them. */
XEN_GUEST_HANDLE_64(char) name; /* OUT: Array of names. Each member
may have an arbitrary length up to
XEN_LIVEPATCH_NAME_SIZE bytes. Must have
nr of them. */
XEN_GUEST_HANDLE_64(uint32) len; /* OUT: Array of lengths of name's.
Must have nr of them. */
XEN_GUEST_HANDLE_64(char) metadata; /* OUT: Array of metadata strings. Each
member may have an arbitrary length.
Must have nr of them. */
XEN_GUEST_HANDLE_64(uint32) metadata_len; /* OUT: Array of lengths of metadata's.
Must have nr of them. */
};
/*
* Perform an operation on the payload structure referenced by the `name` field.
* The operation request is asynchronous and the status should be retrieved
* by using either XEN_SYSCTL_LIVEPATCH_GET or XEN_SYSCTL_LIVEPATCH_LIST hypercall.
*/
#define XEN_SYSCTL_LIVEPATCH_ACTION 3
struct xen_sysctl_livepatch_action {
struct xen_livepatch_name name; /* IN, name of the patch. */
#define LIVEPATCH_ACTION_UNLOAD 1
#define LIVEPATCH_ACTION_REVERT 2
#define LIVEPATCH_ACTION_APPLY 3
#define LIVEPATCH_ACTION_REPLACE 4
uint32_t cmd; /* IN: LIVEPATCH_ACTION_*. */
uint32_t timeout; /* IN: If zero then uses */
/* hypervisor default. */
/* Or upper bound of time (ns) */
/* for operation to take. */
/*
* Override default inter-module buildid dependency chain enforcement.
* Check only if module is built for given hypervisor by comparing buildid.
*/
#define LIVEPATCH_ACTION_APPLY_NODEPS (1 << 0)
uint32_t flags; /* IN: action flags. */
/* Provide additional parameters */
/* for an action. */
uint32_t pad; /* IN: Always zero. */
};
struct xen_sysctl_livepatch_op {
uint32_t cmd; /* IN: XEN_SYSCTL_LIVEPATCH_*. */
uint32_t flags; /* IN, flags. */
#define LIVEPATCH_FLAG_FORCE (1u << 0) /* Skip some checks. */
#define LIVEPATCH_FLAGS_MASK LIVEPATCH_FLAG_FORCE
union {
struct xen_sysctl_livepatch_upload upload;
struct xen_sysctl_livepatch_list list;
struct xen_sysctl_livepatch_get get;
struct xen_sysctl_livepatch_action action;
} u;
};
#if defined(__i386__) || defined(__x86_64__)
/*
* XEN_SYSCTL_get_cpu_policy (x86 specific)
*
* Return information about CPUID and MSR policies available on this host.
* - Raw: The real H/W values.
* - Host: The values Xen is using, (after command line overrides, etc).
* - Max_*: Maximum set of features a PV or HVM guest can use. Includes
* experimental features outside of security support.
* - Default_*: Default set of features a PV or HVM guest can use. This is
* the security supported set.
* May fail with -EOPNOTSUPP if querying for PV or HVM data when support is
* compiled out of Xen.
*/
struct xen_sysctl_cpu_policy {
#define XEN_SYSCTL_cpu_policy_raw 0
#define XEN_SYSCTL_cpu_policy_host 1
#define XEN_SYSCTL_cpu_policy_pv_max 2
#define XEN_SYSCTL_cpu_policy_hvm_max 3
#define XEN_SYSCTL_cpu_policy_pv_default 4
#define XEN_SYSCTL_cpu_policy_hvm_default 5
uint32_t index; /* IN: Which policy to query? */
uint32_t nr_leaves; /* IN/OUT: Number of leaves in/written to 'leaves',
* or the max number if 'leaves' is NULL. */
uint32_t nr_msrs; /* IN/OUT: Number of MSRs in/written to 'msrs', or
* the max number of if 'msrs' is NULL. */
uint32_t _rsvd; /* Must be zero. */
XEN_GUEST_HANDLE_64(xen_cpuid_leaf_t) leaves; /* OUT */
XEN_GUEST_HANDLE_64(xen_msr_entry_t) msrs; /* OUT */
};
typedef struct xen_sysctl_cpu_policy xen_sysctl_cpu_policy_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpu_policy_t);
#endif
#if defined(__arm__) || defined(__aarch64__)
/*
* XEN_SYSCTL_dt_overlay
* Performs addition/removal of device tree nodes under parent node using dtbo
* from dt_host.
*/
struct xen_sysctl_dt_overlay {
XEN_GUEST_HANDLE_64(const_void) overlay_fdt; /* IN: overlay fdt. */
uint32_t overlay_fdt_size; /* IN: Overlay dtb size. */
#define XEN_SYSCTL_DT_OVERLAY_ADD 1
#define XEN_SYSCTL_DT_OVERLAY_REMOVE 2
uint8_t overlay_op; /* IN: Add or remove. */
uint8_t pad[3]; /* IN: Must be zero. */
};
#endif
struct xen_sysctl {
uint32_t cmd;
#define XEN_SYSCTL_readconsole 1
#define XEN_SYSCTL_tbuf_op 2
#define XEN_SYSCTL_physinfo 3
#define XEN_SYSCTL_sched_id 4
#define XEN_SYSCTL_perfc_op 5
#define XEN_SYSCTL_getdomaininfolist 6
#define XEN_SYSCTL_debug_keys 7
#define XEN_SYSCTL_getcpuinfo 8
#define XEN_SYSCTL_availheap 9
#define XEN_SYSCTL_get_pmstat 10
#define XEN_SYSCTL_cpu_hotplug 11
#define XEN_SYSCTL_pm_op 12
#define XEN_SYSCTL_page_offline_op 14
#define XEN_SYSCTL_lockprof_op 15
#define XEN_SYSCTL_cputopoinfo 16
#define XEN_SYSCTL_numainfo 17
#define XEN_SYSCTL_cpupool_op 18
#define XEN_SYSCTL_scheduler_op 19
#define XEN_SYSCTL_coverage_op 20
#define XEN_SYSCTL_psr_cmt_op 21
#define XEN_SYSCTL_pcitopoinfo 22
#define XEN_SYSCTL_psr_alloc 23
/* #define XEN_SYSCTL_tmem_op 24 */
#define XEN_SYSCTL_get_cpu_levelling_caps 25
#define XEN_SYSCTL_get_cpu_featureset 26
#define XEN_SYSCTL_livepatch_op 27
/* #define XEN_SYSCTL_set_parameter 28 */
#define XEN_SYSCTL_get_cpu_policy 29
#define XEN_SYSCTL_dt_overlay 30
uint32_t interface_version; /* XEN_SYSCTL_INTERFACE_VERSION */
union {
struct xen_sysctl_readconsole readconsole;
struct xen_sysctl_tbuf_op tbuf_op;
struct xen_sysctl_physinfo physinfo;
struct xen_sysctl_cputopoinfo cputopoinfo;
struct xen_sysctl_pcitopoinfo pcitopoinfo;
struct xen_sysctl_numainfo numainfo;
struct xen_sysctl_sched_id sched_id;
struct xen_sysctl_perfc_op perfc_op;
struct xen_sysctl_getdomaininfolist getdomaininfolist;
struct xen_sysctl_debug_keys debug_keys;
struct xen_sysctl_getcpuinfo getcpuinfo;
struct xen_sysctl_availheap availheap;
struct xen_sysctl_get_pmstat get_pmstat;
struct xen_sysctl_cpu_hotplug cpu_hotplug;
struct xen_sysctl_pm_op pm_op;
struct xen_sysctl_page_offline_op page_offline;
struct xen_sysctl_lockprof_op lockprof_op;
struct xen_sysctl_cpupool_op cpupool_op;
struct xen_sysctl_scheduler_op scheduler_op;
struct xen_sysctl_coverage_op coverage_op;
struct xen_sysctl_psr_cmt_op psr_cmt_op;
struct xen_sysctl_psr_alloc psr_alloc;
struct xen_sysctl_cpu_levelling_caps cpu_levelling_caps;
struct xen_sysctl_cpu_featureset cpu_featureset;
struct xen_sysctl_livepatch_op livepatch;
#if defined(__i386__) || defined(__x86_64__)
struct xen_sysctl_cpu_policy cpu_policy;
#endif
#if defined(__arm__) || defined(__aarch64__)
struct xen_sysctl_dt_overlay dt_overlay;
#endif
uint8_t pad[128];
} u;
};
typedef struct xen_sysctl xen_sysctl_t;
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_t);
#endif /* __XEN_PUBLIC_SYSCTL_H__ */
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/