mirror of
https://github.com/freebsd/freebsd-src
synced 2024-07-21 10:19:04 +00:00
3a9fd8242b
The current path of the Xen headers at /sys/xen/interface/ is not correct, as those headers are imported verbatim from the Xen sources and shouldn't be modified, as any modifications would be lost when a new version is imported. Changes to the public headers must be first done in Xen upstream so that they can be backported and new imports will already carry them. Import Xen 4.16 headers in sys/contrib/xen/. It's unlikely that we will import different Xen code, so don't place them inside of any subdirectory. If in the future other pieces of Xen code need to be imported the headers will need to move into an include/ subdirectory. Note that this commit does not yet modify the include path to use the newly imported headers. Sponsored by: Citrix Systems R&D
1149 lines
43 KiB
C
1149 lines
43 KiB
C
/******************************************************************************
|
|
* sysctl.h
|
|
*
|
|
* System management operations. For use by node control stack.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* 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"
|
|
|
|
#define XEN_SYSCTL_INTERFACE_VERSION 0x00000014
|
|
|
|
/*
|
|
* 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
|
|
|
|
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_??? */
|
|
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;
|
|
};
|
|
|
|
/*
|
|
* 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;
|
|
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;
|
|
|
|
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)
|
|
|
|
/* 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;
|
|
uint64_aligned_t get_avgfreq;
|
|
uint32_t set_sched_opt_smt;
|
|
#define XEN_SYSCTL_CX_UNLIMITED 0xffffffff
|
|
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 0xFFFFFFFF
|
|
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. */
|
|
unsigned int 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
|
|
unsigned tslice_ms;
|
|
unsigned 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)
|
|
unsigned vcpu_migr_delay_us;
|
|
};
|
|
|
|
struct xen_sysctl_credit2_schedule {
|
|
unsigned 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
|
|
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 opaque[LIVEPATCH_OPAQUE_SIZE];
|
|
uint8_t applied;
|
|
uint8_t _pad[7];
|
|
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 pad; /* IN: Always zero. */
|
|
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
|
|
* 'cpuid_policy', or the maximum number of leaves
|
|
* if the guest handle is NULL. */
|
|
uint32_t nr_msrs; /* IN/OUT: Number of MSRs in/written to
|
|
* 'msr_policy', or the maximum number of MSRs if
|
|
* the guest handle is NULL. */
|
|
uint32_t _rsvd; /* Must be zero. */
|
|
XEN_GUEST_HANDLE_64(xen_cpuid_leaf_t) cpuid_policy; /* OUT */
|
|
XEN_GUEST_HANDLE_64(xen_msr_entry_t) msr_policy; /* OUT */
|
|
};
|
|
typedef struct xen_sysctl_cpu_policy xen_sysctl_cpu_policy_t;
|
|
DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpu_policy_t);
|
|
#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
|
|
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
|
|
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:
|
|
*/
|