[linux-2.6-block.git] / arch / x86 / include / asm / xen / page.h

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

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/pfn.h>
#include <linux/mm.h>
#include <linux/device.h>

#include <linux/uaccess.h>
#include <asm/page.h>
#include <asm/pgtable.h>

#include <xen/interface/xen.h>
#include <xen/interface/grant_table.h>
#include <xen/features.h>

/* Xen machine address */
typedef struct xmaddr {
	phys_addr_t maddr;
} xmaddr_t;

/* Xen pseudo-physical address */
typedef struct xpaddr {
	phys_addr_t paddr;
} xpaddr_t;

#define XMADDR(x)	((xmaddr_t) { .maddr = (x) })
#define XPADDR(x)	((xpaddr_t) { .paddr = (x) })

/**** MACHINE <-> PHYSICAL CONVERSION MACROS ****/
#define INVALID_P2M_ENTRY	(~0UL)
#define FOREIGN_FRAME_BIT	(1UL<<(BITS_PER_LONG-1))
#define IDENTITY_FRAME_BIT	(1UL<<(BITS_PER_LONG-2))
#define FOREIGN_FRAME(m)	((m) | FOREIGN_FRAME_BIT)
#define IDENTITY_FRAME(m)	((m) | IDENTITY_FRAME_BIT)

#define P2M_PER_PAGE		(PAGE_SIZE / sizeof(unsigned long))

extern unsigned long *machine_to_phys_mapping;
extern unsigned long  machine_to_phys_nr;
extern unsigned long *xen_p2m_addr;
extern unsigned long  xen_p2m_size;
extern unsigned long  xen_max_p2m_pfn;

extern int xen_alloc_p2m_entry(unsigned long pfn);

extern unsigned long get_phys_to_machine(unsigned long pfn);
extern bool set_phys_to_machine(unsigned long pfn, unsigned long mfn);
extern bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn);
extern unsigned long __init set_phys_range_identity(unsigned long pfn_s,
						    unsigned long pfn_e);

#ifdef CONFIG_XEN_PV
extern int set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops,
				   struct gnttab_map_grant_ref *kmap_ops,
				   struct page **pages, unsigned int count);
extern int clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
				     struct gnttab_unmap_grant_ref *kunmap_ops,
				     struct page **pages, unsigned int count);
#else
static inline int
set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops,
			struct gnttab_map_grant_ref *kmap_ops,
			struct page **pages, unsigned int count)
{
	return 0;
}

static inline int
clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
			  struct gnttab_unmap_grant_ref *kunmap_ops,
			  struct page **pages, unsigned int count)
{
	return 0;
}
#endif

/*
 * Helper functions to write or read unsigned long values to/from
 * memory, when the access may fault.
 */
static inline int xen_safe_write_ulong(unsigned long *addr, unsigned long val)
{
	return __put_user(val, (unsigned long __user *)addr);
}

static inline int xen_safe_read_ulong(unsigned long *addr, unsigned long *val)
{
	return __get_user(*val, (unsigned long __user *)addr);
}

#ifdef CONFIG_XEN_PV
/*
 * When to use pfn_to_mfn(), __pfn_to_mfn() or get_phys_to_machine():
 * - pfn_to_mfn() returns either INVALID_P2M_ENTRY or the mfn. No indicator
 *   bits (identity or foreign) are set.
 * - __pfn_to_mfn() returns the found entry of the p2m table. A possibly set
 *   identity or foreign indicator will be still set. __pfn_to_mfn() is
 *   encapsulating get_phys_to_machine() which is called in special cases only.
 * - get_phys_to_machine() is to be called by __pfn_to_mfn() only in special
 *   cases needing an extended handling.
 */
static inline unsigned long __pfn_to_mfn(unsigned long pfn)
{
	unsigned long mfn;

	if (pfn < xen_p2m_size)
		mfn = xen_p2m_addr[pfn];
	else if (unlikely(pfn < xen_max_p2m_pfn))
		return get_phys_to_machine(pfn);
	else
		return IDENTITY_FRAME(pfn);

	if (unlikely(mfn == INVALID_P2M_ENTRY))
		return get_phys_to_machine(pfn);

	return mfn;
}
#else
static inline unsigned long __pfn_to_mfn(unsigned long pfn)
{
	return pfn;
}
#endif

