|
|
@@ -25,15 +25,27 @@
|
|
|
* The current flushing context - we pass it instead of 5 arguments:
|
|
|
*/
|
|
|
struct cpa_data {
|
|
|
- unsigned long vaddr;
|
|
|
+ unsigned long *vaddr;
|
|
|
pgprot_t mask_set;
|
|
|
pgprot_t mask_clr;
|
|
|
int numpages;
|
|
|
- int flushtlb;
|
|
|
+ int flags;
|
|
|
unsigned long pfn;
|
|
|
unsigned force_split : 1;
|
|
|
+ int curpage;
|
|
|
};
|
|
|
|
|
|
+/*
|
|
|
+ * Serialize cpa() (for !DEBUG_PAGEALLOC which uses large identity mappings)
|
|
|
+ * using cpa_lock. So that we don't allow any other cpu, with stale large tlb
|
|
|
+ * entries change the page attribute in parallel to some other cpu
|
|
|
+ * splitting a large page entry along with changing the attribute.
|
|
|
+ */
|
|
|
+static DEFINE_SPINLOCK(cpa_lock);
|
|
|
+
|
|
|
+#define CPA_FLUSHTLB 1
|
|
|
+#define CPA_ARRAY 2
|
|
|
+
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
static unsigned long direct_pages_count[PG_LEVEL_NUM];
|
|
|
|
|
|
@@ -190,6 +202,41 @@ static void cpa_flush_range(unsigned long start, int numpages, int cache)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+static void cpa_flush_array(unsigned long *start, int numpages, int cache)
|
|
|
+{
|
|
|
+ unsigned int i, level;
|
|
|
+ unsigned long *addr;
|
|
|
+
|
|
|
+ BUG_ON(irqs_disabled());
|
|
|
+
|
|
|
+ on_each_cpu(__cpa_flush_range, NULL, 1);
|
|
|
+
|
|
|
+ if (!cache)
|
|
|
+ return;
|
|
|
+
|
|
|
+ /* 4M threshold */
|
|
|
+ if (numpages >= 1024) {
|
|
|
+ if (boot_cpu_data.x86_model >= 4)
|
|
|
+ wbinvd();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * We only need to flush on one CPU,
|
|
|
+ * clflush is a MESI-coherent instruction that
|
|
|
+ * will cause all other CPUs to flush the same
|
|
|
+ * cachelines:
|
|
|
+ */
|
|
|
+ for (i = 0, addr = start; i < numpages; i++, addr++) {
|
|
|
+ pte_t *pte = lookup_address(*addr, &level);
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Only flush present addresses:
|
|
|
+ */
|
|
|
+ if (pte && (pte_val(*pte) & _PAGE_PRESENT))
|
|
|
+ clflush_cache_range((void *) *addr, PAGE_SIZE);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
/*
|
|
|
* Certain areas of memory on x86 require very specific protection flags,
|
|
|
* for example the BIOS area or kernel text. Callers don't always get this
|
|
|
@@ -398,7 +445,7 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
|
|
|
*/
|
|
|
new_pte = pfn_pte(pte_pfn(old_pte), canon_pgprot(new_prot));
|
|
|
__set_pmd_pte(kpte, address, new_pte);
|
|
|
- cpa->flushtlb = 1;
|
|
|
+ cpa->flags |= CPA_FLUSHTLB;
|
|
|
do_split = 0;
|
|
|
}
|
|
|
|
|
|
@@ -408,84 +455,6 @@ out_unlock:
|
|
|
return do_split;
|
|
|
}
|
|
|
|
|
|
-static LIST_HEAD(page_pool);
|
|
|
-static unsigned long pool_size, pool_pages, pool_low;
|
|
|
-static unsigned long pool_used, pool_failed;
|
|
|
-
|
|
|
-static void cpa_fill_pool(struct page **ret)
|
|
|
-{
|
|
|
- gfp_t gfp = GFP_KERNEL;
|
|
|
- unsigned long flags;
|
|
|
- struct page *p;
|
|
|
-
|
|
|
- /*
|
|
|
- * Avoid recursion (on debug-pagealloc) and also signal
|
|
|
- * our priority to get to these pagetables:
|
|
|
- */
|
|
|
- if (current->flags & PF_MEMALLOC)
|
|
|
- return;
|
|
|
- current->flags |= PF_MEMALLOC;
|
|
|
-
|
|
|
- /*
|
|
|
- * Allocate atomically from atomic contexts:
|
|
|
- */
|
|
|
- if (in_atomic() || irqs_disabled() || debug_pagealloc)
|
|
|
- gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
|
|
|
-
|
|
|
- while (pool_pages < pool_size || (ret && !*ret)) {
|
|
|
- p = alloc_pages(gfp, 0);
|
|
|
- if (!p) {
|
|
|
- pool_failed++;
|
|
|
- break;
|
|
|
- }
|
|
|
- /*
|
|
|
- * If the call site needs a page right now, provide it:
|
|
|
- */
|
|
|
- if (ret && !*ret) {
|
|
|
- *ret = p;
|
|
|
- continue;
|
|
|
- }
|
|
|
- spin_lock_irqsave(&pgd_lock, flags);
|
|
|
- list_add(&p->lru, &page_pool);
|
|
|
- pool_pages++;
|
|
|
- spin_unlock_irqrestore(&pgd_lock, flags);
|
|
|
- }
|
|
|
-
|
|
|
- current->flags &= ~PF_MEMALLOC;
|
|
|
-}
|
|
|
-
|
|
|
-#define SHIFT_MB (20 - PAGE_SHIFT)
|
|
|
-#define ROUND_MB_GB ((1 << 10) - 1)
|
|
|
-#define SHIFT_MB_GB 10
|
|
|
-#define POOL_PAGES_PER_GB 16
|
|
|
-
|
|
|
-void __init cpa_init(void)
|
|
|
-{
|
|
|
- struct sysinfo si;
|
|
|
- unsigned long gb;
|
|
|
-
|
|
|
- si_meminfo(&si);
|
|
|
- /*
|
|
|
- * Calculate the number of pool pages:
|
|
|
- *
|
|
|
- * Convert totalram (nr of pages) to MiB and round to the next
|
|
|
- * GiB. Shift MiB to Gib and multiply the result by
|
|
|
- * POOL_PAGES_PER_GB:
|
|
|
- */
|
|
|
- if (debug_pagealloc) {
|
|
|
- gb = ((si.totalram >> SHIFT_MB) + ROUND_MB_GB) >> SHIFT_MB_GB;
|
|
|
- pool_size = POOL_PAGES_PER_GB * gb;
|
|
|
- } else {
|
|
|
- pool_size = 1;
|
|
|
- }
|
|
|
- pool_low = pool_size;
|
|
|
-
|
|
|
- cpa_fill_pool(NULL);
|
|
|
- printk(KERN_DEBUG
|
|
|
- "CPA: page pool initialized %lu of %lu pages preallocated\n",
|
|
|
- pool_pages, pool_size);
|
|
|
-}
|
|
|
-
|
|
|
static int split_large_page(pte_t *kpte, unsigned long address)
|
|
|
{
|
|
|
unsigned long flags, pfn, pfninc = 1;
|
|
|
@@ -494,28 +463,15 @@ static int split_large_page(pte_t *kpte, unsigned long address)
|
|
|
pgprot_t ref_prot;
|
|
|
struct page *base;
|
|
|
|
|
|
- /*
|
|
|
- * Get a page from the pool. The pool list is protected by the
|
|
|
- * pgd_lock, which we have to take anyway for the split
|
|
|
- * operation:
|
|
|
- */
|
|
|
- spin_lock_irqsave(&pgd_lock, flags);
|
|
|
- if (list_empty(&page_pool)) {
|
|
|
- spin_unlock_irqrestore(&pgd_lock, flags);
|
|
|
- base = NULL;
|
|
|
- cpa_fill_pool(&base);
|
|
|
- if (!base)
|
|
|
- return -ENOMEM;
|
|
|
- spin_lock_irqsave(&pgd_lock, flags);
|
|
|
- } else {
|
|
|
- base = list_first_entry(&page_pool, struct page, lru);
|
|
|
- list_del(&base->lru);
|
|
|
- pool_pages--;
|
|
|
-
|
|
|
- if (pool_pages < pool_low)
|
|
|
- pool_low = pool_pages;
|
|
|
- }
|
|
|
+ if (!debug_pagealloc)
|
|
|
+ spin_unlock(&cpa_lock);
|
|
|
+ base = alloc_pages(GFP_KERNEL, 0);
|
|
|
+ if (!debug_pagealloc)
|
|
|
+ spin_lock(&cpa_lock);
|
|
|
+ if (!base)
|
|
|
+ return -ENOMEM;
|
|
|
|
|
|
+ spin_lock_irqsave(&pgd_lock, flags);
|
|
|
/*
|
|
|
* Check for races, another CPU might have split this page
|
|
|
* up for us already:
|
|
|
@@ -572,11 +528,8 @@ out_unlock:
|
|
|
* If we dropped out via the lookup_address check under
|
|
|
* pgd_lock then stick the page back into the pool:
|
|
|
*/
|
|
|
- if (base) {
|
|
|
- list_add(&base->lru, &page_pool);
|
|
|
- pool_pages++;
|
|
|
- } else
|
|
|
- pool_used++;
|
|
|
+ if (base)
|
|
|
+ __free_page(base);
|
|
|
spin_unlock_irqrestore(&pgd_lock, flags);
|
|
|
|
|
|
return 0;
|
|
|
@@ -584,11 +537,16 @@ out_unlock:
|
|
|
|
|
|
static int __change_page_attr(struct cpa_data *cpa, int primary)
|
|
|
{
|
|
|
- unsigned long address = cpa->vaddr;
|
|
|
+ unsigned long address;
|
|
|
int do_split, err;
|
|
|
unsigned int level;
|
|
|
pte_t *kpte, old_pte;
|
|
|
|
|
|
+ if (cpa->flags & CPA_ARRAY)
|
|
|
+ address = cpa->vaddr[cpa->curpage];
|
|
|
+ else
|
|
|
+ address = *cpa->vaddr;
|
|
|
+
|
|
|
repeat:
|
|
|
kpte = lookup_address(address, &level);
|
|
|
if (!kpte)
|
|
|
@@ -600,7 +558,7 @@ repeat:
|
|
|
return 0;
|
|
|
WARN(1, KERN_WARNING "CPA: called for zero pte. "
|
|
|
"vaddr = %lx cpa->vaddr = %lx\n", address,
|
|
|
- cpa->vaddr);
|
|
|
+ *cpa->vaddr);
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
@@ -626,7 +584,7 @@ repeat:
|
|
|
*/
|
|
|
if (pte_val(old_pte) != pte_val(new_pte)) {
|
|
|
set_pte_atomic(kpte, new_pte);
|
|
|
- cpa->flushtlb = 1;
|
|
|
+ cpa->flags |= CPA_FLUSHTLB;
|
|
|
}
|
|
|
cpa->numpages = 1;
|
|
|
return 0;
|
|
|
@@ -650,7 +608,25 @@ repeat:
|
|
|
*/
|
|
|
err = split_large_page(kpte, address);
|
|
|
if (!err) {
|
|
|
- cpa->flushtlb = 1;
|
|
|
+ /*
|
|
|
+ * Do a global flush tlb after splitting the large page
|
|
|
+ * and before we do the actual change page attribute in the PTE.
|
|
|
+ *
|
|
|
+ * With out this, we violate the TLB application note, that says
|
|
|
+ * "The TLBs may contain both ordinary and large-page
|
|
|
+ * translations for a 4-KByte range of linear addresses. This
|
|
|
+ * may occur if software modifies the paging structures so that
|
|
|
+ * the page size used for the address range changes. If the two
|
|
|
+ * translations differ with respect to page frame or attributes
|
|
|
+ * (e.g., permissions), processor behavior is undefined and may
|
|
|
+ * be implementation-specific."
|
|
|
+ *
|
|
|
+ * 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
|
|
|
+ * page attribute in parallel, that also falls into the
|
|
|
+ * just split large page entry.
|
|
|
+ */
|
|
|
+ flush_tlb_all();
|
|
|
goto repeat;
|
|
|
}
|
|
|
|
|
|
@@ -663,6 +639,7 @@ static int cpa_process_alias(struct cpa_data *cpa)
|
|
|
{
|
|
|
struct cpa_data alias_cpa;
|
|
|
int ret = 0;
|
|
|
+ unsigned long temp_cpa_vaddr, vaddr;
|
|
|
|
|
|
if (cpa->pfn >= max_pfn_mapped)
|
|
|
return 0;
|
|
|
@@ -675,16 +652,24 @@ static int cpa_process_alias(struct cpa_data *cpa)
|
|
|
* No need to redo, when the primary call touched the direct
|
|
|
* mapping already:
|
|
|
*/
|
|
|
- if (!(within(cpa->vaddr, PAGE_OFFSET,
|
|
|
+ if (cpa->flags & CPA_ARRAY)
|
|
|
+ vaddr = cpa->vaddr[cpa->curpage];
|
|
|
+ else
|
|
|
+ vaddr = *cpa->vaddr;
|
|
|
+
|
|
|
+ if (!(within(vaddr, PAGE_OFFSET,
|
|
|
PAGE_OFFSET + (max_low_pfn_mapped << PAGE_SHIFT))
|
|
|
#ifdef CONFIG_X86_64
|
|
|
- || within(cpa->vaddr, PAGE_OFFSET + (1UL<<32),
|
|
|
+ || within(vaddr, PAGE_OFFSET + (1UL<<32),
|
|
|
PAGE_OFFSET + (max_pfn_mapped << PAGE_SHIFT))
|
|
|
#endif
|
|
|
)) {
|
|
|
|
|
|
alias_cpa = *cpa;
|
|
|
- alias_cpa.vaddr = (unsigned long) __va(cpa->pfn << PAGE_SHIFT);
|
|
|
+ temp_cpa_vaddr = (unsigned long) __va(cpa->pfn << PAGE_SHIFT);
|
|
|
+ alias_cpa.vaddr = &temp_cpa_vaddr;
|
|
|
+ alias_cpa.flags &= ~CPA_ARRAY;
|
|
|
+
|
|
|
|
|
|
ret = __change_page_attr_set_clr(&alias_cpa, 0);
|
|
|
}
|
|
|
@@ -696,7 +681,7 @@ static int cpa_process_alias(struct cpa_data *cpa)
|
|
|
* No need to redo, when the primary call touched the high
|
|
|
* mapping already:
|
|
|
*/
|
|
|
- if (within(cpa->vaddr, (unsigned long) _text, (unsigned long) _end))
|
|
|
+ if (within(vaddr, (unsigned long) _text, (unsigned long) _end))
|
|
|
return 0;
|
|
|
|
|
|
/*
|
|
|
@@ -707,8 +692,9 @@ static int cpa_process_alias(struct cpa_data *cpa)
|
|
|
return 0;
|
|
|
|
|
|
alias_cpa = *cpa;
|
|
|
- alias_cpa.vaddr =
|
|
|
- (cpa->pfn << PAGE_SHIFT) + __START_KERNEL_map - phys_base;
|
|
|
+ temp_cpa_vaddr = (cpa->pfn << PAGE_SHIFT) + __START_KERNEL_map - phys_base;
|
|
|
+ alias_cpa.vaddr = &temp_cpa_vaddr;
|
|
|
+ alias_cpa.flags &= ~CPA_ARRAY;
|
|
|
|
|
|
/*
|
|
|
* The high mapping range is imprecise, so ignore the return value.
|
|
|
@@ -728,8 +714,15 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias)
|
|
|
* preservation check.
|
|
|
*/
|
|
|
cpa->numpages = numpages;
|
|
|
+ /* for array changes, we can't use large page */
|
|
|
+ if (cpa->flags & CPA_ARRAY)
|
|
|
+ cpa->numpages = 1;
|
|
|
|
|
|
+ if (!debug_pagealloc)
|
|
|
+ spin_lock(&cpa_lock);
|
|
|
ret = __change_page_attr(cpa, checkalias);
|
|
|
+ if (!debug_pagealloc)
|
|
|
+ spin_unlock(&cpa_lock);
|
|
|
if (ret)
|
|
|
return ret;
|
|
|
|
|
|
@@ -746,7 +739,11 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias)
|
|
|
*/
|
|
|
BUG_ON(cpa->numpages > numpages);
|
|
|
numpages -= cpa->numpages;
|
|
|
- cpa->vaddr += cpa->numpages * PAGE_SIZE;
|
|
|
+ if (cpa->flags & CPA_ARRAY)
|
|
|
+ cpa->curpage++;
|
|
|
+ else
|
|
|
+ *cpa->vaddr += cpa->numpages * PAGE_SIZE;
|
|
|
+
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
@@ -757,9 +754,9 @@ static inline int cache_attr(pgprot_t attr)
|
|
|
(_PAGE_PAT | _PAGE_PAT_LARGE | _PAGE_PWT | _PAGE_PCD);
|
|
|
}
|
|
|
|
|
|
-static int change_page_attr_set_clr(unsigned long addr, int numpages,
|
|
|
+static int change_page_attr_set_clr(unsigned long *addr, int numpages,
|
|
|
pgprot_t mask_set, pgprot_t mask_clr,
|
|
|
- int force_split)
|
|
|
+ int force_split, int array)
|
|
|
{
|
|
|
struct cpa_data cpa;
|
|
|
int ret, cache, checkalias;
|
|
|
@@ -774,21 +771,38 @@ static int change_page_attr_set_clr(unsigned long addr, int numpages,
|
|
|
return 0;
|
|
|
|
|
|
/* Ensure we are PAGE_SIZE aligned */
|
|
|
- if (addr & ~PAGE_MASK) {
|
|
|
- addr &= PAGE_MASK;
|
|
|
- /*
|
|
|
- * People should not be passing in unaligned addresses:
|
|
|
- */
|
|
|
- WARN_ON_ONCE(1);
|
|
|
+ if (!array) {
|
|
|
+ if (*addr & ~PAGE_MASK) {
|
|
|
+ *addr &= PAGE_MASK;
|
|
|
+ /*
|
|
|
+ * People should not be passing in unaligned addresses:
|
|
|
+ */
|
|
|
+ WARN_ON_ONCE(1);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < numpages; i++) {
|
|
|
+ if (addr[i] & ~PAGE_MASK) {
|
|
|
+ addr[i] &= PAGE_MASK;
|
|
|
+ WARN_ON_ONCE(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
+ /* Must avoid aliasing mappings in the highmem code */
|
|
|
+ kmap_flush_unused();
|
|
|
+
|
|
|
cpa.vaddr = addr;
|
|
|
cpa.numpages = numpages;
|
|
|
cpa.mask_set = mask_set;
|
|
|
cpa.mask_clr = mask_clr;
|
|
|
- cpa.flushtlb = 0;
|
|
|
+ cpa.flags = 0;
|
|
|
+ cpa.curpage = 0;
|
|
|
cpa.force_split = force_split;
|
|
|
|
|
|
+ if (array)
|
|
|
+ cpa.flags |= CPA_ARRAY;
|
|
|
+
|
|
|
/* No alias checking for _NX bit modifications */
|
|
|
checkalias = (pgprot_val(mask_set) | pgprot_val(mask_clr)) != _PAGE_NX;
|
|
|
|
|
|
@@ -797,7 +811,7 @@ static int change_page_attr_set_clr(unsigned long addr, int numpages,
|
|
|
/*
|
|
|
* Check whether we really changed something:
|
|
|
*/
|
|
|
- if (!cpa.flushtlb)
|
|
|
+ if (!(cpa.flags & CPA_FLUSHTLB))
|
|
|
goto out;
|
|
|
|
|
|
/*
|
|
|
@@ -812,27 +826,30 @@ static int change_page_attr_set_clr(unsigned long addr, int numpages,
|
|
|
* error case we fall back to cpa_flush_all (which uses
|
|
|
* wbindv):
|
|
|
*/
|
|
|
- if (!ret && cpu_has_clflush)
|
|
|
- cpa_flush_range(addr, numpages, cache);
|
|
|
- else
|
|
|
+ if (!ret && cpu_has_clflush) {
|
|
|
+ if (cpa.flags & CPA_ARRAY)
|
|
|
+ cpa_flush_array(addr, numpages, cache);
|
|
|
+ else
|
|
|
+ cpa_flush_range(*addr, numpages, cache);
|
|
|
+ } else
|
|
|
cpa_flush_all(cache);
|
|
|
|
|
|
out:
|
|
|
- cpa_fill_pool(NULL);
|
|
|
-
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
-static inline int change_page_attr_set(unsigned long addr, int numpages,
|
|
|
- pgprot_t mask)
|
|
|
+static inline int change_page_attr_set(unsigned long *addr, int numpages,
|
|
|
+ pgprot_t mask, int array)
|
|
|
{
|
|
|
- return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0), 0);
|
|
|
+ return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0), 0,
|
|
|
+ array);
|
|
|
}
|
|
|
|
|
|
-static inline int change_page_attr_clear(unsigned long addr, int numpages,
|
|
|
- pgprot_t mask)
|
|
|
+static inline int change_page_attr_clear(unsigned long *addr, int numpages,
|
|
|
+ pgprot_t mask, int array)
|
|
|
{
|
|
|
- return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask, 0);
|
|
|
+ return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask, 0,
|
|
|
+ array);
|
|
|
}
|
|
|
|
|
|
int _set_memory_uc(unsigned long addr, int numpages)
|
|
|
@@ -840,8 +857,8 @@ int _set_memory_uc(unsigned long addr, int numpages)
|
|
|
/*
|
|
|
* for now UC MINUS. see comments in ioremap_nocache()
|
|
|
*/
|
|
|
- return change_page_attr_set(addr, numpages,
|
|
|
- __pgprot(_PAGE_CACHE_UC_MINUS));
|
|
|
+ return change_page_attr_set(&addr, numpages,
|
|
|
+ __pgprot(_PAGE_CACHE_UC_MINUS), 0);
|
|
|
}
|
|
|
|
|
|
int set_memory_uc(unsigned long addr, int numpages)
|
|
|
@@ -857,10 +874,48 @@ int set_memory_uc(unsigned long addr, int numpages)
|
|
|
}
|
|
|
EXPORT_SYMBOL(set_memory_uc);
|
|
|
|
|
|
+int set_memory_array_uc(unsigned long *addr, int addrinarray)
|
|
|
+{
|
|
|
+ unsigned long start;
|
|
|
+ unsigned long end;
|
|
|
+ int i;
|
|
|
+ /*
|
|
|
+ * for now UC MINUS. see comments in ioremap_nocache()
|
|
|
+ */
|
|
|
+ for (i = 0; i < addrinarray; i++) {
|
|
|
+ start = __pa(addr[i]);
|
|
|
+ for (end = start + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
|
|
|
+ if (end != __pa(addr[i + 1]))
|
|
|
+ break;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (reserve_memtype(start, end, _PAGE_CACHE_UC_MINUS, NULL))
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+
|
|
|
+ return change_page_attr_set(addr, addrinarray,
|
|
|
+ __pgprot(_PAGE_CACHE_UC_MINUS), 1);
|
|
|
+out:
|
|
|
+ for (i = 0; i < addrinarray; i++) {
|
|
|
+ unsigned long tmp = __pa(addr[i]);
|
|
|
+
|
|
|
+ if (tmp == start)
|
|
|
+ break;
|
|
|
+ for (end = tmp + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
|
|
|
+ if (end != __pa(addr[i + 1]))
|
|
|
+ break;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ free_memtype(tmp, end);
|
|
|
+ }
|
|
|
+ return -EINVAL;
|
|
|
+}
|
|
|
+EXPORT_SYMBOL(set_memory_array_uc);
|
|
|
+
|
|
|
int _set_memory_wc(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_set(addr, numpages,
|
|
|
- __pgprot(_PAGE_CACHE_WC));
|
|
|
+ return change_page_attr_set(&addr, numpages,
|
|
|
+ __pgprot(_PAGE_CACHE_WC), 0);
|
|
|
}
|
|
|
|
|
|
int set_memory_wc(unsigned long addr, int numpages)
|
|
|
@@ -878,8 +933,8 @@ EXPORT_SYMBOL(set_memory_wc);
|
|
|
|
|
|
int _set_memory_wb(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_clear(addr, numpages,
|
|
|
- __pgprot(_PAGE_CACHE_MASK));
|
|
|
+ return change_page_attr_clear(&addr, numpages,
|
|
|
+ __pgprot(_PAGE_CACHE_MASK), 0);
|
|
|
}
|
|
|
|
|
|
int set_memory_wb(unsigned long addr, int numpages)
|
|
|
@@ -890,39 +945,59 @@ int set_memory_wb(unsigned long addr, int numpages)
|
|
|
}
|
|
|
EXPORT_SYMBOL(set_memory_wb);
|
|
|
|
|
|
+int set_memory_array_wb(unsigned long *addr, int addrinarray)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ for (i = 0; i < addrinarray; i++) {
|
|
|
+ unsigned long start = __pa(addr[i]);
|
|
|
+ unsigned long end;
|
|
|
+
|
|
|
+ for (end = start + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
|
|
|
+ if (end != __pa(addr[i + 1]))
|
|
|
+ break;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ free_memtype(start, end);
|
|
|
+ }
|
|
|
+ return change_page_attr_clear(addr, addrinarray,
|
|
|
+ __pgprot(_PAGE_CACHE_MASK), 1);
|
|
|
+}
|
|
|
+EXPORT_SYMBOL(set_memory_array_wb);
|
|
|
+
|
|
|
int set_memory_x(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_NX));
|
|
|
+ return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_NX), 0);
|
|
|
}
|
|
|
EXPORT_SYMBOL(set_memory_x);
|
|
|
|
|
|
int set_memory_nx(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_set(addr, numpages, __pgprot(_PAGE_NX));
|
|
|
+ return change_page_attr_set(&addr, numpages, __pgprot(_PAGE_NX), 0);
|
|
|
}
|
|
|
EXPORT_SYMBOL(set_memory_nx);
|
|
|
|
|
|
int set_memory_ro(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_RW));
|
|
|
+ return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_RW), 0);
|
|
|
}
|
|
|
EXPORT_SYMBOL_GPL(set_memory_ro);
|
|
|
|
|
|
int set_memory_rw(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_set(addr, numpages, __pgprot(_PAGE_RW));
|
|
|
+ return change_page_attr_set(&addr, numpages, __pgprot(_PAGE_RW), 0);
|
|
|
}
|
|
|
EXPORT_SYMBOL_GPL(set_memory_rw);
|
|
|
|
|
|
int set_memory_np(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_PRESENT));
|
|
|
+ return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_PRESENT), 0);
|
|
|
}
|
|
|
|
|
|
int set_memory_4k(unsigned long addr, int numpages)
|
|
|
{
|
|
|
- return change_page_attr_set_clr(addr, numpages, __pgprot(0),
|
|
|
- __pgprot(0), 1);
|
|
|
+ return change_page_attr_set_clr(&addr, numpages, __pgprot(0),
|
|
|
+ __pgprot(0), 1, 0);
|
|
|
}
|
|
|
|
|
|
int set_pages_uc(struct page *page, int numpages)
|
|
|
@@ -975,22 +1050,38 @@ int set_pages_rw(struct page *page, int numpages)
|
|
|
|
|
|
static int __set_pages_p(struct page *page, int numpages)
|
|
|
{
|
|
|
- struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
|
|
|
+ unsigned long tempaddr = (unsigned long) page_address(page);
|
|
|
+ struct cpa_data cpa = { .vaddr = &tempaddr,
|
|
|
.numpages = numpages,
|
|
|
.mask_set = __pgprot(_PAGE_PRESENT | _PAGE_RW),
|
|
|
- .mask_clr = __pgprot(0)};
|
|
|
+ .mask_clr = __pgprot(0),
|
|
|
+ .flags = 0};
|
|
|
|
|
|
- return __change_page_attr_set_clr(&cpa, 1);
|
|
|
+ /*
|
|
|
+ * No alias checking needed for setting present flag. otherwise,
|
|
|
+ * we may need to break large pages for 64-bit kernel text
|
|
|
+ * mappings (this adds to complexity if we want to do this from
|
|
|
+ * atomic context especially). Let's keep it simple!
|
|
|
+ */
|
|
|
+ return __change_page_attr_set_clr(&cpa, 0);
|
|
|
}
|
|
|
|
|
|
static int __set_pages_np(struct page *page, int numpages)
|
|
|
{
|
|
|
- struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
|
|
|
+ unsigned long tempaddr = (unsigned long) page_address(page);
|
|
|
+ struct cpa_data cpa = { .vaddr = &tempaddr,
|
|
|
.numpages = numpages,
|
|
|
.mask_set = __pgprot(0),
|
|
|
- .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW)};
|
|
|
+ .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW),
|
|
|
+ .flags = 0};
|
|
|
|
|
|
- return __change_page_attr_set_clr(&cpa, 1);
|
|
|
+ /*
|
|
|
+ * No alias checking needed for setting not present flag. otherwise,
|
|
|
+ * we may need to break large pages for 64-bit kernel text
|
|
|
+ * mappings (this adds to complexity if we want to do this from
|
|
|
+ * atomic context especially). Let's keep it simple!
|
|
|
+ */
|
|
|
+ return __change_page_attr_set_clr(&cpa, 0);
|
|
|
}
|
|
|
|
|
|
void kernel_map_pages(struct page *page, int numpages, int enable)
|
|
|
@@ -1010,11 +1101,8 @@ void kernel_map_pages(struct page *page, int numpages, int enable)
|
|
|
|
|
|
/*
|
|
|
* The return value is ignored as the calls cannot fail.
|
|
|
- * Large pages are kept enabled at boot time, and are
|
|
|
- * split up quickly with DEBUG_PAGEALLOC. If a splitup
|
|
|
- * fails here (due to temporary memory shortage) no damage
|
|
|
- * is done because we just keep the largepage intact up
|
|
|
- * to the next attempt when it will likely be split up:
|
|
|
+ * Large pages for identity mappings are not used at boot time
|
|
|
+ * and hence no memory allocations during large page split.
|
|
|
*/
|
|
|
if (enable)
|
|
|
__set_pages_p(page, numpages);
|
|
|
@@ -1026,53 +1114,8 @@ void kernel_map_pages(struct page *page, int numpages, int enable)
|
|
|
* but that can deadlock->flush only current cpu:
|
|
|
*/
|
|
|
__flush_tlb_all();
|
|
|
-
|
|
|
- /*
|
|
|
- * Try to refill the page pool here. We can do this only after
|
|
|
- * the tlb flush.
|
|
|
- */
|
|
|
- cpa_fill_pool(NULL);
|
|
|
}
|
|
|
|
|
|
-#ifdef CONFIG_DEBUG_FS
|
|
|
-static int dpa_show(struct seq_file *m, void *v)
|
|
|
-{
|
|
|
- seq_puts(m, "DEBUG_PAGEALLOC\n");
|
|
|
- seq_printf(m, "pool_size : %lu\n", pool_size);
|
|
|
- seq_printf(m, "pool_pages : %lu\n", pool_pages);
|
|
|
- seq_printf(m, "pool_low : %lu\n", pool_low);
|
|
|
- seq_printf(m, "pool_used : %lu\n", pool_used);
|
|
|
- seq_printf(m, "pool_failed : %lu\n", pool_failed);
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int dpa_open(struct inode *inode, struct file *filp)
|
|
|
-{
|
|
|
- return single_open(filp, dpa_show, NULL);
|
|
|
-}
|
|
|
-
|
|
|
-static const struct file_operations dpa_fops = {
|
|
|
- .open = dpa_open,
|
|
|
- .read = seq_read,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-static int __init debug_pagealloc_proc_init(void)
|
|
|
-{
|
|
|
- struct dentry *de;
|
|
|
-
|
|
|
- de = debugfs_create_file("debug_pagealloc", 0600, NULL, NULL,
|
|
|
- &dpa_fops);
|
|
|
- if (!de)
|
|
|
- return -ENOMEM;
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-__initcall(debug_pagealloc_proc_init);
|
|
|
-#endif
|
|
|
-
|
|
|
#ifdef CONFIG_HIBERNATION
|
|
|
|
|
|
bool kernel_page_present(struct page *page)
|
Linus Torvalds