![Hugh Dickins](/assets/img/avatar_default.png)
There's a worrying function translation_exists in parisc cacheflush.h, unaffected by split ptlock since flush_dcache_page is using it on some other mm, without any relevant lock. Oh well, make it a slightly more robust by factoring the pfn check within it. And it looked liable to confuse a camouflaged swap or file entry with a good pte: fix that too. Signed-off-by: Hugh Dickins <hugh@veritas.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
187 lines
5 KiB
C
187 lines
5 KiB
C
#ifndef _PARISC_CACHEFLUSH_H
|
|
#define _PARISC_CACHEFLUSH_H
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/mm.h>
|
|
#include <asm/cache.h> /* for flush_user_dcache_range_asm() proto */
|
|
|
|
/* The usual comment is "Caches aren't brain-dead on the <architecture>".
|
|
* Unfortunately, that doesn't apply to PA-RISC. */
|
|
|
|
/* Cache flush operations */
|
|
|
|
#ifdef CONFIG_SMP
|
|
#define flush_cache_mm(mm) flush_cache_all()
|
|
#else
|
|
#define flush_cache_mm(mm) flush_cache_all_local()
|
|
#endif
|
|
|
|
#define flush_kernel_dcache_range(start,size) \
|
|
flush_kernel_dcache_range_asm((start), (start)+(size));
|
|
|
|
extern void flush_cache_all_local(void);
|
|
|
|
static inline void cacheflush_h_tmp_function(void *dummy)
|
|
{
|
|
flush_cache_all_local();
|
|
}
|
|
|
|
static inline void flush_cache_all(void)
|
|
{
|
|
on_each_cpu(cacheflush_h_tmp_function, NULL, 1, 1);
|
|
}
|
|
|
|
#define flush_cache_vmap(start, end) flush_cache_all()
|
|
#define flush_cache_vunmap(start, end) flush_cache_all()
|
|
|
|
extern int parisc_cache_flush_threshold;
|
|
void parisc_setup_cache_timing(void);
|
|
|
|
static inline void
|
|
flush_user_dcache_range(unsigned long start, unsigned long end)
|
|
{
|
|
if ((end - start) < parisc_cache_flush_threshold)
|
|
flush_user_dcache_range_asm(start,end);
|
|
else
|
|
flush_data_cache();
|
|
}
|
|
|
|
static inline void
|
|
flush_user_icache_range(unsigned long start, unsigned long end)
|
|
{
|
|
if ((end - start) < parisc_cache_flush_threshold)
|
|
flush_user_icache_range_asm(start,end);
|
|
else
|
|
flush_instruction_cache();
|
|
}
|
|
|
|
extern void flush_dcache_page(struct page *page);
|
|
|
|
#define flush_dcache_mmap_lock(mapping) \
|
|
write_lock_irq(&(mapping)->tree_lock)
|
|
#define flush_dcache_mmap_unlock(mapping) \
|
|
write_unlock_irq(&(mapping)->tree_lock)
|
|
|
|
#define flush_icache_page(vma,page) do { flush_kernel_dcache_page(page_address(page)); flush_kernel_icache_page(page_address(page)); } while (0)
|
|
|
|
#define flush_icache_range(s,e) do { flush_kernel_dcache_range_asm(s,e); flush_kernel_icache_range_asm(s,e); } while (0)
|
|
|
|
#define copy_to_user_page(vma, page, vaddr, dst, src, len) \
|
|
do { \
|
|
flush_cache_page(vma, vaddr, page_to_pfn(page)); \
|
|
memcpy(dst, src, len); \
|
|
flush_kernel_dcache_range_asm((unsigned long)dst, (unsigned long)dst + len); \
|
|
} while (0)
|
|
|
|
#define copy_from_user_page(vma, page, vaddr, dst, src, len) \
|
|
do { \
|
|
flush_cache_page(vma, vaddr, page_to_pfn(page)); \
|
|
memcpy(dst, src, len); \
|
|
} while (0)
|
|
|
|
static inline void flush_cache_range(struct vm_area_struct *vma,
|
|
unsigned long start, unsigned long end)
|
|
{
|
|
int sr3;
|
|
|
|
if (!vma->vm_mm->context) {
|
|
BUG();
|
|
return;
|
|
}
|
|
|
|
sr3 = mfsp(3);
|
|
if (vma->vm_mm->context == sr3) {
|
|
flush_user_dcache_range(start,end);
|
|
flush_user_icache_range(start,end);
|
|
} else {
|
|
flush_cache_all();
|
|
}
|
|
}
|
|
|
|
/* Simple function to work out if we have an existing address translation
|
|
* for a user space vma. */
|
|
static inline int translation_exists(struct vm_area_struct *vma,
|
|
unsigned long addr, unsigned long pfn)
|
|
{
|
|
pgd_t *pgd = pgd_offset(vma->vm_mm, addr);
|
|
pmd_t *pmd;
|
|
pte_t pte;
|
|
|
|
if(pgd_none(*pgd))
|
|
return 0;
|
|
|
|
pmd = pmd_offset(pgd, addr);
|
|
if(pmd_none(*pmd) || pmd_bad(*pmd))
|
|
return 0;
|
|
|
|
/* We cannot take the pte lock here: flush_cache_page is usually
|
|
* called with pte lock already held. Whereas flush_dcache_page
|
|
* takes flush_dcache_mmap_lock, which is lower in the hierarchy:
|
|
* the vma itself is secure, but the pte might come or go racily.
|
|
*/
|
|
pte = *pte_offset_map(pmd, addr);
|
|
/* But pte_unmap() does nothing on this architecture */
|
|
|
|
/* Filter out coincidental file entries and swap entries */
|
|
if (!(pte_val(pte) & (_PAGE_FLUSH|_PAGE_PRESENT)))
|
|
return 0;
|
|
|
|
return pte_pfn(pte) == pfn;
|
|
}
|
|
|
|
/* Private function to flush a page from the cache of a non-current
|
|
* process. cr25 contains the Page Directory of the current user
|
|
* process; we're going to hijack both it and the user space %sr3 to
|
|
* temporarily make the non-current process current. We have to do
|
|
* this because cache flushing may cause a non-access tlb miss which
|
|
* the handlers have to fill in from the pgd of the non-current
|
|
* process. */
|
|
static inline void
|
|
flush_user_cache_page_non_current(struct vm_area_struct *vma,
|
|
unsigned long vmaddr)
|
|
{
|
|
/* save the current process space and pgd */
|
|
unsigned long space = mfsp(3), pgd = mfctl(25);
|
|
|
|
/* we don't mind taking interrups since they may not
|
|
* do anything with user space, but we can't
|
|
* be preempted here */
|
|
preempt_disable();
|
|
|
|
/* make us current */
|
|
mtctl(__pa(vma->vm_mm->pgd), 25);
|
|
mtsp(vma->vm_mm->context, 3);
|
|
|
|
flush_user_dcache_page(vmaddr);
|
|
if(vma->vm_flags & VM_EXEC)
|
|
flush_user_icache_page(vmaddr);
|
|
|
|
/* put the old current process back */
|
|
mtsp(space, 3);
|
|
mtctl(pgd, 25);
|
|
preempt_enable();
|
|
}
|
|
|
|
static inline void
|
|
__flush_cache_page(struct vm_area_struct *vma, unsigned long vmaddr)
|
|
{
|
|
if (likely(vma->vm_mm->context == mfsp(3))) {
|
|
flush_user_dcache_page(vmaddr);
|
|
if (vma->vm_flags & VM_EXEC)
|
|
flush_user_icache_page(vmaddr);
|
|
} else {
|
|
flush_user_cache_page_non_current(vma, vmaddr);
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
flush_cache_page(struct vm_area_struct *vma, unsigned long vmaddr, unsigned long pfn)
|
|
{
|
|
BUG_ON(!vma->vm_mm->context);
|
|
|
|
if (likely(translation_exists(vma, vmaddr, pfn)))
|
|
__flush_cache_page(vma, vmaddr);
|
|
|
|
}
|
|
#endif
|