static inline unsigned long pfn_to_mfn(unsigned long pfn)
{
	unsigned long mfn;

	/*
	 * Some x86 code are still using pfn_to_mfn instead of
	 * pfn_to_mfn. This will have to be removed when we figured
	 * out which call.
	 */
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return pfn;

	mfn = __pfn_to_mfn(pfn);

	if (mfn != INVALID_P2M_ENTRY)
		mfn &= ~(FOREIGN_FRAME_BIT | IDENTITY_FRAME_BIT);

	return mfn;
}

static inline int phys_to_machine_mapping_valid(unsigned long pfn)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return 1;

	return __pfn_to_mfn(pfn) != INVALID_P2M_ENTRY;
}

static inline unsigned long mfn_to_pfn_no_overrides(unsigned long mfn)
{
	unsigned long pfn;
	int ret;

	if (unlikely(mfn >= machine_to_phys_nr))
		return ~0;

	/*
	 * The array access can fail (e.g., device space beyond end of RAM).
	 * In such cases it doesn't matter what we return (we return garbage),
	 * but we must handle the fault without crashing!
	 */
	ret = xen_safe_read_ulong(&machine_to_phys_mapping[mfn], &pfn);
	if (ret < 0)
		return ~0;

	return pfn;
}

static inline unsigned long mfn_to_pfn(unsigned long mfn)
{
	unsigned long pfn;

	/*
	 * Some x86 code are still using mfn_to_pfn instead of
	 * gfn_to_pfn. This will have to be removed when we figure
	 * out which call.
	 */
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return mfn;

	pfn = mfn_to_pfn_no_overrides(mfn);
	if (__pfn_to_mfn(pfn) != mfn)
		pfn = ~0;

	/*
	 * pfn is ~0 if there are no entries in the m2p for mfn or the
	 * entry doesn't map back to the mfn.
	 */
	if (pfn == ~0 && __pfn_to_mfn(mfn) == IDENTITY_FRAME(mfn))
		pfn = mfn;

	return pfn;
}

static inline xmaddr_t phys_to_machine(xpaddr_t phys)
{
	unsigned offset = phys.paddr & ~PAGE_MASK;
	return XMADDR(PFN_PHYS(pfn_to_mfn(PFN_DOWN(phys.paddr))) | offset);
}

static inline xpaddr_t machine_to_phys(xmaddr_t machine)
{
	unsigned offset = machine.maddr & ~PAGE_MASK;
	return XPADDR(PFN_PHYS(mfn_to_pfn(PFN_DOWN(machine.maddr))) | offset);
}

/* Pseudo-physical <-> Guest conversion */
static inline unsigned long pfn_to_gfn(unsigned long pfn)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return pfn;
	else
		return pfn_to_mfn(pfn);
}

static inline unsigned long gfn_to_pfn(unsigned long gfn)
{
	if (xen_feature(XENFEAT_auto_translated_physmap))
		return gfn;
	else
		return mfn_to_pfn(gfn);
}

/* Pseudo-physical <-> Bus conversion */
#define pfn_to_bfn(pfn)		pfn_to_gfn(pfn)
#define bfn_to_pfn(bfn)		gfn_to_pfn(bfn)

