Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / arch / ppc / kernel / process.c
1 /*
2  *  arch/ppc/kernel/process.c
3  *
4  *  Derived from "arch/i386/kernel/process.c"
5  *    Copyright (C) 1995  Linus Torvalds
6  *
7  *  Updated and modified by Cort Dougan (cort@cs.nmt.edu) and
8  *  Paul Mackerras (paulus@cs.anu.edu.au)
9  *
10  *  PowerPC version
11  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
12  *
13  *  This program is free software; you can redistribute it and/or
14  *  modify it under the terms of the GNU General Public License
15  *  as published by the Free Software Foundation; either version
16  *  2 of the License, or (at your option) any later version.
17  *
18  */
19
20 #include <linux/config.h>
21 #include <linux/errno.h>
22 #include <linux/sched.h>
23 #include <linux/kernel.h>
24 #include <linux/mm.h>
25 #include <linux/smp.h>
26 #include <linux/smp_lock.h>
27 #include <linux/stddef.h>
28 #include <linux/unistd.h>
29 #include <linux/ptrace.h>
30 #include <linux/slab.h>
31 #include <linux/user.h>
32 #include <linux/elf.h>
33 #include <linux/init.h>
34 #include <linux/prctl.h>
35 #include <linux/init_task.h>
36 #include <linux/module.h>
37 #include <linux/kallsyms.h>
38 #include <linux/mqueue.h>
39 #include <linux/hardirq.h>
40
41 #include <asm/pgtable.h>
42 #include <asm/uaccess.h>
43 #include <asm/system.h>
44 #include <asm/io.h>
45 #include <asm/processor.h>
46 #include <asm/mmu.h>
47 #include <asm/prom.h>
48
49 extern unsigned long _get_SP(void);
50
51 struct task_struct *last_task_used_math = NULL;
52 struct task_struct *last_task_used_altivec = NULL;
53 struct task_struct *last_task_used_spe = NULL;
54
55 static struct fs_struct init_fs = INIT_FS;
56 static struct files_struct init_files = INIT_FILES;
57 static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
58 static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
59 struct mm_struct init_mm = INIT_MM(init_mm);
60 EXPORT_SYMBOL(init_mm);
61
62 /* this is 8kB-aligned so we can get to the thread_info struct
63    at the base of it from the stack pointer with 1 integer instruction. */
64 union thread_union init_thread_union
65         __attribute__((__section__(".data.init_task"))) =
66 { INIT_THREAD_INFO(init_task) };
67
68 /* initial task structure */
69 struct task_struct init_task = INIT_TASK(init_task);
70 EXPORT_SYMBOL(init_task);
71
72 /* only used to get secondary processor up */
73 struct task_struct *current_set[NR_CPUS] = {&init_task, };
74
75 #undef SHOW_TASK_SWITCHES
76 #undef CHECK_STACK
77
78 #if defined(CHECK_STACK)
79 unsigned long
80 kernel_stack_top(struct task_struct *tsk)
81 {
82         return ((unsigned long)tsk) + sizeof(union task_union);
83 }
84
85 unsigned long
86 task_top(struct task_struct *tsk)
87 {
88         return ((unsigned long)tsk) + sizeof(struct thread_info);
89 }
90
91 /* check to make sure the kernel stack is healthy */
92 int check_stack(struct task_struct *tsk)
93 {
94         unsigned long stack_top = kernel_stack_top(tsk);
95         unsigned long tsk_top = task_top(tsk);
96         int ret = 0;
97
98 #if 0
99         /* check thread magic */
100         if ( tsk->thread.magic != THREAD_MAGIC )
101         {
102                 ret |= 1;
103                 printk("thread.magic bad: %08x\n", tsk->thread.magic);
104         }
105 #endif
106
107         if ( !tsk )
108                 printk("check_stack(): tsk bad tsk %p\n",tsk);
109
110         /* check if stored ksp is bad */
111         if ( (tsk->thread.ksp > stack_top) || (tsk->thread.ksp < tsk_top) )
112         {
113                 printk("stack out of bounds: %s/%d\n"
114                        " tsk_top %08lx ksp %08lx stack_top %08lx\n",
115                        tsk->comm,tsk->pid,
116                        tsk_top, tsk->thread.ksp, stack_top);
117                 ret |= 2;
118         }
119
120         /* check if stack ptr RIGHT NOW is bad */
121         if ( (tsk == current) && ((_get_SP() > stack_top ) || (_get_SP() < tsk_top)) )
122         {
123                 printk("current stack ptr out of bounds: %s/%d\n"
124                        " tsk_top %08lx sp %08lx stack_top %08lx\n",
125                        current->comm,current->pid,
126                        tsk_top, _get_SP(), stack_top);
127                 ret |= 4;
128         }
129
130 #if 0
131         /* check amount of free stack */
132         for ( i = (unsigned long *)task_top(tsk) ; i < kernel_stack_top(tsk) ; i++ )
133         {
134                 if ( !i )
135                         printk("check_stack(): i = %p\n", i);
136                 if ( *i != 0 )
137                 {
138                         /* only notify if it's less than 900 bytes */
139                         if ( (i - (unsigned long *)task_top(tsk))  < 900 )
140                                 printk("%d bytes free on stack\n",
141                                        i - task_top(tsk));
142                         break;
143                 }
144         }
145 #endif
146
147         if (ret)
148         {
149                 panic("bad kernel stack");
150         }
151         return(ret);
152 }
153 #endif /* defined(CHECK_STACK) */
154
155 /*
156  * Make sure the floating-point register state in the
157  * the thread_struct is up to date for task tsk.
158  */
159 void flush_fp_to_thread(struct task_struct *tsk)
160 {
161         if (tsk->thread.regs) {
162                 /*
163                  * We need to disable preemption here because if we didn't,
164                  * another process could get scheduled after the regs->msr
165                  * test but before we have finished saving the FP registers
166                  * to the thread_struct.  That process could take over the
167                  * FPU, and then when we get scheduled again we would store
168                  * bogus values for the remaining FP registers.
169                  */
170                 preempt_disable();
171                 if (tsk->thread.regs->msr & MSR_FP) {
172 #ifdef CONFIG_SMP
173                         /*
174                          * This should only ever be called for current or
175                          * for a stopped child process.  Since we save away
176                          * the FP register state on context switch on SMP,
177                          * there is something wrong if a stopped child appears
178                          * to still have its FP state in the CPU registers.
179                          */
180                         BUG_ON(tsk != current);
181 #endif
182                         giveup_fpu(current);
183                 }
184                 preempt_enable();
185         }
186 }
187
188 void enable_kernel_fp(void)
189 {
190         WARN_ON(preemptible());
191
192 #ifdef CONFIG_SMP
193         if (current->thread.regs && (current->thread.regs->msr & MSR_FP))
194                 giveup_fpu(current);
195         else
196                 giveup_fpu(NULL);       /* just enables FP for kernel */
197 #else
198         giveup_fpu(last_task_used_math);
199 #endif /* CONFIG_SMP */
200 }
201 EXPORT_SYMBOL(enable_kernel_fp);
202
203 int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
204 {
205         preempt_disable();
206         if (tsk->thread.regs && (tsk->thread.regs->msr & MSR_FP))
207                 giveup_fpu(tsk);
208         preempt_enable();
209         memcpy(fpregs, &tsk->thread.fpr[0], sizeof(*fpregs));
210         return 1;
211 }
212
213 #ifdef CONFIG_ALTIVEC
214 void enable_kernel_altivec(void)
215 {
216         WARN_ON(preemptible());
217
218 #ifdef CONFIG_SMP
219         if (current->thread.regs && (current->thread.regs->msr & MSR_VEC))
220                 giveup_altivec(current);
221         else
222                 giveup_altivec(NULL);   /* just enable AltiVec for kernel - force */
223 #else
224         giveup_altivec(last_task_used_altivec);
225 #endif /* __SMP __ */
226 }
227 EXPORT_SYMBOL(enable_kernel_altivec);
228
229 /*
230  * Make sure the VMX/Altivec register state in the
231  * the thread_struct is up to date for task tsk.
232  */
233 void flush_altivec_to_thread(struct task_struct *tsk)
234 {
235         if (tsk->thread.regs) {
236                 preempt_disable();
237                 if (tsk->thread.regs->msr & MSR_VEC) {
238 #ifdef CONFIG_SMP
239                         BUG_ON(tsk != current);
240 #endif
241                         giveup_altivec(current);
242                 }
243                 preempt_enable();
244         }
245 }
246
247 int dump_altivec(struct pt_regs *regs, elf_vrregset_t *vrregs)
248 {
249         if (regs->msr & MSR_VEC)
250                 giveup_altivec(current);
251         memcpy(vrregs, &current->thread.vr[0], sizeof(*vrregs));
252         return 1;
253 }
254 #endif /* CONFIG_ALTIVEC */
255
256 #ifdef CONFIG_SPE
257 void
258 enable_kernel_spe(void)
259 {
260         WARN_ON(preemptible());
261
262 #ifdef CONFIG_SMP
263         if (current->thread.regs && (current->thread.regs->msr & MSR_SPE))
264                 giveup_spe(current);
265         else
266                 giveup_spe(NULL);       /* just enable SPE for kernel - force */
267 #else
268         giveup_spe(last_task_used_spe);
269 #endif /* __SMP __ */
270 }
271 EXPORT_SYMBOL(enable_kernel_spe);
272
273 void flush_spe_to_thread(struct task_struct *tsk)
274 {
275         if (tsk->thread.regs) {
276                 preempt_disable();
277                 if (tsk->thread.regs->msr & MSR_SPE) {
278 #ifdef CONFIG_SMP
279                         BUG_ON(tsk != current);
280 #endif
281                         giveup_spe(current);
282                 }
283                 preempt_enable();
284         }
285 }
286
287 int dump_spe(struct pt_regs *regs, elf_vrregset_t *evrregs)
288 {
289         if (regs->msr & MSR_SPE)
290                 giveup_spe(current);
291         /* We copy u32 evr[32] + u64 acc + u32 spefscr -> 35 */
292         memcpy(evrregs, &current->thread.evr[0], sizeof(u32) * 35);
293         return 1;
294 }
295 #endif /* CONFIG_SPE */
296
297 struct task_struct *__switch_to(struct task_struct *prev,
298         struct task_struct *new)
299 {
300         struct thread_struct *new_thread, *old_thread;
301         unsigned long s;
302         struct task_struct *last;
303
304         local_irq_save(s);
305 #ifdef CHECK_STACK
306         check_stack(prev);
307         check_stack(new);
308 #endif
309
310 #ifdef CONFIG_SMP
311         /* avoid complexity of lazy save/restore of fpu
312          * by just saving it every time we switch out if
313          * this task used the fpu during the last quantum.
314          *
315          * If it tries to use the fpu again, it'll trap and
316          * reload its fp regs.  So we don't have to do a restore
317          * every switch, just a save.
318          *  -- Cort
319          */
320         if (prev->thread.regs && (prev->thread.regs->msr & MSR_FP))
321                 giveup_fpu(prev);
322 #ifdef CONFIG_ALTIVEC
323         /*
324          * If the previous thread used altivec in the last quantum
325          * (thus changing altivec regs) then save them.
326          * We used to check the VRSAVE register but not all apps
327          * set it, so we don't rely on it now (and in fact we need
328          * to save & restore VSCR even if VRSAVE == 0).  -- paulus
329          *
330          * On SMP we always save/restore altivec regs just to avoid the
331          * complexity of changing processors.
332          *  -- Cort
333          */
334         if ((prev->thread.regs && (prev->thread.regs->msr & MSR_VEC)))
335                 giveup_altivec(prev);
336 #endif /* CONFIG_ALTIVEC */
337 #ifdef CONFIG_SPE
338         /*
339          * If the previous thread used spe in the last quantum
340          * (thus changing spe regs) then save them.
341          *
342          * On SMP we always save/restore spe regs just to avoid the
343          * complexity of changing processors.
344          */
345         if ((prev->thread.regs && (prev->thread.regs->msr & MSR_SPE)))
346                 giveup_spe(prev);
347 #endif /* CONFIG_SPE */
348 #endif /* CONFIG_SMP */
349
350 #ifdef CONFIG_ALTIVEC
351         /* Avoid the trap.  On smp this this never happens since
352          * we don't set last_task_used_altivec -- Cort
353          */
354         if (new->thread.regs && last_task_used_altivec == new)
355                 new->thread.regs->msr |= MSR_VEC;
356 #endif
357 #ifdef CONFIG_SPE
358         /* Avoid the trap.  On smp this this never happens since
359          * we don't set last_task_used_spe
360          */
361         if (new->thread.regs && last_task_used_spe == new)
362                 new->thread.regs->msr |= MSR_SPE;
363 #endif /* CONFIG_SPE */
364         new_thread = &new->thread;
365         old_thread = &current->thread;
366         last = _switch(old_thread, new_thread);
367         local_irq_restore(s);
368         return last;
369 }
370
371 void show_regs(struct pt_regs * regs)
372 {
373         int i, trap;
374
375         printk("NIP: %08lX LR: %08lX SP: %08lX REGS: %p TRAP: %04lx    %s\n",
376                regs->nip, regs->link, regs->gpr[1], regs, regs->trap,
377                print_tainted());
378         printk("MSR: %08lx EE: %01x PR: %01x FP: %01x ME: %01x IR/DR: %01x%01x\n",
379                regs->msr, regs->msr&MSR_EE ? 1 : 0, regs->msr&MSR_PR ? 1 : 0,
380                regs->msr & MSR_FP ? 1 : 0,regs->msr&MSR_ME ? 1 : 0,
381                regs->msr&MSR_IR ? 1 : 0,
382                regs->msr&MSR_DR ? 1 : 0);
383         trap = TRAP(regs);
384         if (trap == 0x300 || trap == 0x600)
385                 printk("DAR: %08lX, DSISR: %08lX\n", regs->dar, regs->dsisr);
386         printk("TASK = %p[%d] '%s' THREAD: %p\n",
387                current, current->pid, current->comm, current->thread_info);
388         printk("Last syscall: %ld ", current->thread.last_syscall);
389
390 #ifdef CONFIG_SMP
391         printk(" CPU: %d", smp_processor_id());
392 #endif /* CONFIG_SMP */
393
394         for (i = 0;  i < 32;  i++) {
395                 long r;
396                 if ((i % 8) == 0)
397                         printk("\n" KERN_INFO "GPR%02d: ", i);
398                 if (__get_user(r, &regs->gpr[i]))
399                         break;
400                 printk("%08lX ", r);
401                 if (i == 12 && !FULL_REGS(regs))
402                         break;
403         }
404         printk("\n");
405 #ifdef CONFIG_KALLSYMS
406         /*
407          * Lookup NIP late so we have the best change of getting the
408          * above info out without failing
409          */
410         printk("NIP [%08lx] ", regs->nip);
411         print_symbol("%s\n", regs->nip);
412         printk("LR [%08lx] ", regs->link);
413         print_symbol("%s\n", regs->link);
414 #endif
415         show_stack(current, (unsigned long *) regs->gpr[1]);
416 }
417
418 void exit_thread(void)
419 {
420         if (last_task_used_math == current)
421                 last_task_used_math = NULL;
422         if (last_task_used_altivec == current)
423                 last_task_used_altivec = NULL;
424 #ifdef CONFIG_SPE
425         if (last_task_used_spe == current)
426                 last_task_used_spe = NULL;
427 #endif
428 }
429
430 void flush_thread(void)
431 {
432         if (last_task_used_math == current)
433                 last_task_used_math = NULL;
434         if (last_task_used_altivec == current)
435                 last_task_used_altivec = NULL;
436 #ifdef CONFIG_SPE
437         if (last_task_used_spe == current)
438                 last_task_used_spe = NULL;
439 #endif
440 }
441
442 void
443 release_thread(struct task_struct *t)
444 {
445 }
446
447 /*
448  * This gets called before we allocate a new thread and copy
449  * the current task into it.
450  */
451 void prepare_to_copy(struct task_struct *tsk)
452 {
453         struct pt_regs *regs = tsk->thread.regs;
454
455         if (regs == NULL)
456                 return;
457         preempt_disable();
458         if (regs->msr & MSR_FP)
459                 giveup_fpu(current);
460 #ifdef CONFIG_ALTIVEC
461         if (regs->msr & MSR_VEC)
462                 giveup_altivec(current);
463 #endif /* CONFIG_ALTIVEC */
464 #ifdef CONFIG_SPE
465         if (regs->msr & MSR_SPE)
466                 giveup_spe(current);
467 #endif /* CONFIG_SPE */
468         preempt_enable();
469 }
470
471 /*
472  * Copy a thread..
473  */
474 int
475 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
476             unsigned long unused,
477             struct task_struct *p, struct pt_regs *regs)
478 {
479         struct pt_regs *childregs, *kregs;
480         extern void ret_from_fork(void);
481         unsigned long sp = (unsigned long)p->thread_info + THREAD_SIZE;
482         unsigned long childframe;
483
484         CHECK_FULL_REGS(regs);
485         /* Copy registers */
486         sp -= sizeof(struct pt_regs);
487         childregs = (struct pt_regs *) sp;
488         *childregs = *regs;
489         if ((childregs->msr & MSR_PR) == 0) {
490                 /* for kernel thread, set `current' and stackptr in new task */
491                 childregs->gpr[1] = sp + sizeof(struct pt_regs);
492                 childregs->gpr[2] = (unsigned long) p;
493                 p->thread.regs = NULL;  /* no user register state */
494         } else {
495                 childregs->gpr[1] = usp;
496                 p->thread.regs = childregs;
497                 if (clone_flags & CLONE_SETTLS)
498                         childregs->gpr[2] = childregs->gpr[6];
499         }
500         childregs->gpr[3] = 0;  /* Result from fork() */
501         sp -= STACK_FRAME_OVERHEAD;
502         childframe = sp;
503
504         /*
505          * The way this works is that at some point in the future
506          * some task will call _switch to switch to the new task.
507          * That will pop off the stack frame created below and start
508          * the new task running at ret_from_fork.  The new task will
509          * do some house keeping and then return from the fork or clone
510          * system call, using the stack frame created above.
511          */
512         sp -= sizeof(struct pt_regs);
513         kregs = (struct pt_regs *) sp;
514         sp -= STACK_FRAME_OVERHEAD;
515         p->thread.ksp = sp;
516         kregs->nip = (unsigned long)ret_from_fork;
517
518         p->thread.last_syscall = -1;
519
520         return 0;
521 }
522
523 /*
524  * Set up a thread for executing a new program
525  */
526 void start_thread(struct pt_regs *regs, unsigned long nip, unsigned long sp)
527 {
528         set_fs(USER_DS);
529         memset(regs->gpr, 0, sizeof(regs->gpr));
530         regs->ctr = 0;
531         regs->link = 0;
532         regs->xer = 0;
533         regs->ccr = 0;
534         regs->mq = 0;
535         regs->nip = nip;
536         regs->gpr[1] = sp;
537         regs->msr = MSR_USER;
538         if (last_task_used_math == current)
539                 last_task_used_math = NULL;
540         if (last_task_used_altivec == current)
541                 last_task_used_altivec = NULL;
542 #ifdef CONFIG_SPE
543         if (last_task_used_spe == current)
544                 last_task_used_spe = NULL;
545 #endif
546         memset(current->thread.fpr, 0, sizeof(current->thread.fpr));
547         current->thread.fpscr.val = 0;
548 #ifdef CONFIG_ALTIVEC
549         memset(current->thread.vr, 0, sizeof(current->thread.vr));
550         memset(&current->thread.vscr, 0, sizeof(current->thread.vscr));
551         current->thread.vrsave = 0;
552         current->thread.used_vr = 0;
553 #endif /* CONFIG_ALTIVEC */
554 #ifdef CONFIG_SPE
555         memset(current->thread.evr, 0, sizeof(current->thread.evr));
556         current->thread.acc = 0;
557         current->thread.spefscr = 0;
558         current->thread.used_spe = 0;
559 #endif /* CONFIG_SPE */
560 }
561
562 #define PR_FP_ALL_EXCEPT (PR_FP_EXC_DIV | PR_FP_EXC_OVF | PR_FP_EXC_UND \
563                 | PR_FP_EXC_RES | PR_FP_EXC_INV)
564
565 int set_fpexc_mode(struct task_struct *tsk, unsigned int val)
566 {
567         struct pt_regs *regs = tsk->thread.regs;
568
569         /* This is a bit hairy.  If we are an SPE enabled  processor
570          * (have embedded fp) we store the IEEE exception enable flags in
571          * fpexc_mode.  fpexc_mode is also used for setting FP exception
572          * mode (asyn, precise, disabled) for 'Classic' FP. */
573         if (val & PR_FP_EXC_SW_ENABLE) {
574 #ifdef CONFIG_SPE
575                 tsk->thread.fpexc_mode = val &
576                         (PR_FP_EXC_SW_ENABLE | PR_FP_ALL_EXCEPT);
577 #else
578                 return -EINVAL;
579 #endif
580         } else {
581                 /* on a CONFIG_SPE this does not hurt us.  The bits that
582                  * __pack_fe01 use do not overlap with bits used for
583                  * PR_FP_EXC_SW_ENABLE.  Additionally, the MSR[FE0,FE1] bits
584                  * on CONFIG_SPE implementations are reserved so writing to
585                  * them does not change anything */
586                 if (val > PR_FP_EXC_PRECISE)
587                         return -EINVAL;
588                 tsk->thread.fpexc_mode = __pack_fe01(val);
589                 if (regs != NULL && (regs->msr & MSR_FP) != 0)
590                         regs->msr = (regs->msr & ~(MSR_FE0|MSR_FE1))
591                                 | tsk->thread.fpexc_mode;
592         }
593         return 0;
594 }
595
596 int get_fpexc_mode(struct task_struct *tsk, unsigned long adr)
597 {
598         unsigned int val;
599
600         if (tsk->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE)
601 #ifdef CONFIG_SPE
602                 val = tsk->thread.fpexc_mode;
603 #else
604                 return -EINVAL;
605 #endif
606         else
607                 val = __unpack_fe01(tsk->thread.fpexc_mode);
608         return put_user(val, (unsigned int __user *) adr);
609 }
610
611 int sys_clone(unsigned long clone_flags, unsigned long usp,
612               int __user *parent_tidp, void __user *child_threadptr,
613               int __user *child_tidp, int p6,
614               struct pt_regs *regs)
615 {
616         CHECK_FULL_REGS(regs);
617         if (usp == 0)
618                 usp = regs->gpr[1];     /* stack pointer for child */
619         return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp);
620 }
621
622 int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3,
623              unsigned long p4, unsigned long p5, unsigned long p6,
624              struct pt_regs *regs)
625 {
626         CHECK_FULL_REGS(regs);
627         return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL);
628 }
629
630 int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3,
631               unsigned long p4, unsigned long p5, unsigned long p6,
632               struct pt_regs *regs)
633 {
634         CHECK_FULL_REGS(regs);
635         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1],
636                         regs, 0, NULL, NULL);
637 }
638
639 int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
640                unsigned long a3, unsigned long a4, unsigned long a5,
641                struct pt_regs *regs)
642 {
643         int error;
644         char * filename;
645
646         filename = getname((char __user *) a0);
647         error = PTR_ERR(filename);
648         if (IS_ERR(filename))
649                 goto out;
650         preempt_disable();
651         if (regs->msr & MSR_FP)
652                 giveup_fpu(current);
653 #ifdef CONFIG_ALTIVEC
654         if (regs->msr & MSR_VEC)
655                 giveup_altivec(current);
656 #endif /* CONFIG_ALTIVEC */
657 #ifdef CONFIG_SPE
658         if (regs->msr & MSR_SPE)
659                 giveup_spe(current);
660 #endif /* CONFIG_SPE */
661         preempt_enable();
662         error = do_execve(filename, (char __user *__user *) a1,
663                           (char __user *__user *) a2, regs);
664         if (error == 0) {
665                 task_lock(current);
666                 current->ptrace &= ~PT_DTRACE;
667                 task_unlock(current);
668         }
669         putname(filename);
670 out:
671         return error;
672 }
673
674 void dump_stack(void)
675 {
676         show_stack(current, NULL);
677 }
678
679 EXPORT_SYMBOL(dump_stack);
680
681 void show_stack(struct task_struct *tsk, unsigned long *stack)
682 {
683         unsigned long sp, stack_top, prev_sp, ret;
684         int count = 0;
685         unsigned long next_exc = 0;
686         struct pt_regs *regs;
687         extern char ret_from_except, ret_from_except_full, ret_from_syscall;
688
689         sp = (unsigned long) stack;
690         if (tsk == NULL)
691                 tsk = current;
692         if (sp == 0) {
693                 if (tsk == current)
694                         asm("mr %0,1" : "=r" (sp));
695                 else
696                         sp = tsk->thread.ksp;
697         }
698
699         prev_sp = (unsigned long) (tsk->thread_info + 1);
700         stack_top = (unsigned long) tsk->thread_info + THREAD_SIZE;
701         while (count < 16 && sp > prev_sp && sp < stack_top && (sp & 3) == 0) {
702                 if (count == 0) {
703                         printk("Call trace:");
704 #ifdef CONFIG_KALLSYMS
705                         printk("\n");
706 #endif
707                 } else {
708                         if (next_exc) {
709                                 ret = next_exc;
710                                 next_exc = 0;
711                         } else
712                                 ret = *(unsigned long *)(sp + 4);
713                         printk(" [%08lx] ", ret);
714 #ifdef CONFIG_KALLSYMS
715                         print_symbol("%s", ret);
716                         printk("\n");
717 #endif
718                         if (ret == (unsigned long) &ret_from_except
719                             || ret == (unsigned long) &ret_from_except_full
720                             || ret == (unsigned long) &ret_from_syscall) {
721                                 /* sp + 16 points to an exception frame */
722                                 regs = (struct pt_regs *) (sp + 16);
723                                 if (sp + 16 + sizeof(*regs) <= stack_top)
724                                         next_exc = regs->nip;
725                         }
726                 }
727                 ++count;
728                 sp = *(unsigned long *)sp;
729         }
730 #ifndef CONFIG_KALLSYMS
731         if (count > 0)
732                 printk("\n");
733 #endif
734 }
735
736 #if 0
737 /*
738  * Low level print for debugging - Cort
739  */
740 int __init ll_printk(const char *fmt, ...)
741 {
742         va_list args;
743         char buf[256];
744         int i;
745
746         va_start(args, fmt);
747         i=vsprintf(buf,fmt,args);
748         ll_puts(buf);
749         va_end(args);
750         return i;
751 }
752
753 int lines = 24, cols = 80;
754 int orig_x = 0, orig_y = 0;
755
756 void puthex(unsigned long val)
757 {
758         unsigned char buf[10];
759         int i;
760         for (i = 7;  i >= 0;  i--)
761         {
762                 buf[i] = "0123456789ABCDEF"[val & 0x0F];
763                 val >>= 4;
764         }
765         buf[8] = '\0';
766         prom_print(buf);
767 }
768
769 void __init ll_puts(const char *s)
770 {
771         int x,y;
772         char *vidmem = (char *)/*(_ISA_MEM_BASE + 0xB8000) */0xD00B8000;
773         char c;
774         extern int mem_init_done;
775
776         if ( mem_init_done ) /* assume this means we can printk */
777         {
778                 printk(s);
779                 return;
780         }
781
782 #if 0
783         if ( have_of )
784         {
785                 prom_print(s);
786                 return;
787         }
788 #endif
789
790         /*
791          * can't ll_puts on chrp without openfirmware yet.
792          * vidmem just needs to be setup for it.
793          * -- Cort
794          */
795         if ( _machine != _MACH_prep )
796                 return;
797         x = orig_x;
798         y = orig_y;
799
800         while ( ( c = *s++ ) != '\0' ) {
801                 if ( c == '\n' ) {
802                         x = 0;
803                         if ( ++y >= lines ) {
804                                 /*scroll();*/
805                                 /*y--;*/
806                                 y = 0;
807                         }
808                 } else {
809                         vidmem [ ( x + cols * y ) * 2 ] = c;
810                         if ( ++x >= cols ) {
811                                 x = 0;
812                                 if ( ++y >= lines ) {
813                                         /*scroll();*/
814                                         /*y--;*/
815                                         y = 0;
816                                 }
817                         }
818                 }
819         }
820
821         orig_x = x;
822         orig_y = y;
823 }
824 #endif
825
826 unsigned long get_wchan(struct task_struct *p)
827 {
828         unsigned long ip, sp;
829         unsigned long stack_page = (unsigned long) p->thread_info;
830         int count = 0;
831         if (!p || p == current || p->state == TASK_RUNNING)
832                 return 0;
833         sp = p->thread.ksp;
834         do {
835                 sp = *(unsigned long *)sp;
836                 if (sp < stack_page || sp >= stack_page + 8188)
837                         return 0;
838                 if (count > 0) {
839                         ip = *(unsigned long *)(sp + 4);
840                         if (!in_sched_functions(ip))
841                                 return ip;
842                 }
843         } while (count++ < 16);
844         return 0;
845 }