mm/hmm: use uint64_t for HMM pfn instead of defining hmm_pfn_t to ulong

struct hmm;

/*

 * hmm_pfn_t - HMM uses its own pfn type to keep several flags per page

 *

 * Flags:

 * HMM_PFN_VALID: pfn is valid. It has, at least, read permission.

 * HMM_PFN_WRITE: CPU page table has write permission set

 *      set and the pfn value is undefined.

 * HMM_PFN_DEVICE_UNADDRESSABLE: unaddressable device memory (ZONE_DEVICE)

 */

typedef unsigned long hmm_pfn_t;

#define HMM_PFN_VALID (1 << 0)

#define HMM_PFN_WRITE (1 << 1)

#define HMM_PFN_ERROR (1 << 2)

#define HMM_PFN_SHIFT 6

/*

 * hmm_pfn_t_to_page() - return struct page pointed to by a valid hmm_pfn_t

 * @pfn: hmm_pfn_t to convert to struct page

 * Returns: struct page pointer if pfn is a valid hmm_pfn_t, NULL otherwise

 * hmm_pfn_to_page() - return struct page pointed to by a valid HMM pfn

 * @pfn: HMM pfn value to get corresponding struct page from

 * Returns: struct page pointer if pfn is a valid HMM pfn, NULL otherwise

 *

 * If the hmm_pfn_t is valid (ie valid flag set) then return the struct page

 * matching the pfn value stored in the hmm_pfn_t. Otherwise return NULL.

 * If the HMM pfn is valid (ie valid flag set) then return the struct page

 * matching the pfn value stored in the HMM pfn. Otherwise return NULL.

 */

static inline struct page *hmm_pfn_t_to_page(hmm_pfn_t pfn)

static inline struct page *hmm_pfn_to_page(uint64_t pfn)

{

	if (!(pfn & HMM_PFN_VALID))

		return NULL;

}

/*

 * hmm_pfn_t_to_pfn() - return pfn value store in a hmm_pfn_t

 * @pfn: hmm_pfn_t to extract pfn from

 * Returns: pfn value if hmm_pfn_t is valid, -1UL otherwise

 * hmm_pfn_to_pfn() - return pfn value store in a HMM pfn

 * @pfn: HMM pfn value to extract pfn from

 * Returns: pfn value if HMM pfn is valid, -1UL otherwise

 */

static inline unsigned long hmm_pfn_t_to_pfn(hmm_pfn_t pfn)

static inline unsigned long hmm_pfn_to_pfn(uint64_t pfn)

{

	if (!(pfn & HMM_PFN_VALID))

		return -1UL;

}

/*

 * hmm_pfn_t_from_page() - create a valid hmm_pfn_t value from struct page

 * @page: struct page pointer for which to create the hmm_pfn_t

 * Returns: valid hmm_pfn_t for the page

 * hmm_pfn_from_page() - create a valid HMM pfn value from struct page

 * @page: struct page pointer for which to create the HMM pfn

 * Returns: valid HMM pfn for the page

 */

static inline hmm_pfn_t hmm_pfn_t_from_page(struct page *page)

static inline uint64_t hmm_pfn_from_page(struct page *page)

{

	return (page_to_pfn(page) << HMM_PFN_SHIFT) | HMM_PFN_VALID;

}

/*

 * hmm_pfn_t_from_pfn() - create a valid hmm_pfn_t value from pfn

 * @pfn: pfn value for which to create the hmm_pfn_t

 * Returns: valid hmm_pfn_t for the pfn

 * hmm_pfn_from_pfn() - create a valid HMM pfn value from pfn

 * @pfn: pfn value for which to create the HMM pfn

 * Returns: valid HMM pfn for the pfn

 */

static inline hmm_pfn_t hmm_pfn_t_from_pfn(unsigned long pfn)

static inline uint64_t hmm_pfn_from_pfn(unsigned long pfn)

{

	return (pfn << HMM_PFN_SHIFT) | HMM_PFN_VALID;

}

	struct list_head	list;

	unsigned long		start;

	unsigned long		end;

	hmm_pfn_t		*pfns;

	uint64_t		*pfns;

	bool			valid;

};