/*
 * We detect special mappings in one of two ways:
 *  1. If the MFN is an I/O page then Xen will set the m2p entry
 *     to be outside our maximum possible pseudophys range.
 *  2. If the MFN belongs to a different domain then we will certainly
 *     not have MFN in our p2m table. Conversely, if the page is ours,
 *     then we'll have p2m(m2p(MFN))==MFN.
 * If we detect a special mapping then it doesn't have a 'struct page'.
 * We force !pfn_valid() by returning an out-of-range pointer.
 *
 * NB. These checks require that, for any MFN that is not in our reservation,
 * there is no PFN such that p2m(PFN) == MFN. Otherwise we can get confused if
 * we are foreign-mapping the MFN, and the other domain as m2p(MFN) == PFN.
 * Yikes! Various places must poke in INVALID_P2M_ENTRY for safety.
 *
 * NB2. When deliberately mapping foreign pages into the p2m table, you *must*
 *      use FOREIGN_FRAME(). This will cause pte_pfn() to choke on it, as we
 *      require. In all the cases we care about, the FOREIGN_FRAME bit is
 *      masked (e.g., pfn_to_mfn()) so behaviour there is correct.
 */
static inline unsigned long bfn_to_local_pfn(unsigned long mfn)
{
	unsigned long pfn;

	if (xen_feature(XENFEAT_auto_translated_physmap))
		return mfn;

	pfn = mfn_to_pfn(mfn);
	if (__pfn_to_mfn(pfn) != mfn)
		return -1; /* force !pfn_valid() */
	return pfn;
}

/* VIRT <-> MACHINE conversion */
#define virt_to_machine(v)	(phys_to_machine(XPADDR(__pa(v))))
#define virt_to_pfn(v)          (PFN_DOWN(__pa(v)))
#define virt_to_mfn(v)		(pfn_to_mfn(virt_to_pfn(v)))
#define mfn_to_virt(m)		(__va(mfn_to_pfn(m) << PAGE_SHIFT))

/* VIRT <-> GUEST conversion */
#define virt_to_gfn(v)		(pfn_to_gfn(virt_to_pfn(v)))
#define gfn_to_virt(g)		(__va(gfn_to_pfn(g) << PAGE_SHIFT))

static inline unsigned long pte_mfn(pte_t pte)
{
	return (pte.pte & PTE_PFN_MASK) >> PAGE_SHIFT;
}

static inline pte_t mfn_pte(unsigned long page_nr, pgprot_t pgprot)
{
	pte_t pte;

	pte.pte = ((phys_addr_t)page_nr << PAGE_SHIFT) |
			massage_pgprot(pgprot);

	return pte;
}

static inline pteval_t pte_val_ma(pte_t pte)
{
	return pte.pte;
}

static inline pte_t __pte_ma(pteval_t x)
{
	return (pte_t) { .pte = x };
}

#define pmd_val_ma(v) ((v).pmd)
#ifdef __PAGETABLE_PUD_FOLDED
#define pud_val_ma(v) ((v).p4d.pgd.pgd)
#else
#define pud_val_ma(v) ((v).pud)
#endif
#define __pmd_ma(x)	((pmd_t) { (x) } )

#ifdef __PAGETABLE_P4D_FOLDED
#define p4d_val_ma(x)	((x).pgd.pgd)
#else
#define p4d_val_ma(x)	((x).p4d)
#endif

xmaddr_t arbitrary_virt_to_machine(void *address);
unsigned long arbitrary_virt_to_mfn(void *vaddr);
void make_lowmem_page_readonly(void *vaddr);
void make_lowmem_page_readwrite(void *vaddr);

#define xen_remap(cookie, size) ioremap((cookie), (size));
#define xen_unmap(cookie) iounmap((cookie))

static inline bool xen_arch_need_swiotlb(struct device *dev,
					 phys_addr_t phys,
					 dma_addr_t dev_addr)
{
	return false;
}

static inline unsigned long xen_get_swiotlb_free_pages(unsigned int order)
{
	return __get_free_pages(__GFP_NOWARN, order);
}

#endif /* _ASM_X86_XEN_PAGE_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
05e4d316 PA	2	#ifndef _ASM_X86_XEN_PAGE_H
05e4d316 PA	3	#define _ASM_X86_XEN_PAGE_H
20e71f2e	4
ecbf29cd JF	5	#include <linux/kernel.h>
	6	#include <linux/types.h>
	7	#include <linux/spinlock.h>
