diff options
Diffstat (limited to 'arch')
-rw-r--r-- | arch/sparc/kernel/setup.c | 2 | ||||
-rw-r--r-- | arch/sparc64/kernel/head.S | 7 | ||||
-rw-r--r-- | arch/sparc64/kernel/ptrace.c | 14 | ||||
-rw-r--r-- | arch/sparc64/kernel/setup.c | 21 | ||||
-rw-r--r-- | arch/sparc64/kernel/sys32.S | 170 | ||||
-rw-r--r-- | arch/sparc64/kernel/traps.c | 60 | ||||
-rw-r--r-- | arch/sparc64/kernel/una_asm.S | 65 | ||||
-rw-r--r-- | arch/sparc64/kernel/unaligned.c | 45 | ||||
-rw-r--r-- | arch/sparc64/lib/strncpy_from_user.S | 16 | ||||
-rw-r--r-- | arch/sparc64/lib/user_fixup.c | 63 | ||||
-rw-r--r-- | arch/sparc64/mm/Makefile | 2 | ||||
-rw-r--r-- | arch/sparc64/mm/extable.c | 80 | ||||
-rw-r--r-- | arch/sparc64/mm/fault.c | 69 | ||||
-rw-r--r-- | arch/sparc64/mm/init.c | 259 | ||||
-rw-r--r-- | arch/sparc64/prom/Makefile | 2 | ||||
-rw-r--r-- | arch/sparc64/prom/init.c | 3 | ||||
-rw-r--r-- | arch/sparc64/prom/memory.c | 152 |
17 files changed, 359 insertions, 671 deletions
diff --git a/arch/sparc/kernel/setup.c b/arch/sparc/kernel/setup.c index 53c192a4982f..3509e4305532 100644 --- a/arch/sparc/kernel/setup.c +++ b/arch/sparc/kernel/setup.c | |||
@@ -249,8 +249,6 @@ struct tt_entry *sparc_ttable; | |||
249 | 249 | ||
250 | struct pt_regs fake_swapper_regs; | 250 | struct pt_regs fake_swapper_regs; |
251 | 251 | ||
252 | extern void paging_init(void); | ||
253 | |||
254 | void __init setup_arch(char **cmdline_p) | 252 | void __init setup_arch(char **cmdline_p) |
255 | { | 253 | { |
256 | int i; | 254 | int i; |
diff --git a/arch/sparc64/kernel/head.S b/arch/sparc64/kernel/head.S index ecc748fb9ad7..89406f9649a9 100644 --- a/arch/sparc64/kernel/head.S +++ b/arch/sparc64/kernel/head.S | |||
@@ -540,8 +540,11 @@ bootup_user_stack_end: | |||
540 | prom_tba: .xword 0 | 540 | prom_tba: .xword 0 |
541 | tlb_type: .word 0 /* Must NOT end up in BSS */ | 541 | tlb_type: .word 0 /* Must NOT end up in BSS */ |
542 | .section ".fixup",#alloc,#execinstr | 542 | .section ".fixup",#alloc,#execinstr |
543 | .globl __ret_efault | 543 | |
544 | .globl __ret_efault, __retl_efault | ||
544 | __ret_efault: | 545 | __ret_efault: |
545 | ret | 546 | ret |
546 | restore %g0, -EFAULT, %o0 | 547 | restore %g0, -EFAULT, %o0 |
547 | 548 | __retl_efault: | |
549 | retl | ||
550 | mov -EFAULT, %o0 | ||
diff --git a/arch/sparc64/kernel/ptrace.c b/arch/sparc64/kernel/ptrace.c index 5efbff90d668..774ecbb8a031 100644 --- a/arch/sparc64/kernel/ptrace.c +++ b/arch/sparc64/kernel/ptrace.c | |||
@@ -31,6 +31,7 @@ | |||
31 | #include <asm/visasm.h> | 31 | #include <asm/visasm.h> |
32 | #include <asm/spitfire.h> | 32 | #include <asm/spitfire.h> |
33 | #include <asm/page.h> | 33 | #include <asm/page.h> |
34 | #include <asm/cpudata.h> | ||
34 | 35 | ||
35 | /* Returning from ptrace is a bit tricky because the syscall return | 36 | /* Returning from ptrace is a bit tricky because the syscall return |
36 | * low level code assumes any value returned which is negative and | 37 | * low level code assumes any value returned which is negative and |
@@ -132,12 +133,16 @@ void flush_ptrace_access(struct vm_area_struct *vma, struct page *page, | |||
132 | if ((uaddr ^ (unsigned long) kaddr) & (1UL << 13)) { | 133 | if ((uaddr ^ (unsigned long) kaddr) & (1UL << 13)) { |
133 | unsigned long start = __pa(kaddr); | 134 | unsigned long start = __pa(kaddr); |
134 | unsigned long end = start + len; | 135 | unsigned long end = start + len; |
136 | unsigned long dcache_line_size; | ||
137 | |||
138 | dcache_line_size = local_cpu_data().dcache_line_size; | ||
135 | 139 | ||
136 | if (tlb_type == spitfire) { | 140 | if (tlb_type == spitfire) { |
137 | for (; start < end; start += 32) | 141 | for (; start < end; start += dcache_line_size) |
138 | spitfire_put_dcache_tag(start & 0x3fe0, 0x0); | 142 | spitfire_put_dcache_tag(start & 0x3fe0, 0x0); |
139 | } else { | 143 | } else { |
140 | for (; start < end; start += 32) | 144 | start &= ~(dcache_line_size - 1); |
145 | for (; start < end; start += dcache_line_size) | ||
141 | __asm__ __volatile__( | 146 | __asm__ __volatile__( |
142 | "stxa %%g0, [%0] %1\n\t" | 147 | "stxa %%g0, [%0] %1\n\t" |
143 | "membar #Sync" | 148 | "membar #Sync" |
@@ -150,8 +155,11 @@ void flush_ptrace_access(struct vm_area_struct *vma, struct page *page, | |||
150 | if (write && tlb_type == spitfire) { | 155 | if (write && tlb_type == spitfire) { |
151 | unsigned long start = (unsigned long) kaddr; | 156 | unsigned long start = (unsigned long) kaddr; |
152 | unsigned long end = start + len; | 157 | unsigned long end = start + len; |
158 | unsigned long icache_line_size; | ||
159 | |||
160 | icache_line_size = local_cpu_data().icache_line_size; | ||
153 | 161 | ||
154 | for (; start < end; start += 32) | 162 | for (; start < end; start += icache_line_size) |
155 | flushi(start); | 163 | flushi(start); |
156 | } | 164 | } |
157 | } | 165 | } |
diff --git a/arch/sparc64/kernel/setup.c b/arch/sparc64/kernel/setup.c index 8e8baf2354df..4c9c8f241748 100644 --- a/arch/sparc64/kernel/setup.c +++ b/arch/sparc64/kernel/setup.c | |||
@@ -464,8 +464,6 @@ static void __init boot_flags_init(char *commands) | |||
464 | } | 464 | } |
465 | } | 465 | } |
466 | 466 | ||
467 | extern int prom_probe_memory(void); | ||
468 | extern unsigned long start, end; | ||
469 | extern void panic_setup(char *, int *); | 467 | extern void panic_setup(char *, int *); |
470 | 468 | ||
471 | extern unsigned short root_flags; | 469 | extern unsigned short root_flags; |
@@ -492,12 +490,8 @@ void register_prom_callbacks(void) | |||
492 | "' linux-.soft2 to .soft2"); | 490 | "' linux-.soft2 to .soft2"); |
493 | } | 491 | } |
494 | 492 | ||
495 | extern void paging_init(void); | ||
496 | |||
497 | void __init setup_arch(char **cmdline_p) | 493 | void __init setup_arch(char **cmdline_p) |
498 | { | 494 | { |
499 | int i; | ||
500 | |||
501 | /* Initialize PROM console and command line. */ | 495 | /* Initialize PROM console and command line. */ |
502 | *cmdline_p = prom_getbootargs(); | 496 | *cmdline_p = prom_getbootargs(); |
503 | strcpy(saved_command_line, *cmdline_p); | 497 | strcpy(saved_command_line, *cmdline_p); |
@@ -516,21 +510,6 @@ void __init setup_arch(char **cmdline_p) | |||
516 | boot_flags_init(*cmdline_p); | 510 | boot_flags_init(*cmdline_p); |
517 | 511 | ||
518 | idprom_init(); | 512 | idprom_init(); |
519 | (void) prom_probe_memory(); | ||
520 | |||
521 | phys_base = 0xffffffffffffffffUL; | ||
522 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { | ||
523 | unsigned long top; | ||
524 | |||
525 | if (sp_banks[i].base_addr < phys_base) | ||
526 | phys_base = sp_banks[i].base_addr; | ||
527 | top = sp_banks[i].base_addr + | ||
528 | sp_banks[i].num_bytes; | ||
529 | } | ||
530 | pfn_base = phys_base >> PAGE_SHIFT; | ||
531 | |||
532 | kern_base = (prom_boot_mapping_phys_low >> 22UL) << 22UL; | ||
533 | kern_size = (unsigned long)&_end - (unsigned long)KERNBASE; | ||
534 | 513 | ||
535 | if (!root_flags) | 514 | if (!root_flags) |
536 | root_mountflags &= ~MS_RDONLY; | 515 | root_mountflags &= ~MS_RDONLY; |
diff --git a/arch/sparc64/kernel/sys32.S b/arch/sparc64/kernel/sys32.S index 5f9e4fae612e..9cd272ac3ac1 100644 --- a/arch/sparc64/kernel/sys32.S +++ b/arch/sparc64/kernel/sys32.S | |||
@@ -157,173 +157,199 @@ sys32_socketcall: /* %o0=call, %o1=args */ | |||
157 | or %g2, %lo(__socketcall_table_begin), %g2 | 157 | or %g2, %lo(__socketcall_table_begin), %g2 |
158 | jmpl %g2 + %o0, %g0 | 158 | jmpl %g2 + %o0, %g0 |
159 | nop | 159 | nop |
160 | do_einval: | ||
161 | retl | ||
162 | mov -EINVAL, %o0 | ||
160 | 163 | ||
161 | /* Each entry is exactly 32 bytes. */ | ||
162 | .align 32 | 164 | .align 32 |
163 | __socketcall_table_begin: | 165 | __socketcall_table_begin: |
166 | |||
167 | /* Each entry is exactly 32 bytes. */ | ||
164 | do_sys_socket: /* sys_socket(int, int, int) */ | 168 | do_sys_socket: /* sys_socket(int, int, int) */ |
165 | ldswa [%o1 + 0x0] %asi, %o0 | 169 | 1: ldswa [%o1 + 0x0] %asi, %o0 |
166 | sethi %hi(sys_socket), %g1 | 170 | sethi %hi(sys_socket), %g1 |
167 | ldswa [%o1 + 0x8] %asi, %o2 | 171 | 2: ldswa [%o1 + 0x8] %asi, %o2 |
168 | jmpl %g1 + %lo(sys_socket), %g0 | 172 | jmpl %g1 + %lo(sys_socket), %g0 |
169 | ldswa [%o1 + 0x4] %asi, %o1 | 173 | 3: ldswa [%o1 + 0x4] %asi, %o1 |
170 | nop | 174 | nop |
171 | nop | 175 | nop |
172 | nop | 176 | nop |
173 | do_sys_bind: /* sys_bind(int fd, struct sockaddr *, int) */ | 177 | do_sys_bind: /* sys_bind(int fd, struct sockaddr *, int) */ |
174 | ldswa [%o1 + 0x0] %asi, %o0 | 178 | 4: ldswa [%o1 + 0x0] %asi, %o0 |
175 | sethi %hi(sys_bind), %g1 | 179 | sethi %hi(sys_bind), %g1 |
176 | ldswa [%o1 + 0x8] %asi, %o2 | 180 | 5: ldswa [%o1 + 0x8] %asi, %o2 |
177 | jmpl %g1 + %lo(sys_bind), %g0 | 181 | jmpl %g1 + %lo(sys_bind), %g0 |
178 | lduwa [%o1 + 0x4] %asi, %o1 | 182 | 6: lduwa [%o1 + 0x4] %asi, %o1 |
179 | nop | 183 | nop |
180 | nop | 184 | nop |
181 | nop | 185 | nop |
182 | do_sys_connect: /* sys_connect(int, struct sockaddr *, int) */ | 186 | do_sys_connect: /* sys_connect(int, struct sockaddr *, int) */ |
183 | ldswa [%o1 + 0x0] %asi, %o0 | 187 | 7: ldswa [%o1 + 0x0] %asi, %o0 |
184 | sethi %hi(sys_connect), %g1 | 188 | sethi %hi(sys_connect), %g1 |
185 | ldswa [%o1 + 0x8] %asi, %o2 | 189 | 8: ldswa [%o1 + 0x8] %asi, %o2 |
186 | jmpl %g1 + %lo(sys_connect), %g0 | 190 | jmpl %g1 + %lo(sys_connect), %g0 |
187 | lduwa [%o1 + 0x4] %asi, %o1 | 191 | 9: lduwa [%o1 + 0x4] %asi, %o1 |
188 | nop | 192 | nop |
189 | nop | 193 | nop |
190 | nop | 194 | nop |
191 | do_sys_listen: /* sys_listen(int, int) */ | 195 | do_sys_listen: /* sys_listen(int, int) */ |
192 | ldswa [%o1 + 0x0] %asi, %o0 | 196 | 10: ldswa [%o1 + 0x0] %asi, %o0 |
193 | sethi %hi(sys_listen), %g1 | 197 | sethi %hi(sys_listen), %g1 |
194 | jmpl %g1 + %lo(sys_listen), %g0 | 198 | jmpl %g1 + %lo(sys_listen), %g0 |
195 | ldswa [%o1 + 0x4] %asi, %o1 | 199 | 11: ldswa [%o1 + 0x4] %asi, %o1 |
196 | nop | 200 | nop |
197 | nop | 201 | nop |
198 | nop | 202 | nop |
199 | nop | 203 | nop |
200 | do_sys_accept: /* sys_accept(int, struct sockaddr *, int *) */ | 204 | do_sys_accept: /* sys_accept(int, struct sockaddr *, int *) */ |
201 | ldswa [%o1 + 0x0] %asi, %o0 | 205 | 12: ldswa [%o1 + 0x0] %asi, %o0 |
202 | sethi %hi(sys_accept), %g1 | 206 | sethi %hi(sys_accept), %g1 |
203 | lduwa [%o1 + 0x8] %asi, %o2 | 207 | 13: lduwa [%o1 + 0x8] %asi, %o2 |
204 | jmpl %g1 + %lo(sys_accept), %g0 | 208 | jmpl %g1 + %lo(sys_accept), %g0 |
205 | lduwa [%o1 + 0x4] %asi, %o1 | 209 | 14: lduwa [%o1 + 0x4] %asi, %o1 |
206 | nop | 210 | nop |
207 | nop | 211 | nop |
208 | nop | 212 | nop |
209 | do_sys_getsockname: /* sys_getsockname(int, struct sockaddr *, int *) */ | 213 | do_sys_getsockname: /* sys_getsockname(int, struct sockaddr *, int *) */ |
210 | ldswa [%o1 + 0x0] %asi, %o0 | 214 | 15: ldswa [%o1 + 0x0] %asi, %o0 |
211 | sethi %hi(sys_getsockname), %g1 | 215 | sethi %hi(sys_getsockname), %g1 |
212 | lduwa [%o1 + 0x8] %asi, %o2 | 216 | 16: lduwa [%o1 + 0x8] %asi, %o2 |
213 | jmpl %g1 + %lo(sys_getsockname), %g0 | 217 | jmpl %g1 + %lo(sys_getsockname), %g0 |
214 | lduwa [%o1 + 0x4] %asi, %o1 | 218 | 17: lduwa [%o1 + 0x4] %asi, %o1 |
215 | nop | 219 | nop |
216 | nop | 220 | nop |
217 | nop | 221 | nop |
218 | do_sys_getpeername: /* sys_getpeername(int, struct sockaddr *, int *) */ | 222 | do_sys_getpeername: /* sys_getpeername(int, struct sockaddr *, int *) */ |
219 | ldswa [%o1 + 0x0] %asi, %o0 | 223 | 18: ldswa [%o1 + 0x0] %asi, %o0 |
220 | sethi %hi(sys_getpeername), %g1 | 224 | sethi %hi(sys_getpeername), %g1 |
221 | lduwa [%o1 + 0x8] %asi, %o2 | 225 | 19: lduwa [%o1 + 0x8] %asi, %o2 |
222 | jmpl %g1 + %lo(sys_getpeername), %g0 | 226 | jmpl %g1 + %lo(sys_getpeername), %g0 |
223 | lduwa [%o1 + 0x4] %asi, %o1 | 227 | 20: lduwa [%o1 + 0x4] %asi, %o1 |
224 | nop | 228 | nop |
225 | nop | 229 | nop |
226 | nop | 230 | nop |
227 | do_sys_socketpair: /* sys_socketpair(int, int, int, int *) */ | 231 | do_sys_socketpair: /* sys_socketpair(int, int, int, int *) */ |
228 | ldswa [%o1 + 0x0] %asi, %o0 | 232 | 21: ldswa [%o1 + 0x0] %asi, %o0 |
229 | sethi %hi(sys_socketpair), %g1 | 233 | sethi %hi(sys_socketpair), %g1 |
230 | ldswa [%o1 + 0x8] %asi, %o2 | 234 | 22: ldswa [%o1 + 0x8] %asi, %o2 |
231 | lduwa [%o1 + 0xc] %asi, %o3 | 235 | 23: lduwa [%o1 + 0xc] %asi, %o3 |
232 | jmpl %g1 + %lo(sys_socketpair), %g0 | 236 | jmpl %g1 + %lo(sys_socketpair), %g0 |
233 | ldswa [%o1 + 0x4] %asi, %o1 | 237 | 24: ldswa [%o1 + 0x4] %asi, %o1 |
234 | nop | 238 | nop |
235 | nop | 239 | nop |
236 | do_sys_send: /* sys_send(int, void *, size_t, unsigned int) */ | 240 | do_sys_send: /* sys_send(int, void *, size_t, unsigned int) */ |
237 | ldswa [%o1 + 0x0] %asi, %o0 | 241 | 25: ldswa [%o1 + 0x0] %asi, %o0 |
238 | sethi %hi(sys_send), %g1 | 242 | sethi %hi(sys_send), %g1 |
239 | lduwa [%o1 + 0x8] %asi, %o2 | 243 | 26: lduwa [%o1 + 0x8] %asi, %o2 |
240 | lduwa [%o1 + 0xc] %asi, %o3 | 244 | 27: lduwa [%o1 + 0xc] %asi, %o3 |
241 | jmpl %g1 + %lo(sys_send), %g0 | 245 | jmpl %g1 + %lo(sys_send), %g0 |
242 | lduwa [%o1 + 0x4] %asi, %o1 | 246 | 28: lduwa [%o1 + 0x4] %asi, %o1 |
243 | nop | 247 | nop |
244 | nop | 248 | nop |
245 | do_sys_recv: /* sys_recv(int, void *, size_t, unsigned int) */ | 249 | do_sys_recv: /* sys_recv(int, void *, size_t, unsigned int) */ |
246 | ldswa [%o1 + 0x0] %asi, %o0 | 250 | 29: ldswa [%o1 + 0x0] %asi, %o0 |
247 | sethi %hi(sys_recv), %g1 | 251 | sethi %hi(sys_recv), %g1 |
248 | lduwa [%o1 + 0x8] %asi, %o2 | 252 | 30: lduwa [%o1 + 0x8] %asi, %o2 |
249 | lduwa [%o1 + 0xc] %asi, %o3 | 253 | 31: lduwa [%o1 + 0xc] %asi, %o3 |
250 | jmpl %g1 + %lo(sys_recv), %g0 | 254 | jmpl %g1 + %lo(sys_recv), %g0 |
251 | lduwa [%o1 + 0x4] %asi, %o1 | 255 | 32: lduwa [%o1 + 0x4] %asi, %o1 |
252 | nop | 256 | nop |
253 | nop | 257 | nop |
254 | do_sys_sendto: /* sys_sendto(int, u32, compat_size_t, unsigned int, u32, int) */ | 258 | do_sys_sendto: /* sys_sendto(int, u32, compat_size_t, unsigned int, u32, int) */ |
255 | ldswa [%o1 + 0x0] %asi, %o0 | 259 | 33: ldswa [%o1 + 0x0] %asi, %o0 |
256 | sethi %hi(sys_sendto), %g1 | 260 | sethi %hi(sys_sendto), %g1 |
257 | lduwa [%o1 + 0x8] %asi, %o2 | 261 | 34: lduwa [%o1 + 0x8] %asi, %o2 |
258 | lduwa [%o1 + 0xc] %asi, %o3 | 262 | 35: lduwa [%o1 + 0xc] %asi, %o3 |
259 | lduwa [%o1 + 0x10] %asi, %o4 | 263 | 36: lduwa [%o1 + 0x10] %asi, %o4 |
260 | ldswa [%o1 + 0x14] %asi, %o5 | 264 | 37: ldswa [%o1 + 0x14] %asi, %o5 |
261 | jmpl %g1 + %lo(sys_sendto), %g0 | 265 | jmpl %g1 + %lo(sys_sendto), %g0 |
262 | lduwa [%o1 + 0x4] %asi, %o1 | 266 | 38: lduwa [%o1 + 0x4] %asi, %o1 |
263 | do_sys_recvfrom: /* sys_recvfrom(int, u32, compat_size_t, unsigned int, u32, u32) */ | 267 | do_sys_recvfrom: /* sys_recvfrom(int, u32, compat_size_t, unsigned int, u32, u32) */ |
264 | ldswa [%o1 + 0x0] %asi, %o0 | 268 | 39: ldswa [%o1 + 0x0] %asi, %o0 |
265 | sethi %hi(sys_recvfrom), %g1 | 269 | sethi %hi(sys_recvfrom), %g1 |
266 | lduwa [%o1 + 0x8] %asi, %o2 | 270 | 40: lduwa [%o1 + 0x8] %asi, %o2 |
267 | lduwa [%o1 + 0xc] %asi, %o3 | 271 | 41: lduwa [%o1 + 0xc] %asi, %o3 |
268 | lduwa [%o1 + 0x10] %asi, %o4 | 272 | 42: lduwa [%o1 + 0x10] %asi, %o4 |
269 | lduwa [%o1 + 0x14] %asi, %o5 | 273 | 43: lduwa [%o1 + 0x14] %asi, %o5 |
270 | jmpl %g1 + %lo(sys_recvfrom), %g0 | 274 | jmpl %g1 + %lo(sys_recvfrom), %g0 |
271 | lduwa [%o1 + 0x4] %asi, %o1 | 275 | 44: lduwa [%o1 + 0x4] %asi, %o1 |
272 | do_sys_shutdown: /* sys_shutdown(int, int) */ | 276 | do_sys_shutdown: /* sys_shutdown(int, int) */ |
273 | ldswa [%o1 + 0x0] %asi, %o0 | 277 | 45: ldswa [%o1 + 0x0] %asi, %o0 |
274 | sethi %hi(sys_shutdown), %g1 | 278 | sethi %hi(sys_shutdown), %g1 |
275 | jmpl %g1 + %lo(sys_shutdown), %g0 | 279 | jmpl %g1 + %lo(sys_shutdown), %g0 |
276 | ldswa [%o1 + 0x4] %asi, %o1 | 280 | 46: ldswa [%o1 + 0x4] %asi, %o1 |
277 | nop | 281 | nop |
278 | nop | 282 | nop |
279 | nop | 283 | nop |
280 | nop | 284 | nop |
281 | do_sys_setsockopt: /* compat_sys_setsockopt(int, int, int, char *, int) */ | 285 | do_sys_setsockopt: /* compat_sys_setsockopt(int, int, int, char *, int) */ |
282 | ldswa [%o1 + 0x0] %asi, %o0 | 286 | 47: ldswa [%o1 + 0x0] %asi, %o0 |
283 | sethi %hi(compat_sys_setsockopt), %g1 | 287 | sethi %hi(compat_sys_setsockopt), %g1 |
284 | ldswa [%o1 + 0x8] %asi, %o2 | 288 | 48: ldswa [%o1 + 0x8] %asi, %o2 |
285 | lduwa [%o1 + 0xc] %asi, %o3 | 289 | 49: lduwa [%o1 + 0xc] %asi, %o3 |
286 | ldswa [%o1 + 0x10] %asi, %o4 | 290 | 50: ldswa [%o1 + 0x10] %asi, %o4 |
287 | jmpl %g1 + %lo(compat_sys_setsockopt), %g0 | 291 | jmpl %g1 + %lo(compat_sys_setsockopt), %g0 |
288 | ldswa [%o1 + 0x4] %asi, %o1 | 292 | 51: ldswa [%o1 + 0x4] %asi, %o1 |
289 | nop | 293 | nop |
290 | do_sys_getsockopt: /* compat_sys_getsockopt(int, int, int, u32, u32) */ | 294 | do_sys_getsockopt: /* compat_sys_getsockopt(int, int, int, u32, u32) */ |
291 | ldswa [%o1 + 0x0] %asi, %o0 | 295 | 52: ldswa [%o1 + 0x0] %asi, %o0 |
292 | sethi %hi(compat_sys_getsockopt), %g1 | 296 | sethi %hi(compat_sys_getsockopt), %g1 |
293 | ldswa [%o1 + 0x8] %asi, %o2 | 297 | 53: ldswa [%o1 + 0x8] %asi, %o2 |
294 | lduwa [%o1 + 0xc] %asi, %o3 | 298 | 54: lduwa [%o1 + 0xc] %asi, %o3 |
295 | lduwa [%o1 + 0x10] %asi, %o4 | 299 | 55: lduwa [%o1 + 0x10] %asi, %o4 |
296 | jmpl %g1 + %lo(compat_sys_getsockopt), %g0 | 300 | jmpl %g1 + %lo(compat_sys_getsockopt), %g0 |
297 | ldswa [%o1 + 0x4] %asi, %o1 | 301 | 56: ldswa [%o1 + 0x4] %asi, %o1 |
298 | nop | 302 | nop |
299 | do_sys_sendmsg: /* compat_sys_sendmsg(int, struct compat_msghdr *, unsigned int) */ | 303 | do_sys_sendmsg: /* compat_sys_sendmsg(int, struct compat_msghdr *, unsigned int) */ |
300 | ldswa [%o1 + 0x0] %asi, %o0 | 304 | 57: ldswa [%o1 + 0x0] %asi, %o0 |
301 | sethi %hi(compat_sys_sendmsg), %g1 | 305 | sethi %hi(compat_sys_sendmsg), %g1 |
302 | lduwa [%o1 + 0x8] %asi, %o2 | 306 | 58: lduwa [%o1 + 0x8] %asi, %o2 |
303 | jmpl %g1 + %lo(compat_sys_sendmsg), %g0 | 307 | jmpl %g1 + %lo(compat_sys_sendmsg), %g0 |
304 | lduwa [%o1 + 0x4] %asi, %o1 | 308 | 59: lduwa [%o1 + 0x4] %asi, %o1 |
305 | nop | 309 | nop |
306 | nop | 310 | nop |
307 | nop | 311 | nop |
308 | do_sys_recvmsg: /* compat_sys_recvmsg(int, struct compat_msghdr *, unsigned int) */ | 312 | do_sys_recvmsg: /* compat_sys_recvmsg(int, struct compat_msghdr *, unsigned int) */ |
309 | ldswa [%o1 + 0x0] %asi, %o0 | 313 | 60: ldswa [%o1 + 0x0] %asi, %o0 |
310 | sethi %hi(compat_sys_recvmsg), %g1 | 314 | sethi %hi(compat_sys_recvmsg), %g1 |
311 | lduwa [%o1 + 0x8] %asi, %o2 | 315 | 61: lduwa [%o1 + 0x8] %asi, %o2 |
312 | jmpl %g1 + %lo(compat_sys_recvmsg), %g0 | 316 | jmpl %g1 + %lo(compat_sys_recvmsg), %g0 |
313 | lduwa [%o1 + 0x4] %asi, %o1 | 317 | 62: lduwa [%o1 + 0x4] %asi, %o1 |
314 | nop | 318 | nop |
315 | nop | 319 | nop |
316 | nop | 320 | nop |
317 | __socketcall_table_end: | ||
318 | |||
319 | do_einval: | ||
320 | retl | ||
321 | mov -EINVAL, %o0 | ||
322 | do_efault: | ||
323 | retl | ||
324 | mov -EFAULT, %o0 | ||
325 | 321 | ||
326 | .section __ex_table | 322 | .section __ex_table |
327 | .align 4 | 323 | .align 4 |
328 | .word __socketcall_table_begin, 0, __socketcall_table_end, do_efault | 324 | .word 1b, __retl_efault, 2b, __retl_efault |
325 | .word 3b, __retl_efault, 4b, __retl_efault | ||
326 | .word 5b, __retl_efault, 6b, __retl_efault | ||
327 | .word 7b, __retl_efault, 8b, __retl_efault | ||
328 | .word 9b, __retl_efault, 10b, __retl_efault | ||
329 | .word 11b, __retl_efault, 12b, __retl_efault | ||
330 | .word 13b, __retl_efault, 14b, __retl_efault | ||
331 | .word 15b, __retl_efault, 16b, __retl_efault | ||
332 | .word 17b, __retl_efault, 18b, __retl_efault | ||
333 | .word 19b, __retl_efault, 20b, __retl_efault | ||
334 | .word 21b, __retl_efault, 22b, __retl_efault | ||
335 | .word 23b, __retl_efault, 24b, __retl_efault | ||
336 | .word 25b, __retl_efault, 26b, __retl_efault | ||
337 | .word 27b, __retl_efault, 28b, __retl_efault | ||
338 | .word 29b, __retl_efault, 30b, __retl_efault | ||
339 | .word 31b, __retl_efault, 32b, __retl_efault | ||
340 | .word 33b, __retl_efault, 34b, __retl_efault | ||
341 | .word 35b, __retl_efault, 36b, __retl_efault | ||
342 | .word 37b, __retl_efault, 38b, __retl_efault | ||
343 | .word 39b, __retl_efault, 40b, __retl_efault | ||
344 | .word 41b, __retl_efault, 42b, __retl_efault | ||
345 | .word 43b, __retl_efault, 44b, __retl_efault | ||
346 | .word 45b, __retl_efault, 46b, __retl_efault | ||
347 | .word 47b, __retl_efault, 48b, __retl_efault | ||
348 | .word 49b, __retl_efault, 50b, __retl_efault | ||
349 | .word 51b, __retl_efault, 52b, __retl_efault | ||
350 | .word 53b, __retl_efault, 54b, __retl_efault | ||
351 | .word 55b, __retl_efault, 56b, __retl_efault | ||
352 | .word 57b, __retl_efault, 58b, __retl_efault | ||
353 | .word 59b, __retl_efault, 60b, __retl_efault | ||
354 | .word 61b, __retl_efault, 62b, __retl_efault | ||
329 | .previous | 355 | .previous |
diff --git a/arch/sparc64/kernel/traps.c b/arch/sparc64/kernel/traps.c index f8e7005fede9..5570e7bb22bb 100644 --- a/arch/sparc64/kernel/traps.c +++ b/arch/sparc64/kernel/traps.c | |||
@@ -189,19 +189,18 @@ void spitfire_data_access_exception(struct pt_regs *regs, unsigned long sfsr, un | |||
189 | 189 | ||
190 | if (regs->tstate & TSTATE_PRIV) { | 190 | if (regs->tstate & TSTATE_PRIV) { |
191 | /* Test if this comes from uaccess places. */ | 191 | /* Test if this comes from uaccess places. */ |
192 | unsigned long fixup; | 192 | const struct exception_table_entry *entry; |
193 | unsigned long g2 = regs->u_regs[UREG_G2]; | ||
194 | 193 | ||
195 | if ((fixup = search_extables_range(regs->tpc, &g2))) { | 194 | entry = search_exception_tables(regs->tpc); |
196 | /* Ouch, somebody is trying ugly VM hole tricks on us... */ | 195 | if (entry) { |
196 | /* Ouch, somebody is trying VM hole tricks on us... */ | ||
197 | #ifdef DEBUG_EXCEPTIONS | 197 | #ifdef DEBUG_EXCEPTIONS |
198 | printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc); | 198 | printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc); |
199 | printk("EX_TABLE: insn<%016lx> fixup<%016lx> " | 199 | printk("EX_TABLE: insn<%016lx> fixup<%016lx>\n", |
200 | "g2<%016lx>\n", regs->tpc, fixup, g2); | 200 | regs->tpc, entry->fixup); |
201 | #endif | 201 | #endif |
202 | regs->tpc = fixup; | 202 | regs->tpc = entry->fixup; |
203 | regs->tnpc = regs->tpc + 4; | 203 | regs->tnpc = regs->tpc + 4; |
204 | regs->u_regs[UREG_G2] = g2; | ||
205 | return; | 204 | return; |
206 | } | 205 | } |
207 | /* Shit... */ | 206 | /* Shit... */ |
@@ -758,26 +757,12 @@ void __init cheetah_ecache_flush_init(void) | |||
758 | ecache_flush_size = (2 * largest_size); | 757 | ecache_flush_size = (2 * largest_size); |
759 | ecache_flush_linesize = smallest_linesize; | 758 | ecache_flush_linesize = smallest_linesize; |
760 | 759 | ||
761 | /* Discover a physically contiguous chunk of physical | 760 | ecache_flush_physbase = find_ecache_flush_span(ecache_flush_size); |
762 | * memory in 'sp_banks' of size ecache_flush_size calculated | ||
763 | * above. Store the physical base of this area at | ||
764 | * ecache_flush_physbase. | ||
765 | */ | ||
766 | for (node = 0; ; node++) { | ||
767 | if (sp_banks[node].num_bytes == 0) | ||
768 | break; | ||
769 | if (sp_banks[node].num_bytes >= ecache_flush_size) { | ||
770 | ecache_flush_physbase = sp_banks[node].base_addr; | ||
771 | break; | ||
772 | } | ||
773 | } | ||
774 | 761 | ||
775 | /* Note: Zero would be a valid value of ecache_flush_physbase so | 762 | if (ecache_flush_physbase == ~0UL) { |
776 | * don't use that as the success test. :-) | ||
777 | */ | ||
778 | if (sp_banks[node].num_bytes == 0) { | ||
779 | prom_printf("cheetah_ecache_flush_init: Cannot find %d byte " | 763 | prom_printf("cheetah_ecache_flush_init: Cannot find %d byte " |
780 | "contiguous physical memory.\n", ecache_flush_size); | 764 | "contiguous physical memory.\n", |
765 | ecache_flush_size); | ||
781 | prom_halt(); | 766 | prom_halt(); |
782 | } | 767 | } |
783 | 768 | ||
@@ -1346,16 +1331,12 @@ static int cheetah_fix_ce(unsigned long physaddr) | |||
1346 | /* Return non-zero if PADDR is a valid physical memory address. */ | 1331 | /* Return non-zero if PADDR is a valid physical memory address. */ |
1347 | static int cheetah_check_main_memory(unsigned long paddr) | 1332 | static int cheetah_check_main_memory(unsigned long paddr) |
1348 | { | 1333 | { |
1349 | int i; | 1334 | unsigned long vaddr = PAGE_OFFSET + paddr; |
1350 | 1335 | ||
1351 | for (i = 0; ; i++) { | 1336 | if (vaddr > (unsigned long) high_memory) |
1352 | if (sp_banks[i].num_bytes == 0) | 1337 | return 0; |
1353 | break; | 1338 | |
1354 | if (paddr >= sp_banks[i].base_addr && | 1339 | return kern_addr_valid(vaddr); |
1355 | paddr < (sp_banks[i].base_addr + sp_banks[i].num_bytes)) | ||
1356 | return 1; | ||
1357 | } | ||
1358 | return 0; | ||
1359 | } | 1340 | } |
1360 | 1341 | ||
1361 | void cheetah_cee_handler(struct pt_regs *regs, unsigned long afsr, unsigned long afar) | 1342 | void cheetah_cee_handler(struct pt_regs *regs, unsigned long afsr, unsigned long afar) |
@@ -1610,10 +1591,10 @@ void cheetah_deferred_handler(struct pt_regs *regs, unsigned long afsr, unsigned | |||
1610 | /* OK, usermode access. */ | 1591 | /* OK, usermode access. */ |
1611 | recoverable = 1; | 1592 | recoverable = 1; |
1612 | } else { | 1593 | } else { |
1613 | unsigned long g2 = regs->u_regs[UREG_G2]; | 1594 | const struct exception_table_entry *entry; |
1614 | unsigned long fixup = search_extables_range(regs->tpc, &g2); | ||
1615 | 1595 | ||
1616 | if (fixup != 0UL) { | 1596 | entry = search_exception_tables(regs->tpc); |
1597 | if (entry) { | ||
1617 | /* OK, kernel access to userspace. */ | 1598 | /* OK, kernel access to userspace. */ |
1618 | recoverable = 1; | 1599 | recoverable = 1; |
1619 | 1600 | ||
@@ -1632,9 +1613,8 @@ void cheetah_deferred_handler(struct pt_regs *regs, unsigned long afsr, unsigned | |||
1632 | * recoverable condition. | 1613 | * recoverable condition. |
1633 | */ | 1614 | */ |
1634 | if (recoverable) { | 1615 | if (recoverable) { |
1635 | regs->tpc = fixup; | 1616 | regs->tpc = entry->fixup; |
1636 | regs->tnpc = regs->tpc + 4; | 1617 | regs->tnpc = regs->tpc + 4; |
1637 | regs->u_regs[UREG_G2] = g2; | ||
1638 | } | 1618 | } |
1639 | } | 1619 | } |
1640 | } | 1620 | } |
diff --git a/arch/sparc64/kernel/una_asm.S b/arch/sparc64/kernel/una_asm.S index da48400bcc95..1f5b5b708ce7 100644 --- a/arch/sparc64/kernel/una_asm.S +++ b/arch/sparc64/kernel/una_asm.S | |||
@@ -6,13 +6,6 @@ | |||
6 | 6 | ||
7 | .text | 7 | .text |
8 | 8 | ||
9 | kernel_unaligned_trap_fault: | ||
10 | call kernel_mna_trap_fault | ||
11 | nop | ||
12 | retl | ||
13 | nop | ||
14 | .size kern_unaligned_trap_fault, .-kern_unaligned_trap_fault | ||
15 | |||
16 | .globl __do_int_store | 9 | .globl __do_int_store |
17 | __do_int_store: | 10 | __do_int_store: |
18 | rd %asi, %o4 | 11 | rd %asi, %o4 |
@@ -51,24 +44,24 @@ __do_int_store: | |||
51 | 0: | 44 | 0: |
52 | wr %o4, 0x0, %asi | 45 | wr %o4, 0x0, %asi |
53 | retl | 46 | retl |
54 | nop | 47 | mov 0, %o0 |
55 | .size __do_int_store, .-__do_int_store | 48 | .size __do_int_store, .-__do_int_store |
56 | 49 | ||
57 | .section __ex_table | 50 | .section __ex_table |
58 | .word 4b, kernel_unaligned_trap_fault | 51 | .word 4b, __retl_efault |
59 | .word 5b, kernel_unaligned_trap_fault | 52 | .word 5b, __retl_efault |
60 | .word 6b, kernel_unaligned_trap_fault | 53 | .word 6b, __retl_efault |
61 | .word 7b, kernel_unaligned_trap_fault | 54 | .word 7b, __retl_efault |
62 | .word 8b, kernel_unaligned_trap_fault | 55 | .word 8b, __retl_efault |
63 | .word 9b, kernel_unaligned_trap_fault | 56 | .word 9b, __retl_efault |
64 | .word 10b, kernel_unaligned_trap_fault | 57 | .word 10b, __retl_efault |
65 | .word 11b, kernel_unaligned_trap_fault | 58 | .word 11b, __retl_efault |
66 | .word 12b, kernel_unaligned_trap_fault | 59 | .word 12b, __retl_efault |
67 | .word 13b, kernel_unaligned_trap_fault | 60 | .word 13b, __retl_efault |
68 | .word 14b, kernel_unaligned_trap_fault | 61 | .word 14b, __retl_efault |
69 | .word 15b, kernel_unaligned_trap_fault | 62 | .word 15b, __retl_efault |
70 | .word 16b, kernel_unaligned_trap_fault | 63 | .word 16b, __retl_efault |
71 | .word 17b, kernel_unaligned_trap_fault | 64 | .word 17b, __retl_efault |
72 | .previous | 65 | .previous |
73 | 66 | ||
74 | .globl do_int_load | 67 | .globl do_int_load |
@@ -133,21 +126,21 @@ do_int_load: | |||
133 | 0: | 126 | 0: |
134 | wr %o5, 0x0, %asi | 127 | wr %o5, 0x0, %asi |
135 | retl | 128 | retl |
136 | nop | 129 | mov 0, %o0 |
137 | .size __do_int_load, .-__do_int_load | 130 | .size __do_int_load, .-__do_int_load |
138 | 131 | ||
139 | .section __ex_table | 132 | .section __ex_table |
140 | .word 4b, kernel_unaligned_trap_fault | 133 | .word 4b, __retl_efault |
141 | .word 5b, kernel_unaligned_trap_fault | 134 | .word 5b, __retl_efault |
142 | .word 6b, kernel_unaligned_trap_fault | 135 | .word 6b, __retl_efault |
143 | .word 7b, kernel_unaligned_trap_fault | 136 | .word 7b, __retl_efault |
144 | .word 8b, kernel_unaligned_trap_fault | 137 | .word 8b, __retl_efault |
145 | .word 9b, kernel_unaligned_trap_fault | 138 | .word 9b, __retl_efault |
146 | .word 10b, kernel_unaligned_trap_fault | 139 | .word 10b, __retl_efault |
147 | .word 11b, kernel_unaligned_trap_fault | 140 | .word 11b, __retl_efault |
148 | .word 12b, kernel_unaligned_trap_fault | 141 | .word 12b, __retl_efault |
149 | .word 13b, kernel_unaligned_trap_fault | 142 | .word 13b, __retl_efault |
150 | .word 14b, kernel_unaligned_trap_fault | 143 | .word 14b, __retl_efault |
151 | .word 15b, kernel_unaligned_trap_fault | 144 | .word 15b, __retl_efault |
152 | .word 16b, kernel_unaligned_trap_fault | 145 | .word 16b, __retl_efault |
153 | .previous | 146 | .previous |
diff --git a/arch/sparc64/kernel/unaligned.c b/arch/sparc64/kernel/unaligned.c index 02af08ffec8f..70faf630603b 100644 --- a/arch/sparc64/kernel/unaligned.c +++ b/arch/sparc64/kernel/unaligned.c | |||
@@ -180,14 +180,14 @@ static void __attribute_used__ unaligned_panic(char *str, struct pt_regs *regs) | |||
180 | die_if_kernel(str, regs); | 180 | die_if_kernel(str, regs); |
181 | } | 181 | } |
182 | 182 | ||
183 | extern void do_int_load(unsigned long *dest_reg, int size, | 183 | extern int do_int_load(unsigned long *dest_reg, int size, |
184 | unsigned long *saddr, int is_signed, int asi); | 184 | unsigned long *saddr, int is_signed, int asi); |
185 | 185 | ||
186 | extern void __do_int_store(unsigned long *dst_addr, int size, | 186 | extern int __do_int_store(unsigned long *dst_addr, int size, |
187 | unsigned long src_val, int asi); | 187 | unsigned long src_val, int asi); |
188 | 188 | ||
189 | static inline void do_int_store(int reg_num, int size, unsigned long *dst_addr, | 189 | static inline int do_int_store(int reg_num, int size, unsigned long *dst_addr, |
190 | struct pt_regs *regs, int asi, int orig_asi) | 190 | struct pt_regs *regs, int asi, int orig_asi) |
191 | { | 191 | { |
192 | unsigned long zero = 0; | 192 | unsigned long zero = 0; |
193 | unsigned long *src_val_p = &zero; | 193 | unsigned long *src_val_p = &zero; |
@@ -219,7 +219,7 @@ static inline void do_int_store(int reg_num, int size, unsigned long *dst_addr, | |||
219 | break; | 219 | break; |
220 | }; | 220 | }; |
221 | } | 221 | } |
222 | __do_int_store(dst_addr, size, src_val, asi); | 222 | return __do_int_store(dst_addr, size, src_val, asi); |
223 | } | 223 | } |
224 | 224 | ||
225 | static inline void advance(struct pt_regs *regs) | 225 | static inline void advance(struct pt_regs *regs) |
@@ -242,14 +242,14 @@ static inline int ok_for_kernel(unsigned int insn) | |||
242 | return !floating_point_load_or_store_p(insn); | 242 | return !floating_point_load_or_store_p(insn); |
243 | } | 243 | } |
244 | 244 | ||
245 | void kernel_mna_trap_fault(void) | 245 | static void kernel_mna_trap_fault(void) |
246 | { | 246 | { |
247 | struct pt_regs *regs = current_thread_info()->kern_una_regs; | 247 | struct pt_regs *regs = current_thread_info()->kern_una_regs; |
248 | unsigned int insn = current_thread_info()->kern_una_insn; | 248 | unsigned int insn = current_thread_info()->kern_una_insn; |
249 | unsigned long g2 = regs->u_regs[UREG_G2]; | 249 | const struct exception_table_entry *entry; |
250 | unsigned long fixup = search_extables_range(regs->tpc, &g2); | ||
251 | 250 | ||
252 | if (!fixup) { | 251 | entry = search_exception_tables(regs->tpc); |
252 | if (!entry) { | ||
253 | unsigned long address; | 253 | unsigned long address; |
254 | 254 | ||
255 | address = compute_effective_address(regs, insn, | 255 | address = compute_effective_address(regs, insn, |
@@ -270,9 +270,8 @@ void kernel_mna_trap_fault(void) | |||
270 | die_if_kernel("Oops", regs); | 270 | die_if_kernel("Oops", regs); |
271 | /* Not reached */ | 271 | /* Not reached */ |
272 | } | 272 | } |
273 | regs->tpc = fixup; | 273 | regs->tpc = entry->fixup; |
274 | regs->tnpc = regs->tpc + 4; | 274 | regs->tnpc = regs->tpc + 4; |
275 | regs->u_regs [UREG_G2] = g2; | ||
276 | 275 | ||
277 | regs->tstate &= ~TSTATE_ASI; | 276 | regs->tstate &= ~TSTATE_ASI; |
278 | regs->tstate |= (ASI_AIUS << 24UL); | 277 | regs->tstate |= (ASI_AIUS << 24UL); |
@@ -295,7 +294,7 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn, u | |||
295 | kernel_mna_trap_fault(); | 294 | kernel_mna_trap_fault(); |
296 | } else { | 295 | } else { |
297 | unsigned long addr, *reg_addr; | 296 | unsigned long addr, *reg_addr; |
298 | int orig_asi, asi; | 297 | int orig_asi, asi, err; |
299 | 298 | ||
300 | addr = compute_effective_address(regs, insn, | 299 | addr = compute_effective_address(regs, insn, |
301 | ((insn >> 25) & 0x1f)); | 300 | ((insn >> 25) & 0x1f)); |
@@ -320,9 +319,10 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn, u | |||
320 | switch (dir) { | 319 | switch (dir) { |
321 | case load: | 320 | case load: |
322 | reg_addr = fetch_reg_addr(((insn>>25)&0x1f), regs); | 321 | reg_addr = fetch_reg_addr(((insn>>25)&0x1f), regs); |
323 | do_int_load(reg_addr, size, (unsigned long *) addr, | 322 | err = do_int_load(reg_addr, size, |
324 | decode_signedness(insn), asi); | 323 | (unsigned long *) addr, |
325 | if (unlikely(asi != orig_asi)) { | 324 | decode_signedness(insn), asi); |
325 | if (likely(!err) && unlikely(asi != orig_asi)) { | ||
326 | unsigned long val_in = *reg_addr; | 326 | unsigned long val_in = *reg_addr; |
327 | switch (size) { | 327 | switch (size) { |
328 | case 2: | 328 | case 2: |
@@ -344,16 +344,19 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn, u | |||
344 | break; | 344 | break; |
345 | 345 | ||
346 | case store: | 346 | case store: |
347 | do_int_store(((insn>>25)&0x1f), size, | 347 | err = do_int_store(((insn>>25)&0x1f), size, |
348 | (unsigned long *) addr, regs, | 348 | (unsigned long *) addr, regs, |
349 | asi, orig_asi); | 349 | asi, orig_asi); |
350 | break; | 350 | break; |
351 | 351 | ||
352 | default: | 352 | default: |
353 | panic("Impossible kernel unaligned trap."); | 353 | panic("Impossible kernel unaligned trap."); |
354 | /* Not reached... */ | 354 | /* Not reached... */ |
355 | } | 355 | } |
356 | advance(regs); | 356 | if (unlikely(err)) |
357 | kernel_mna_trap_fault(); | ||
358 | else | ||
359 | advance(regs); | ||
357 | } | 360 | } |
358 | } | 361 | } |
359 | 362 | ||
diff --git a/arch/sparc64/lib/strncpy_from_user.S b/arch/sparc64/lib/strncpy_from_user.S index 09cbbaa0ebf4..e1264650ca7a 100644 --- a/arch/sparc64/lib/strncpy_from_user.S +++ b/arch/sparc64/lib/strncpy_from_user.S | |||
@@ -125,15 +125,11 @@ __strncpy_from_user: | |||
125 | add %o2, %o3, %o0 | 125 | add %o2, %o3, %o0 |
126 | .size __strncpy_from_user, .-__strncpy_from_user | 126 | .size __strncpy_from_user, .-__strncpy_from_user |
127 | 127 | ||
128 | .section .fixup,#alloc,#execinstr | ||
129 | .align 4 | ||
130 | 4: retl | ||
131 | mov -EFAULT, %o0 | ||
132 | |||
133 | .section __ex_table,#alloc | 128 | .section __ex_table,#alloc |
134 | .align 4 | 129 | .align 4 |
135 | .word 60b, 4b | 130 | .word 60b, __retl_efault |
136 | .word 61b, 4b | 131 | .word 61b, __retl_efault |
137 | .word 62b, 4b | 132 | .word 62b, __retl_efault |
138 | .word 63b, 4b | 133 | .word 63b, __retl_efault |
139 | .word 64b, 4b | 134 | .word 64b, __retl_efault |
135 | .previous | ||
diff --git a/arch/sparc64/lib/user_fixup.c b/arch/sparc64/lib/user_fixup.c index 0278e34125db..19d1fdb17d0e 100644 --- a/arch/sparc64/lib/user_fixup.c +++ b/arch/sparc64/lib/user_fixup.c | |||
@@ -11,61 +11,56 @@ | |||
11 | 11 | ||
12 | /* Calculating the exact fault address when using | 12 | /* Calculating the exact fault address when using |
13 | * block loads and stores can be very complicated. | 13 | * block loads and stores can be very complicated. |
14 | * | ||
14 | * Instead of trying to be clever and handling all | 15 | * Instead of trying to be clever and handling all |
15 | * of the cases, just fix things up simply here. | 16 | * of the cases, just fix things up simply here. |
16 | */ | 17 | */ |
17 | 18 | ||
18 | unsigned long copy_from_user_fixup(void *to, const void __user *from, unsigned long size) | 19 | static unsigned long compute_size(unsigned long start, unsigned long size, unsigned long *offset) |
19 | { | 20 | { |
20 | char *dst = to; | 21 | unsigned long fault_addr = current_thread_info()->fault_address; |
21 | const char __user *src = from; | 22 | unsigned long end = start + size; |
22 | 23 | ||
23 | while (size) { | 24 | if (fault_addr < start || fault_addr >= end) { |
24 | if (__get_user(*dst, src)) | 25 | *offset = 0; |
25 | break; | 26 | } else { |
26 | dst++; | 27 | *offset = start - fault_addr; |
27 | src++; | 28 | size = end - fault_addr; |
28 | size--; | ||
29 | } | 29 | } |
30 | return size; | ||
31 | } | ||
30 | 32 | ||
31 | if (size) | 33 | unsigned long copy_from_user_fixup(void *to, const void __user *from, unsigned long size) |
32 | memset(dst, 0, size); | 34 | { |
35 | unsigned long offset; | ||
36 | |||
37 | size = compute_size((unsigned long) from, size, &offset); | ||
38 | if (likely(size)) | ||
39 | memset(to + offset, 0, size); | ||
33 | 40 | ||
34 | return size; | 41 | return size; |
35 | } | 42 | } |
36 | 43 | ||
37 | unsigned long copy_to_user_fixup(void __user *to, const void *from, unsigned long size) | 44 | unsigned long copy_to_user_fixup(void __user *to, const void *from, unsigned long size) |
38 | { | 45 | { |
39 | char __user *dst = to; | 46 | unsigned long offset; |
40 | const char *src = from; | ||
41 | |||
42 | while (size) { | ||
43 | if (__put_user(*src, dst)) | ||
44 | break; | ||
45 | dst++; | ||
46 | src++; | ||
47 | size--; | ||
48 | } | ||
49 | 47 | ||
50 | return size; | 48 | return compute_size((unsigned long) to, size, &offset); |
51 | } | 49 | } |
52 | 50 | ||
53 | unsigned long copy_in_user_fixup(void __user *to, void __user *from, unsigned long size) | 51 | unsigned long copy_in_user_fixup(void __user *to, void __user *from, unsigned long size) |
54 | { | 52 | { |
55 | char __user *dst = to; | 53 | unsigned long fault_addr = current_thread_info()->fault_address; |
56 | char __user *src = from; | 54 | unsigned long start = (unsigned long) to; |
55 | unsigned long end = start + size; | ||
57 | 56 | ||
58 | while (size) { | 57 | if (fault_addr >= start && fault_addr < end) |
59 | char tmp; | 58 | return end - fault_addr; |
60 | 59 | ||
61 | if (__get_user(tmp, src)) | 60 | start = (unsigned long) from; |
62 | break; | 61 | end = start + size; |
63 | if (__put_user(tmp, dst)) | 62 | if (fault_addr >= start && fault_addr < end) |
64 | break; | 63 | return end - fault_addr; |
65 | dst++; | ||
66 | src++; | ||
67 | size--; | ||
68 | } | ||
69 | 64 | ||
70 | return size; | 65 | return size; |
71 | } | 66 | } |
diff --git a/arch/sparc64/mm/Makefile b/arch/sparc64/mm/Makefile index cda87333a77b..9d0960e69f48 100644 --- a/arch/sparc64/mm/Makefile +++ b/arch/sparc64/mm/Makefile | |||
@@ -5,6 +5,6 @@ | |||
5 | EXTRA_AFLAGS := -ansi | 5 | EXTRA_AFLAGS := -ansi |
6 | EXTRA_CFLAGS := -Werror | 6 | EXTRA_CFLAGS := -Werror |
7 | 7 | ||
8 | obj-y := ultra.o tlb.o fault.o init.o generic.o extable.o | 8 | obj-y := ultra.o tlb.o fault.o init.o generic.o |
9 | 9 | ||
10 | obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o | 10 | obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o |
diff --git a/arch/sparc64/mm/extable.c b/arch/sparc64/mm/extable.c deleted file mode 100644 index ec334297ff4f..000000000000 --- a/arch/sparc64/mm/extable.c +++ /dev/null | |||
@@ -1,80 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sparc64/mm/extable.c | ||
3 | */ | ||
4 | |||
5 | #include <linux/config.h> | ||
6 | #include <linux/module.h> | ||
7 | #include <asm/uaccess.h> | ||
8 | |||
9 | extern const struct exception_table_entry __start___ex_table[]; | ||
10 | extern const struct exception_table_entry __stop___ex_table[]; | ||
11 | |||
12 | void sort_extable(struct exception_table_entry *start, | ||
13 | struct exception_table_entry *finish) | ||
14 | { | ||
15 | } | ||
16 | |||
17 | /* Caller knows they are in a range if ret->fixup == 0 */ | ||
18 | const struct exception_table_entry * | ||
19 | search_extable(const struct exception_table_entry *start, | ||
20 | const struct exception_table_entry *last, | ||
21 | unsigned long value) | ||
22 | { | ||
23 | const struct exception_table_entry *walk; | ||
24 | |||
25 | /* Single insn entries are encoded as: | ||
26 | * word 1: insn address | ||
27 | * word 2: fixup code address | ||
28 | * | ||
29 | * Range entries are encoded as: | ||
30 | * word 1: first insn address | ||
31 | * word 2: 0 | ||
32 | * word 3: last insn address + 4 bytes | ||
33 | * word 4: fixup code address | ||
34 | * | ||
35 | * See asm/uaccess.h for more details. | ||
36 | */ | ||
37 | |||
38 | /* 1. Try to find an exact match. */ | ||
39 | for (walk = start; walk <= last; walk++) { | ||
40 | if (walk->fixup == 0) { | ||
41 | /* A range entry, skip both parts. */ | ||
42 | walk++; | ||
43 | continue; | ||
44 | } | ||
45 | |||
46 | if (walk->insn == value) | ||
47 | return walk; | ||
48 | } | ||
49 | |||
50 | /* 2. Try to find a range match. */ | ||
51 | for (walk = start; walk <= (last - 1); walk++) { | ||
52 | if (walk->fixup) | ||
53 | continue; | ||
54 | |||
55 | if (walk[0].insn <= value && walk[1].insn > value) | ||
56 | return walk; | ||
57 | |||
58 | walk++; | ||
59 | } | ||
60 | |||
61 | return NULL; | ||
62 | } | ||
63 | |||
64 | /* Special extable search, which handles ranges. Returns fixup */ | ||
65 | unsigned long search_extables_range(unsigned long addr, unsigned long *g2) | ||
66 | { | ||
67 | const struct exception_table_entry *entry; | ||
68 | |||
69 | entry = search_exception_tables(addr); | ||
70 | if (!entry) | ||
71 | return 0; | ||
72 | |||
73 | /* Inside range? Fix g2 and return correct fixup */ | ||
74 | if (!entry->fixup) { | ||
75 | *g2 = (addr - entry->insn) / 4; | ||
76 | return (entry + 1)->fixup; | ||
77 | } | ||
78 | |||
79 | return entry->fixup; | ||
80 | } | ||
diff --git a/arch/sparc64/mm/fault.c b/arch/sparc64/mm/fault.c index db1e3310e907..31fbc67719a1 100644 --- a/arch/sparc64/mm/fault.c +++ b/arch/sparc64/mm/fault.c | |||
@@ -32,8 +32,6 @@ | |||
32 | 32 | ||
33 | #define ELEMENTS(arr) (sizeof (arr)/sizeof (arr[0])) | 33 | #define ELEMENTS(arr) (sizeof (arr)/sizeof (arr[0])) |
34 | 34 | ||
35 | extern struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS]; | ||
36 | |||
37 | /* | 35 | /* |
38 | * To debug kernel to catch accesses to certain virtual/physical addresses. | 36 | * To debug kernel to catch accesses to certain virtual/physical addresses. |
39 | * Mode = 0 selects physical watchpoints, mode = 1 selects virtual watchpoints. | 37 | * Mode = 0 selects physical watchpoints, mode = 1 selects virtual watchpoints. |
@@ -71,53 +69,6 @@ void set_brkpt(unsigned long addr, unsigned char mask, int flags, int mode) | |||
71 | : "memory"); | 69 | : "memory"); |
72 | } | 70 | } |
73 | 71 | ||
74 | /* Nice, simple, prom library does all the sweating for us. ;) */ | ||
75 | unsigned long __init prom_probe_memory (void) | ||
76 | { | ||
77 | register struct linux_mlist_p1275 *mlist; | ||
78 | register unsigned long bytes, base_paddr, tally; | ||
79 | register int i; | ||
80 | |||
81 | i = 0; | ||
82 | mlist = *prom_meminfo()->p1275_available; | ||
83 | bytes = tally = mlist->num_bytes; | ||
84 | base_paddr = mlist->start_adr; | ||
85 | |||
86 | sp_banks[0].base_addr = base_paddr; | ||
87 | sp_banks[0].num_bytes = bytes; | ||
88 | |||
89 | while (mlist->theres_more != (void *) 0) { | ||
90 | i++; | ||
91 | mlist = mlist->theres_more; | ||
92 | bytes = mlist->num_bytes; | ||
93 | tally += bytes; | ||
94 | if (i >= SPARC_PHYS_BANKS-1) { | ||
95 | printk ("The machine has more banks than " | ||
96 | "this kernel can support\n" | ||
97 | "Increase the SPARC_PHYS_BANKS " | ||
98 | "setting (currently %d)\n", | ||
99 | SPARC_PHYS_BANKS); | ||
100 | i = SPARC_PHYS_BANKS-1; | ||
101 | break; | ||
102 | } | ||
103 | |||
104 | sp_banks[i].base_addr = mlist->start_adr; | ||
105 | sp_banks[i].num_bytes = mlist->num_bytes; | ||
106 | } | ||
107 | |||
108 | i++; | ||
109 | sp_banks[i].base_addr = 0xdeadbeefbeefdeadUL; | ||
110 | sp_banks[i].num_bytes = 0; | ||
111 | |||
112 | /* Now mask all bank sizes on a page boundary, it is all we can | ||
113 | * use anyways. | ||
114 | */ | ||
115 | for (i = 0; sp_banks[i].num_bytes != 0; i++) | ||
116 | sp_banks[i].num_bytes &= PAGE_MASK; | ||
117 | |||
118 | return tally; | ||
119 | } | ||
120 | |||
121 | static void __kprobes unhandled_fault(unsigned long address, | 72 | static void __kprobes unhandled_fault(unsigned long address, |
122 | struct task_struct *tsk, | 73 | struct task_struct *tsk, |
123 | struct pt_regs *regs) | 74 | struct pt_regs *regs) |
@@ -242,7 +193,6 @@ static unsigned int get_fault_insn(struct pt_regs *regs, unsigned int insn) | |||
242 | static void do_kernel_fault(struct pt_regs *regs, int si_code, int fault_code, | 193 | static void do_kernel_fault(struct pt_regs *regs, int si_code, int fault_code, |
243 | unsigned int insn, unsigned long address) | 194 | unsigned int insn, unsigned long address) |
244 | { | 195 | { |
245 | unsigned long g2; | ||
246 | unsigned char asi = ASI_P; | 196 | unsigned char asi = ASI_P; |
247 | 197 | ||
248 | if ((!insn) && (regs->tstate & TSTATE_PRIV)) | 198 | if ((!insn) && (regs->tstate & TSTATE_PRIV)) |
@@ -273,11 +223,9 @@ static void do_kernel_fault(struct pt_regs *regs, int si_code, int fault_code, | |||
273 | } | 223 | } |
274 | } | 224 | } |
275 | 225 | ||
276 | g2 = regs->u_regs[UREG_G2]; | ||
277 | |||
278 | /* Is this in ex_table? */ | 226 | /* Is this in ex_table? */ |
279 | if (regs->tstate & TSTATE_PRIV) { | 227 | if (regs->tstate & TSTATE_PRIV) { |
280 | unsigned long fixup; | 228 | const struct exception_table_entry *entry; |
281 | 229 | ||
282 | if (asi == ASI_P && (insn & 0xc0800000) == 0xc0800000) { | 230 | if (asi == ASI_P && (insn & 0xc0800000) == 0xc0800000) { |
283 | if (insn & 0x2000) | 231 | if (insn & 0x2000) |
@@ -288,10 +236,9 @@ static void do_kernel_fault(struct pt_regs *regs, int si_code, int fault_code, | |||
288 | 236 | ||
289 | /* Look in asi.h: All _S asis have LS bit set */ | 237 | /* Look in asi.h: All _S asis have LS bit set */ |
290 | if ((asi & 0x1) && | 238 | if ((asi & 0x1) && |
291 | (fixup = search_extables_range(regs->tpc, &g2))) { | 239 | (entry = search_exception_tables(regs->tpc))) { |
292 | regs->tpc = fixup; | 240 | regs->tpc = entry->fixup; |
293 | regs->tnpc = regs->tpc + 4; | 241 | regs->tnpc = regs->tpc + 4; |
294 | regs->u_regs[UREG_G2] = g2; | ||
295 | return; | 242 | return; |
296 | } | 243 | } |
297 | } else { | 244 | } else { |
@@ -461,7 +408,7 @@ good_area: | |||
461 | } | 408 | } |
462 | 409 | ||
463 | up_read(&mm->mmap_sem); | 410 | up_read(&mm->mmap_sem); |
464 | goto fault_done; | 411 | return; |
465 | 412 | ||
466 | /* | 413 | /* |
467 | * Something tried to access memory that isn't in our memory map.. | 414 | * Something tried to access memory that isn't in our memory map.. |
@@ -473,8 +420,7 @@ bad_area: | |||
473 | 420 | ||
474 | handle_kernel_fault: | 421 | handle_kernel_fault: |
475 | do_kernel_fault(regs, si_code, fault_code, insn, address); | 422 | do_kernel_fault(regs, si_code, fault_code, insn, address); |
476 | 423 | return; | |
477 | goto fault_done; | ||
478 | 424 | ||
479 | /* | 425 | /* |
480 | * We ran out of memory, or some other thing happened to us that made | 426 | * We ran out of memory, or some other thing happened to us that made |
@@ -505,9 +451,4 @@ do_sigbus: | |||
505 | /* Kernel mode? Handle exceptions or die */ | 451 | /* Kernel mode? Handle exceptions or die */ |
506 | if (regs->tstate & TSTATE_PRIV) | 452 | if (regs->tstate & TSTATE_PRIV) |
507 | goto handle_kernel_fault; | 453 | goto handle_kernel_fault; |
508 | |||
509 | fault_done: | ||
510 | /* These values are no longer needed, clear them. */ | ||
511 | set_thread_fault_code(0); | ||
512 | current_thread_info()->fault_address = 0; | ||
513 | } | 454 | } |
diff --git a/arch/sparc64/mm/init.c b/arch/sparc64/mm/init.c index 9f6ca624892d..5db50524f20d 100644 --- a/arch/sparc64/mm/init.c +++ b/arch/sparc64/mm/init.c | |||
@@ -21,6 +21,7 @@ | |||
21 | #include <linux/seq_file.h> | 21 | #include <linux/seq_file.h> |
22 | #include <linux/kprobes.h> | 22 | #include <linux/kprobes.h> |
23 | #include <linux/cache.h> | 23 | #include <linux/cache.h> |
24 | #include <linux/sort.h> | ||
24 | 25 | ||
25 | #include <asm/head.h> | 26 | #include <asm/head.h> |
26 | #include <asm/system.h> | 27 | #include <asm/system.h> |
@@ -41,7 +42,72 @@ | |||
41 | 42 | ||
42 | extern void device_scan(void); | 43 | extern void device_scan(void); |
43 | 44 | ||
44 | struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS]; | 45 | #define MAX_BANKS 32 |
46 | |||
47 | static struct linux_prom64_registers pavail[MAX_BANKS] __initdata; | ||
48 | static struct linux_prom64_registers pavail_rescan[MAX_BANKS] __initdata; | ||
49 | static int pavail_ents __initdata; | ||
50 | static int pavail_rescan_ents __initdata; | ||
51 | |||
52 | static int cmp_p64(const void *a, const void *b) | ||
53 | { | ||
54 | const struct linux_prom64_registers *x = a, *y = b; | ||
55 | |||
56 | if (x->phys_addr > y->phys_addr) | ||
57 | return 1; | ||
58 | if (x->phys_addr < y->phys_addr) | ||
59 | return -1; | ||
60 | return 0; | ||
61 | } | ||
62 | |||
63 | static void __init read_obp_memory(const char *property, | ||
64 | struct linux_prom64_registers *regs, | ||
65 | int *num_ents) | ||
66 | { | ||
67 | int node = prom_finddevice("/memory"); | ||
68 | int prop_size = prom_getproplen(node, property); | ||
69 | int ents, ret, i; | ||
70 | |||
71 | ents = prop_size / sizeof(struct linux_prom64_registers); | ||
72 | if (ents > MAX_BANKS) { | ||
73 | prom_printf("The machine has more %s property entries than " | ||
74 | "this kernel can support (%d).\n", | ||
75 | property, MAX_BANKS); | ||
76 | prom_halt(); | ||
77 | } | ||
78 | |||
79 | ret = prom_getproperty(node, property, (char *) regs, prop_size); | ||
80 | if (ret == -1) { | ||
81 | prom_printf("Couldn't get %s property from /memory.\n"); | ||
82 | prom_halt(); | ||
83 | } | ||
84 | |||
85 | *num_ents = ents; | ||
86 | |||
87 | /* Sanitize what we got from the firmware, by page aligning | ||
88 | * everything. | ||
89 | */ | ||
90 | for (i = 0; i < ents; i++) { | ||
91 | unsigned long base, size; | ||
92 | |||
93 | base = regs[i].phys_addr; | ||
94 | size = regs[i].reg_size; | ||
95 | |||
96 | size &= PAGE_MASK; | ||
97 | if (base & ~PAGE_MASK) { | ||
98 | unsigned long new_base = PAGE_ALIGN(base); | ||
99 | |||
100 | size -= new_base - base; | ||
101 | if ((long) size < 0L) | ||
102 | size = 0UL; | ||
103 | base = new_base; | ||
104 | } | ||
105 | regs[i].phys_addr = base; | ||
106 | regs[i].reg_size = size; | ||
107 | } | ||
108 | sort(regs, ents, sizeof(struct linux_prom64_registers), | ||
109 | cmp_p64, NULL); | ||
110 | } | ||
45 | 111 | ||
46 | unsigned long *sparc64_valid_addr_bitmap __read_mostly; | 112 | unsigned long *sparc64_valid_addr_bitmap __read_mostly; |
47 | 113 | ||
@@ -1206,14 +1272,14 @@ unsigned long __init bootmem_init(unsigned long *pages_avail) | |||
1206 | int i; | 1272 | int i; |
1207 | 1273 | ||
1208 | #ifdef CONFIG_DEBUG_BOOTMEM | 1274 | #ifdef CONFIG_DEBUG_BOOTMEM |
1209 | prom_printf("bootmem_init: Scan sp_banks, "); | 1275 | prom_printf("bootmem_init: Scan pavail, "); |
1210 | #endif | 1276 | #endif |
1211 | 1277 | ||
1212 | bytes_avail = 0UL; | 1278 | bytes_avail = 0UL; |
1213 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { | 1279 | for (i = 0; i < pavail_ents; i++) { |
1214 | end_of_phys_memory = sp_banks[i].base_addr + | 1280 | end_of_phys_memory = pavail[i].phys_addr + |
1215 | sp_banks[i].num_bytes; | 1281 | pavail[i].reg_size; |
1216 | bytes_avail += sp_banks[i].num_bytes; | 1282 | bytes_avail += pavail[i].reg_size; |
1217 | if (cmdline_memory_size) { | 1283 | if (cmdline_memory_size) { |
1218 | if (bytes_avail > cmdline_memory_size) { | 1284 | if (bytes_avail > cmdline_memory_size) { |
1219 | unsigned long slack = bytes_avail - cmdline_memory_size; | 1285 | unsigned long slack = bytes_avail - cmdline_memory_size; |
@@ -1221,12 +1287,15 @@ unsigned long __init bootmem_init(unsigned long *pages_avail) | |||
1221 | bytes_avail -= slack; | 1287 | bytes_avail -= slack; |
1222 | end_of_phys_memory -= slack; | 1288 | end_of_phys_memory -= slack; |
1223 | 1289 | ||
1224 | sp_banks[i].num_bytes -= slack; | 1290 | pavail[i].reg_size -= slack; |
1225 | if (sp_banks[i].num_bytes == 0) { | 1291 | if ((long)pavail[i].reg_size <= 0L) { |
1226 | sp_banks[i].base_addr = 0xdeadbeef; | 1292 | pavail[i].phys_addr = 0xdeadbeefUL; |
1293 | pavail[i].reg_size = 0UL; | ||
1294 | pavail_ents = i; | ||
1227 | } else { | 1295 | } else { |
1228 | sp_banks[i+1].num_bytes = 0; | 1296 | pavail[i+1].reg_size = 0Ul; |
1229 | sp_banks[i+1].base_addr = 0xdeadbeef; | 1297 | pavail[i+1].phys_addr = 0xdeadbeefUL; |
1298 | pavail_ents = i + 1; | ||
1230 | } | 1299 | } |
1231 | break; | 1300 | break; |
1232 | } | 1301 | } |
@@ -1280,12 +1349,12 @@ unsigned long __init bootmem_init(unsigned long *pages_avail) | |||
1280 | /* Now register the available physical memory with the | 1349 | /* Now register the available physical memory with the |
1281 | * allocator. | 1350 | * allocator. |
1282 | */ | 1351 | */ |
1283 | for (i = 0; sp_banks[i].num_bytes != 0; i++) { | 1352 | for (i = 0; i < pavail_ents; i++) { |
1284 | #ifdef CONFIG_DEBUG_BOOTMEM | 1353 | #ifdef CONFIG_DEBUG_BOOTMEM |
1285 | prom_printf("free_bootmem(sp_banks:%d): base[%lx] size[%lx]\n", | 1354 | prom_printf("free_bootmem(pavail:%d): base[%lx] size[%lx]\n", |
1286 | i, sp_banks[i].base_addr, sp_banks[i].num_bytes); | 1355 | i, pavail[i].phys_addr, pavail[i].reg_size); |
1287 | #endif | 1356 | #endif |
1288 | free_bootmem(sp_banks[i].base_addr, sp_banks[i].num_bytes); | 1357 | free_bootmem(pavail[i].phys_addr, pavail[i].reg_size); |
1289 | } | 1358 | } |
1290 | 1359 | ||
1291 | #ifdef CONFIG_BLK_DEV_INITRD | 1360 | #ifdef CONFIG_BLK_DEV_INITRD |
@@ -1334,7 +1403,7 @@ static unsigned long kernel_map_range(unsigned long pstart, unsigned long pend, | |||
1334 | unsigned long alloc_bytes = 0UL; | 1403 | unsigned long alloc_bytes = 0UL; |
1335 | 1404 | ||
1336 | if ((vstart & ~PAGE_MASK) || (vend & ~PAGE_MASK)) { | 1405 | if ((vstart & ~PAGE_MASK) || (vend & ~PAGE_MASK)) { |
1337 | prom_printf("kernel_map: Unaligned sp_banks[%lx:%lx]\n", | 1406 | prom_printf("kernel_map: Unaligned physmem[%lx:%lx]\n", |
1338 | vstart, vend); | 1407 | vstart, vend); |
1339 | prom_halt(); | 1408 | prom_halt(); |
1340 | } | 1409 | } |
@@ -1381,23 +1450,24 @@ static unsigned long kernel_map_range(unsigned long pstart, unsigned long pend, | |||
1381 | return alloc_bytes; | 1450 | return alloc_bytes; |
1382 | } | 1451 | } |
1383 | 1452 | ||
1384 | extern struct linux_mlist_p1275 *prom_ptot_ptr; | 1453 | static struct linux_prom64_registers pall[MAX_BANKS] __initdata; |
1454 | static int pall_ents __initdata; | ||
1455 | |||
1385 | extern unsigned int kvmap_linear_patch[1]; | 1456 | extern unsigned int kvmap_linear_patch[1]; |
1386 | 1457 | ||
1387 | static void __init kernel_physical_mapping_init(void) | 1458 | static void __init kernel_physical_mapping_init(void) |
1388 | { | 1459 | { |
1389 | struct linux_mlist_p1275 *p = prom_ptot_ptr; | 1460 | unsigned long i, mem_alloced = 0UL; |
1390 | unsigned long mem_alloced = 0UL; | 1461 | |
1462 | read_obp_memory("reg", &pall[0], &pall_ents); | ||
1391 | 1463 | ||
1392 | while (p) { | 1464 | for (i = 0; i < pall_ents; i++) { |
1393 | unsigned long phys_start, phys_end; | 1465 | unsigned long phys_start, phys_end; |
1394 | 1466 | ||
1395 | phys_start = p->start_adr; | 1467 | phys_start = pall[i].phys_addr; |
1396 | phys_end = phys_start + p->num_bytes; | 1468 | phys_end = phys_start + pall[i].reg_size; |
1397 | mem_alloced += kernel_map_range(phys_start, phys_end, | 1469 | mem_alloced += kernel_map_range(phys_start, phys_end, |
1398 | PAGE_KERNEL); | 1470 | PAGE_KERNEL); |
1399 | |||
1400 | p = p->theres_more; | ||
1401 | } | 1471 | } |
1402 | 1472 | ||
1403 | printk("Allocated %ld bytes for kernel page tables.\n", | 1473 | printk("Allocated %ld bytes for kernel page tables.\n", |
@@ -1425,6 +1495,18 @@ void kernel_map_pages(struct page *page, int numpages, int enable) | |||
1425 | } | 1495 | } |
1426 | #endif | 1496 | #endif |
1427 | 1497 | ||
1498 | unsigned long __init find_ecache_flush_span(unsigned long size) | ||
1499 | { | ||
1500 | int i; | ||
1501 | |||
1502 | for (i = 0; i < pavail_ents; i++) { | ||
1503 | if (pavail[i].reg_size >= size) | ||
1504 | return pavail[i].phys_addr; | ||
1505 | } | ||
1506 | |||
1507 | return ~0UL; | ||
1508 | } | ||
1509 | |||
1428 | /* paging_init() sets up the page tables */ | 1510 | /* paging_init() sets up the page tables */ |
1429 | 1511 | ||
1430 | extern void cheetah_ecache_flush_init(void); | 1512 | extern void cheetah_ecache_flush_init(void); |
@@ -1435,7 +1517,19 @@ pgd_t swapper_pg_dir[2048]; | |||
1435 | void __init paging_init(void) | 1517 | void __init paging_init(void) |
1436 | { | 1518 | { |
1437 | unsigned long end_pfn, pages_avail, shift; | 1519 | unsigned long end_pfn, pages_avail, shift; |
1438 | unsigned long real_end; | 1520 | unsigned long real_end, i; |
1521 | |||
1522 | /* Find available physical memory... */ | ||
1523 | read_obp_memory("available", &pavail[0], &pavail_ents); | ||
1524 | |||
1525 | phys_base = 0xffffffffffffffffUL; | ||
1526 | for (i = 0; i < pavail_ents; i++) | ||
1527 | phys_base = min(phys_base, pavail[i].phys_addr); | ||
1528 | |||
1529 | pfn_base = phys_base >> PAGE_SHIFT; | ||
1530 | |||
1531 | kern_base = (prom_boot_mapping_phys_low >> 22UL) << 22UL; | ||
1532 | kern_size = (unsigned long)&_end - (unsigned long)KERNBASE; | ||
1439 | 1533 | ||
1440 | set_bit(0, mmu_context_bmap); | 1534 | set_bit(0, mmu_context_bmap); |
1441 | 1535 | ||
@@ -1507,128 +1601,35 @@ void __init paging_init(void) | |||
1507 | device_scan(); | 1601 | device_scan(); |
1508 | } | 1602 | } |
1509 | 1603 | ||
1510 | /* Ok, it seems that the prom can allocate some more memory chunks | ||
1511 | * as a side effect of some prom calls we perform during the | ||
1512 | * boot sequence. My most likely theory is that it is from the | ||
1513 | * prom_set_traptable() call, and OBP is allocating a scratchpad | ||
1514 | * for saving client program register state etc. | ||
1515 | */ | ||
1516 | static void __init sort_memlist(struct linux_mlist_p1275 *thislist) | ||
1517 | { | ||
1518 | int swapi = 0; | ||
1519 | int i, mitr; | ||
1520 | unsigned long tmpaddr, tmpsize; | ||
1521 | unsigned long lowest; | ||
1522 | |||
1523 | for (i = 0; thislist[i].theres_more != 0; i++) { | ||
1524 | lowest = thislist[i].start_adr; | ||
1525 | for (mitr = i+1; thislist[mitr-1].theres_more != 0; mitr++) | ||
1526 | if (thislist[mitr].start_adr < lowest) { | ||
1527 | lowest = thislist[mitr].start_adr; | ||
1528 | swapi = mitr; | ||
1529 | } | ||
1530 | if (lowest == thislist[i].start_adr) | ||
1531 | continue; | ||
1532 | tmpaddr = thislist[swapi].start_adr; | ||
1533 | tmpsize = thislist[swapi].num_bytes; | ||
1534 | for (mitr = swapi; mitr > i; mitr--) { | ||
1535 | thislist[mitr].start_adr = thislist[mitr-1].start_adr; | ||
1536 | thislist[mitr].num_bytes = thislist[mitr-1].num_bytes; | ||
1537 | } | ||
1538 | thislist[i].start_adr = tmpaddr; | ||
1539 | thislist[i].num_bytes = tmpsize; | ||
1540 | } | ||
1541 | } | ||
1542 | |||
1543 | void __init rescan_sp_banks(void) | ||
1544 | { | ||
1545 | struct linux_prom64_registers memlist[64]; | ||
1546 | struct linux_mlist_p1275 avail[64], *mlist; | ||
1547 | unsigned long bytes, base_paddr; | ||
1548 | int num_regs, node = prom_finddevice("/memory"); | ||
1549 | int i; | ||
1550 | |||
1551 | num_regs = prom_getproperty(node, "available", | ||
1552 | (char *) memlist, sizeof(memlist)); | ||
1553 | num_regs = (num_regs / sizeof(struct linux_prom64_registers)); | ||
1554 | for (i = 0; i < num_regs; i++) { | ||
1555 | avail[i].start_adr = memlist[i].phys_addr; | ||
1556 | avail[i].num_bytes = memlist[i].reg_size; | ||
1557 | avail[i].theres_more = &avail[i + 1]; | ||
1558 | } | ||
1559 | avail[i - 1].theres_more = NULL; | ||
1560 | sort_memlist(avail); | ||
1561 | |||
1562 | mlist = &avail[0]; | ||
1563 | i = 0; | ||
1564 | bytes = mlist->num_bytes; | ||
1565 | base_paddr = mlist->start_adr; | ||
1566 | |||
1567 | sp_banks[0].base_addr = base_paddr; | ||
1568 | sp_banks[0].num_bytes = bytes; | ||
1569 | |||
1570 | while (mlist->theres_more != NULL){ | ||
1571 | i++; | ||
1572 | mlist = mlist->theres_more; | ||
1573 | bytes = mlist->num_bytes; | ||
1574 | if (i >= SPARC_PHYS_BANKS-1) { | ||
1575 | printk ("The machine has more banks than " | ||
1576 | "this kernel can support\n" | ||
1577 | "Increase the SPARC_PHYS_BANKS " | ||
1578 | "setting (currently %d)\n", | ||
1579 | SPARC_PHYS_BANKS); | ||
1580 | i = SPARC_PHYS_BANKS-1; | ||
1581 | break; | ||
1582 | } | ||
1583 | |||
1584 | sp_banks[i].base_addr = mlist->start_adr; | ||
1585 | sp_banks[i].num_bytes = mlist->num_bytes; | ||
1586 | } | ||
1587 | |||
1588 | i++; | ||
1589 | sp_banks[i].base_addr = 0xdeadbeefbeefdeadUL; | ||
1590 | sp_banks[i].num_bytes = 0; | ||
1591 | |||
1592 | for (i = 0; sp_banks[i].num_bytes != 0; i++) | ||
1593 | sp_banks[i].num_bytes &= PAGE_MASK; | ||
1594 | } | ||
1595 | |||
1596 | static void __init taint_real_pages(void) | 1604 | static void __init taint_real_pages(void) |
1597 | { | 1605 | { |
1598 | struct sparc_phys_banks saved_sp_banks[SPARC_PHYS_BANKS]; | ||
1599 | int i; | 1606 | int i; |
1600 | 1607 | ||
1601 | for (i = 0; i < SPARC_PHYS_BANKS; i++) { | 1608 | read_obp_memory("available", &pavail_rescan[0], &pavail_rescan_ents); |
1602 | saved_sp_banks[i].base_addr = | ||
1603 | sp_banks[i].base_addr; | ||
1604 | saved_sp_banks[i].num_bytes = | ||
1605 | sp_banks[i].num_bytes; | ||
1606 | } | ||
1607 | |||
1608 | rescan_sp_banks(); | ||
1609 | 1609 | ||
1610 | /* Find changes discovered in the sp_bank rescan and | 1610 | /* Find changes discovered in the physmem available rescan and |
1611 | * reserve the lost portions in the bootmem maps. | 1611 | * reserve the lost portions in the bootmem maps. |
1612 | */ | 1612 | */ |
1613 | for (i = 0; saved_sp_banks[i].num_bytes; i++) { | 1613 | for (i = 0; i < pavail_ents; i++) { |
1614 | unsigned long old_start, old_end; | 1614 | unsigned long old_start, old_end; |
1615 | 1615 | ||
1616 | old_start = saved_sp_banks[i].base_addr; | 1616 | old_start = pavail[i].phys_addr; |
1617 | old_end = old_start + | 1617 | old_end = old_start + |
1618 | saved_sp_banks[i].num_bytes; | 1618 | pavail[i].reg_size; |
1619 | while (old_start < old_end) { | 1619 | while (old_start < old_end) { |
1620 | int n; | 1620 | int n; |
1621 | 1621 | ||
1622 | for (n = 0; sp_banks[n].num_bytes; n++) { | 1622 | for (n = 0; pavail_rescan_ents; n++) { |
1623 | unsigned long new_start, new_end; | 1623 | unsigned long new_start, new_end; |
1624 | 1624 | ||
1625 | new_start = sp_banks[n].base_addr; | 1625 | new_start = pavail_rescan[n].phys_addr; |
1626 | new_end = new_start + sp_banks[n].num_bytes; | 1626 | new_end = new_start + |
1627 | pavail_rescan[n].reg_size; | ||
1627 | 1628 | ||
1628 | if (new_start <= old_start && | 1629 | if (new_start <= old_start && |
1629 | new_end >= (old_start + PAGE_SIZE)) { | 1630 | new_end >= (old_start + PAGE_SIZE)) { |
1630 | set_bit (old_start >> 22, | 1631 | set_bit(old_start >> 22, |
1631 | sparc64_valid_addr_bitmap); | 1632 | sparc64_valid_addr_bitmap); |
1632 | goto do_next_page; | 1633 | goto do_next_page; |
1633 | } | 1634 | } |
1634 | } | 1635 | } |
diff --git a/arch/sparc64/prom/Makefile b/arch/sparc64/prom/Makefile index c7898a5ee456..3d33ed27bc27 100644 --- a/arch/sparc64/prom/Makefile +++ b/arch/sparc64/prom/Makefile | |||
@@ -6,5 +6,5 @@ | |||
6 | EXTRA_AFLAGS := -ansi | 6 | EXTRA_AFLAGS := -ansi |
7 | EXTRA_CFLAGS := -Werror | 7 | EXTRA_CFLAGS := -Werror |
8 | 8 | ||
9 | lib-y := bootstr.o devops.o init.o memory.o misc.o \ | 9 | lib-y := bootstr.o devops.o init.o misc.o \ |
10 | tree.o console.o printf.o p1275.o cif.o | 10 | tree.o console.o printf.o p1275.o cif.o |
diff --git a/arch/sparc64/prom/init.c b/arch/sparc64/prom/init.c index 8b4b622d0909..f3cc2d8578b2 100644 --- a/arch/sparc64/prom/init.c +++ b/arch/sparc64/prom/init.c | |||
@@ -27,7 +27,6 @@ int prom_chosen_node; | |||
27 | * failure. It gets passed the pointer to the PROM vector. | 27 | * failure. It gets passed the pointer to the PROM vector. |
28 | */ | 28 | */ |
29 | 29 | ||
30 | extern void prom_meminit(void); | ||
31 | extern void prom_cif_init(void *, void *); | 30 | extern void prom_cif_init(void *, void *); |
32 | 31 | ||
33 | void __init prom_init(void *cif_handler, void *cif_stack) | 32 | void __init prom_init(void *cif_handler, void *cif_stack) |
@@ -90,8 +89,6 @@ void __init prom_init(void *cif_handler, void *cif_stack) | |||
90 | 89 | ||
91 | printk ("PROMLIB: Sun IEEE Boot Prom %s\n", buffer + bufadjust); | 90 | printk ("PROMLIB: Sun IEEE Boot Prom %s\n", buffer + bufadjust); |
92 | 91 | ||
93 | prom_meminit(); | ||
94 | |||
95 | /* Initialization successful. */ | 92 | /* Initialization successful. */ |
96 | return; | 93 | return; |
97 | 94 | ||
diff --git a/arch/sparc64/prom/memory.c b/arch/sparc64/prom/memory.c deleted file mode 100644 index f4a8143e052c..000000000000 --- a/arch/sparc64/prom/memory.c +++ /dev/null | |||
@@ -1,152 +0,0 @@ | |||
1 | /* $Id: memory.c,v 1.5 1999/08/31 06:55:04 davem Exp $ | ||
2 | * memory.c: Prom routine for acquiring various bits of information | ||
3 | * about RAM on the machine, both virtual and physical. | ||
4 | * | ||
5 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | ||
6 | * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) | ||
7 | */ | ||
8 | |||
9 | #include <linux/kernel.h> | ||
10 | #include <linux/init.h> | ||
11 | |||
12 | #include <asm/openprom.h> | ||
13 | #include <asm/oplib.h> | ||
14 | |||
15 | /* This routine, for consistency, returns the ram parameters in the | ||
16 | * V0 prom memory descriptor format. I choose this format because I | ||
17 | * think it was the easiest to work with. I feel the religious | ||
18 | * arguments now... ;) Also, I return the linked lists sorted to | ||
19 | * prevent paging_init() upset stomach as I have not yet written | ||
20 | * the pepto-bismol kernel module yet. | ||
21 | */ | ||
22 | |||
23 | struct linux_prom64_registers prom_reg_memlist[64]; | ||
24 | struct linux_prom64_registers prom_reg_tmp[64]; | ||
25 | |||
26 | struct linux_mlist_p1275 prom_phys_total[64]; | ||
27 | struct linux_mlist_p1275 prom_prom_taken[64]; | ||
28 | struct linux_mlist_p1275 prom_phys_avail[64]; | ||
29 | |||
30 | struct linux_mlist_p1275 *prom_ptot_ptr = prom_phys_total; | ||
31 | struct linux_mlist_p1275 *prom_ptak_ptr = prom_prom_taken; | ||
32 | struct linux_mlist_p1275 *prom_pavl_ptr = prom_phys_avail; | ||
33 | |||
34 | struct linux_mem_p1275 prom_memlist; | ||
35 | |||
36 | |||
37 | /* Internal Prom library routine to sort a linux_mlist_p1275 memory | ||
38 | * list. Used below in initialization. | ||
39 | */ | ||
40 | static void __init | ||
41 | prom_sortmemlist(struct linux_mlist_p1275 *thislist) | ||
42 | { | ||
43 | int swapi = 0; | ||
44 | int i, mitr; | ||
45 | unsigned long tmpaddr, tmpsize; | ||
46 | unsigned long lowest; | ||
47 | |||
48 | for(i=0; thislist[i].theres_more; i++) { | ||
49 | lowest = thislist[i].start_adr; | ||
50 | for(mitr = i+1; thislist[mitr-1].theres_more; mitr++) | ||
51 | if(thislist[mitr].start_adr < lowest) { | ||
52 | lowest = thislist[mitr].start_adr; | ||
53 | swapi = mitr; | ||
54 | } | ||
55 | if(lowest == thislist[i].start_adr) continue; | ||
56 | tmpaddr = thislist[swapi].start_adr; | ||
57 | tmpsize = thislist[swapi].num_bytes; | ||
58 | for(mitr = swapi; mitr > i; mitr--) { | ||
59 | thislist[mitr].start_adr = thislist[mitr-1].start_adr; | ||
60 | thislist[mitr].num_bytes = thislist[mitr-1].num_bytes; | ||
61 | } | ||
62 | thislist[i].start_adr = tmpaddr; | ||
63 | thislist[i].num_bytes = tmpsize; | ||
64 | } | ||
65 | } | ||
66 | |||
67 | /* Initialize the memory lists based upon the prom version. */ | ||
68 | void __init prom_meminit(void) | ||
69 | { | ||
70 | int node = 0; | ||
71 | unsigned int iter, num_regs; | ||
72 | |||
73 | node = prom_finddevice("/memory"); | ||
74 | num_regs = prom_getproperty(node, "available", | ||
75 | (char *) prom_reg_memlist, | ||
76 | sizeof(prom_reg_memlist)); | ||
77 | num_regs = (num_regs/sizeof(struct linux_prom64_registers)); | ||
78 | for(iter=0; iter<num_regs; iter++) { | ||
79 | prom_phys_avail[iter].start_adr = | ||
80 | prom_reg_memlist[iter].phys_addr; | ||
81 | prom_phys_avail[iter].num_bytes = | ||
82 | prom_reg_memlist[iter].reg_size; | ||
83 | prom_phys_avail[iter].theres_more = | ||
84 | &prom_phys_avail[iter+1]; | ||
85 | } | ||
86 | prom_phys_avail[iter-1].theres_more = NULL; | ||
87 | |||
88 | num_regs = prom_getproperty(node, "reg", | ||
89 | (char *) prom_reg_memlist, | ||
90 | sizeof(prom_reg_memlist)); | ||
91 | num_regs = (num_regs/sizeof(struct linux_prom64_registers)); | ||
92 | for(iter=0; iter<num_regs; iter++) { | ||
93 | prom_phys_total[iter].start_adr = | ||
94 | prom_reg_memlist[iter].phys_addr; | ||
95 | prom_phys_total[iter].num_bytes = | ||
96 | prom_reg_memlist[iter].reg_size; | ||
97 | prom_phys_total[iter].theres_more = | ||
98 | &prom_phys_total[iter+1]; | ||
99 | } | ||
100 | prom_phys_total[iter-1].theres_more = NULL; | ||
101 | |||
102 | node = prom_finddevice("/virtual-memory"); | ||
103 | num_regs = prom_getproperty(node, "available", | ||
104 | (char *) prom_reg_memlist, | ||
105 | sizeof(prom_reg_memlist)); | ||
106 | num_regs = (num_regs/sizeof(struct linux_prom64_registers)); | ||
107 | |||
108 | /* Convert available virtual areas to taken virtual | ||
109 | * areas. First sort, then convert. | ||
110 | */ | ||
111 | for(iter=0; iter<num_regs; iter++) { | ||
112 | prom_prom_taken[iter].start_adr = | ||
113 | prom_reg_memlist[iter].phys_addr; | ||
114 | prom_prom_taken[iter].num_bytes = | ||
115 | prom_reg_memlist[iter].reg_size; | ||
116 | prom_prom_taken[iter].theres_more = | ||
117 | &prom_prom_taken[iter+1]; | ||
118 | } | ||
119 | prom_prom_taken[iter-1].theres_more = NULL; | ||
120 | |||
121 | prom_sortmemlist(prom_prom_taken); | ||
122 | |||
123 | /* Finally, convert. */ | ||
124 | for(iter=0; iter<num_regs; iter++) { | ||
125 | prom_prom_taken[iter].start_adr = | ||
126 | prom_prom_taken[iter].start_adr + | ||
127 | prom_prom_taken[iter].num_bytes; | ||
128 | prom_prom_taken[iter].num_bytes = | ||
129 | prom_prom_taken[iter+1].start_adr - | ||
130 | prom_prom_taken[iter].start_adr; | ||
131 | } | ||
132 | prom_prom_taken[iter-1].num_bytes = | ||
133 | -1UL - prom_prom_taken[iter-1].start_adr; | ||
134 | |||
135 | /* Sort the other two lists. */ | ||
136 | prom_sortmemlist(prom_phys_total); | ||
137 | prom_sortmemlist(prom_phys_avail); | ||
138 | |||
139 | /* Link all the lists into the top-level descriptor. */ | ||
140 | prom_memlist.p1275_totphys=&prom_ptot_ptr; | ||
141 | prom_memlist.p1275_prommap=&prom_ptak_ptr; | ||
142 | prom_memlist.p1275_available=&prom_pavl_ptr; | ||
143 | } | ||
144 | |||
145 | /* This returns a pointer to our libraries internal p1275 format | ||
146 | * memory descriptor. | ||
147 | */ | ||
148 | struct linux_mem_p1275 * | ||
149 | prom_meminfo(void) | ||
150 | { | ||
151 | return &prom_memlist; | ||
152 | } | ||