/*

 * Fault memory on behalf of device driver. Unlike handle_mm_fault(), this will

 * not migrate any device memory back to system memory. The hmm_pfn_t array will

 * not migrate any device memory back to system memory. The HMM pfn array will

 * be updated with the fault result and current snapshot of the CPU page table

 * for the range.

 *

 * function returns -EAGAIN.

 *

 * Return value does not reflect if the fault was successful for every single

 * address or not. Therefore, the caller must to inspect the hmm_pfn_t array to

 * address or not. Therefore, the caller must to inspect the HMM pfn array to

 * determine fault status for each address.

 *

 * Trying to fault inside an invalid vma will result in -EINVAL.

static int hmm_vma_do_fault(struct mm_walk *walk,

			    unsigned long addr,

			    hmm_pfn_t *pfn)

			    uint64_t *pfn)

{

	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_REMOTE;

	struct hmm_vma_walk *hmm_vma_walk = walk->private;

	return -EAGAIN;

}

static void hmm_pfns_special(hmm_pfn_t *pfns,

static void hmm_pfns_special(uint64_t *pfns,

			     unsigned long addr,

			     unsigned long end)

{

{

	struct hmm_vma_walk *hmm_vma_walk = walk->private;

	struct hmm_range *range = hmm_vma_walk->range;

	hmm_pfn_t *pfns = range->pfns;

	uint64_t *pfns = range->pfns;

	unsigned long i;

	i = (addr - range->start) >> PAGE_SHIFT;

	return 0;

}

static void hmm_pfns_clear(hmm_pfn_t *pfns,

static void hmm_pfns_clear(uint64_t *pfns,

			   unsigned long addr,

			   unsigned long end)

{

{

	struct hmm_vma_walk *hmm_vma_walk = walk->private;

	struct hmm_range *range = hmm_vma_walk->range;

	hmm_pfn_t *pfns = range->pfns;

	uint64_t *pfns = range->pfns;

	unsigned long i;

	hmm_vma_walk->last = addr;

{

	struct hmm_vma_walk *hmm_vma_walk = walk->private;

	struct hmm_range *range = hmm_vma_walk->range;

	hmm_pfn_t *pfns = range->pfns;

	uint64_t *pfns = range->pfns;

	unsigned long i;

	hmm_vma_walk->last = addr;

	struct hmm_vma_walk *hmm_vma_walk = walk->private;

	struct hmm_range *range = hmm_vma_walk->range;

	struct vm_area_struct *vma = walk->vma;

	hmm_pfn_t *pfns = range->pfns;

	uint64_t *pfns = range->pfns;

	unsigned long addr = start, i;

	bool write_fault;

	pte_t *ptep;

	if (pmd_devmap(*pmdp) || pmd_trans_huge(*pmdp)) {

		unsigned long pfn;

		hmm_pfn_t flag = 0;

		uint64_t flag = 0;

		pmd_t pmd;

		/*

		pfn = pmd_pfn(pmd) + pte_index(addr);

		flag |= pmd_write(pmd) ? HMM_PFN_WRITE : 0;

		for (; addr < end; addr += PAGE_SIZE, i++, pfn++)

			pfns[i] = hmm_pfn_t_from_pfn(pfn) | flag;

			pfns[i] = hmm_pfn_from_pfn(pfn) | flag;

		return 0;

	}

			 * device and report anything else as error.

			 */

			if (is_device_private_entry(entry)) {

				pfns[i] = hmm_pfn_t_from_pfn(swp_offset(entry));

				pfns[i] = hmm_pfn_from_pfn(swp_offset(entry));

				if (is_write_device_private_entry(entry)) {

					pfns[i] |= HMM_PFN_WRITE;

				} else if (write_fault)

		if (write_fault && !pte_write(pte))

			goto fault;

		pfns[i] = hmm_pfn_t_from_pfn(pte_pfn(pte));

		pfns[i] = hmm_pfn_from_pfn(pte_pfn(pte));

		pfns[i] |= pte_write(pte) ? HMM_PFN_WRITE : 0;

		continue;

 * This is similar to a regular CPU page fault except that it will not trigger

 * any memory migration if the memory being faulted is not accessible by CPUs.

 *

 * On error, for one virtual address in the range, the function will set the

 * hmm_pfn_t error flag for the corresponding pfn entry.

 * On error, for one virtual address in the range, the function will mark the

 * corresponding HMM pfn entry with an error flag.

 *

 * Expected use pattern:

 * retry: