x86/mm/cpa: Split, rename and clean up try_preserve_large_page() (8679de09) · Commits · 戴 / test

arch/x86/mm/pageattr.c

+60 −61

Original line number	Original line	Diff line number	Diff line
	@@ -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 there are no changes, return. maxpages has been updated		if (pgprot_val(new_prot) == pgprot_val(old_prot))
	* above:		return 0;
	*/
	if (pgprot_val(new_prot) == pgprot_val(old_prot)) {
	do_split = 0;
	goto out_unlock;
	}

	/*		/*
	* We need to change the attributes. Check, whether we can		* Verify that the address is aligned and the number of pages
	* change the large page in one go. We request a split, when
	* the address is not aligned and the number of pages is
	* smaller than the number of pages in the large page. Note
	* 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.		* covers the full page.
	*/		*/
			if (address != lpaddr \|\| cpa->numpages != numpages)
			return 1;

			/* All checks passed. Update the large page mapping. */
	new_pte = pfn_pte(old_pfn, new_prot);		new_pte = pfn_pte(old_pfn, new_prot);
	__set_pmd_pte(kpte, address, new_pte);		__set_pmd_pte(kpte, address, new_pte);
	cpa->flags \|= CPA_FLUSHTLB;		cpa->flags \|= CPA_FLUSHTLB;
	do_split = 0;		return 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

Admin message