20e71f2e	8	#include <linux/pfn.h>
7e77506a	9	#include <linux/mm.h>
7fd5cf0b	10	#include <linux/device.h>
20e71f2e	11
7c0f6ba6	12	#include <linux/uaccess.h>
ecbf29cd	13	#include <asm/page.h>
20e71f2e IY	14	#include <asm/pgtable.h>
20e71f2e IY	15
ecbf29cd	16	#include <xen/interface/xen.h>
008c320a	17	#include <xen/interface/grant_table.h>
20e71f2e IY	18	#include <xen/features.h>
	19
	20	/* Xen machine address */
	21	typedef struct xmaddr {
	22	phys_addr_t maddr;
	23	} xmaddr_t;
	24
	25	/* Xen pseudo-physical address */
	26	typedef struct xpaddr {
	27	phys_addr_t paddr;
	28	} xpaddr_t;
	29
	30	#define XMADDR(x) ((xmaddr_t) { .maddr = (x) })
	31	#define XPADDR(x) ((xpaddr_t) { .paddr = (x) })
	32
	33	/** MACHINE <-> PHYSICAL CONVERSION MACROS **/
	34	#define INVALID_P2M_ENTRY (~0UL)
f4cec35b KRW	35	#define FOREIGN_FRAME_BIT (1UL<<(BITS_PER_LONG-1))
f4cec35b KRW	36	#define IDENTITY_FRAME_BIT (1UL<<(BITS_PER_LONG-2))
20e71f2e	37	#define FOREIGN_FRAME(m) ((m) \| FOREIGN_FRAME_BIT)
f4cec35b	38	#define IDENTITY_FRAME(m) ((m) \| IDENTITY_FRAME_BIT)
20e71f2e	39
cb3eb850 JG	40	#define P2M_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
cb3eb850 JG	41
7e77506a	42	extern unsigned long *machine_to_phys_mapping;
ccbcdf7c	43	extern unsigned long machine_to_phys_nr;
5b8e7d80 JG	44	extern unsigned long *xen_p2m_addr;
	45	extern unsigned long xen_p2m_size;
	46	extern unsigned long xen_max_p2m_pfn;
8006ec3e	47
8edfcf88 DV	48	extern int xen_alloc_p2m_entry(unsigned long pfn);
8edfcf88 DV	49
d451bb7a	50	extern unsigned long get_phys_to_machine(unsigned long pfn);
c3798062	51	extern bool set_phys_to_machine(unsigned long pfn, unsigned long mfn);
6eaa412f	52	extern bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn);
cb3eb850 JG	53	extern unsigned long __init set_phys_range_identity(unsigned long pfn_s,
cb3eb850 JG	54	unsigned long pfn_e);
20e71f2e	55
3d4ebdb2	56	#ifdef CONFIG_XEN_PV
1429d46d ZK	57	extern int set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops,
	58	struct gnttab_map_grant_ref *kmap_ops,
	59	struct page **pages, unsigned int count);
1429d46d	60	extern int clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
853d0289	61	struct gnttab_unmap_grant_ref *kunmap_ops,
1429d46d	62	struct page **pages, unsigned int count);
3d4ebdb2 VK	63	#else
	64	static inline int
	65	set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops,
	66	struct gnttab_map_grant_ref *kmap_ops,
	67	struct page **pages, unsigned int count)
	68	{
	69	return 0;
	70	}
	71
	72	static inline int
	73	clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops,
	74	struct gnttab_unmap_grant_ref *kunmap_ops,
	75	struct page **pages, unsigned int count)
	76	{
	77	return 0;
	78	}
	79	#endif
448f2831	80
90fff3ea JG	81	/*
	82	* Helper functions to write or read unsigned long values to/from
	83	* memory, when the access may fault.
	84	*/
	85	static inline int xen_safe_write_ulong(unsigned long *addr, unsigned long val)
	86	{
	87	return __put_user(val, (unsigned long __user *)addr);
	88	}
	89
	90	static inline int xen_safe_read_ulong(unsigned long addr, unsigned long val)
	91	{
	92	return __get_user(val, (unsigned long __user )addr);
	93	}
	94
