1/*
  2 * Based on arch/arm/mm/flush.c
  3 *
  4 * Copyright (C) 1995-2002 Russell King
  5 * Copyright (C) 2012 ARM Ltd.
  6 *
  7 * This program is free software; you can redistribute it and/or modify
  8 * it under the terms of the GNU General Public License version 2 as
  9 * published by the Free Software Foundation.
 10 *
 11 * This program is distributed in the hope that it will be useful,
 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 * GNU General Public License for more details.
 15 *
 16 * You should have received a copy of the GNU General Public License
 17 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 18 */
 19
 20#include <linux/export.h>
 21#include <linux/mm.h>
 22#include <linux/pagemap.h>
 23
 24#include <asm/cacheflush.h>
 25#include <asm/cachetype.h>
 26#include <asm/tlbflush.h>
 27
 28#include "mm.h"
 29
 30void flush_cache_range(struct vm_area_struct *vma, unsigned long start,
 31		       unsigned long end)
 32{
 33	if (vma->vm_flags & VM_EXEC)
 34		__flush_icache_all();
 35}
 36
 37static void sync_icache_aliases(void *kaddr, unsigned long len)
 38{
 39	unsigned long addr = (unsigned long)kaddr;
 40
 41	if (icache_is_aliasing()) {
 42		__clean_dcache_area_pou(kaddr, len);
 43		__flush_icache_all();
 44	} else {
 45		flush_icache_range(addr, addr + len);
 
 
 
 
 46	}
 47}
 48
 49static void flush_ptrace_access(struct vm_area_struct *vma, struct page *page,
 50				unsigned long uaddr, void *kaddr,
 51				unsigned long len)
 52{
 53	if (vma->vm_flags & VM_EXEC)
 54		sync_icache_aliases(kaddr, len);
 55}
 56
 57/*
 58 * Copy user data from/to a page which is mapped into a different processes
 59 * address space.  Really, we want to allow our "user space" model to handle
 60 * this.
 61 */
 62void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
 63		       unsigned long uaddr, void *dst, const void *src,
 64		       unsigned long len)
 65{
 66	memcpy(dst, src, len);
 67	flush_ptrace_access(vma, page, uaddr, dst, len);
 68}
 69
 70void __sync_icache_dcache(pte_t pte, unsigned long addr)
 71{
 72	struct page *page = pte_page(pte);
 73
 74	/* no flushing needed for anonymous pages */
 75	if (!page_mapping(page))
 76		return;
 77
 78	if (!test_and_set_bit(PG_dcache_clean, &page->flags))
 79		sync_icache_aliases(page_address(page),
 80				    PAGE_SIZE << compound_order(page));
 81	else if (icache_is_aivivt())
 82		__flush_icache_all();
 83}
 
 84
 85/*
 86 * This function is called when a page has been modified by the kernel. Mark
 87 * it as dirty for later flushing when mapped in user space (if executable,
 88 * see __sync_icache_dcache).
 89 */
 90void flush_dcache_page(struct page *page)
 91{
 92	if (test_bit(PG_dcache_clean, &page->flags))
 93		clear_bit(PG_dcache_clean, &page->flags);
 94}
 95EXPORT_SYMBOL(flush_dcache_page);
 96
 97/*
 98 * Additional functions defined in assembly.
 99 */
100EXPORT_SYMBOL(flush_icache_range);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 1// SPDX-License-Identifier: GPL-2.0-only
 2/*
 3 * Based on arch/arm/mm/flush.c
 4 *
 5 * Copyright (C) 1995-2002 Russell King
 6 * Copyright (C) 2012 ARM Ltd.
 
 
 
 
 
 
 
 
 
 
 
 
 7 */
 8
 9#include <linux/export.h>
10#include <linux/mm.h>
11#include <linux/pagemap.h>
12
13#include <asm/cacheflush.h>
14#include <asm/cache.h>
15#include <asm/tlbflush.h>
16
17void sync_icache_aliases(unsigned long start, unsigned long end)
 
 
 
 
 
 
 
 
 
18{
 
 
19	if (icache_is_aliasing()) {
20		dcache_clean_pou(start, end);
21		icache_inval_all_pou();
22	} else {
23		/*
24		 * Don't issue kick_all_cpus_sync() after I-cache invalidation
25		 * for user mappings.
26		 */
27		caches_clean_inval_pou(start, end);
28	}
29}
30
31static void flush_ptrace_access(struct vm_area_struct *vma, unsigned long start,
32				unsigned long end)
 
33{
34	if (vma->vm_flags & VM_EXEC)
35		sync_icache_aliases(start, end);
36}
37
38/*
39 * Copy user data from/to a page which is mapped into a different processes
40 * address space.  Really, we want to allow our "user space" model to handle
41 * this.
42 */
43void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
44		       unsigned long uaddr, void *dst, const void *src,
45		       unsigned long len)
46{
47	memcpy(dst, src, len);
48	flush_ptrace_access(vma, (unsigned long)dst, (unsigned long)dst + len);
49}
50
51void __sync_icache_dcache(pte_t pte)
52{
53	struct page *page = pte_page(pte);
54
55	if (!test_bit(PG_dcache_clean, &page->flags)) {
56		sync_icache_aliases((unsigned long)page_address(page),
57				    (unsigned long)page_address(page) +
58					    page_size(page));
59		set_bit(PG_dcache_clean, &page->flags);
60	}
 
 
 
61}
62EXPORT_SYMBOL_GPL(__sync_icache_dcache);
63
64/*
65 * This function is called when a page has been modified by the kernel. Mark
66 * it as dirty for later flushing when mapped in user space (if executable,
67 * see __sync_icache_dcache).
68 */
69void flush_dcache_page(struct page *page)
70{
71	if (test_bit(PG_dcache_clean, &page->flags))
72		clear_bit(PG_dcache_clean, &page->flags);
73}
74EXPORT_SYMBOL(flush_dcache_page);
75
76/*
77 * Additional functions defined in assembly.
78 */
79EXPORT_SYMBOL(caches_clean_inval_pou);
80
81#ifdef CONFIG_ARCH_HAS_PMEM_API
82void arch_wb_cache_pmem(void *addr, size_t size)
83{
84	/* Ensure order against any prior non-cacheable writes */
85	dmb(osh);
86	dcache_clean_pop((unsigned long)addr, (unsigned long)addr + size);
87}
88EXPORT_SYMBOL_GPL(arch_wb_cache_pmem);
89
90void arch_invalidate_pmem(void *addr, size_t size)
91{
92	dcache_inval_poc((unsigned long)addr, (unsigned long)addr + size);
93}
94EXPORT_SYMBOL_GPL(arch_invalidate_pmem);
95#endif