[SPARC64]: exec PT_DTRACE
[linux-2.6.git] / arch / sparc64 / kernel / process.c
1 /*  $Id: process.c,v 1.131 2002/02/09 19:49:30 davem Exp $
2  *  arch/sparc64/kernel/process.c
3  *
4  *  Copyright (C) 1995, 1996 David S. Miller (davem@caip.rutgers.edu)
5  *  Copyright (C) 1996       Eddie C. Dost   (ecd@skynet.be)
6  *  Copyright (C) 1997, 1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
7  */
8
9 /*
10  * This file handles the architecture-dependent parts of process handling..
11  */
12
13 #include <stdarg.h>
14
15 #include <linux/errno.h>
16 #include <linux/module.h>
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/kallsyms.h>
20 #include <linux/mm.h>
21 #include <linux/fs.h>
22 #include <linux/smp.h>
23 #include <linux/stddef.h>
24 #include <linux/ptrace.h>
25 #include <linux/slab.h>
26 #include <linux/user.h>
27 #include <linux/reboot.h>
28 #include <linux/delay.h>
29 #include <linux/compat.h>
30 #include <linux/tick.h>
31 #include <linux/init.h>
32 #include <linux/cpu.h>
33 #include <linux/elfcore.h>
34
35 #include <asm/oplib.h>
36 #include <asm/uaccess.h>
37 #include <asm/system.h>
38 #include <asm/page.h>
39 #include <asm/pgalloc.h>
40 #include <asm/pgtable.h>
41 #include <asm/processor.h>
42 #include <asm/pstate.h>
43 #include <asm/elf.h>
44 #include <asm/fpumacro.h>
45 #include <asm/head.h>
46 #include <asm/cpudata.h>
47 #include <asm/mmu_context.h>
48 #include <asm/unistd.h>
49 #include <asm/hypervisor.h>
50 #include <asm/sstate.h>
51 #include <asm/reboot.h>
52 #include <asm/syscalls.h>
53
54 /* #define VERBOSE_SHOWREGS */
55
56 static void sparc64_yield(int cpu)
57 {
58         if (tlb_type != hypervisor)
59                 return;
60
61         clear_thread_flag(TIF_POLLING_NRFLAG);
62         smp_mb__after_clear_bit();
63
64         while (!need_resched() && !cpu_is_offline(cpu)) {
65                 unsigned long pstate;
66
67                 /* Disable interrupts. */
68                 __asm__ __volatile__(
69                         "rdpr %%pstate, %0\n\t"
70                         "andn %0, %1, %0\n\t"
71                         "wrpr %0, %%g0, %%pstate"
72                         : "=&r" (pstate)
73                         : "i" (PSTATE_IE));
74
75                 if (!need_resched() && !cpu_is_offline(cpu))
76                         sun4v_cpu_yield();
77
78                 /* Re-enable interrupts. */
79                 __asm__ __volatile__(
80                         "rdpr %%pstate, %0\n\t"
81                         "or %0, %1, %0\n\t"
82                         "wrpr %0, %%g0, %%pstate"
83                         : "=&r" (pstate)
84                         : "i" (PSTATE_IE));
85         }
86
87         set_thread_flag(TIF_POLLING_NRFLAG);
88 }
89
90 /* The idle loop on sparc64. */
91 void cpu_idle(void)
92 {
93         int cpu = smp_processor_id();
94
95         set_thread_flag(TIF_POLLING_NRFLAG);
96
97         while(1) {
98                 tick_nohz_stop_sched_tick();
99
100                 while (!need_resched() && !cpu_is_offline(cpu))
101                         sparc64_yield(cpu);
102
103                 tick_nohz_restart_sched_tick();
104
105                 preempt_enable_no_resched();
106
107 #ifdef CONFIG_HOTPLUG_CPU
108                 if (cpu_is_offline(cpu))
109                         cpu_play_dead();
110 #endif
111
112                 schedule();
113                 preempt_disable();
114         }
115 }
116
117 void machine_halt(void)
118 {
119         sstate_halt();
120         prom_halt();
121         panic("Halt failed!");
122 }
123
124 void machine_alt_power_off(void)
125 {
126         sstate_poweroff();
127         prom_halt_power_off();
128         panic("Power-off failed!");
129 }
130
131 void machine_restart(char * cmd)
132 {
133         char *p;
134         
135         sstate_reboot();
136         p = strchr (reboot_command, '\n');
137         if (p) *p = 0;
138         if (cmd)
139                 prom_reboot(cmd);
140         if (*reboot_command)
141                 prom_reboot(reboot_command);
142         prom_reboot("");
143         panic("Reboot failed!");
144 }
145
146 #ifdef CONFIG_COMPAT
147 static void show_regwindow32(struct pt_regs *regs)
148 {
149         struct reg_window32 __user *rw;
150         struct reg_window32 r_w;
151         mm_segment_t old_fs;
152         
153         __asm__ __volatile__ ("flushw");
154         rw = compat_ptr((unsigned)regs->u_regs[14]);
155         old_fs = get_fs();
156         set_fs (USER_DS);
157         if (copy_from_user (&r_w, rw, sizeof(r_w))) {
158                 set_fs (old_fs);
159                 return;
160         }
161
162         set_fs (old_fs);                        
163         printk("l0: %08x l1: %08x l2: %08x l3: %08x "
164                "l4: %08x l5: %08x l6: %08x l7: %08x\n",
165                r_w.locals[0], r_w.locals[1], r_w.locals[2], r_w.locals[3],
166                r_w.locals[4], r_w.locals[5], r_w.locals[6], r_w.locals[7]);
167         printk("i0: %08x i1: %08x i2: %08x i3: %08x "
168                "i4: %08x i5: %08x i6: %08x i7: %08x\n",
169                r_w.ins[0], r_w.ins[1], r_w.ins[2], r_w.ins[3],
170                r_w.ins[4], r_w.ins[5], r_w.ins[6], r_w.ins[7]);
171 }
172 #else
173 #define show_regwindow32(regs)  do { } while (0)
174 #endif
175
176 static void show_regwindow(struct pt_regs *regs)
177 {
178         struct reg_window __user *rw;
179         struct reg_window *rwk;
180         struct reg_window r_w;
181         mm_segment_t old_fs;
182
183         if ((regs->tstate & TSTATE_PRIV) || !(test_thread_flag(TIF_32BIT))) {
184                 __asm__ __volatile__ ("flushw");
185                 rw = (struct reg_window __user *)
186                         (regs->u_regs[14] + STACK_BIAS);
187                 rwk = (struct reg_window *)
188                         (regs->u_regs[14] + STACK_BIAS);
189                 if (!(regs->tstate & TSTATE_PRIV)) {
190                         old_fs = get_fs();
191                         set_fs (USER_DS);
192                         if (copy_from_user (&r_w, rw, sizeof(r_w))) {
193                                 set_fs (old_fs);
194                                 return;
195                         }
196                         rwk = &r_w;
197                         set_fs (old_fs);                        
198                 }
199         } else {
200                 show_regwindow32(regs);
201                 return;
202         }
203         printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lx\n",
204                rwk->locals[0], rwk->locals[1], rwk->locals[2], rwk->locals[3]);
205         printk("l4: %016lx l5: %016lx l6: %016lx l7: %016lx\n",
206                rwk->locals[4], rwk->locals[5], rwk->locals[6], rwk->locals[7]);
207         printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lx\n",
208                rwk->ins[0], rwk->ins[1], rwk->ins[2], rwk->ins[3]);
209         printk("i4: %016lx i5: %016lx i6: %016lx i7: %016lx\n",
210                rwk->ins[4], rwk->ins[5], rwk->ins[6], rwk->ins[7]);
211         if (regs->tstate & TSTATE_PRIV)
212                 print_symbol("I7: <%s>\n", rwk->ins[7]);
213 }
214
215 #ifdef CONFIG_SMP
216 static DEFINE_SPINLOCK(regdump_lock);
217 #endif
218
219 void __show_regs(struct pt_regs * regs)
220 {
221 #ifdef CONFIG_SMP
222         unsigned long flags;
223
224         /* Protect against xcall ipis which might lead to livelock on the lock */
225         __asm__ __volatile__("rdpr      %%pstate, %0\n\t"
226                              "wrpr      %0, %1, %%pstate"
227                              : "=r" (flags)
228                              : "i" (PSTATE_IE));
229         spin_lock(&regdump_lock);
230 #endif
231         printk("TSTATE: %016lx TPC: %016lx TNPC: %016lx Y: %08x    %s\n", regs->tstate,
232                regs->tpc, regs->tnpc, regs->y, print_tainted());
233         print_symbol("TPC: <%s>\n", regs->tpc);
234         printk("g0: %016lx g1: %016lx g2: %016lx g3: %016lx\n",
235                regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
236                regs->u_regs[3]);
237         printk("g4: %016lx g5: %016lx g6: %016lx g7: %016lx\n",
238                regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
239                regs->u_regs[7]);
240         printk("o0: %016lx o1: %016lx o2: %016lx o3: %016lx\n",
241                regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
242                regs->u_regs[11]);
243         printk("o4: %016lx o5: %016lx sp: %016lx ret_pc: %016lx\n",
244                regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
245                regs->u_regs[15]);
246         print_symbol("RPC: <%s>\n", regs->u_regs[15]);
247         show_regwindow(regs);
248 #ifdef CONFIG_SMP
249         spin_unlock(&regdump_lock);
250         __asm__ __volatile__("wrpr      %0, 0, %%pstate"
251                              : : "r" (flags));
252 #endif
253 }
254
255 #ifdef VERBOSE_SHOWREGS
256 static void idump_from_user (unsigned int *pc)
257 {
258         int i;
259         int code;
260         
261         if((((unsigned long) pc) & 3))
262                 return;
263         
264         pc -= 3;
265         for(i = -3; i < 6; i++) {
266                 get_user(code, pc);
267                 printk("%c%08x%c",i?' ':'<',code,i?' ':'>');
268                 pc++;
269         }
270         printk("\n");
271 }
272 #endif
273
274 void show_regs(struct pt_regs *regs)
275 {
276 #ifdef VERBOSE_SHOWREGS
277         extern long etrap, etraptl1;
278 #endif
279         __show_regs(regs);
280 #if 0
281 #ifdef CONFIG_SMP
282         {
283                 extern void smp_report_regs(void);
284
285                 smp_report_regs();
286         }
287 #endif
288 #endif
289
290 #ifdef VERBOSE_SHOWREGS 
291         if (regs->tpc >= &etrap && regs->tpc < &etraptl1 &&
292             regs->u_regs[14] >= (long)current - PAGE_SIZE &&
293             regs->u_regs[14] < (long)current + 6 * PAGE_SIZE) {
294                 printk ("*********parent**********\n");
295                 __show_regs((struct pt_regs *)(regs->u_regs[14] + PTREGS_OFF));
296                 idump_from_user(((struct pt_regs *)(regs->u_regs[14] + PTREGS_OFF))->tpc);
297                 printk ("*********endpar**********\n");
298         }
299 #endif
300 }
301
302 unsigned long thread_saved_pc(struct task_struct *tsk)
303 {
304         struct thread_info *ti = task_thread_info(tsk);
305         unsigned long ret = 0xdeadbeefUL;
306         
307         if (ti && ti->ksp) {
308                 unsigned long *sp;
309                 sp = (unsigned long *)(ti->ksp + STACK_BIAS);
310                 if (((unsigned long)sp & (sizeof(long) - 1)) == 0UL &&
311                     sp[14]) {
312                         unsigned long *fp;
313                         fp = (unsigned long *)(sp[14] + STACK_BIAS);
314                         if (((unsigned long)fp & (sizeof(long) - 1)) == 0UL)
315                                 ret = fp[15];
316                 }
317         }
318         return ret;
319 }
320
321 /* Free current thread data structures etc.. */
322 void exit_thread(void)
323 {
324         struct thread_info *t = current_thread_info();
325
326         if (t->utraps) {
327                 if (t->utraps[0] < 2)
328                         kfree (t->utraps);
329                 else
330                         t->utraps[0]--;
331         }
332
333         if (test_and_clear_thread_flag(TIF_PERFCTR)) {
334                 t->user_cntd0 = t->user_cntd1 = NULL;
335                 t->pcr_reg = 0;
336                 write_pcr(0);
337         }
338 }
339
340 void flush_thread(void)
341 {
342         struct thread_info *t = current_thread_info();
343         struct mm_struct *mm;
344
345         if (test_ti_thread_flag(t, TIF_ABI_PENDING)) {
346                 clear_ti_thread_flag(t, TIF_ABI_PENDING);
347                 if (test_ti_thread_flag(t, TIF_32BIT))
348                         clear_ti_thread_flag(t, TIF_32BIT);
349                 else
350                         set_ti_thread_flag(t, TIF_32BIT);
351         }
352
353         mm = t->task->mm;
354         if (mm)
355                 tsb_context_switch(mm);
356
357         set_thread_wsaved(0);
358
359         /* Turn off performance counters if on. */
360         if (test_and_clear_thread_flag(TIF_PERFCTR)) {
361                 t->user_cntd0 = t->user_cntd1 = NULL;
362                 t->pcr_reg = 0;
363                 write_pcr(0);
364         }
365
366         /* Clear FPU register state. */
367         t->fpsaved[0] = 0;
368         
369         if (get_thread_current_ds() != ASI_AIUS)
370                 set_fs(USER_DS);
371
372         /* Init new signal delivery disposition. */
373         clear_thread_flag(TIF_NEWSIGNALS);
374 }
375
376 /* It's a bit more tricky when 64-bit tasks are involved... */
377 static unsigned long clone_stackframe(unsigned long csp, unsigned long psp)
378 {
379         unsigned long fp, distance, rval;
380
381         if (!(test_thread_flag(TIF_32BIT))) {
382                 csp += STACK_BIAS;
383                 psp += STACK_BIAS;
384                 __get_user(fp, &(((struct reg_window __user *)psp)->ins[6]));
385                 fp += STACK_BIAS;
386         } else
387                 __get_user(fp, &(((struct reg_window32 __user *)psp)->ins[6]));
388
389         /* Now 8-byte align the stack as this is mandatory in the
390          * Sparc ABI due to how register windows work.  This hides
391          * the restriction from thread libraries etc.  -DaveM
392          */
393         csp &= ~7UL;
394
395         distance = fp - psp;
396         rval = (csp - distance);
397         if (copy_in_user((void __user *) rval, (void __user *) psp, distance))
398                 rval = 0;
399         else if (test_thread_flag(TIF_32BIT)) {
400                 if (put_user(((u32)csp),
401                              &(((struct reg_window32 __user *)rval)->ins[6])))
402                         rval = 0;
403         } else {
404                 if (put_user(((u64)csp - STACK_BIAS),
405                              &(((struct reg_window __user *)rval)->ins[6])))
406                         rval = 0;
407                 else
408                         rval = rval - STACK_BIAS;
409         }
410
411         return rval;
412 }
413
414 /* Standard stuff. */
415 static inline void shift_window_buffer(int first_win, int last_win,
416                                        struct thread_info *t)
417 {
418         int i;
419
420         for (i = first_win; i < last_win; i++) {
421                 t->rwbuf_stkptrs[i] = t->rwbuf_stkptrs[i+1];
422                 memcpy(&t->reg_window[i], &t->reg_window[i+1],
423                        sizeof(struct reg_window));
424         }
425 }
426
427 void synchronize_user_stack(void)
428 {
429         struct thread_info *t = current_thread_info();
430         unsigned long window;
431
432         flush_user_windows();
433         if ((window = get_thread_wsaved()) != 0) {
434                 int winsize = sizeof(struct reg_window);
435                 int bias = 0;
436
437                 if (test_thread_flag(TIF_32BIT))
438                         winsize = sizeof(struct reg_window32);
439                 else
440                         bias = STACK_BIAS;
441
442                 window -= 1;
443                 do {
444                         unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
445                         struct reg_window *rwin = &t->reg_window[window];
446
447                         if (!copy_to_user((char __user *)sp, rwin, winsize)) {
448                                 shift_window_buffer(window, get_thread_wsaved() - 1, t);
449                                 set_thread_wsaved(get_thread_wsaved() - 1);
450                         }
451                 } while (window--);
452         }
453 }
454
455 static void stack_unaligned(unsigned long sp)
456 {
457         siginfo_t info;
458
459         info.si_signo = SIGBUS;
460         info.si_errno = 0;
461         info.si_code = BUS_ADRALN;
462         info.si_addr = (void __user *) sp;
463         info.si_trapno = 0;
464         force_sig_info(SIGBUS, &info, current);
465 }
466
467 void fault_in_user_windows(void)
468 {
469         struct thread_info *t = current_thread_info();
470         unsigned long window;
471         int winsize = sizeof(struct reg_window);
472         int bias = 0;
473
474         if (test_thread_flag(TIF_32BIT))
475                 winsize = sizeof(struct reg_window32);
476         else
477                 bias = STACK_BIAS;
478
479         flush_user_windows();
480         window = get_thread_wsaved();
481
482         if (likely(window != 0)) {
483                 window -= 1;
484                 do {
485                         unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
486                         struct reg_window *rwin = &t->reg_window[window];
487
488                         if (unlikely(sp & 0x7UL))
489                                 stack_unaligned(sp);
490
491                         if (unlikely(copy_to_user((char __user *)sp,
492                                                   rwin, winsize)))
493                                 goto barf;
494                 } while (window--);
495         }
496         set_thread_wsaved(0);
497         return;
498
499 barf:
500         set_thread_wsaved(window + 1);
501         do_exit(SIGILL);
502 }
503
504 asmlinkage long sparc_do_fork(unsigned long clone_flags,
505                               unsigned long stack_start,
506                               struct pt_regs *regs,
507                               unsigned long stack_size)
508 {
509         int __user *parent_tid_ptr, *child_tid_ptr;
510
511 #ifdef CONFIG_COMPAT
512         if (test_thread_flag(TIF_32BIT)) {
513                 parent_tid_ptr = compat_ptr(regs->u_regs[UREG_I2]);
514                 child_tid_ptr = compat_ptr(regs->u_regs[UREG_I4]);
515         } else
516 #endif
517         {
518                 parent_tid_ptr = (int __user *) regs->u_regs[UREG_I2];
519                 child_tid_ptr = (int __user *) regs->u_regs[UREG_I4];
520         }
521
522         return do_fork(clone_flags, stack_start,
523                        regs, stack_size,
524                        parent_tid_ptr, child_tid_ptr);
525 }
526
527 /* Copy a Sparc thread.  The fork() return value conventions
528  * under SunOS are nothing short of bletcherous:
529  * Parent -->  %o0 == childs  pid, %o1 == 0
530  * Child  -->  %o0 == parents pid, %o1 == 1
531  */
532 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
533                 unsigned long unused,
534                 struct task_struct *p, struct pt_regs *regs)
535 {
536         struct thread_info *t = task_thread_info(p);
537         char *child_trap_frame;
538
539         /* Calculate offset to stack_frame & pt_regs */
540         child_trap_frame = task_stack_page(p) + (THREAD_SIZE - (TRACEREG_SZ+STACKFRAME_SZ));
541         memcpy(child_trap_frame, (((struct sparc_stackf *)regs)-1), (TRACEREG_SZ+STACKFRAME_SZ));
542
543         t->flags = (t->flags & ~((0xffUL << TI_FLAG_CWP_SHIFT) | (0xffUL << TI_FLAG_CURRENT_DS_SHIFT))) |
544                 (((regs->tstate + 1) & TSTATE_CWP) << TI_FLAG_CWP_SHIFT);
545         t->new_child = 1;
546         t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
547         t->kregs = (struct pt_regs *)(child_trap_frame+sizeof(struct sparc_stackf));
548         t->fpsaved[0] = 0;
549
550         if (regs->tstate & TSTATE_PRIV) {
551                 /* Special case, if we are spawning a kernel thread from
552                  * a userspace task (via KMOD, NFS, or similar) we must
553                  * disable performance counters in the child because the
554                  * address space and protection realm are changing.
555                  */
556                 if (t->flags & _TIF_PERFCTR) {
557                         t->user_cntd0 = t->user_cntd1 = NULL;
558                         t->pcr_reg = 0;
559                         t->flags &= ~_TIF_PERFCTR;
560                 }
561                 t->kregs->u_regs[UREG_FP] = t->ksp;
562                 t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT);
563                 flush_register_windows();
564                 memcpy((void *)(t->ksp + STACK_BIAS),
565                        (void *)(regs->u_regs[UREG_FP] + STACK_BIAS),
566                        sizeof(struct sparc_stackf));
567                 t->kregs->u_regs[UREG_G6] = (unsigned long) t;
568                 t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
569         } else {
570                 if (t->flags & _TIF_32BIT) {
571                         sp &= 0x00000000ffffffffUL;
572                         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
573                 }
574                 t->kregs->u_regs[UREG_FP] = sp;
575                 t->flags |= ((long)ASI_AIUS << TI_FLAG_CURRENT_DS_SHIFT);
576                 if (sp != regs->u_regs[UREG_FP]) {
577                         unsigned long csp;
578
579                         csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
580                         if (!csp)
581                                 return -EFAULT;
582                         t->kregs->u_regs[UREG_FP] = csp;
583                 }
584                 if (t->utraps)
585                         t->utraps[0]++;
586         }
587
588         /* Set the return value for the child. */
589         t->kregs->u_regs[UREG_I0] = current->pid;
590         t->kregs->u_regs[UREG_I1] = 1;
591
592         /* Set the second return value for the parent. */
593         regs->u_regs[UREG_I1] = 0;
594
595         if (clone_flags & CLONE_SETTLS)
596                 t->kregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
597
598         return 0;
599 }
600
601 /*
602  * This is the mechanism for creating a new kernel thread.
603  *
604  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
605  * who haven't done an "execve()") should use this: it will work within
606  * a system call from a "real" process, but the process memory space will
607  * not be freed until both the parent and the child have exited.
608  */
609 pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
610 {
611         long retval;
612
613         /* If the parent runs before fn(arg) is called by the child,
614          * the input registers of this function can be clobbered.
615          * So we stash 'fn' and 'arg' into global registers which
616          * will not be modified by the parent.
617          */
618         __asm__ __volatile__("mov %4, %%g2\n\t"    /* Save FN into global */
619                              "mov %5, %%g3\n\t"    /* Save ARG into global */
620                              "mov %1, %%g1\n\t"    /* Clone syscall nr. */
621                              "mov %2, %%o0\n\t"    /* Clone flags. */
622                              "mov 0, %%o1\n\t"     /* usp arg == 0 */
623                              "t 0x6d\n\t"          /* Linux/Sparc clone(). */
624                              "brz,a,pn %%o1, 1f\n\t" /* Parent, just return. */
625                              " mov %%o0, %0\n\t"
626                              "jmpl %%g2, %%o7\n\t"   /* Call the function. */
627                              " mov %%g3, %%o0\n\t"   /* Set arg in delay. */
628                              "mov %3, %%g1\n\t"
629                              "t 0x6d\n\t"          /* Linux/Sparc exit(). */
630                              /* Notreached by child. */
631                              "1:" :
632                              "=r" (retval) :
633                              "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
634                              "i" (__NR_exit),  "r" (fn), "r" (arg) :
635                              "g1", "g2", "g3", "o0", "o1", "memory", "cc");
636         return retval;
637 }
638
639 typedef struct {
640         union {
641                 unsigned int    pr_regs[32];
642                 unsigned long   pr_dregs[16];
643         } pr_fr;
644         unsigned int __unused;
645         unsigned int    pr_fsr;
646         unsigned char   pr_qcnt;
647         unsigned char   pr_q_entrysize;
648         unsigned char   pr_en;
649         unsigned int    pr_q[64];
650 } elf_fpregset_t32;
651
652 /*
653  * fill in the fpu structure for a core dump.
654  */
655 int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
656 {
657         unsigned long *kfpregs = current_thread_info()->fpregs;
658         unsigned long fprs = current_thread_info()->fpsaved[0];
659
660         if (test_thread_flag(TIF_32BIT)) {
661                 elf_fpregset_t32 *fpregs32 = (elf_fpregset_t32 *)fpregs;
662
663                 if (fprs & FPRS_DL)
664                         memcpy(&fpregs32->pr_fr.pr_regs[0], kfpregs,
665                                sizeof(unsigned int) * 32);
666                 else
667                         memset(&fpregs32->pr_fr.pr_regs[0], 0,
668                                sizeof(unsigned int) * 32);
669                 fpregs32->pr_qcnt = 0;
670                 fpregs32->pr_q_entrysize = 8;
671                 memset(&fpregs32->pr_q[0], 0,
672                        (sizeof(unsigned int) * 64));
673                 if (fprs & FPRS_FEF) {
674                         fpregs32->pr_fsr = (unsigned int) current_thread_info()->xfsr[0];
675                         fpregs32->pr_en = 1;
676                 } else {
677                         fpregs32->pr_fsr = 0;
678                         fpregs32->pr_en = 0;
679                 }
680         } else {
681                 if(fprs & FPRS_DL)
682                         memcpy(&fpregs->pr_regs[0], kfpregs,
683                                sizeof(unsigned int) * 32);
684                 else
685                         memset(&fpregs->pr_regs[0], 0,
686                                sizeof(unsigned int) * 32);
687                 if(fprs & FPRS_DU)
688                         memcpy(&fpregs->pr_regs[16], kfpregs+16,
689                                sizeof(unsigned int) * 32);
690                 else
691                         memset(&fpregs->pr_regs[16], 0,
692                                sizeof(unsigned int) * 32);
693                 if(fprs & FPRS_FEF) {
694                         fpregs->pr_fsr = current_thread_info()->xfsr[0];
695                         fpregs->pr_gsr = current_thread_info()->gsr[0];
696                 } else {
697                         fpregs->pr_fsr = fpregs->pr_gsr = 0;
698                 }
699                 fpregs->pr_fprs = fprs;
700         }
701         return 1;
702 }
703
704 /*
705  * sparc_execve() executes a new program after the asm stub has set
706  * things up for us.  This should basically do what I want it to.
707  */
708 asmlinkage int sparc_execve(struct pt_regs *regs)
709 {
710         int error, base = 0;
711         char *filename;
712
713         /* User register window flush is done by entry.S */
714
715         /* Check for indirect call. */
716         if (regs->u_regs[UREG_G1] == 0)
717                 base = 1;
718
719         filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
720         error = PTR_ERR(filename);
721         if (IS_ERR(filename))
722                 goto out;
723         error = do_execve(filename,
724                           (char __user * __user *)
725                           regs->u_regs[base + UREG_I1],
726                           (char __user * __user *)
727                           regs->u_regs[base + UREG_I2], regs);
728         putname(filename);
729         if (!error) {
730                 fprs_write(0);
731                 current_thread_info()->xfsr[0] = 0;
732                 current_thread_info()->fpsaved[0] = 0;
733                 regs->tstate &= ~TSTATE_PEF;
734         }
735 out:
736         return error;
737 }
738
739 unsigned long get_wchan(struct task_struct *task)
740 {
741         unsigned long pc, fp, bias = 0;
742         unsigned long thread_info_base;
743         struct reg_window *rw;
744         unsigned long ret = 0;
745         int count = 0; 
746
747         if (!task || task == current ||
748             task->state == TASK_RUNNING)
749                 goto out;
750
751         thread_info_base = (unsigned long) task_stack_page(task);
752         bias = STACK_BIAS;
753         fp = task_thread_info(task)->ksp + bias;
754
755         do {
756                 /* Bogus frame pointer? */
757                 if (fp < (thread_info_base + sizeof(struct thread_info)) ||
758                     fp >= (thread_info_base + THREAD_SIZE))
759                         break;
760                 rw = (struct reg_window *) fp;
761                 pc = rw->ins[7];
762                 if (!in_sched_functions(pc)) {
763                         ret = pc;
764                         goto out;
765                 }
766                 fp = rw->ins[6] + bias;
767         } while (++count < 16);
768
769 out:
770         return ret;
771 }