[linux-2.6-block.git] / include / xen / xen-ops.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef INCLUDE_XEN_OPS_H
#define INCLUDE_XEN_OPS_H

#include <linux/percpu.h>
#include <linux/notifier.h>
#include <linux/efi.h>
#include <asm/xen/interface.h>
#include <xen/interface/vcpu.h>

DECLARE_PER_CPU(struct vcpu_info *, xen_vcpu);

DECLARE_PER_CPU(uint32_t, xen_vcpu_id);
static inline uint32_t xen_vcpu_nr(int cpu)
{
	return per_cpu(xen_vcpu_id, cpu);
}

#define XEN_VCPU_ID_INVALID U32_MAX

void xen_arch_pre_suspend(void);
void xen_arch_post_suspend(int suspend_cancelled);

void xen_timer_resume(void);
void xen_arch_resume(void);
void xen_arch_suspend(void);

void xen_reboot(int reason);

void xen_resume_notifier_register(struct notifier_block *nb);
void xen_resume_notifier_unregister(struct notifier_block *nb);

bool xen_vcpu_stolen(int vcpu);
void xen_setup_runstate_info(int cpu);
void xen_time_setup_guest(void);
void xen_manage_runstate_time(int action);
void xen_get_runstate_snapshot(struct vcpu_runstate_info *res);
u64 xen_steal_clock(int cpu);

int xen_setup_shutdown_event(void);

extern unsigned long *xen_contiguous_bitmap;

#ifdef CONFIG_XEN_PV
int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order,
				unsigned int address_bits,
				dma_addr_t *dma_handle);

void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order);
#else
static inline int xen_create_contiguous_region(phys_addr_t pstart,
					       unsigned int order,
					       unsigned int address_bits,
					       dma_addr_t *dma_handle)
{
	return 0;
}

static inline void xen_destroy_contiguous_region(phys_addr_t pstart,
						 unsigned int order) { }
#endif

struct vm_area_struct;

/*
 * xen_remap_domain_gfn_array() - map an array of foreign frames by gfn
 * @vma:     VMA to map the pages into
 * @addr:    Address at which to map the pages
 * @gfn:     Array of GFNs to map
 * @nr:      Number entries in the GFN array
 * @err_ptr: Returns per-GFN error status.
 * @prot:    page protection mask
 * @domid:   Domain owning the pages
 * @pages:   Array of pages if this domain has an auto-translated physmap
 *
 * @gfn and @err_ptr may point to the same buffer, the GFNs will be
 * overwritten by the error codes after they are mapped.
 *
 * Returns the number of successfully mapped frames, or a -ve error
 * code.
 */
int xen_remap_domain_gfn_array(struct vm_area_struct *vma,
			       unsigned long addr,
			       xen_pfn_t *gfn, int nr,
			       int *err_ptr, pgprot_t prot,
			       unsigned domid,
			       struct page **pages);

/*
 * xen_remap_domain_mfn_array() - map an array of foreign frames by mfn
 * @vma:     VMA to map the pages into
 * @addr:    Address at which to map the pages
 * @mfn:     Array of MFNs to map
 * @nr:      Number entries in the MFN array
 * @err_ptr: Returns per-MFN error status.
 * @prot:    page protection mask
 * @domid:   Domain owning the pages
 * @pages:   Array of pages if this domain has an auto-translated physmap
 *
 * @mfn and @err_ptr may point to the same buffer, the MFNs will be
 * overwritten by the error codes after they are mapped.
 *
 * Returns the number of successfully mapped frames, or a -ve error
 * code.
 */
int xen_remap_domain_mfn_array(struct vm_area_struct *vma,
			       unsigned long addr, xen_pfn_t *mfn, int nr,
			       int *err_ptr, pgprot_t prot,
			       unsigned int domid, struct page **pages);

/* xen_remap_domain_gfn_range() - map a range of foreign frames
 * @vma:     VMA to map the pages into
 * @addr:    Address at which to map the pages
 * @gfn:     First GFN to map.
 * @nr:      Number frames to map
 * @prot:    page protection mask
 * @domid:   Domain owning the pages
 * @pages:   Array of pages if this domain has an auto-translated physmap
 *
 * Returns the number of successfully mapped frames, or a -ve error
 * code.
 */
int xen_remap_domain_gfn_range(struct vm_area_struct *vma,
			       unsigned long addr,
			       xen_pfn_t gfn, int nr,
			       pgprot_t prot, unsigned domid,
			       struct page **pages);