3d4ebdb2	95	#ifdef CONFIG_XEN_PV
0aad5689 JG	96	/*
	97	* When to use pfn_to_mfn(), __pfn_to_mfn() or get_phys_to_machine():
	98	* - pfn_to_mfn() returns either INVALID_P2M_ENTRY or the mfn. No indicator
	99	* bits (identity or foreign) are set.
	100	* - __pfn_to_mfn() returns the found entry of the p2m table. A possibly set
	101	* identity or foreign indicator will be still set. __pfn_to_mfn() is
054954eb JG	102	* encapsulating get_phys_to_machine() which is called in special cases only.
	103	* - get_phys_to_machine() is to be called by __pfn_to_mfn() only in special
	104	* cases needing an extended handling.
0aad5689 JG	105	*/
	106	static inline unsigned long __pfn_to_mfn(unsigned long pfn)
	107	{
054954eb JG	108	unsigned long mfn;
	109
	110	if (pfn < xen_p2m_size)
	111	mfn = xen_p2m_addr[pfn];
	112	else if (unlikely(pfn < xen_max_p2m_pfn))
	113	return get_phys_to_machine(pfn);
	114	else
	115	return IDENTITY_FRAME(pfn);
	116
	117	if (unlikely(mfn == INVALID_P2M_ENTRY))
	118	return get_phys_to_machine(pfn);
	119
	120	return mfn;
0aad5689	121	}
3d4ebdb2 VK	122	#else
	123	static inline unsigned long __pfn_to_mfn(unsigned long pfn)
	124	{
	125	return pfn;
	126	}
	127	#endif
0aad5689	128
20e71f2e IY	129	static inline unsigned long pfn_to_mfn(unsigned long pfn)
20e71f2e IY	130	{
cfd8951e JF	131	unsigned long mfn;
cfd8951e JF	132
0df4f266 JG	133	/*
	134	* Some x86 code are still using pfn_to_mfn instead of
	135	* pfn_to_mfn. This will have to be removed when we figured
	136	* out which call.
	137	*/
20e71f2e IY	138	if (xen_feature(XENFEAT_auto_translated_physmap))
	139	return pfn;
	140
0aad5689	141	mfn = __pfn_to_mfn(pfn);
cfd8951e JF	142
cfd8951e JF	143	if (mfn != INVALID_P2M_ENTRY)
f4cec35b	144	mfn &= ~(FOREIGN_FRAME_BIT \| IDENTITY_FRAME_BIT);
cfd8951e JF	145
cfd8951e JF	146	return mfn;
20e71f2e IY	147	}
	148
	149	static inline int phys_to_machine_mapping_valid(unsigned long pfn)
	150	{
	151	if (xen_feature(XENFEAT_auto_translated_physmap))
	152	return 1;
	153
0aad5689	154	return __pfn_to_mfn(pfn) != INVALID_P2M_ENTRY;
20e71f2e IY	155	}
20e71f2e IY	156
0160676b	157	static inline unsigned long mfn_to_pfn_no_overrides(unsigned long mfn)
20e71f2e IY	158	{
20e71f2e IY	159	unsigned long pfn;
0160676b	160	int ret;
20e71f2e	161
0160676b DV	162	if (unlikely(mfn >= machine_to_phys_nr))
	163	return ~0;
	164
20e71f2e IY	165	/*
	166	* The array access can fail (e.g., device space beyond end of RAM).
	167	* In such cases it doesn't matter what we return (we return garbage),
	168	* but we must handle the fault without crashing!
	169	*/
90fff3ea	170	ret = xen_safe_read_ulong(&machine_to_phys_mapping[mfn], &pfn);
706cc9d2	171	if (ret < 0)
0160676b DV	172	return ~0;
	173
	174	return pfn;
	175	}
	176
	177	static inline unsigned long mfn_to_pfn(unsigned long mfn)
	178	{
	179	unsigned long pfn;
	180
0df4f266 JG	181	/*
	182	* Some x86 code are still using mfn_to_pfn instead of
	183	* gfn_to_pfn. This will have to be removed when we figure
	184	* out which call.
	185	*/
0160676b DV	186	if (xen_feature(XENFEAT_auto_translated_physmap))
	187	return mfn;
	188
	189	pfn = mfn_to_pfn_no_overrides(mfn);
0bb599fd DV	190	if (__pfn_to_mfn(pfn) != mfn)
0bb599fd DV	191	pfn = ~0;
706cc9d2	192
1429d46d	193	/*
0bb599fd DV	194	* pfn is ~0 if there are no entries in the m2p for mfn or the
0bb599fd DV	195	* entry doesn't map back to the mfn.
448f2831	196	*/
0aad5689	197	if (pfn == ~0 && __pfn_to_mfn(mfn) == IDENTITY_FRAME(mfn))
706cc9d2	198	pfn = mfn;
448f2831	199
20e71f2e IY	200	return pfn;
	201	}
	202
	203	static inline xmaddr_t phys_to_machine(xpaddr_t phys)
	204	{
	205	unsigned offset = phys.paddr & ~PAGE_MASK;
947d0496	206	return XMADDR(PFN_PHYS(pfn_to_mfn(PFN_DOWN(phys.paddr))) \| offset);
20e71f2e IY	207	}
	208
	209	static inline xpaddr_t machine_to_phys(xmaddr_t machine)
	210	{
	211	unsigned offset = machine.maddr & ~PAGE_MASK;
947d0496	212	return XPADDR(PFN_PHYS(mfn_to_pfn(PFN_DOWN(machine.maddr))) \| offset);
20e71f2e IY	213	}
20e71f2e IY	214
0df4f266 JG	215	/* Pseudo-physical <-> Guest conversion */
	216	static inline unsigned long pfn_to_gfn(unsigned long pfn)
	217	{
	218	if (xen_feature(XENFEAT_auto_translated_physmap))
	219	return pfn;
	220	else
	221	return pfn_to_mfn(pfn);
	222	}
	223
	224	static inline unsigned long gfn_to_pfn(unsigned long gfn)
	225	{
	226	if (xen_feature(XENFEAT_auto_translated_physmap))
	227	return gfn;
	228	else
	229	return mfn_to_pfn(gfn);
	230	}
	231
