Skip to content

Commit

Permalink
mm/hmm: use uint64_t for HMM pfn instead of defining hmm_pfn_t to ulong
Browse files Browse the repository at this point in the history 
All device driver we care about are using 64bits page table entry.  In
order to match this and to avoid useless define convert all HMM pfn to
directly use uint64_t.  It is a first step on the road to allow driver to
directly use pfn value return by HMM (saving memory and CPU cycles use for
conversion between the two).

Link: http://lkml.kernel.org/r/20180323005527.758-9-jglisse@redhat.com
Signed-off-by: Jérôme Glisse <jglisse@redhat.com>
Reviewed-by: John Hubbard <jhubbard@nvidia.com>
Cc: Evgeny Baskakov <ebaskakov@nvidia.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Mark Hairgrove <mhairgrove@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
  • Loading branch information
Jérôme Glisse authored and Linus Torvalds committed Apr 11, 2018
1 parent 86586a4 commit ff05c0c
Show file tree
Hide file tree
Showing 2 changed files with 34 additions and 38 deletions.
46 changes: 21 additions & 25 deletions include/linux/hmm.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,8 +80,6 @@
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
Expand All @@ -93,8 +91,6 @@ struct hmm;
* 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)
Expand All @@ -104,48 +100,48 @@ typedef unsigned long hmm_pfn_t;
#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;
return pfn_to_page(pfn >> HMM_PFN_SHIFT);
}

/*
* 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;
return (pfn >> HMM_PFN_SHIFT);
}

/*
* 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;
}
Expand Down Expand Up @@ -284,7 +280,7 @@ struct hmm_range {
struct list_head list;
unsigned long start;
unsigned long end;
hmm_pfn_t *pfns;
uint64_t *pfns;
bool valid;
};

Expand All @@ -307,7 +303,7 @@ bool hmm_vma_range_done(struct hmm_range *range);

/*
* 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.
*
Expand All @@ -316,7 +312,7 @@ bool hmm_vma_range_done(struct hmm_range *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.
Expand Down
26 changes: 13 additions & 13 deletions mm/hmm.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -304,7 +304,7 @@ struct hmm_vma_walk {

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;
Expand All @@ -324,7 +324,7 @@ static int hmm_vma_do_fault(struct mm_walk *walk,
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)
{
Expand All @@ -338,7 +338,7 @@ static int hmm_pfns_bad(unsigned long 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;

i = (addr - range->start) >> PAGE_SHIFT;
Expand All @@ -348,7 +348,7 @@ static int hmm_pfns_bad(unsigned long addr,
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)
{
Expand All @@ -362,7 +362,7 @@ static int hmm_vma_walk_hole(unsigned long 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;
Expand All @@ -387,7 +387,7 @@ static int hmm_vma_walk_clear(unsigned long 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;
Expand All @@ -414,7 +414,7 @@ static int hmm_vma_walk_pmd(pmd_t *pmdp,
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;
Expand All @@ -431,7 +431,7 @@ static int hmm_vma_walk_pmd(pmd_t *pmdp,

if (pmd_devmap(*pmdp) || pmd_trans_huge(*pmdp)) {
unsigned long pfn;
hmm_pfn_t flag = 0;
uint64_t flag = 0;
pmd_t pmd;

/*
Expand All @@ -456,7 +456,7 @@ static int hmm_vma_walk_pmd(pmd_t *pmdp,
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;
}

Expand Down Expand Up @@ -490,7 +490,7 @@ static int hmm_vma_walk_pmd(pmd_t *pmdp,
* 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)
Expand All @@ -515,7 +515,7 @@ static int hmm_vma_walk_pmd(pmd_t *pmdp,
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;

Expand Down Expand Up @@ -678,8 +678,8 @@ EXPORT_SYMBOL(hmm_vma_range_done);
* 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:
Expand Down

0 comments on commit ff05c0c

Please sign in to comment.