int xen_unmap_domain_gfn_range(struct vm_area_struct *vma,
			       int numpgs, struct page **pages);

#ifdef CONFIG_XEN_AUTO_XLATE
int xen_xlate_remap_gfn_array(struct vm_area_struct *vma,
			      unsigned long addr,
			      xen_pfn_t *gfn, int nr,
			      int *err_ptr, pgprot_t prot,
			      unsigned domid,
			      struct page **pages);
int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma,
			      int nr, struct page **pages);
#else
/*
 * These two functions are called from arch/x86/xen/mmu.c and so stubs
 * are needed for a configuration not specifying CONFIG_XEN_AUTO_XLATE.
 */
static inline int xen_xlate_remap_gfn_array(struct vm_area_struct *vma,
					    unsigned long addr,
					    xen_pfn_t *gfn, int nr,
					    int *err_ptr, pgprot_t prot,
					    unsigned int domid,
					    struct page **pages)
{
	return -EOPNOTSUPP;
}

static inline int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma,
					    int nr, struct page **pages)
{
	return -EOPNOTSUPP;
}
#endif

int xen_xlate_map_ballooned_pages(xen_pfn_t **pfns, void **vaddr,
				  unsigned long nr_grant_frames);

bool xen_running_on_version_or_later(unsigned int major, unsigned int minor);

efi_status_t xen_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc);
efi_status_t xen_efi_set_time(efi_time_t *tm);
efi_status_t xen_efi_get_wakeup_time(efi_bool_t *enabled, efi_bool_t *pending,
				     efi_time_t *tm);
efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm);
efi_status_t xen_efi_get_variable(efi_char16_t *name, efi_guid_t *vendor,
				  u32 *attr, unsigned long *data_size,
				  void *data);
efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
				       efi_char16_t *name, efi_guid_t *vendor);
efi_status_t xen_efi_set_variable(efi_char16_t *name, efi_guid_t *vendor,
				  u32 attr, unsigned long data_size,
				  void *data);
efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
					 u64 *remaining_space,
					 u64 *max_variable_size);
efi_status_t xen_efi_get_next_high_mono_count(u32 *count);
efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
				    unsigned long count, unsigned long sg_list);
efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
					unsigned long count, u64 *max_size,
					int *reset_type);
void xen_efi_reset_system(int reset_type, efi_status_t status,
			  unsigned long data_size, efi_char16_t *data);


#ifdef CONFIG_PREEMPT

static inline void xen_preemptible_hcall_begin(void)
{
}

static inline void xen_preemptible_hcall_end(void)
{
}

#else

DECLARE_PER_CPU(bool, xen_in_preemptible_hcall);

static inline void xen_preemptible_hcall_begin(void)
{
	__this_cpu_write(xen_in_preemptible_hcall, true);
}

static inline void xen_preemptible_hcall_end(void)
{
	__this_cpu_write(xen_in_preemptible_hcall, false);
}

#endif /* CONFIG_PREEMPT */

#endif /* INCLUDE_XEN_OPS_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
e04d0d07 IY	2	#ifndef INCLUDE_XEN_OPS_H
	3	#define INCLUDE_XEN_OPS_H
	4
	5	#include <linux/percpu.h>
cd979883	6	#include <linux/notifier.h>
be81c8a1	7	#include <linux/efi.h>
7892f692	8	#include <asm/xen/interface.h>
4ccefbe5	9	#include <xen/interface/vcpu.h>
e04d0d07 IY	10
	11	DECLARE_PER_CPU(struct vcpu_info *, xen_vcpu);
	12
55467dea VK	13	DECLARE_PER_CPU(uint32_t, xen_vcpu_id);
55467dea VK	14	static inline uint32_t xen_vcpu_nr(int cpu)
88e957d6 VK	15	{
	16	return per_cpu(xen_vcpu_id, cpu);
	17	}
	18
0b64ffb8 AA	19	#define XEN_VCPU_ID_INVALID U32_MAX
0b64ffb8 AA	20
03c8142b IC	21	void xen_arch_pre_suspend(void);
03c8142b IC	22	void xen_arch_post_suspend(int suspend_cancelled);
0e91398f	23
ad55db9f IY	24	void xen_timer_resume(void);
ad55db9f IY	25	void xen_arch_resume(void);
2b953a5e	26	void xen_arch_suspend(void);
ad55db9f	27
5d9404e1 JG	28	void xen_reboot(int reason);
5d9404e1 JG	29
cd979883 SG	30	void xen_resume_notifier_register(struct notifier_block *nb);
	31	void xen_resume_notifier_unregister(struct notifier_block *nb);
	32