32e09870	232	/* Pseudo-physical <-> Bus conversion */
0df4f266 JG	233	#define pfn_to_bfn(pfn) pfn_to_gfn(pfn)
0df4f266 JG	234	#define bfn_to_pfn(bfn) gfn_to_pfn(bfn)
32e09870	235
20e71f2e IY	236	/*
	237	* We detect special mappings in one of two ways:
	238	* 1. If the MFN is an I/O page then Xen will set the m2p entry
	239	* to be outside our maximum possible pseudophys range.
	240	* 2. If the MFN belongs to a different domain then we will certainly
	241	* not have MFN in our p2m table. Conversely, if the page is ours,
	242	* then we'll have p2m(m2p(MFN))==MFN.
	243	* If we detect a special mapping then it doesn't have a 'struct page'.
	244	* We force !pfn_valid() by returning an out-of-range pointer.
	245	*
	246	* NB. These checks require that, for any MFN that is not in our reservation,
	247	* there is no PFN such that p2m(PFN) == MFN. Otherwise we can get confused if
	248	* we are foreign-mapping the MFN, and the other domain as m2p(MFN) == PFN.
	249	* Yikes! Various places must poke in INVALID_P2M_ENTRY for safety.
	250	*
	251	* NB2. When deliberately mapping foreign pages into the p2m table, you must
	252	* use FOREIGN_FRAME(). This will cause pte_pfn() to choke on it, as we
	253	* require. In all the cases we care about, the FOREIGN_FRAME bit is
	254	* masked (e.g., pfn_to_mfn()) so behaviour there is correct.
	255	*/
