leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

x86/mm/cpa: Split, rename and clean up try_preserve_large_page()

Browse Source 
Avoid the extra variable and gotos by splitting the function into the
actual algorithm and a callable function which contains the lock
protection.

Rename it to should_split_large_page() while at it so the return values make
actually sense.

Clean up the code flow, comments and general whitespace damage while at it. No
functional change.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Dave Hansen <dave.hansen@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Bin Yang <bin.yang@intel.com>
Cc: Mark Gross <mark.gross@intel.com>
Link: https://lkml.kernel.org/r/20180917143545.830507216@linutronix.de
This commit is contained in:
Thomas Gleixner 2018-09-17 16:29:08 +02:00
parent 2a25dc7c79
commit 8679de0959
1 changed files with 60 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
arch/x86/mm/pageattr.c
View File

@ -421,18 +421,18 @@ pte_t *lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
*/ */
pte_t *lookup_address(unsigned long address, unsigned int *level) pte_t *lookup_address(unsigned long address, unsigned int *level)
{ {
return lookup_address_in_pgd(pgd_offset_k(address), address, level); return lookup_address_in_pgd(pgd_offset_k(address), address, level);
} }
EXPORT_SYMBOL_GPL(lookup_address); EXPORT_SYMBOL_GPL(lookup_address);
static pte_t *_lookup_address_cpa(struct cpa_data *cpa, unsigned long address, static pte_t *_lookup_address_cpa(struct cpa_data *cpa, unsigned long address,
unsigned int *level) unsigned int *level)
{ {
if (cpa->pgd) if (cpa->pgd)
return lookup_address_in_pgd(cpa->pgd + pgd_index(address), return lookup_address_in_pgd(cpa->pgd + pgd_index(address),
address, level); address, level);
return lookup_address(address, level); return lookup_address(address, level);
} }
/* /*
@ -549,27 +549,22 @@ static pgprot_t pgprot_clear_protnone_bits(pgprot_t prot)
return prot; return prot;
} }
static int static int __should_split_large_page(pte_t *kpte, unsigned long address,
try_preserve_large_page(pte_t *kpte, unsigned long address, struct cpa_data *cpa)
struct cpa_data *cpa)
{ {
unsigned long nextpage_addr, numpages, pmask, psize, addr, pfn, old_pfn; unsigned long numpages, pmask, psize, lpaddr, addr, pfn, old_pfn;
pte_t new_pte, old_pte, *tmp;
pgprot_t old_prot, new_prot, req_prot; pgprot_t old_prot, new_prot, req_prot;
int i, do_split = 1; pte_t new_pte, old_pte, *tmp;
enum pg_level level; enum pg_level level;
int i;
if (cpa->force_split)
return 1;
spin_lock(&pgd_lock);
/* /*
* Check for races, another CPU might have split this page * Check for races, another CPU might have split this page
* up already: * up already:
*/ */
tmp = _lookup_address_cpa(cpa, address, &level); tmp = _lookup_address_cpa(cpa, address, &level);
if (tmp != kpte) if (tmp != kpte)
goto out_unlock; return 1;
switch (level) { switch (level) {
case PG_LEVEL_2M: case PG_LEVEL_2M:
@ -581,8 +576,7 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
old_pfn = pud_pfn(*(pud_t *)kpte); old_pfn = pud_pfn(*(pud_t *)kpte);
break; break;
default: default:
do_split = -EINVAL; return -EINVAL;
goto out_unlock;
} }
psize = page_level_size(level); psize = page_level_size(level);
@ -592,8 +586,8 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
* Calculate the number of pages, which fit into this large * Calculate the number of pages, which fit into this large
* page starting at address: * page starting at address:
*/ */
nextpage_addr = (address + psize) & pmask; lpaddr = (address + psize) & pmask;
numpages = (nextpage_addr - address) >> PAGE_SHIFT; numpages = (lpaddr - address) >> PAGE_SHIFT;
if (numpages < cpa->numpages) if (numpages < cpa->numpages)
cpa->numpages = numpages; cpa->numpages = numpages;
@ -620,57 +614,62 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
pgprot_val(req_prot) |= _PAGE_PSE; pgprot_val(req_prot) |= _PAGE_PSE;
/* /*
* old_pfn points to the large page base pfn. So we need * old_pfn points to the large page base pfn. So we need to add the
* to add the offset of the virtual address: * offset of the virtual address:
*/ */
pfn = old_pfn + ((address & (psize - 1)) >> PAGE_SHIFT); pfn = old_pfn + ((address & (psize - 1)) >> PAGE_SHIFT);
cpa->pfn = pfn; cpa->pfn = pfn;
new_prot = static_protections(req_prot, address, pfn); /*
* Calculate the large page base address and the number of 4K pages
* in the large page
*/
lpaddr = address & pmask;
numpages = psize >> PAGE_SHIFT;
/* /*
* We need to check the full range, whether * Make sure that the requested pgprot does not violate the static
* static_protection() requires a different pgprot for one of * protections. Check the full large page whether one of the pages
* the pages in the range we try to preserve: * in it results in a different pgprot than the first one of the
* requested range. If yes, then the page needs to be split.
*/ */
addr = address & pmask; new_prot = static_protections(req_prot, address, pfn);
pfn = old_pfn; pfn = old_pfn;
for (i = 0; i < (psize >> PAGE_SHIFT); i++, addr += PAGE_SIZE, pfn++) { for (i = 0, addr = lpaddr; i < numpages; i++, addr += PAGE_SIZE, pfn++) {
pgprot_t chk_prot = static_protections(req_prot, addr, pfn); pgprot_t chk_prot = static_protections(req_prot, addr, pfn);
if (pgprot_val(chk_prot) != pgprot_val(new_prot)) if (pgprot_val(chk_prot) != pgprot_val(new_prot))
goto out_unlock; return 1;
} }
/* If there are no changes, return. */
if (pgprot_val(new_prot) == pgprot_val(old_prot))
return 0;
/* /*
* If there are no changes, return. maxpages has been updated * Verify that the address is aligned and the number of pages
* above: * covers the full page.
*/ */
if (pgprot_val(new_prot) == pgprot_val(old_prot)) { if (address != lpaddr || cpa->numpages != numpages)
do_split = 0; return 1;
goto out_unlock;
}
/* /* All checks passed. Update the large page mapping. */
* We need to change the attributes. Check, whether we can new_pte = pfn_pte(old_pfn, new_prot);
* change the large page in one go. We request a split, when __set_pmd_pte(kpte, address, new_pte);
* the address is not aligned and the number of pages is cpa->flags |= CPA_FLUSHTLB;
* smaller than the number of pages in the large page. Note return 0;
* that we limited the number of possible pages already to }
* the number of pages in the large page.
*/
if (address == (address & pmask) && cpa->numpages == (psize >> PAGE_SHIFT)) {
/*
* The address is aligned and the number of pages
* covers the full page.
*/
new_pte = pfn_pte(old_pfn, new_prot);
__set_pmd_pte(kpte, address, new_pte);
cpa->flags |= CPA_FLUSHTLB;
do_split = 0;
}
out_unlock: static int should_split_large_page(pte_t *kpte, unsigned long address,
struct cpa_data *cpa)
{
int do_split;
if (cpa->force_split)
return 1;
spin_lock(&pgd_lock);
do_split = __should_split_large_page(kpte, address, cpa);
spin_unlock(&pgd_lock); spin_unlock(&pgd_lock);
return do_split; return do_split;
@ -1273,7 +1272,7 @@ repeat:
* Check, whether we can keep the large page intact * Check, whether we can keep the large page intact
* and just change the pte: * and just change the pte:
*/ */
do_split = try_preserve_large_page(kpte, address, cpa); do_split = should_split_large_page(kpte, address, cpa);
/* /*
* When the range fits into the existing large page, * When the range fits into the existing large page,
* return. cp->numpages and cpa->tlbflush have been updated in * return. cp->numpages and cpa->tlbflush have been updated in
@ -1288,23 +1287,23 @@ repeat:
err = split_large_page(cpa, kpte, address); err = split_large_page(cpa, kpte, address);
if (!err) { if (!err) {
/* /*
* Do a global flush tlb after splitting the large page * Do a global flush tlb after splitting the large page
* and before we do the actual change page attribute in the PTE. * and before we do the actual change page attribute in the PTE.
* *
* With out this, we violate the TLB application note, that says * With out this, we violate the TLB application note, that says
* "The TLBs may contain both ordinary and large-page * "The TLBs may contain both ordinary and large-page
* translations for a 4-KByte range of linear addresses. This * translations for a 4-KByte range of linear addresses. This
* may occur if software modifies the paging structures so that * may occur if software modifies the paging structures so that
* the page size used for the address range changes. If the two * the page size used for the address range changes. If the two
* translations differ with respect to page frame or attributes * translations differ with respect to page frame or attributes
* (e.g., permissions), processor behavior is undefined and may * (e.g., permissions), processor behavior is undefined and may
* be implementation-specific." * be implementation-specific."
* *
* We do this global tlb flush inside the cpa_lock, so that we * We do this global tlb flush inside the cpa_lock, so that we
* don't allow any other cpu, with stale tlb entries change the * don't allow any other cpu, with stale tlb entries change the
* page attribute in parallel, that also falls into the * page attribute in parallel, that also falls into the
* just split large page entry. * just split large page entry.
*/ */
flush_tlb_all(); flush_tlb_all();
goto repeat; goto repeat;
} }