4ccefbe5 SS	33	bool xen_vcpu_stolen(int vcpu);
4ccefbe5 SS	34	void xen_setup_runstate_info(int cpu);
ecb23dc6	35	void xen_time_setup_guest(void);
5e25f5db	36	void xen_manage_runstate_time(int action);
4ccefbe5	37	void xen_get_runstate_snapshot(struct vcpu_runstate_info *res);
d34c30cc	38	u64 xen_steal_clock(int cpu);
4ccefbe5	39
016b6f5f SS	40	int xen_setup_shutdown_event(void);
016b6f5f SS	41
08bbc9da	42	extern unsigned long *xen_contiguous_bitmap;
16624390 VK	43
16624390 VK	44	#ifdef CONFIG_XEN_PV
1b65c4e5	45	int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order,
69908907 SS	46	unsigned int address_bits,
69908907 SS	47	dma_addr_t *dma_handle);
08bbc9da	48
1b65c4e5	49	void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order);
16624390 VK	50	#else
	51	static inline int xen_create_contiguous_region(phys_addr_t pstart,
	52	unsigned int order,
	53	unsigned int address_bits,
	54	dma_addr_t *dma_handle)
	55	{
	56	return 0;
	57	}
	58
	59	static inline void xen_destroy_contiguous_region(phys_addr_t pstart,
	60	unsigned int order) { }
	61	#endif
08bbc9da	62
c140d879	63	struct vm_area_struct;
4e8c0c8c DV	64
4e8c0c8c DV	65	/*
3ad08765	66	* xen_remap_domain_gfn_array() - map an array of foreign frames by gfn
4e8c0c8c DV	67	* @vma: VMA to map the pages into
	68	* @addr: Address at which to map the pages
	69	* @gfn: Array of GFNs to map
	70	* @nr: Number entries in the GFN array
	71	* @err_ptr: Returns per-GFN error status.
	72	* @prot: page protection mask
	73	* @domid: Domain owning the pages
	74	* @pages: Array of pages if this domain has an auto-translated physmap
	75	*
	76	* @gfn and @err_ptr may point to the same buffer, the GFNs will be
	77	* overwritten by the error codes after they are mapped.
	78	*
	79	* Returns the number of successfully mapped frames, or a -ve error
	80	* code.
	81	*/
a13d7201	82	int xen_remap_domain_gfn_array(struct vm_area_struct *vma,
4e8c0c8c DV	83	unsigned long addr,
	84	xen_pfn_t *gfn, int nr,
	85	int *err_ptr, pgprot_t prot,
	86	unsigned domid,
	87	struct page **pages);
	88
3ad08765 PD	89	/*
	90	* xen_remap_domain_mfn_array() - map an array of foreign frames by mfn
	91	* @vma: VMA to map the pages into
	92	* @addr: Address at which to map the pages
	93	* @mfn: Array of MFNs to map
	94	* @nr: Number entries in the MFN array
	95	* @err_ptr: Returns per-MFN error status.
	96	* @prot: page protection mask
	97	* @domid: Domain owning the pages
	98	* @pages: Array of pages if this domain has an auto-translated physmap
	99	*
	100	* @mfn and @err_ptr may point to the same buffer, the MFNs will be
	101	* overwritten by the error codes after they are mapped.
	102	*
	103	* Returns the number of successfully mapped frames, or a -ve error
	104	* code.
	105	*/
	106	int xen_remap_domain_mfn_array(struct vm_area_struct *vma,
	107	unsigned long addr, xen_pfn_t *mfn, int nr,
	108	int *err_ptr, pgprot_t prot,
	109	unsigned int domid, struct page **pages);
	110
a13d7201	111	/* xen_remap_domain_gfn_range() - map a range of foreign frames
4e8c0c8c DV	112	* @vma: VMA to map the pages into
	113	* @addr: Address at which to map the pages
	114	* @gfn: First GFN to map.
	115	* @nr: Number frames to map
	116	* @prot: page protection mask
	117	* @domid: Domain owning the pages
	118	* @pages: Array of pages if this domain has an auto-translated physmap
	119	*
	120	* Returns the number of successfully mapped frames, or a -ve error
	121	* code.
	122	*/