32e09870	256	static inline unsigned long bfn_to_local_pfn(unsigned long mfn)
20e71f2e	257	{
fc590efe MR	258	unsigned long pfn;
	259
	260	if (xen_feature(XENFEAT_auto_translated_physmap))
	261	return mfn;
	262
	263	pfn = mfn_to_pfn(mfn);
0aad5689	264	if (__pfn_to_mfn(pfn) != mfn)
c0011dbf	265	return -1; /* force !pfn_valid() */
20e71f2e IY	266	return pfn;
	267	}
	268
20e71f2e IY	269	/* VIRT <-> MACHINE conversion */
20e71f2e IY	270	#define virt_to_machine(v) (phys_to_machine(XPADDR(__pa(v))))
b40bf53e AN	271	#define virt_to_pfn(v) (PFN_DOWN(__pa(v)))
b40bf53e AN	272	#define virt_to_mfn(v) (pfn_to_mfn(virt_to_pfn(v)))
20e71f2e IY	273	#define mfn_to_virt(m) (__va(mfn_to_pfn(m) << PAGE_SHIFT))
20e71f2e IY	274
0df4f266 JG	275	/* VIRT <-> GUEST conversion */
	276	#define virt_to_gfn(v) (pfn_to_gfn(virt_to_pfn(v)))
	277	#define gfn_to_virt(g) (__va(gfn_to_pfn(g) << PAGE_SHIFT))
	278
20e71f2e IY	279	static inline unsigned long pte_mfn(pte_t pte)
20e71f2e IY	280	{
59438c9f	281	return (pte.pte & PTE_PFN_MASK) >> PAGE_SHIFT;
20e71f2e IY	282	}
	283
	284	static inline pte_t mfn_pte(unsigned long page_nr, pgprot_t pgprot)
	285	{
	286	pte_t pte;
	287
	288	pte.pte = ((phys_addr_t)page_nr << PAGE_SHIFT) \|
b534816b	289	massage_pgprot(pgprot);
20e71f2e IY	290
	291	return pte;
	292	}
	293
	294	static inline pteval_t pte_val_ma(pte_t pte)
	295	{
	296	return pte.pte;
	297	}
	298
	299	static inline pte_t __pte_ma(pteval_t x)
	300	{
	301	return (pte_t) { .pte = x };
	302	}
	303
20e71f2e	304	#define pmd_val_ma(v) ((v).pmd)
f6e58732	305	#ifdef __PAGETABLE_PUD_FOLDED
f2a6a705	306	#define pud_val_ma(v) ((v).p4d.pgd.pgd)
f6e58732 JF	307	#else
	308	#define pud_val_ma(v) ((v).pud)
	309	#endif
20e71f2e	310	#define __pmd_ma(x) ((pmd_t) { (x) } )
20e71f2e	311
f2a6a705 KS	312	#ifdef __PAGETABLE_P4D_FOLDED
	313	#define p4d_val_ma(x) ((x).pgd.pgd)
	314	#else
	315	#define p4d_val_ma(x) ((x).p4d)
	316	#endif
20e71f2e	317
ce803e70	318	xmaddr_t arbitrary_virt_to_machine(void *address);
9976b39b	319	unsigned long arbitrary_virt_to_mfn(void *vaddr);
20e71f2e IY	320	void make_lowmem_page_readonly(void *vaddr);
	321	void make_lowmem_page_readwrite(void *vaddr);
	322
3216dceb	323	#define xen_remap(cookie, size) ioremap((cookie), (size));
efaf30a3	324	#define xen_unmap(cookie) iounmap((cookie))
3216dceb	325
a4dba130	326	static inline bool xen_arch_need_swiotlb(struct device *dev,
291be10f JG	327	phys_addr_t phys,
291be10f JG	328	dma_addr_t dev_addr)
a4dba130 SS	329	{
	330	return false;
	331	}
	332
8746515d SS	333	static inline unsigned long xen_get_swiotlb_free_pages(unsigned int order)
	334	{
	335	return __get_free_pages(__GFP_NOWARN, order);
	336	}
	337
05e4d316	338	#endif /* _ASM_X86_XEN_PAGE_H */