1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/* $Id: fault.c,v 1.9 1997/05/19 05:58:54 davem Exp $
* arch/sparc64/mm/fault.c: Page fault handlers for the 64-bit Sparc.
*
* Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*/
#include <asm/head.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/ptrace.h>
#include <linux/mman.h>
#include <linux/signal.h>
#include <linux/mm.h>
#include <linux/smp_lock.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/uaccess.h>
#define ELEMENTS(arr) (sizeof (arr)/sizeof (arr[0]))
extern struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS];
/* Nice, simple, prom library does all the sweating for us. ;) */
unsigned long prom_probe_memory (void)
{
register struct linux_mlist_p1275 *mlist;
register unsigned long bytes, base_paddr, tally;
register int i;
i = 0;
mlist = *prom_meminfo()->p1275_available;
bytes = tally = mlist->num_bytes;
base_paddr = (unsigned int) mlist->start_adr;
sp_banks[0].base_addr = base_paddr;
sp_banks[0].num_bytes = bytes;
while (mlist->theres_more != (void *) 0){
i++;
mlist = mlist->theres_more;
bytes = mlist->num_bytes;
tally += bytes;
if (i >= SPARC_PHYS_BANKS-1) {
printk ("The machine has more banks than "
"this kernel can support\n"
"Increase the SPARC_PHYS_BANKS "
"setting (currently %d)\n",
SPARC_PHYS_BANKS);
i = SPARC_PHYS_BANKS-1;
break;
}
sp_banks[i].base_addr = (unsigned long) mlist->start_adr;
sp_banks[i].num_bytes = mlist->num_bytes;
}
i++;
sp_banks[i].base_addr = 0xdeadbeef;
sp_banks[i].num_bytes = 0;
/* Now mask all bank sizes on a page boundary, it is all we can
* use anyways.
*/
for(i=0; sp_banks[i].num_bytes != 0; i++)
sp_banks[i].num_bytes &= PAGE_MASK;
return tally;
}
/* Traverse the memory lists in the prom to see how much physical we
* have.
*/
unsigned long
probe_memory(void)
{
unsigned long total;
total = prom_probe_memory();
/* Oh man, much nicer, keep the dirt in promlib. */
return total;
}
void unhandled_fault(unsigned long address, struct task_struct *tsk,
struct pt_regs *regs)
{
if((unsigned long) address < PAGE_SIZE) {
printk(KERN_ALERT "Unable to handle kernel NULL "
"pointer dereference");
} else {
printk(KERN_ALERT "Unable to handle kernel paging request "
"at virtual address %016lx\n", (unsigned long)address);
}
printk(KERN_ALERT "tsk->mm->context = %016lx\n",
(unsigned long) tsk->mm->context);
printk(KERN_ALERT "tsk->mm->pgd = %016lx\n",
(unsigned long) tsk->mm->pgd);
die_if_kernel("Oops", regs);
}
asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
unsigned long address)
{
unsigned long g2;
int i;
unsigned insn;
struct pt_regs regs;
i = search_exception_table (ret_pc, &g2);
switch (i) {
/* load & store will be handled by fixup */
case 3: return 3;
/* store will be handled by fixup, load will bump out */
/* for _to_ macros */
case 1: insn = *(unsigned *)pc; if ((insn >> 21) & 1) return 1; break;
/* load will be handled by fixup, store will bump out */
/* for _from_ macros */
case 2: insn = *(unsigned *)pc;
if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15) return 2;
break;
default: break;
}
memset (®s, 0, sizeof (regs));
regs.tpc = pc;
regs.tnpc = pc + 4;
/* FIXME: Should set up regs->tstate? */
unhandled_fault (address, current, ®s);
/* Not reached */
return 0;
}
/* #define FAULT_TRACER */
asmlinkage void do_sparc64_fault(struct pt_regs *regs, int text_fault, int write,
unsigned long address, unsigned long tag,
unsigned long sfsr)
{
struct vm_area_struct *vma;
struct task_struct *tsk = current;
struct mm_struct *mm = tsk->mm;
unsigned long fixup;
unsigned long g2;
int from_user = !(regs->tstate & TSTATE_PRIV);
#ifdef FAULT_TRACER
static unsigned long last_addr = 0;
static int rcnt = 0;
printk("FAULT(PC[%016lx],t[%d],w[%d],addr[%016lx])\n",
regs->tpc, text_fault, write, address);
if(address == last_addr && rcnt++ > 5) {
printk("Wheee lotsa bogus faults, something wrong, spinning\n");
while(1)
barrier();
} else rcnt = 0;
last_addr = address;
#endif
lock_kernel ();
down(&mm->mmap_sem);
vma = find_vma(mm, address);
if(!vma)
goto bad_area;
if(vma->vm_start <= address)
goto good_area;
if(!(vma->vm_flags & VM_GROWSDOWN))
goto bad_area;
if(expand_stack(vma, address))
goto bad_area;
/*
* Ok, we have a good vm_area for this memory access, so
* we can handle it..
*/
good_area:
if(write) {
if(!(vma->vm_flags & VM_WRITE))
goto bad_area;
} else {
/* Allow reads even for write-only mappings */
if(!(vma->vm_flags & (VM_READ | VM_EXEC)))
goto bad_area;
}
handle_mm_fault(current, vma, address, write);
up(&mm->mmap_sem);
goto out;
/*
* Something tried to access memory that isn't in our memory map..
* Fix it, but check if it's kernel or user first..
*/
bad_area:
up(&mm->mmap_sem);
/* Is this in ex_table? */
g2 = regs->u_regs[UREG_G2];
if (!from_user && (fixup = search_exception_table (regs->tpc, &g2))) {
printk("Exception: PC<%016lx> faddr<%016lx>\n", regs->tpc, address);
printk("EX_TABLE: insn<%016lx> fixup<%016lx> g2<%016lx>\n",
regs->tpc, fixup, g2);
regs->tpc = fixup;
regs->tnpc = regs->tpc + 4;
regs->u_regs[UREG_G2] = g2;
goto out;
}
if(from_user) {
tsk->tss.sig_address = address;
tsk->tss.sig_desc = SUBSIG_NOMAPPING;
send_sig(SIGSEGV, tsk, 1);
goto out;
}
unhandled_fault (address, tsk, regs);
out:
unlock_kernel();
}
|