a13d7201	123	int xen_remap_domain_gfn_range(struct vm_area_struct *vma,
de1ef206	124	unsigned long addr,
4e8c0c8c	125	xen_pfn_t gfn, int nr,
9a032e39 IC	126	pgprot_t prot, unsigned domid,
9a032e39 IC	127	struct page **pages);
a13d7201	128	int xen_unmap_domain_gfn_range(struct vm_area_struct *vma,
9a032e39	129	int numpgs, struct page **pages);
ec4001c3 PD	130
ec4001c3 PD	131	#ifdef CONFIG_XEN_AUTO_XLATE
4e8c0c8c	132	int xen_xlate_remap_gfn_array(struct vm_area_struct *vma,
628c28ee	133	unsigned long addr,
4e8c0c8c DV	134	xen_pfn_t *gfn, int nr,
4e8c0c8c DV	135	int *err_ptr, pgprot_t prot,
628c28ee DV	136	unsigned domid,
	137	struct page **pages);
	138	int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma,
	139	int nr, struct page **pages);
ec4001c3 PD	140	#else
	141	/*
	142	* These two functions are called from arch/x86/xen/mmu.c and so stubs
	143	* are needed for a configuration not specifying CONFIG_XEN_AUTO_XLATE.
	144	*/
	145	static inline int xen_xlate_remap_gfn_array(struct vm_area_struct *vma,
	146	unsigned long addr,
	147	xen_pfn_t *gfn, int nr,
	148	int *err_ptr, pgprot_t prot,
	149	unsigned int domid,
	150	struct page **pages)
	151	{
	152	return -EOPNOTSUPP;
	153	}
	154
	155	static inline int xen_xlate_unmap_gfn_range(struct vm_area_struct *vma,
	156	int nr, struct page **pages)
	157	{
	158	return -EOPNOTSUPP;
	159	}
	160	#endif
	161
243848fc SZ	162	int xen_xlate_map_ballooned_pages(xen_pfn_t pfns, void vaddr,
243848fc SZ	163	unsigned long nr_grant_frames);
de1ef206	164
394b40f6	165	bool xen_running_on_version_or_later(unsigned int major, unsigned int minor);
be81c8a1	166
a62ed500 SZ	167	efi_status_t xen_efi_get_time(efi_time_t tm, efi_time_cap_t tc);
	168	efi_status_t xen_efi_set_time(efi_time_t *tm);
	169	efi_status_t xen_efi_get_wakeup_time(efi_bool_t enabled, efi_bool_t pending,
	170	efi_time_t *tm);
	171	efi_status_t xen_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm);
	172	efi_status_t xen_efi_get_variable(efi_char16_t name, efi_guid_t vendor,
	173	u32 attr, unsigned long data_size,
	174	void *data);
	175	efi_status_t xen_efi_get_next_variable(unsigned long *name_size,
	176	efi_char16_t name, efi_guid_t vendor);
	177	efi_status_t xen_efi_set_variable(efi_char16_t name, efi_guid_t vendor,
	178	u32 attr, unsigned long data_size,
	179	void *data);
	180	efi_status_t xen_efi_query_variable_info(u32 attr, u64 *storage_space,
	181	u64 *remaining_space,
	182	u64 *max_variable_size);
	183	efi_status_t xen_efi_get_next_high_mono_count(u32 *count);
	184	efi_status_t xen_efi_update_capsule(efi_capsule_header_t **capsules,
	185	unsigned long count, unsigned long sg_list);
	186	efi_status_t xen_efi_query_capsule_caps(efi_capsule_header_t **capsules,
	187	unsigned long count, u64 *max_size,
	188	int *reset_type);
e371fd76 JG	189	void xen_efi_reset_system(int reset_type, efi_status_t status,
	190	unsigned long data_size, efi_char16_t *data);
	191
be81c8a1	192
fdfd811d DV	193	#ifdef CONFIG_PREEMPT
	194
	195	static inline void xen_preemptible_hcall_begin(void)
	196	{
	197	}
	198
	199	static inline void xen_preemptible_hcall_end(void)
	200	{
	201	}
	202
	203	#else
	204
	205	DECLARE_PER_CPU(bool, xen_in_preemptible_hcall);
	206
	207	static inline void xen_preemptible_hcall_begin(void)
	208	{
	209	__this_cpu_write(xen_in_preemptible_hcall, true);
	210	}
	211
	212	static inline void xen_preemptible_hcall_end(void)
	213	{
	214	__this_cpu_write(xen_in_preemptible_hcall, false);
	215	}
	216
	217	#endif /* CONFIG_PREEMPT */
	218
e04d0d07	219	#endif /* INCLUDE_XEN_OPS_H */