[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 <xen/features.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;

#if defined(CONFIG_XEN_PV) || defined(CONFIG_ARM) || defined(CONFIG_ARM64)
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

#if defined(CONFIG_XEN_PV)
int xen_remap_pfn(struct vm_area_struct *vma, unsigned long addr,
		  xen_pfn_t *pfn, int nr, int *err_ptr, pgprot_t prot,
		  unsigned int domid, bool no_translate, struct page **pages);
#else
static inline int xen_remap_pfn(struct vm_area_struct *vma, unsigned long addr,
				xen_pfn_t *pfn, int nr, int *err_ptr,
				pgprot_t prot,  unsigned int domid,
				bool no_translate, struct page **pages)
{
	BUG();
	return 0;
}
#endif

struct vm_area_struct;

#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 int 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

/*
 * 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.
 */
static inline 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 int domid,
					     struct page **pages)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return xen_xlate_remap_gfn_array(vma, addr, gfn, nr, err_ptr,
						 prot, domid, pages);

	/* We BUG_ON because it's a programmer error to pass a NULL err_ptr,
	 * and the consequences later is quite hard to detect what the actual
	 * cause of "wrong memory was mapped in".
	 */
	BUG_ON(err_ptr == NULL);
	return xen_remap_pfn(vma, addr, gfn, nr, err_ptr, prot, domid,
			     false, 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.
 */
static inline 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)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return -EOPNOTSUPP;

	return xen_remap_pfn(vma, addr, mfn, nr, err_ptr, prot, domid,
			     true, 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.
 */
static inline int xen_remap_domain_gfn_range(struct vm_area_struct *vma,
					     unsigned long addr,
					     xen_pfn_t gfn, int nr,
					     pgprot_t prot, unsigned int domid,
					     struct page **pages)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return -EOPNOTSUPP;

	return xen_remap_pfn(vma, addr, &gfn, nr, NULL, prot, domid, false,
			     pages);
}

int xen_unmap_domain_gfn_range(struct vm_area_struct *vma,
			       int numpgs, struct page **pages);

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