Linux Audio

Check our new training course

Loading...
Note: File does not exist in v6.8.
  1/*
  2 * The SH64 TLB miss.
  3 *
  4 * Original code from fault.c
  5 * Copyright (C) 2000, 2001  Paolo Alberelli
  6 *
  7 * Fast PTE->TLB refill path
  8 * Copyright (C) 2003 Richard.Curnow@superh.com
  9 *
 10 * IMPORTANT NOTES :
 11 * The do_fast_page_fault function is called from a context in entry.S
 12 * where very few registers have been saved.  In particular, the code in
 13 * this file must be compiled not to use ANY caller-save registers that
 14 * are not part of the restricted save set.  Also, it means that code in
 15 * this file must not make calls to functions elsewhere in the kernel, or
 16 * else the excepting context will see corruption in its caller-save
 17 * registers.  Plus, the entry.S save area is non-reentrant, so this code
 18 * has to run with SR.BL==1, i.e. no interrupts taken inside it and panic
 19 * on any exception.
 20 *
 21 * This file is subject to the terms and conditions of the GNU General Public
 22 * License.  See the file "COPYING" in the main directory of this archive
 23 * for more details.
 24 */
 25#include <linux/signal.h>
 26#include <linux/sched.h>
 27#include <linux/kernel.h>
 28#include <linux/errno.h>
 29#include <linux/string.h>
 30#include <linux/types.h>
 31#include <linux/ptrace.h>
 32#include <linux/mman.h>
 33#include <linux/mm.h>
 34#include <linux/smp.h>
 35#include <linux/interrupt.h>
 36#include <linux/kprobes.h>
 37#include <asm/tlb.h>
 38#include <asm/io.h>
 39#include <linux/uaccess.h>
 40#include <asm/pgalloc.h>
 41#include <asm/mmu_context.h>
 42
 43static int handle_tlbmiss(unsigned long long protection_flags,
 44			  unsigned long address)
 45{
 46	pgd_t *pgd;
 47	pud_t *pud;
 48	pmd_t *pmd;
 49	pte_t *pte;
 50	pte_t entry;
 51
 52	if (is_vmalloc_addr((void *)address)) {
 53		pgd = pgd_offset_k(address);
 54	} else {
 55		if (unlikely(address >= TASK_SIZE || !current->mm))
 56			return 1;
 57
 58		pgd = pgd_offset(current->mm, address);
 59	}
 60
 61	pud = pud_offset(pgd, address);
 62	if (pud_none(*pud) || !pud_present(*pud))
 63		return 1;
 64
 65	pmd = pmd_offset(pud, address);
 66	if (pmd_none(*pmd) || !pmd_present(*pmd))
 67		return 1;
 68
 69	pte = pte_offset_kernel(pmd, address);
 70	entry = *pte;
 71	if (pte_none(entry) || !pte_present(entry))
 72		return 1;
 73
 74	/*
 75	 * If the page doesn't have sufficient protection bits set to
 76	 * service the kind of fault being handled, there's not much
 77	 * point doing the TLB refill.  Punt the fault to the general
 78	 * handler.
 79	 */
 80	if ((pte_val(entry) & protection_flags) != protection_flags)
 81		return 1;
 82
 83	update_mmu_cache(NULL, address, pte);
 84
 85	return 0;
 86}
 87
 88/*
 89 * Put all this information into one structure so that everything is just
 90 * arithmetic relative to a single base address.  This reduces the number
 91 * of movi/shori pairs needed just to load addresses of static data.
 92 */
 93struct expevt_lookup {
 94	unsigned short protection_flags[8];
 95	unsigned char  is_text_access[8];
 96	unsigned char  is_write_access[8];
 97};
 98
 99#define PRU (1<<9)
100#define PRW (1<<8)
101#define PRX (1<<7)
102#define PRR (1<<6)
103
104/* Sized as 8 rather than 4 to allow checking the PTE's PRU bit against whether
105   the fault happened in user mode or privileged mode. */
106static struct expevt_lookup expevt_lookup_table = {
107	.protection_flags = {PRX, PRX, 0, 0, PRR, PRR, PRW, PRW},
108	.is_text_access   = {1,   1,   0, 0, 0,   0,   0,   0}
109};
110
111static inline unsigned int
112expevt_to_fault_code(unsigned long expevt)
113{
114	if (expevt == 0xa40)
115		return FAULT_CODE_ITLB;
116	else if (expevt == 0x060)
117		return FAULT_CODE_WRITE;
118
119	return 0;
120}
121
122/*
123   This routine handles page faults that can be serviced just by refilling a
124   TLB entry from an existing page table entry.  (This case represents a very
125   large majority of page faults.) Return 1 if the fault was successfully
126   handled.  Return 0 if the fault could not be handled.  (This leads into the
127   general fault handling in fault.c which deals with mapping file-backed
128   pages, stack growth, segmentation faults, swapping etc etc)
129 */
130asmlinkage int __kprobes
131do_fast_page_fault(unsigned long long ssr_md, unsigned long long expevt,
132		   unsigned long address)
133{
134	unsigned long long protection_flags;
135	unsigned long long index;
136	unsigned long long expevt4;
137	unsigned int fault_code;
138
139	/* The next few lines implement a way of hashing EXPEVT into a
140	 * small array index which can be used to lookup parameters
141	 * specific to the type of TLBMISS being handled.
142	 *
143	 * Note:
144	 *	ITLBMISS has EXPEVT==0xa40
145	 *	RTLBMISS has EXPEVT==0x040
146	 *	WTLBMISS has EXPEVT==0x060
147	 */
148	expevt4 = (expevt >> 4);
149	/* TODO : xor ssr_md into this expression too. Then we can check
150	 * that PRU is set when it needs to be. */
151	index = expevt4 ^ (expevt4 >> 5);
152	index &= 7;
153
154	fault_code = expevt_to_fault_code(expevt);
155
156	protection_flags = expevt_lookup_table.protection_flags[index];
157
158	if (expevt_lookup_table.is_text_access[index])
159		fault_code |= FAULT_CODE_ITLB;
160	if (!ssr_md)
161		fault_code |= FAULT_CODE_USER;
162
163	set_thread_fault_code(fault_code);
164
165	return handle_tlbmiss(protection_flags, address);
166}