2008-10-23 13:26:29 +08:00
|
|
|
#ifndef _ASM_X86_PGTABLE_H
|
|
|
|
#define _ASM_X86_PGTABLE_H
|
2008-01-30 20:32:55 +08:00
|
|
|
|
2009-02-09 18:57:45 +08:00
|
|
|
#include <asm/page.h>
|
x86, pat: Allow ISA memory range uncacheable mapping requests
Max Vozeler reported:
> Bug 13877 - bogl-term broken with CONFIG_X86_PAT=y, works with =n
>
> strace of bogl-term:
> 814 mmap2(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0)
> = -1 EAGAIN (Resource temporarily unavailable)
> 814 write(2, "bogl: mmaping /dev/fb0: Resource temporarily unavailable\n",
> 57) = 57
PAT code maps the ISA memory range as WB in the PAT attribute, so that
fixed range MTRR registers define the actual memory type (UC/WC/WT etc).
But the upper level is_new_memtype_allowed() API checks are failing,
as the request here is for UC and the return tracked type is WB (Tracked type is
WB as MTRR type for this legacy range potentially will be different for each
4k page).
Fix is_new_memtype_allowed() by always succeeding the ISA address range
checks, as the null PAT (WB) and def MTRR fixed range register settings
satisfy the memory type needs of the applications that map the ISA address
range.
Reported-and-Tested-by: Max Vozeler <xam@debian.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2009-08-18 04:23:50 +08:00
|
|
|
#include <asm/e820.h>
|
2009-02-09 18:57:45 +08:00
|
|
|
|
2009-02-09 10:46:18 +08:00
|
|
|
#include <asm/pgtable_types.h>
|
2008-09-24 05:00:36 +08:00
|
|
|
|
2008-12-19 03:41:31 +08:00
|
|
|
/*
|
|
|
|
* Macro to mark a page protection value as UC-
|
|
|
|
*/
|
|
|
|
#define pgprot_noncached(prot) \
|
|
|
|
((boot_cpu_data.x86 > 3) \
|
|
|
|
? (__pgprot(pgprot_val(prot) | _PAGE_CACHE_UC_MINUS)) \
|
|
|
|
: (prot))
|
|
|
|
|
2008-01-30 20:32:56 +08:00
|
|
|
#ifndef __ASSEMBLY__
|
2008-01-30 20:32:58 +08:00
|
|
|
|
2009-11-24 07:12:07 +08:00
|
|
|
#include <asm/x86_init.h>
|
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
/*
|
|
|
|
* ZERO_PAGE is a global shared page that is always zero: used
|
|
|
|
* for zero-mapped memory areas etc..
|
|
|
|
*/
|
2008-03-23 16:03:12 +08:00
|
|
|
extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
|
2008-01-30 20:32:58 +08:00
|
|
|
#define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
|
|
|
|
|
2008-01-30 20:34:11 +08:00
|
|
|
extern spinlock_t pgd_lock;
|
|
|
|
extern struct list_head pgd_list;
|
2008-01-30 20:32:58 +08:00
|
|
|
|
2010-09-22 03:01:51 +08:00
|
|
|
extern struct mm_struct *pgd_page_get_mm(struct page *page);
|
|
|
|
|
2009-02-12 02:20:05 +08:00
|
|
|
#ifdef CONFIG_PARAVIRT
|
|
|
|
#include <asm/paravirt.h>
|
|
|
|
#else /* !CONFIG_PARAVIRT */
|
|
|
|
#define set_pte(ptep, pte) native_set_pte(ptep, pte)
|
|
|
|
#define set_pte_at(mm, addr, ptep, pte) native_set_pte_at(mm, addr, ptep, pte)
|
2011-01-14 07:46:37 +08:00
|
|
|
#define set_pmd_at(mm, addr, pmdp, pmd) native_set_pmd_at(mm, addr, pmdp, pmd)
|
2009-02-12 02:20:05 +08:00
|
|
|
|
|
|
|
#define set_pte_atomic(ptep, pte) \
|
|
|
|
native_set_pte_atomic(ptep, pte)
|
|
|
|
|
|
|
|
#define set_pmd(pmdp, pmd) native_set_pmd(pmdp, pmd)
|
|
|
|
|
|
|
|
#ifndef __PAGETABLE_PUD_FOLDED
|
|
|
|
#define set_pgd(pgdp, pgd) native_set_pgd(pgdp, pgd)
|
|
|
|
#define pgd_clear(pgd) native_pgd_clear(pgd)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef set_pud
|
|
|
|
# define set_pud(pudp, pud) native_set_pud(pudp, pud)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef __PAGETABLE_PMD_FOLDED
|
|
|
|
#define pud_clear(pud) native_pud_clear(pud)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define pte_clear(mm, addr, ptep) native_pte_clear(mm, addr, ptep)
|
|
|
|
#define pmd_clear(pmd) native_pmd_clear(pmd)
|
|
|
|
|
|
|
|
#define pte_update(mm, addr, ptep) do { } while (0)
|
|
|
|
#define pte_update_defer(mm, addr, ptep) do { } while (0)
|
2011-01-14 07:46:37 +08:00
|
|
|
#define pmd_update(mm, addr, ptep) do { } while (0)
|
|
|
|
#define pmd_update_defer(mm, addr, ptep) do { } while (0)
|
2009-02-12 02:20:05 +08:00
|
|
|
|
|
|
|
#define pgd_val(x) native_pgd_val(x)
|
|
|
|
#define __pgd(x) native_make_pgd(x)
|
|
|
|
|
|
|
|
#ifndef __PAGETABLE_PUD_FOLDED
|
|
|
|
#define pud_val(x) native_pud_val(x)
|
|
|
|
#define __pud(x) native_make_pud(x)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef __PAGETABLE_PMD_FOLDED
|
|
|
|
#define pmd_val(x) native_pmd_val(x)
|
|
|
|
#define __pmd(x) native_make_pmd(x)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define pte_val(x) native_pte_val(x)
|
|
|
|
#define __pte(x) native_make_pte(x)
|
|
|
|
|
2009-02-19 03:18:57 +08:00
|
|
|
#define arch_end_context_switch(prev) do {} while(0)
|
|
|
|
|
2009-02-12 02:20:05 +08:00
|
|
|
#endif /* CONFIG_PARAVIRT */
|
|
|
|
|
2008-01-30 20:32:56 +08:00
|
|
|
/*
|
|
|
|
* The following only work if pte_present() is true.
|
|
|
|
* Undefined behaviour if not..
|
|
|
|
*/
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline int pte_dirty(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_DIRTY;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pte_young(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_ACCESSED;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
2011-01-14 07:47:01 +08:00
|
|
|
static inline int pmd_young(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_flags(pmd) & _PAGE_ACCESSED;
|
|
|
|
}
|
|
|
|
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline int pte_write(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_RW;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pte_file(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_FILE;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pte_huge(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_PSE;
|
2008-01-30 20:32:56 +08:00
|
|
|
}
|
|
|
|
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline int pte_global(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return pte_flags(pte) & _PAGE_GLOBAL;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pte_exec(pte_t pte)
|
|
|
|
{
|
2008-05-27 06:31:06 +08:00
|
|
|
return !(pte_flags(pte) & _PAGE_NX);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
mm: introduce pte_special pte bit
s390 for one, cannot implement VM_MIXEDMAP with pfn_valid, due to their memory
model (which is more dynamic than most). Instead, they had proposed to
implement it with an additional path through vm_normal_page(), using a bit in
the pte to determine whether or not the page should be refcounted:
vm_normal_page()
{
...
if (unlikely(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP))) {
if (vma->vm_flags & VM_MIXEDMAP) {
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
#else
if (!pfn_valid(pfn))
return NULL;
#endif
goto out;
}
...
}
This is fine, however if we are allowed to use a bit in the pte to determine
refcountedness, we can use that to _completely_ replace all the vma based
schemes. So instead of adding more cases to the already complex vma-based
scheme, we can have a clearly seperate and simple pte-based scheme (and get
slightly better code generation in the process):
vm_normal_page()
{
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
return pte_page(pte);
#else
...
#endif
}
And finally, we may rather make this concept usable by any architecture rather
than making it s390 only, so implement a new type of pte state for this.
Unfortunately the old vma based code must stay, because some architectures may
not be able to spare pte bits. This makes vm_normal_page a little bit more
ugly than we would like, but the 2 cases are clearly seperate.
So introduce a pte_special pte state, and use it in mm/memory.c. It is
currently a noop for all architectures, so this doesn't actually result in any
compiled code changes to mm/memory.o.
BTW:
I haven't put vm_normal_page() into arch code as-per an earlier suggestion.
The reason is that, regardless of where vm_normal_page is actually
implemented, the *abstraction* is still exactly the same. Also, while it
depends on whether the architecture has pte_special or not, that is the
only two possible cases, and it really isn't an arch specific function --
the role of the arch code should be to provide primitive functions and
accessors with which to build the core code; pte_special does that. We do
not want architectures to know or care about vm_normal_page itself, and
we definitely don't want them being able to invent something new there
out of sight of mm/ code. If we made vm_normal_page an arch function, then
we have to make vm_insert_mixed (next patch) an arch function too. So I
don't think moving it to arch code fundamentally improves any abstractions,
while it does practically make the code more difficult to follow, for both
mm and arch developers, and easier to misuse.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Acked-by: Carsten Otte <cotte@de.ibm.com>
Cc: Jared Hulbert <jaredeh@gmail.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 17:13:00 +08:00
|
|
|
static inline int pte_special(pte_t pte)
|
|
|
|
{
|
2008-09-17 23:48:17 +08:00
|
|
|
return pte_flags(pte) & _PAGE_SPECIAL;
|
mm: introduce pte_special pte bit
s390 for one, cannot implement VM_MIXEDMAP with pfn_valid, due to their memory
model (which is more dynamic than most). Instead, they had proposed to
implement it with an additional path through vm_normal_page(), using a bit in
the pte to determine whether or not the page should be refcounted:
vm_normal_page()
{
...
if (unlikely(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP))) {
if (vma->vm_flags & VM_MIXEDMAP) {
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
#else
if (!pfn_valid(pfn))
return NULL;
#endif
goto out;
}
...
}
This is fine, however if we are allowed to use a bit in the pte to determine
refcountedness, we can use that to _completely_ replace all the vma based
schemes. So instead of adding more cases to the already complex vma-based
scheme, we can have a clearly seperate and simple pte-based scheme (and get
slightly better code generation in the process):
vm_normal_page()
{
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
return pte_page(pte);
#else
...
#endif
}
And finally, we may rather make this concept usable by any architecture rather
than making it s390 only, so implement a new type of pte state for this.
Unfortunately the old vma based code must stay, because some architectures may
not be able to spare pte bits. This makes vm_normal_page a little bit more
ugly than we would like, but the 2 cases are clearly seperate.
So introduce a pte_special pte state, and use it in mm/memory.c. It is
currently a noop for all architectures, so this doesn't actually result in any
compiled code changes to mm/memory.o.
BTW:
I haven't put vm_normal_page() into arch code as-per an earlier suggestion.
The reason is that, regardless of where vm_normal_page is actually
implemented, the *abstraction* is still exactly the same. Also, while it
depends on whether the architecture has pte_special or not, that is the
only two possible cases, and it really isn't an arch specific function --
the role of the arch code should be to provide primitive functions and
accessors with which to build the core code; pte_special does that. We do
not want architectures to know or care about vm_normal_page itself, and
we definitely don't want them being able to invent something new there
out of sight of mm/ code. If we made vm_normal_page an arch function, then
we have to make vm_insert_mixed (next patch) an arch function too. So I
don't think moving it to arch code fundamentally improves any abstractions,
while it does practically make the code more difficult to follow, for both
mm and arch developers, and easier to misuse.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Acked-by: Carsten Otte <cotte@de.ibm.com>
Cc: Jared Hulbert <jaredeh@gmail.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 17:13:00 +08:00
|
|
|
}
|
|
|
|
|
2008-09-09 23:42:45 +08:00
|
|
|
static inline unsigned long pte_pfn(pte_t pte)
|
|
|
|
{
|
|
|
|
return (pte_val(pte) & PTE_PFN_MASK) >> PAGE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2009-06-27 14:35:15 +08:00
|
|
|
static inline unsigned long pmd_pfn(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return (pmd_val(pmd) & PTE_PFN_MASK) >> PAGE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2013-02-11 22:52:36 +08:00
|
|
|
static inline unsigned long pud_pfn(pud_t pud)
|
|
|
|
{
|
|
|
|
return (pud_val(pud) & PTE_PFN_MASK) >> PAGE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2008-09-09 23:42:45 +08:00
|
|
|
#define pte_page(pte) pfn_to_page(pte_pfn(pte))
|
|
|
|
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline int pmd_large(pmd_t pte)
|
|
|
|
{
|
2012-10-09 07:33:27 +08:00
|
|
|
return pmd_flags(pte) & _PAGE_PSE;
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
2011-01-14 07:47:01 +08:00
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
|
|
static inline int pmd_trans_splitting(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_val(pmd) & _PAGE_SPLITTING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pmd_trans_huge(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_val(pmd) & _PAGE_PSE;
|
|
|
|
}
|
2011-01-14 07:47:09 +08:00
|
|
|
|
|
|
|
static inline int has_transparent_hugepage(void)
|
|
|
|
{
|
|
|
|
return cpu_has_pse;
|
|
|
|
}
|
2011-01-14 07:47:01 +08:00
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|
|
|
|
|
2009-01-23 06:24:22 +08:00
|
|
|
static inline pte_t pte_set_flags(pte_t pte, pteval_t set)
|
|
|
|
{
|
|
|
|
pteval_t v = native_pte_val(pte);
|
|
|
|
|
|
|
|
return native_make_pte(v | set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_clear_flags(pte_t pte, pteval_t clear)
|
|
|
|
{
|
|
|
|
pteval_t v = native_pte_val(pte);
|
|
|
|
|
|
|
|
return native_make_pte(v & ~clear);
|
|
|
|
}
|
|
|
|
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline pte_t pte_mkclean(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_DIRTY);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkold(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_ACCESSED);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_wrprotect(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_RW);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkexec(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_NX);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkdirty(pte_t pte)
|
|
|
|
{
|
mm: soft-dirty bits for user memory changes tracking
The soft-dirty is a bit on a PTE which helps to track which pages a task
writes to. In order to do this tracking one should
1. Clear soft-dirty bits from PTEs ("echo 4 > /proc/PID/clear_refs)
2. Wait some time.
3. Read soft-dirty bits (55'th in /proc/PID/pagemap2 entries)
To do this tracking, the writable bit is cleared from PTEs when the
soft-dirty bit is. Thus, after this, when the task tries to modify a
page at some virtual address the #PF occurs and the kernel sets the
soft-dirty bit on the respective PTE.
Note, that although all the task's address space is marked as r/o after
the soft-dirty bits clear, the #PF-s that occur after that are processed
fast. This is so, since the pages are still mapped to physical memory,
and thus all the kernel does is finds this fact out and puts back
writable, dirty and soft-dirty bits on the PTE.
Another thing to note, is that when mremap moves PTEs they are marked
with soft-dirty as well, since from the user perspective mremap modifies
the virtual memory at mremap's new address.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Cc: Matt Mackall <mpm@selenic.com>
Cc: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-04 06:01:20 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkyoung(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_ACCESSED);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkwrite(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_RW);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkhuge(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_PSE);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_clrhuge(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_PSE);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mkglobal(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_GLOBAL);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_clrglobal(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_clear_flags(pte, _PAGE_GLOBAL);
|
2008-03-23 16:03:12 +08:00
|
|
|
}
|
2008-01-30 20:32:56 +08:00
|
|
|
|
mm: introduce pte_special pte bit
s390 for one, cannot implement VM_MIXEDMAP with pfn_valid, due to their memory
model (which is more dynamic than most). Instead, they had proposed to
implement it with an additional path through vm_normal_page(), using a bit in
the pte to determine whether or not the page should be refcounted:
vm_normal_page()
{
...
if (unlikely(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP))) {
if (vma->vm_flags & VM_MIXEDMAP) {
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
#else
if (!pfn_valid(pfn))
return NULL;
#endif
goto out;
}
...
}
This is fine, however if we are allowed to use a bit in the pte to determine
refcountedness, we can use that to _completely_ replace all the vma based
schemes. So instead of adding more cases to the already complex vma-based
scheme, we can have a clearly seperate and simple pte-based scheme (and get
slightly better code generation in the process):
vm_normal_page()
{
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
return pte_page(pte);
#else
...
#endif
}
And finally, we may rather make this concept usable by any architecture rather
than making it s390 only, so implement a new type of pte state for this.
Unfortunately the old vma based code must stay, because some architectures may
not be able to spare pte bits. This makes vm_normal_page a little bit more
ugly than we would like, but the 2 cases are clearly seperate.
So introduce a pte_special pte state, and use it in mm/memory.c. It is
currently a noop for all architectures, so this doesn't actually result in any
compiled code changes to mm/memory.o.
BTW:
I haven't put vm_normal_page() into arch code as-per an earlier suggestion.
The reason is that, regardless of where vm_normal_page is actually
implemented, the *abstraction* is still exactly the same. Also, while it
depends on whether the architecture has pte_special or not, that is the
only two possible cases, and it really isn't an arch specific function --
the role of the arch code should be to provide primitive functions and
accessors with which to build the core code; pte_special does that. We do
not want architectures to know or care about vm_normal_page itself, and
we definitely don't want them being able to invent something new there
out of sight of mm/ code. If we made vm_normal_page an arch function, then
we have to make vm_insert_mixed (next patch) an arch function too. So I
don't think moving it to arch code fundamentally improves any abstractions,
while it does practically make the code more difficult to follow, for both
mm and arch developers, and easier to misuse.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Acked-by: Carsten Otte <cotte@de.ibm.com>
Cc: Jared Hulbert <jaredeh@gmail.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 17:13:00 +08:00
|
|
|
static inline pte_t pte_mkspecial(pte_t pte)
|
|
|
|
{
|
2009-01-23 06:24:22 +08:00
|
|
|
return pte_set_flags(pte, _PAGE_SPECIAL);
|
mm: introduce pte_special pte bit
s390 for one, cannot implement VM_MIXEDMAP with pfn_valid, due to their memory
model (which is more dynamic than most). Instead, they had proposed to
implement it with an additional path through vm_normal_page(), using a bit in
the pte to determine whether or not the page should be refcounted:
vm_normal_page()
{
...
if (unlikely(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP))) {
if (vma->vm_flags & VM_MIXEDMAP) {
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
#else
if (!pfn_valid(pfn))
return NULL;
#endif
goto out;
}
...
}
This is fine, however if we are allowed to use a bit in the pte to determine
refcountedness, we can use that to _completely_ replace all the vma based
schemes. So instead of adding more cases to the already complex vma-based
scheme, we can have a clearly seperate and simple pte-based scheme (and get
slightly better code generation in the process):
vm_normal_page()
{
#ifdef s390
if (!mixedmap_refcount_pte(pte))
return NULL;
return pte_page(pte);
#else
...
#endif
}
And finally, we may rather make this concept usable by any architecture rather
than making it s390 only, so implement a new type of pte state for this.
Unfortunately the old vma based code must stay, because some architectures may
not be able to spare pte bits. This makes vm_normal_page a little bit more
ugly than we would like, but the 2 cases are clearly seperate.
So introduce a pte_special pte state, and use it in mm/memory.c. It is
currently a noop for all architectures, so this doesn't actually result in any
compiled code changes to mm/memory.o.
BTW:
I haven't put vm_normal_page() into arch code as-per an earlier suggestion.
The reason is that, regardless of where vm_normal_page is actually
implemented, the *abstraction* is still exactly the same. Also, while it
depends on whether the architecture has pte_special or not, that is the
only two possible cases, and it really isn't an arch specific function --
the role of the arch code should be to provide primitive functions and
accessors with which to build the core code; pte_special does that. We do
not want architectures to know or care about vm_normal_page itself, and
we definitely don't want them being able to invent something new there
out of sight of mm/ code. If we made vm_normal_page an arch function, then
we have to make vm_insert_mixed (next patch) an arch function too. So I
don't think moving it to arch code fundamentally improves any abstractions,
while it does practically make the code more difficult to follow, for both
mm and arch developers, and easier to misuse.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Acked-by: Carsten Otte <cotte@de.ibm.com>
Cc: Jared Hulbert <jaredeh@gmail.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-04-28 17:13:00 +08:00
|
|
|
}
|
|
|
|
|
2011-01-14 07:47:01 +08:00
|
|
|
static inline pmd_t pmd_set_flags(pmd_t pmd, pmdval_t set)
|
|
|
|
{
|
|
|
|
pmdval_t v = native_pmd_val(pmd);
|
|
|
|
|
|
|
|
return __pmd(v | set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_clear_flags(pmd_t pmd, pmdval_t clear)
|
|
|
|
{
|
|
|
|
pmdval_t v = native_pmd_val(pmd);
|
|
|
|
|
|
|
|
return __pmd(v & ~clear);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mkold(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_clear_flags(pmd, _PAGE_ACCESSED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_wrprotect(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_clear_flags(pmd, _PAGE_RW);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mkdirty(pmd_t pmd)
|
|
|
|
{
|
mm: soft-dirty bits for user memory changes tracking
The soft-dirty is a bit on a PTE which helps to track which pages a task
writes to. In order to do this tracking one should
1. Clear soft-dirty bits from PTEs ("echo 4 > /proc/PID/clear_refs)
2. Wait some time.
3. Read soft-dirty bits (55'th in /proc/PID/pagemap2 entries)
To do this tracking, the writable bit is cleared from PTEs when the
soft-dirty bit is. Thus, after this, when the task tries to modify a
page at some virtual address the #PF occurs and the kernel sets the
soft-dirty bit on the respective PTE.
Note, that although all the task's address space is marked as r/o after
the soft-dirty bits clear, the #PF-s that occur after that are processed
fast. This is so, since the pages are still mapped to physical memory,
and thus all the kernel does is finds this fact out and puts back
writable, dirty and soft-dirty bits on the PTE.
Another thing to note, is that when mremap moves PTEs they are marked
with soft-dirty as well, since from the user perspective mremap modifies
the virtual memory at mremap's new address.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Cc: Matt Mackall <mpm@selenic.com>
Cc: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-04 06:01:20 +08:00
|
|
|
return pmd_set_flags(pmd, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
|
2011-01-14 07:47:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mkhuge(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_set_flags(pmd, _PAGE_PSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mkyoung(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_set_flags(pmd, _PAGE_ACCESSED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mkwrite(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_set_flags(pmd, _PAGE_RW);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mknotpresent(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_clear_flags(pmd, _PAGE_PRESENT);
|
|
|
|
}
|
|
|
|
|
mm: soft-dirty bits for user memory changes tracking
The soft-dirty is a bit on a PTE which helps to track which pages a task
writes to. In order to do this tracking one should
1. Clear soft-dirty bits from PTEs ("echo 4 > /proc/PID/clear_refs)
2. Wait some time.
3. Read soft-dirty bits (55'th in /proc/PID/pagemap2 entries)
To do this tracking, the writable bit is cleared from PTEs when the
soft-dirty bit is. Thus, after this, when the task tries to modify a
page at some virtual address the #PF occurs and the kernel sets the
soft-dirty bit on the respective PTE.
Note, that although all the task's address space is marked as r/o after
the soft-dirty bits clear, the #PF-s that occur after that are processed
fast. This is so, since the pages are still mapped to physical memory,
and thus all the kernel does is finds this fact out and puts back
writable, dirty and soft-dirty bits on the PTE.
Another thing to note, is that when mremap moves PTEs they are marked
with soft-dirty as well, since from the user perspective mremap modifies
the virtual memory at mremap's new address.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Cc: Matt Mackall <mpm@selenic.com>
Cc: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-04 06:01:20 +08:00
|
|
|
static inline int pte_soft_dirty(pte_t pte)
|
|
|
|
{
|
|
|
|
return pte_flags(pte) & _PAGE_SOFT_DIRTY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pmd_soft_dirty(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_flags(pmd) & _PAGE_SOFT_DIRTY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pte_t pte_mksoft_dirty(pte_t pte)
|
|
|
|
{
|
|
|
|
return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pmd_mksoft_dirty(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);
|
|
|
|
}
|
|
|
|
|
2009-02-05 10:33:38 +08:00
|
|
|
/*
|
|
|
|
* Mask out unsupported bits in a present pgprot. Non-present pgprots
|
|
|
|
* can use those bits for other purposes, so leave them be.
|
|
|
|
*/
|
|
|
|
static inline pgprotval_t massage_pgprot(pgprot_t pgprot)
|
|
|
|
{
|
|
|
|
pgprotval_t protval = pgprot_val(pgprot);
|
|
|
|
|
|
|
|
if (protval & _PAGE_PRESENT)
|
|
|
|
protval &= __supported_pte_mask;
|
|
|
|
|
|
|
|
return protval;
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:32:57 +08:00
|
|
|
static inline pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
|
|
|
|
{
|
2009-02-05 10:33:38 +08:00
|
|
|
return __pte(((phys_addr_t)page_nr << PAGE_SHIFT) |
|
|
|
|
massage_pgprot(pgprot));
|
2008-01-30 20:32:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
|
|
|
|
{
|
2009-02-05 10:33:38 +08:00
|
|
|
return __pmd(((phys_addr_t)page_nr << PAGE_SHIFT) |
|
|
|
|
massage_pgprot(pgprot));
|
2008-01-30 20:32:57 +08:00
|
|
|
}
|
|
|
|
|
2008-01-30 20:32:57 +08:00
|
|
|
static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
|
|
|
|
{
|
|
|
|
pteval_t val = pte_val(pte);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Chop off the NX bit (if present), and add the NX portion of
|
|
|
|
* the newprot (if present):
|
|
|
|
*/
|
2008-05-15 07:05:51 +08:00
|
|
|
val &= _PAGE_CHG_MASK;
|
2009-02-05 10:33:38 +08:00
|
|
|
val |= massage_pgprot(newprot) & ~_PAGE_CHG_MASK;
|
2008-01-30 20:32:57 +08:00
|
|
|
|
|
|
|
return __pte(val);
|
|
|
|
}
|
|
|
|
|
2011-01-14 07:47:02 +08:00
|
|
|
static inline pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
|
|
|
|
{
|
|
|
|
pmdval_t val = pmd_val(pmd);
|
|
|
|
|
|
|
|
val &= _HPAGE_CHG_MASK;
|
|
|
|
val |= massage_pgprot(newprot) & ~_HPAGE_CHG_MASK;
|
|
|
|
|
|
|
|
return __pmd(val);
|
|
|
|
}
|
|
|
|
|
2008-05-15 07:05:51 +08:00
|
|
|
/* mprotect needs to preserve PAT bits when updating vm_page_prot */
|
|
|
|
#define pgprot_modify pgprot_modify
|
|
|
|
static inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
|
|
|
|
{
|
|
|
|
pgprotval_t preservebits = pgprot_val(oldprot) & _PAGE_CHG_MASK;
|
|
|
|
pgprotval_t addbits = pgprot_val(newprot);
|
|
|
|
return __pgprot(preservebits | addbits);
|
|
|
|
}
|
|
|
|
|
2008-07-22 13:59:56 +08:00
|
|
|
#define pte_pgprot(x) __pgprot(pte_flags(x) & PTE_FLAGS_MASK)
|
2008-01-30 20:33:51 +08:00
|
|
|
|
2009-02-05 10:33:38 +08:00
|
|
|
#define canon_pgprot(p) __pgprot(massage_pgprot(p))
|
2008-01-30 20:33:53 +08:00
|
|
|
|
x86, pat: Allow ISA memory range uncacheable mapping requests
Max Vozeler reported:
> Bug 13877 - bogl-term broken with CONFIG_X86_PAT=y, works with =n
>
> strace of bogl-term:
> 814 mmap2(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0)
> = -1 EAGAIN (Resource temporarily unavailable)
> 814 write(2, "bogl: mmaping /dev/fb0: Resource temporarily unavailable\n",
> 57) = 57
PAT code maps the ISA memory range as WB in the PAT attribute, so that
fixed range MTRR registers define the actual memory type (UC/WC/WT etc).
But the upper level is_new_memtype_allowed() API checks are failing,
as the request here is for UC and the return tracked type is WB (Tracked type is
WB as MTRR type for this legacy range potentially will be different for each
4k page).
Fix is_new_memtype_allowed() by always succeeding the ISA address range
checks, as the null PAT (WB) and def MTRR fixed range register settings
satisfy the memory type needs of the applications that map the ISA address
range.
Reported-and-Tested-by: Max Vozeler <xam@debian.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2009-08-18 04:23:50 +08:00
|
|
|
static inline int is_new_memtype_allowed(u64 paddr, unsigned long size,
|
|
|
|
unsigned long flags,
|
|
|
|
unsigned long new_flags)
|
2009-01-10 08:13:10 +08:00
|
|
|
{
|
x86, pat: Allow ISA memory range uncacheable mapping requests
Max Vozeler reported:
> Bug 13877 - bogl-term broken with CONFIG_X86_PAT=y, works with =n
>
> strace of bogl-term:
> 814 mmap2(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0)
> = -1 EAGAIN (Resource temporarily unavailable)
> 814 write(2, "bogl: mmaping /dev/fb0: Resource temporarily unavailable\n",
> 57) = 57
PAT code maps the ISA memory range as WB in the PAT attribute, so that
fixed range MTRR registers define the actual memory type (UC/WC/WT etc).
But the upper level is_new_memtype_allowed() API checks are failing,
as the request here is for UC and the return tracked type is WB (Tracked type is
WB as MTRR type for this legacy range potentially will be different for each
4k page).
Fix is_new_memtype_allowed() by always succeeding the ISA address range
checks, as the null PAT (WB) and def MTRR fixed range register settings
satisfy the memory type needs of the applications that map the ISA address
range.
Reported-and-Tested-by: Max Vozeler <xam@debian.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2009-08-18 04:23:50 +08:00
|
|
|
/*
|
2009-11-24 07:12:07 +08:00
|
|
|
* PAT type is always WB for untracked ranges, so no need to check.
|
x86, pat: Allow ISA memory range uncacheable mapping requests
Max Vozeler reported:
> Bug 13877 - bogl-term broken with CONFIG_X86_PAT=y, works with =n
>
> strace of bogl-term:
> 814 mmap2(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0)
> = -1 EAGAIN (Resource temporarily unavailable)
> 814 write(2, "bogl: mmaping /dev/fb0: Resource temporarily unavailable\n",
> 57) = 57
PAT code maps the ISA memory range as WB in the PAT attribute, so that
fixed range MTRR registers define the actual memory type (UC/WC/WT etc).
But the upper level is_new_memtype_allowed() API checks are failing,
as the request here is for UC and the return tracked type is WB (Tracked type is
WB as MTRR type for this legacy range potentially will be different for each
4k page).
Fix is_new_memtype_allowed() by always succeeding the ISA address range
checks, as the null PAT (WB) and def MTRR fixed range register settings
satisfy the memory type needs of the applications that map the ISA address
range.
Reported-and-Tested-by: Max Vozeler <xam@debian.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2009-08-18 04:23:50 +08:00
|
|
|
*/
|
2009-11-24 06:49:20 +08:00
|
|
|
if (x86_platform.is_untracked_pat_range(paddr, paddr + size))
|
x86, pat: Allow ISA memory range uncacheable mapping requests
Max Vozeler reported:
> Bug 13877 - bogl-term broken with CONFIG_X86_PAT=y, works with =n
>
> strace of bogl-term:
> 814 mmap2(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, 4, 0)
> = -1 EAGAIN (Resource temporarily unavailable)
> 814 write(2, "bogl: mmaping /dev/fb0: Resource temporarily unavailable\n",
> 57) = 57
PAT code maps the ISA memory range as WB in the PAT attribute, so that
fixed range MTRR registers define the actual memory type (UC/WC/WT etc).
But the upper level is_new_memtype_allowed() API checks are failing,
as the request here is for UC and the return tracked type is WB (Tracked type is
WB as MTRR type for this legacy range potentially will be different for each
4k page).
Fix is_new_memtype_allowed() by always succeeding the ISA address range
checks, as the null PAT (WB) and def MTRR fixed range register settings
satisfy the memory type needs of the applications that map the ISA address
range.
Reported-and-Tested-by: Max Vozeler <xam@debian.org>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2009-08-18 04:23:50 +08:00
|
|
|
return 1;
|
|
|
|
|
2009-01-10 08:13:10 +08:00
|
|
|
/*
|
|
|
|
* Certain new memtypes are not allowed with certain
|
|
|
|
* requested memtype:
|
|
|
|
* - request is uncached, return cannot be write-back
|
|
|
|
* - request is write-combine, return cannot be write-back
|
|
|
|
*/
|
|
|
|
if ((flags == _PAGE_CACHE_UC_MINUS &&
|
|
|
|
new_flags == _PAGE_CACHE_WB) ||
|
|
|
|
(flags == _PAGE_CACHE_WC &&
|
|
|
|
new_flags == _PAGE_CACHE_WB)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-02-24 10:57:21 +08:00
|
|
|
pmd_t *populate_extra_pmd(unsigned long vaddr);
|
|
|
|
pte_t *populate_extra_pte(unsigned long vaddr);
|
2008-01-30 20:32:56 +08:00
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
2007-10-11 17:20:03 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
2012-10-03 01:01:25 +08:00
|
|
|
# include <asm/pgtable_32.h>
|
2007-10-11 17:20:03 +08:00
|
|
|
#else
|
2012-10-03 01:01:25 +08:00
|
|
|
# include <asm/pgtable_64.h>
|
2007-10-11 17:20:03 +08:00
|
|
|
#endif
|
2008-01-30 20:32:55 +08:00
|
|
|
|
2009-02-06 03:30:54 +08:00
|
|
|
#ifndef __ASSEMBLY__
|
2009-02-06 03:30:55 +08:00
|
|
|
#include <linux/mm_types.h>
|
2013-01-23 05:24:31 +08:00
|
|
|
#include <linux/log2.h>
|
2009-02-06 03:30:54 +08:00
|
|
|
|
2009-02-06 03:30:43 +08:00
|
|
|
static inline int pte_none(pte_t pte)
|
|
|
|
{
|
|
|
|
return !pte.pte;
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:44 +08:00
|
|
|
#define __HAVE_ARCH_PTE_SAME
|
|
|
|
static inline int pte_same(pte_t a, pte_t b)
|
|
|
|
{
|
|
|
|
return a.pte == b.pte;
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:45 +08:00
|
|
|
static inline int pte_present(pte_t a)
|
|
|
|
{
|
2012-10-04 07:50:47 +08:00
|
|
|
return pte_flags(a) & (_PAGE_PRESENT | _PAGE_PROTNONE |
|
|
|
|
_PAGE_NUMA);
|
2009-02-06 03:30:45 +08:00
|
|
|
}
|
|
|
|
|
2012-10-09 21:31:12 +08:00
|
|
|
#define pte_accessible pte_accessible
|
|
|
|
static inline int pte_accessible(pte_t a)
|
|
|
|
{
|
|
|
|
return pte_flags(a) & _PAGE_PRESENT;
|
|
|
|
}
|
|
|
|
|
2009-02-07 05:05:56 +08:00
|
|
|
static inline int pte_hidden(pte_t pte)
|
2008-04-04 06:51:41 +08:00
|
|
|
{
|
2009-02-07 05:05:56 +08:00
|
|
|
return pte_flags(pte) & _PAGE_HIDDEN;
|
2008-04-04 06:51:41 +08:00
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:50 +08:00
|
|
|
static inline int pmd_present(pmd_t pmd)
|
|
|
|
{
|
2012-10-09 07:33:27 +08:00
|
|
|
/*
|
|
|
|
* Checking for _PAGE_PSE is needed too because
|
|
|
|
* split_huge_page will temporarily clear the present bit (but
|
|
|
|
* the _PAGE_PSE flag will remain set at all times while the
|
|
|
|
* _PAGE_PRESENT bit is clear).
|
|
|
|
*/
|
2012-10-04 07:50:47 +08:00
|
|
|
return pmd_flags(pmd) & (_PAGE_PRESENT | _PAGE_PROTNONE | _PAGE_PSE |
|
|
|
|
_PAGE_NUMA);
|
2009-02-06 03:30:50 +08:00
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:51 +08:00
|
|
|
static inline int pmd_none(pmd_t pmd)
|
|
|
|
{
|
|
|
|
/* Only check low word on 32-bit platforms, since it might be
|
|
|
|
out of sync with upper half. */
|
2009-02-06 03:31:17 +08:00
|
|
|
return (unsigned long)native_pmd_val(pmd) == 0;
|
2009-02-06 03:30:51 +08:00
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:59 +08:00
|
|
|
static inline unsigned long pmd_page_vaddr(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return (unsigned long)__va(pmd_val(pmd) & PTE_PFN_MASK);
|
|
|
|
}
|
|
|
|
|
2009-02-09 18:42:57 +08:00
|
|
|
/*
|
|
|
|
* Currently stuck as a macro due to indirect forward reference to
|
|
|
|
* linux/mmzone.h's __section_mem_map_addr() definition:
|
|
|
|
*/
|
2011-01-14 07:46:41 +08:00
|
|
|
#define pmd_page(pmd) pfn_to_page((pmd_val(pmd) & PTE_PFN_MASK) >> PAGE_SHIFT)
|
2009-02-06 03:31:00 +08:00
|
|
|
|
2009-02-06 03:31:01 +08:00
|
|
|
/*
|
|
|
|
* the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
|
|
|
|
*
|
|
|
|
* this macro returns the index of the entry in the pmd page which would
|
|
|
|
* control the given virtual address
|
|
|
|
*/
|
2009-06-28 18:07:39 +08:00
|
|
|
static inline unsigned long pmd_index(unsigned long address)
|
2009-02-06 03:31:01 +08:00
|
|
|
{
|
|
|
|
return (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:31:05 +08:00
|
|
|
/*
|
|
|
|
* Conversion functions: convert a page and protection to a page entry,
|
|
|
|
* and a page entry and page directory to the page they refer to.
|
|
|
|
*
|
|
|
|
* (Currently stuck as a macro because of indirect forward reference
|
|
|
|
* to linux/mm.h:page_to_nid())
|
|
|
|
*/
|
|
|
|
#define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot))
|
|
|
|
|
2009-02-06 03:31:06 +08:00
|
|
|
/*
|
|
|
|
* the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
|
|
|
|
*
|
|
|
|
* this function returns the index of the entry in the pte page which would
|
|
|
|
* control the given virtual address
|
|
|
|
*/
|
2009-06-28 18:07:39 +08:00
|
|
|
static inline unsigned long pte_index(unsigned long address)
|
2009-02-06 03:31:06 +08:00
|
|
|
{
|
|
|
|
return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:31:07 +08:00
|
|
|
static inline pte_t *pte_offset_kernel(pmd_t *pmd, unsigned long address)
|
|
|
|
{
|
|
|
|
return (pte_t *)pmd_page_vaddr(*pmd) + pte_index(address);
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:31:11 +08:00
|
|
|
static inline int pmd_bad(pmd_t pmd)
|
|
|
|
{
|
2012-10-04 07:50:47 +08:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
/* pmd_numa check */
|
|
|
|
if ((pmd_flags(pmd) & (_PAGE_NUMA|_PAGE_PRESENT)) == _PAGE_NUMA)
|
|
|
|
return 0;
|
|
|
|
#endif
|
2009-02-06 03:31:16 +08:00
|
|
|
return (pmd_flags(pmd) & ~_PAGE_USER) != _KERNPG_TABLE;
|
2009-02-06 03:31:11 +08:00
|
|
|
}
|
|
|
|
|
2009-02-06 03:31:12 +08:00
|
|
|
static inline unsigned long pages_to_mb(unsigned long npg)
|
|
|
|
{
|
|
|
|
return npg >> (20 - PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:48 +08:00
|
|
|
#if PAGETABLE_LEVELS > 2
|
2009-02-06 03:31:13 +08:00
|
|
|
static inline int pud_none(pud_t pud)
|
|
|
|
{
|
2009-02-06 03:31:17 +08:00
|
|
|
return native_pud_val(pud) == 0;
|
2009-02-06 03:31:13 +08:00
|
|
|
}
|
|
|
|
|
2009-02-06 03:30:48 +08:00
|
|
|
static inline int pud_present(pud_t pud)
|
|
|
|
{
|
2009-02-06 03:31:16 +08:00
|
|
|
return pud_flags(pud) & _PAGE_PRESENT;
|
2009-02-06 03:30:48 +08:00
|
|
|
}
|
2009-02-06 03:30:53 +08:00
|
|
|
|
|
|
|
static inline unsigned long pud_page_vaddr(pud_t pud)
|
|
|
|
{
|
|
|
|
return (unsigned long)__va((unsigned long)pud_val(pud) & PTE_PFN_MASK);
|
|
|
|
}
|
2009-02-06 03:30:55 +08:00
|
|
|
|
2009-02-09 18:42:57 +08:00
|
|
|
/*
|
|
|
|
* Currently stuck as a macro due to indirect forward reference to
|
|
|
|
* linux/mmzone.h's __section_mem_map_addr() definition:
|
|
|
|
*/
|
|
|
|
#define pud_page(pud) pfn_to_page(pud_val(pud) >> PAGE_SHIFT)
|
2009-02-06 03:31:02 +08:00
|
|
|
|
|
|
|
/* Find an entry in the second-level page table.. */
|
|
|
|
static inline pmd_t *pmd_offset(pud_t *pud, unsigned long address)
|
|
|
|
{
|
|
|
|
return (pmd_t *)pud_page_vaddr(*pud) + pmd_index(address);
|
|
|
|
}
|
2009-02-06 03:31:04 +08:00
|
|
|
|
2009-02-06 03:31:08 +08:00
|
|
|
static inline int pud_large(pud_t pud)
|
|
|
|
{
|
2009-02-09 16:09:52 +08:00
|
|
|
return (pud_val(pud) & (_PAGE_PSE | _PAGE_PRESENT)) ==
|
2009-02-06 03:31:08 +08:00
|
|
|
(_PAGE_PSE | _PAGE_PRESENT);
|
|
|
|
}
|
2009-02-06 03:31:10 +08:00
|
|
|
|
|
|
|
static inline int pud_bad(pud_t pud)
|
|
|
|
{
|
2009-02-06 03:31:16 +08:00
|
|
|
return (pud_flags(pud) & ~(_KERNPG_TABLE | _PAGE_USER)) != 0;
|
2009-02-06 03:31:10 +08:00
|
|
|
}
|
2009-02-09 16:09:52 +08:00
|
|
|
#else
|
|
|
|
static inline int pud_large(pud_t pud)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-02-06 03:30:48 +08:00
|
|
|
#endif /* PAGETABLE_LEVELS > 2 */
|
|
|
|
|
2009-02-06 03:30:49 +08:00
|
|
|
#if PAGETABLE_LEVELS > 3
|
|
|
|
static inline int pgd_present(pgd_t pgd)
|
|
|
|
{
|
2009-02-06 03:31:16 +08:00
|
|
|
return pgd_flags(pgd) & _PAGE_PRESENT;
|
2009-02-06 03:30:49 +08:00
|
|
|
}
|
2009-02-06 03:30:52 +08:00
|
|
|
|
|
|
|
static inline unsigned long pgd_page_vaddr(pgd_t pgd)
|
|
|
|
{
|
|
|
|
return (unsigned long)__va((unsigned long)pgd_val(pgd) & PTE_PFN_MASK);
|
|
|
|
}
|
2009-02-06 03:30:56 +08:00
|
|
|
|
2009-02-09 18:42:57 +08:00
|
|
|
/*
|
|
|
|
* Currently stuck as a macro due to indirect forward reference to
|
|
|
|
* linux/mmzone.h's __section_mem_map_addr() definition:
|
|
|
|
*/
|
|
|
|
#define pgd_page(pgd) pfn_to_page(pgd_val(pgd) >> PAGE_SHIFT)
|
2009-02-06 03:30:57 +08:00
|
|
|
|
|
|
|
/* to find an entry in a page-table-directory. */
|
2009-06-28 18:07:39 +08:00
|
|
|
static inline unsigned long pud_index(unsigned long address)
|
2009-02-06 03:30:57 +08:00
|
|
|
{
|
|
|
|
return (address >> PUD_SHIFT) & (PTRS_PER_PUD - 1);
|
|
|
|
}
|
2009-02-06 03:30:58 +08:00
|
|
|
|
|
|
|
static inline pud_t *pud_offset(pgd_t *pgd, unsigned long address)
|
|
|
|
{
|
|
|
|
return (pud_t *)pgd_page_vaddr(*pgd) + pud_index(address);
|
|
|
|
}
|
2009-02-06 03:31:09 +08:00
|
|
|
|
|
|
|
static inline int pgd_bad(pgd_t pgd)
|
|
|
|
{
|
2009-02-06 03:31:16 +08:00
|
|
|
return (pgd_flags(pgd) & ~_PAGE_USER) != _KERNPG_TABLE;
|
2009-02-06 03:31:09 +08:00
|
|
|
}
|
2009-02-06 03:31:14 +08:00
|
|
|
|
|
|
|
static inline int pgd_none(pgd_t pgd)
|
|
|
|
{
|
2009-02-06 03:31:17 +08:00
|
|
|
return !native_pgd_val(pgd);
|
2009-02-06 03:31:14 +08:00
|
|
|
}
|
2009-02-06 03:30:49 +08:00
|
|
|
#endif /* PAGETABLE_LEVELS > 3 */
|
|
|
|
|
2008-01-30 20:32:56 +08:00
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
2008-06-25 12:19:06 +08:00
|
|
|
/*
|
|
|
|
* the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
|
|
|
|
*
|
|
|
|
* this macro returns the index of the entry in the pgd page which would
|
|
|
|
* control the given virtual address
|
|
|
|
*/
|
|
|
|
#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pgd_offset() returns a (pgd_t *)
|
|
|
|
* pgd_index() is used get the offset into the pgd page's array of pgd_t's;
|
|
|
|
*/
|
|
|
|
#define pgd_offset(mm, address) ((mm)->pgd + pgd_index((address)))
|
|
|
|
/*
|
|
|
|
* a shortcut which implies the use of the kernel's pgd, instead
|
|
|
|
* of a process's
|
|
|
|
*/
|
|
|
|
#define pgd_offset_k(address) pgd_offset(&init_mm, (address))
|
|
|
|
|
|
|
|
|
2008-03-18 07:37:13 +08:00
|
|
|
#define KERNEL_PGD_BOUNDARY pgd_index(PAGE_OFFSET)
|
|
|
|
#define KERNEL_PGD_PTRS (PTRS_PER_PGD - KERNEL_PGD_BOUNDARY)
|
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
2009-04-11 02:33:10 +08:00
|
|
|
extern int direct_gbpages;
|
2012-11-17 11:38:41 +08:00
|
|
|
void init_mem_mapping(void);
|
2012-11-17 11:38:58 +08:00
|
|
|
void early_alloc_pgt_buf(void);
|
2009-04-11 02:33:10 +08:00
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
/* local pte updates need not use xchg for locking */
|
|
|
|
static inline pte_t native_local_ptep_get_and_clear(pte_t *ptep)
|
|
|
|
{
|
|
|
|
pte_t res = *ptep;
|
|
|
|
|
|
|
|
/* Pure native function needs no input for mm, addr */
|
|
|
|
native_pte_clear(NULL, 0, ptep);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-01-14 07:47:01 +08:00
|
|
|
static inline pmd_t native_local_pmdp_get_and_clear(pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
pmd_t res = *pmdp;
|
|
|
|
|
|
|
|
native_pmd_clear(pmdp);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
static inline void native_set_pte_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep , pte_t pte)
|
|
|
|
{
|
|
|
|
native_set_pte(ptep, pte);
|
|
|
|
}
|
|
|
|
|
2011-01-14 07:46:35 +08:00
|
|
|
static inline void native_set_pmd_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pmd_t *pmdp , pmd_t pmd)
|
|
|
|
{
|
|
|
|
native_set_pmd(pmdp, pmd);
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
#ifndef CONFIG_PARAVIRT
|
|
|
|
/*
|
|
|
|
* Rules for using pte_update - it must be called after any PTE update which
|
|
|
|
* has not been done using the set_pte / clear_pte interfaces. It is used by
|
|
|
|
* shadow mode hypervisors to resynchronize the shadow page tables. Kernel PTE
|
|
|
|
* updates should either be sets, clears, or set_pte_atomic for P->P
|
|
|
|
* transitions, which means this hook should only be called for user PTEs.
|
|
|
|
* This hook implies a P->P protection or access change has taken place, which
|
|
|
|
* requires a subsequent TLB flush. The notification can optionally be delayed
|
|
|
|
* until the TLB flush event by using the pte_update_defer form of the
|
|
|
|
* interface, but care must be taken to assure that the flush happens while
|
|
|
|
* still holding the same page table lock so that the shadow and primary pages
|
|
|
|
* do not become out of sync on SMP.
|
|
|
|
*/
|
|
|
|
#define pte_update(mm, addr, ptep) do { } while (0)
|
|
|
|
#define pte_update_defer(mm, addr, ptep) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only update the dirty/accessed state if we set
|
|
|
|
* the dirty bit by hand in the kernel, since the hardware
|
|
|
|
* will do the accessed bit for us, and we don't want to
|
|
|
|
* race with other CPU's that might be updating the dirty
|
|
|
|
* bit at the same time.
|
|
|
|
*/
|
2008-06-25 12:18:57 +08:00
|
|
|
struct vm_area_struct;
|
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
#define __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
|
2008-03-18 07:37:03 +08:00
|
|
|
extern int ptep_set_access_flags(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pte_t *ptep,
|
|
|
|
pte_t entry, int dirty);
|
2008-01-30 20:32:58 +08:00
|
|
|
|
|
|
|
#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
|
2008-03-18 07:37:04 +08:00
|
|
|
extern int ptep_test_and_clear_young(struct vm_area_struct *vma,
|
|
|
|
unsigned long addr, pte_t *ptep);
|
2008-01-30 20:32:58 +08:00
|
|
|
|
|
|
|
#define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
|
2008-03-18 07:37:05 +08:00
|
|
|
extern int ptep_clear_flush_young(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pte_t *ptep);
|
2008-01-30 20:32:58 +08:00
|
|
|
|
|
|
|
#define __HAVE_ARCH_PTEP_GET_AND_CLEAR
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep)
|
2008-01-30 20:32:58 +08:00
|
|
|
{
|
|
|
|
pte_t pte = native_ptep_get_and_clear(ptep);
|
|
|
|
pte_update(mm, addr, ptep);
|
|
|
|
return pte;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULL
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pte_t *ptep,
|
|
|
|
int full)
|
2008-01-30 20:32:58 +08:00
|
|
|
{
|
|
|
|
pte_t pte;
|
|
|
|
if (full) {
|
|
|
|
/*
|
|
|
|
* Full address destruction in progress; paravirt does not
|
|
|
|
* care about updates and native needs no locking
|
|
|
|
*/
|
|
|
|
pte = native_local_ptep_get_and_clear(ptep);
|
|
|
|
} else {
|
|
|
|
pte = ptep_get_and_clear(mm, addr, ptep);
|
|
|
|
}
|
|
|
|
return pte;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PTEP_SET_WRPROTECT
|
2008-03-23 16:03:12 +08:00
|
|
|
static inline void ptep_set_wrprotect(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pte_t *ptep)
|
2008-01-30 20:32:58 +08:00
|
|
|
{
|
2008-01-30 20:32:58 +08:00
|
|
|
clear_bit(_PAGE_BIT_RW, (unsigned long *)&ptep->pte);
|
2008-01-30 20:32:58 +08:00
|
|
|
pte_update(mm, addr, ptep);
|
|
|
|
}
|
|
|
|
|
2011-12-18 08:32:09 +08:00
|
|
|
#define flush_tlb_fix_spurious_fault(vma, address) do { } while (0)
|
x86, mm: Avoid unnecessary TLB flush
In x86, access and dirty bits are set automatically by CPU when CPU accesses
memory. When we go into the code path of below flush_tlb_fix_spurious_fault(),
we already set dirty bit for pte and don't need flush tlb. This might mean
tlb entry in some CPUs hasn't dirty bit set, but this doesn't matter. When
the CPUs do page write, they will automatically check the bit and no software
involved.
On the other hand, flush tlb in below position is harmful. Test creates CPU
number of threads, each thread writes to a same but random address in same vma
range and we measure the total time. Under a 4 socket system, original time is
1.96s, while with the patch, the time is 0.8s. Under a 2 socket system, there is
20% time cut too. perf shows a lot of time are taking to send ipi/handle ipi for
tlb flush.
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
LKML-Reference: <20100816011655.GA362@sli10-desk.sh.intel.com>
Acked-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Andrea Archangeli <aarcange@redhat.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2010-08-16 09:16:55 +08:00
|
|
|
|
2011-01-14 07:47:01 +08:00
|
|
|
#define mk_pmd(page, pgprot) pfn_pmd(page_to_pfn(page), (pgprot))
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_SET_ACCESS_FLAGS
|
|
|
|
extern int pmdp_set_access_flags(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pmd_t *pmdp,
|
|
|
|
pmd_t entry, int dirty);
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_TEST_AND_CLEAR_YOUNG
|
|
|
|
extern int pmdp_test_and_clear_young(struct vm_area_struct *vma,
|
|
|
|
unsigned long addr, pmd_t *pmdp);
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_CLEAR_YOUNG_FLUSH
|
|
|
|
extern int pmdp_clear_flush_young(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pmd_t *pmdp);
|
|
|
|
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_SPLITTING_FLUSH
|
|
|
|
extern void pmdp_splitting_flush(struct vm_area_struct *vma,
|
|
|
|
unsigned long addr, pmd_t *pmdp);
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMD_WRITE
|
|
|
|
static inline int pmd_write(pmd_t pmd)
|
|
|
|
{
|
|
|
|
return pmd_flags(pmd) & _PAGE_RW;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_GET_AND_CLEAR
|
|
|
|
static inline pmd_t pmdp_get_and_clear(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
pmd_t pmd = native_pmdp_get_and_clear(pmdp);
|
|
|
|
pmd_update(mm, addr, pmdp);
|
|
|
|
return pmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define __HAVE_ARCH_PMDP_SET_WRPROTECT
|
|
|
|
static inline void pmdp_set_wrprotect(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
clear_bit(_PAGE_BIT_RW, (unsigned long *)pmdp);
|
|
|
|
pmd_update(mm, addr, pmdp);
|
|
|
|
}
|
|
|
|
|
2008-03-18 07:37:14 +08:00
|
|
|
/*
|
|
|
|
* clone_pgd_range(pgd_t *dst, pgd_t *src, int count);
|
|
|
|
*
|
|
|
|
* dst - pointer to pgd range anwhere on a pgd page
|
|
|
|
* src - ""
|
|
|
|
* count - the number of pgds to copy.
|
|
|
|
*
|
|
|
|
* dst and src can be on the same page, but the range must not overlap,
|
|
|
|
* and must not cross a page boundary.
|
|
|
|
*/
|
|
|
|
static inline void clone_pgd_range(pgd_t *dst, pgd_t *src, int count)
|
|
|
|
{
|
|
|
|
memcpy(dst, src, count * sizeof(pgd_t));
|
|
|
|
}
|
|
|
|
|
2013-01-23 05:24:31 +08:00
|
|
|
#define PTE_SHIFT ilog2(PTRS_PER_PTE)
|
|
|
|
static inline int page_level_shift(enum pg_level level)
|
|
|
|
{
|
|
|
|
return (PAGE_SHIFT - PTE_SHIFT) + level * PTE_SHIFT;
|
|
|
|
}
|
|
|
|
static inline unsigned long page_level_size(enum pg_level level)
|
|
|
|
{
|
|
|
|
return 1UL << page_level_shift(level);
|
|
|
|
}
|
|
|
|
static inline unsigned long page_level_mask(enum pg_level level)
|
|
|
|
{
|
|
|
|
return ~(page_level_size(level) - 1);
|
|
|
|
}
|
2008-03-18 07:37:14 +08:00
|
|
|
|
2012-12-19 04:22:18 +08:00
|
|
|
/*
|
|
|
|
* The x86 doesn't have any external MMU info: the kernel page
|
|
|
|
* tables contain all the necessary information.
|
|
|
|
*/
|
|
|
|
static inline void update_mmu_cache(struct vm_area_struct *vma,
|
|
|
|
unsigned long addr, pte_t *ptep)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static inline void update_mmu_cache_pmd(struct vm_area_struct *vma,
|
|
|
|
unsigned long addr, pmd_t *pmd)
|
|
|
|
{
|
|
|
|
}
|
2008-03-18 07:37:14 +08:00
|
|
|
|
2008-01-30 20:32:58 +08:00
|
|
|
#include <asm-generic/pgtable.h>
|
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
2008-10-23 13:26:29 +08:00
|
|
|
#endif /* _ASM_X86_PGTABLE_H */
|