arch/sparc/kernel/process.c

   1 /*  $Id: process.c,v 1.150 2000/07/11 18:49:22 anton Exp $
   2  *  linux/arch/sparc/kernel/process.c
   3  *
   4  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   5  *  Copyright (C) 1996 Eddie C. Dost   (ecd@skynet.be)
   6  */
   7
   8 /*
   9  * This file handles the architecture-dependent parts of process handling..
  10  */
  11
  12 #define __KERNEL_SYSCALLS__
  13 #include <stdarg.h>
  14
  15 #include <linux/errno.h>
  16 #include <linux/sched.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mm.h>
  19 #include <linux/stddef.h>
  20 #include <linux/unistd.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/malloc.h>
  23 #include <linux/user.h>
  24 #include <linux/a.out.h>
  25 #include <linux/config.h>
  26 #include <linux/smp.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/reboot.h>
  29 #include <linux/delay.h>
  30
  31 #include <asm/auxio.h>
  32 #include <asm/oplib.h>
  33 #include <asm/uaccess.h>
  34 #include <asm/system.h>
  35 #include <asm/page.h>
  36 #include <asm/pgalloc.h>
  37 #include <asm/pgtable.h>
  38 #include <asm/delay.h>
  39 #include <asm/processor.h>
  40 #include <asm/psr.h>
  41 #include <asm/elf.h>
  42
  43 extern void fpsave(unsigned long *, unsigned long *, void *, unsigned long *);
  44
  45 struct task_struct *last_task_used_math = NULL;
  46 struct task_struct *current_set[NR_CPUS] = {&init_task, };
  47
  48 #ifndef CONFIG_SMP
  49
  50 #define SUN4C_FAULT_HIGH 100
  51
  52 /*
  53  * the idle loop on a Sparc... ;)
  54  */
  55 int cpu_idle(void)
  56 {
  57         int ret = -EPERM;
  58
  59         if (current->pid != 0)
  60                 goto out;
  61
  62         /* endless idle loop with no priority at all */
  63         current->nice = 20;
  64         current->counter = -100;
  65         init_idle();
  66
  67         for (;;) {
  68                 if (ARCH_SUN4C_SUN4) {
  69                         static int count = HZ;
  70                         static unsigned long last_jiffies = 0;
  71                         static unsigned long last_faults = 0;
  72                         static unsigned long fps = 0;
  73                         unsigned long now;
  74                         unsigned long faults;
  75                         unsigned long flags;
  76
  77                         extern unsigned long sun4c_kernel_faults;
  78                         extern void sun4c_grow_kernel_ring(void);
  79
  80                         save_and_cli(flags);
  81                         now = jiffies;
  82                         count -= (now - last_jiffies);
  83                         last_jiffies = now;
  84                         if (count < 0) {
  85                                 count += HZ;
  86                                 faults = sun4c_kernel_faults;
  87                                 fps = (fps + (faults - last_faults)) >> 1;
  88                                 last_faults = faults;
  89 #if 0
  90                                 printk("kernel faults / second = %d\n", fps);
  91 #endif
  92                                 if (fps >= SUN4C_FAULT_HIGH) {
  93                                         sun4c_grow_kernel_ring();
  94                                 }
  95                         }
  96                         restore_flags(flags);
  97                 }
  98                 check_pgt_cache();
  99                 schedule();
 100         }
 101         ret = 0;
 102 out:
 103         return ret;
 104 }
 105
 106 #else
 107
 108 /* This is being executed in task 0 'user space'. */
 109 int cpu_idle(void)
 110 {
 111         /* endless idle loop with no priority at all */
 112         current->nice = 20;
 113         current->counter = -100;
 114         init_idle();
 115
 116         while(1) {
 117                 if(current->need_resched) {
 118                         schedule();
 119                         check_pgt_cache();
 120                 }
 121                 barrier(); /* or else gcc optimizes... */
 122         }
 123 }
 124
 125 #endif
 126
 127 extern char reboot_command [];
 128
 129 extern int serial_console;
 130
 131 #ifdef CONFIG_SUN_CONSOLE
 132 extern void (*prom_palette)(int);
 133 #endif
 134
 135 void machine_halt(void)
 136 {
 137         sti();
 138         mdelay(8);
 139         cli();
 140 #ifdef CONFIG_SUN_CONSOLE
 141         if (!serial_console && prom_palette)
 142                 prom_palette (1);
 143 #endif
 144         prom_halt();
 145         panic("Halt failed!");
 146 }
 147
 148 void machine_restart(char * cmd)
 149 {
 150         char *p;
 151
 152         sti();
 153         mdelay(8);
 154         cli();
 155
 156         p = strchr (reboot_command, '\n');
 157         if (p) *p = 0;
 158 #ifdef CONFIG_SUN_CONSOLE
 159         if (!serial_console && prom_palette)
 160                 prom_palette (1);
 161 #endif
 162         if (cmd)
 163                 prom_reboot(cmd);
 164         if (*reboot_command)
 165                 prom_reboot(reboot_command);
 166         prom_feval ("reset");
 167         panic("Reboot failed!");
 168 }
 169
 170 void machine_power_off(void)
 171 {
 172 #ifdef CONFIG_SUN_AUXIO
 173         if (auxio_power_register && !serial_console)
 174                 *auxio_power_register |= AUXIO_POWER_OFF;
 175 #endif
 176         machine_halt();
 177 }
 178
 179 void show_regwindow(struct reg_window *rw)
 180 {
 181         printk("l0: %08lx l1: %08lx l2: %08lx l3: %08lx "
 182                "l4: %08lx l5: %08lx l6: %08lx l7: %08lx\n",
 183                rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3],
 184                rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
 185         printk("i0: %08lx i1: %08lx i2: %08lx i3: %08lx "
 186                "i4: %08lx i5: %08lx fp: %08lx i7: %08lx\n",
 187                rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 188                rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
 189 }
 190
 191 static spinlock_t sparc_backtrace_lock = SPIN_LOCK_UNLOCKED;
 192
 193 void __show_backtrace(unsigned long fp)
 194 {
 195         struct reg_window *rw;
 196         unsigned long flags;
 197         int cpu = smp_processor_id();
 198
 199         spin_lock_irqsave(&sparc_backtrace_lock, flags);
 200
 201         rw = (struct reg_window *)fp;
 202         while(rw && (((unsigned long) rw) >= PAGE_OFFSET) &&
 203             !(((unsigned long) rw) & 0x7)) {
 204                 printk("CPU[%d]: ARGS[%08lx,%08lx,%08lx,%08lx,%08lx,%08lx] "
 205                        "FP[%08lx] CALLER[%08lx]\n", cpu,
 206                        rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 207                        rw->ins[4], rw->ins[5],
 208                        rw->ins[6],
 209                        rw->ins[7]);
 210                 rw = (struct reg_window *) rw->ins[6];
 211         }
 212         spin_unlock_irqrestore(&sparc_backtrace_lock, flags);
 213 }
 214
 215 #define __SAVE __asm__ __volatile__("save %sp, -0x40, %sp\n\t")
 216 #define __RESTORE __asm__ __volatile__("restore %g0, %g0, %g0\n\t")
 217 #define __GET_FP(fp) __asm__ __volatile__("mov %%i6, %0" : "=r" (fp))
 218
 219 void show_backtrace(void)
 220 {
 221         unsigned long fp;
 222
 223         __SAVE; __SAVE; __SAVE; __SAVE;
 224         __SAVE; __SAVE; __SAVE; __SAVE;
 225         __RESTORE; __RESTORE; __RESTORE; __RESTORE;
 226         __RESTORE; __RESTORE; __RESTORE; __RESTORE;
 227
 228         __GET_FP(fp);
 229
 230         __show_backtrace(fp);
 231 }
 232
 233 #ifdef CONFIG_SMP
 234 void smp_show_backtrace_all_cpus(void)
 235 {
 236         xc0((smpfunc_t) show_backtrace);
 237         show_backtrace();
 238 }
 239 #endif
 240
 241 void show_stackframe(struct sparc_stackf *sf)
 242 {
 243         unsigned long size;
 244         unsigned long *stk;
 245         int i;
 246
 247         printk("l0: %08lx l1: %08lx l2: %08lx l3: %08lx "
 248                "l4: %08lx l5: %08lx l6: %08lx l7: %08lx\n",
 249                sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
 250                sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
 251         printk("i0: %08lx i1: %08lx i2: %08lx i3: %08lx "
 252                "i4: %08lx i5: %08lx fp: %08lx i7: %08lx\n",
 253                sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
 254                sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
 255         printk("sp: %08lx x0: %08lx x1: %08lx x2: %08lx "
 256                "x3: %08lx x4: %08lx x5: %08lx xx: %08lx\n",
 257                (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
 258                sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
 259                sf->xxargs[0]);
 260         size = ((unsigned long)sf->fp) - ((unsigned long)sf);
 261         size -= STACKFRAME_SZ;
 262         stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
 263         i = 0;
 264         do {
 265                 printk("s%d: %08lx\n", i++, *stk++);
 266         } while ((size -= sizeof(unsigned long)));
 267 }
 268
 269 void show_regs(struct pt_regs * regs)
 270 {
 271         printk("PSR: %08lx PC: %08lx NPC: %08lx Y: %08lx\n", regs->psr,
 272                regs->pc, regs->npc, regs->y);
 273         printk("g0: %08lx g1: %08lx g2: %08lx g3: %08lx ",
 274                regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
 275                regs->u_regs[3]);
 276         printk("g4: %08lx g5: %08lx g6: %08lx g7: %08lx\n",
 277                regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
 278                regs->u_regs[7]);
 279         printk("o0: %08lx o1: %08lx o2: %08lx o3: %08lx ",
 280                regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
 281                regs->u_regs[11]);
 282         printk("o4: %08lx o5: %08lx sp: %08lx o7: %08lx\n",
 283                regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
 284                regs->u_regs[15]);
 285         show_regwindow((struct reg_window *)regs->u_regs[14]);
 286 }
 287
 288 #if NOTUSED
 289 void show_thread(struct thread_struct *thread)
 290 {
 291         int i;
 292
 293         printk("uwinmask:          0x%08lx  kregs:             0x%08lx\n", thread->uwinmask, (unsigned long)thread->kregs);
 294         show_regs(thread->kregs);
 295         printk("ksp:               0x%08lx  kpc:               0x%08lx\n", thread->ksp, thread->kpc);
 296         printk("kpsr:              0x%08lx  kwim:              0x%08lx\n", thread->kpsr, thread->kwim);
 297         printk("fork_kpsr:         0x%08lx  fork_kwim:         0x%08lx\n", thread->fork_kpsr, thread->fork_kwim);
 298
 299         for (i = 0; i < NSWINS; i++) {
 300                 if (!thread->rwbuf_stkptrs[i])
 301                         continue;
 302                 printk("reg_window[%d]:\n", i);
 303                 printk("stack ptr:         0x%08lx\n", thread->rwbuf_stkptrs[i]);
 304                 show_regwindow(&thread->reg_window[i]);
 305         }
 306         printk("w_saved:           0x%08lx\n", thread->w_saved);
 307
 308         /* XXX missing: float_regs */
 309         printk("fsr:               0x%08lx  fpqdepth:          0x%08lx\n", thread->fsr, thread->fpqdepth);
 310         /* XXX missing: fpqueue */
 311
 312         printk("flags:             0x%08lx  current_ds:        0x%08lx\n", thread->flags, thread->current_ds.seg);
 313
 314         show_regwindow((struct reg_window *)thread->ksp);
 315
 316         /* XXX missing: core_exec */
 317 }
 318 #endif
 319
 320 /*
 321  * Free current thread data structures etc..
 322  */
 323 void exit_thread(void)
 324 {
 325 #ifndef CONFIG_SMP
 326         if(last_task_used_math == current) {
 327 #else
 328         if(current->flags & PF_USEDFPU) {
 329 #endif
 330                 /* Keep process from leaving FPU in a bogon state. */
 331                 put_psr(get_psr() | PSR_EF);
 332                 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 333                        &current->thread.fpqueue[0], &current->thread.fpqdepth);
 334 #ifndef CONFIG_SMP
 335                 last_task_used_math = NULL;
 336 #else
 337                 current->flags &= ~PF_USEDFPU;
 338 #endif
 339         }
 340 }
 341
 342 void flush_thread(void)
 343 {
 344         current->thread.w_saved = 0;
 345
 346         /* No new signal delivery by default */
 347         current->thread.new_signal = 0;
 348 #ifndef CONFIG_SMP
 349         if(last_task_used_math == current) {
 350 #else
 351         if(current->flags & PF_USEDFPU) {
 352 #endif
 353                 /* Clean the fpu. */
 354                 put_psr(get_psr() | PSR_EF);
 355                 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 356                        &current->thread.fpqueue[0], &current->thread.fpqdepth);
 357 #ifndef CONFIG_SMP
 358                 last_task_used_math = NULL;
 359 #else
 360                 current->flags &= ~PF_USEDFPU;
 361 #endif
 362         }
 363
 364         /* Now, this task is no longer a kernel thread. */
 365         current->thread.current_ds = USER_DS;
 366         if (current->thread.flags & SPARC_FLAG_KTHREAD) {
 367                 current->thread.flags &= ~SPARC_FLAG_KTHREAD;
 368
 369                 /* We must fixup kregs as well. */
 370                 current->thread.kregs = (struct pt_regs *)
 371                         (((unsigned long)current) +
 372                          (TASK_UNION_SIZE - TRACEREG_SZ));
 373         }
 374 }
 375
 376 static __inline__ void copy_regs(struct pt_regs *dst, struct pt_regs *src)
 377 {
 378         __asm__ __volatile__("ldd\t[%1 + 0x00], %%g2\n\t"
 379                              "ldd\t[%1 + 0x08], %%g4\n\t"
 380                              "ldd\t[%1 + 0x10], %%o4\n\t"
 381                              "std\t%%g2, [%0 + 0x00]\n\t"
 382                              "std\t%%g4, [%0 + 0x08]\n\t"
 383                              "std\t%%o4, [%0 + 0x10]\n\t"
 384                              "ldd\t[%1 + 0x18], %%g2\n\t"
 385                              "ldd\t[%1 + 0x20], %%g4\n\t"
 386                              "ldd\t[%1 + 0x28], %%o4\n\t"
 387                              "std\t%%g2, [%0 + 0x18]\n\t"
 388                              "std\t%%g4, [%0 + 0x20]\n\t"
 389                              "std\t%%o4, [%0 + 0x28]\n\t"
 390                              "ldd\t[%1 + 0x30], %%g2\n\t"
 391                              "ldd\t[%1 + 0x38], %%g4\n\t"
 392                              "ldd\t[%1 + 0x40], %%o4\n\t"
 393                              "std\t%%g2, [%0 + 0x30]\n\t"
 394                              "std\t%%g4, [%0 + 0x38]\n\t"
 395                              "ldd\t[%1 + 0x48], %%g2\n\t"
 396                              "std\t%%o4, [%0 + 0x40]\n\t"
 397                              "std\t%%g2, [%0 + 0x48]\n\t" : :
 398                              "r" (dst), "r" (src) :
 399                              "g2", "g3", "g4", "g5", "o4", "o5");
 400 }
 401
 402 static __inline__ void copy_regwin(struct reg_window *dst, struct reg_window *src)
 403 {
 404         __asm__ __volatile__("ldd\t[%1 + 0x00], %%g2\n\t"
 405                              "ldd\t[%1 + 0x08], %%g4\n\t"
 406                              "ldd\t[%1 + 0x10], %%o4\n\t"
 407                              "std\t%%g2, [%0 + 0x00]\n\t"
 408                              "std\t%%g4, [%0 + 0x08]\n\t"
 409                              "std\t%%o4, [%0 + 0x10]\n\t"
 410                              "ldd\t[%1 + 0x18], %%g2\n\t"
 411                              "ldd\t[%1 + 0x20], %%g4\n\t"
 412                              "ldd\t[%1 + 0x28], %%o4\n\t"
 413                              "std\t%%g2, [%0 + 0x18]\n\t"
 414                              "std\t%%g4, [%0 + 0x20]\n\t"
 415                              "std\t%%o4, [%0 + 0x28]\n\t"
 416                              "ldd\t[%1 + 0x30], %%g2\n\t"
 417                              "ldd\t[%1 + 0x38], %%g4\n\t"
 418                              "std\t%%g2, [%0 + 0x30]\n\t"
 419                              "std\t%%g4, [%0 + 0x38]\n\t" : :
 420                              "r" (dst), "r" (src) :
 421                              "g2", "g3", "g4", "g5", "o4", "o5");
 422 }
 423
 424 static __inline__ struct sparc_stackf *
 425 clone_stackframe(struct sparc_stackf *dst, struct sparc_stackf *src)
 426 {
 427         unsigned long size;
 428         struct sparc_stackf *sp;
 429
 430         size = ((unsigned long)src->fp) - ((unsigned long)src);
 431         sp = (struct sparc_stackf *)(((unsigned long)dst) - size);
 432
 433         /* do_fork() grabs the parent semaphore, we must release it
 434          * temporarily so we can build the child clone stack frame
 435          * without deadlocking.
 436          */
 437         if (copy_to_user(sp, src, size))
 438                 sp = (struct sparc_stackf *) 0;
 439         else if (put_user(dst, &sp->fp))
 440                 sp = (struct sparc_stackf *) 0;
 441
 442         return sp;
 443 }
 444
 445
 446 /* Copy a Sparc thread.  The fork() return value conventions
 447  * under SunOS are nothing short of bletcherous:
 448  * Parent -->  %o0 == childs  pid, %o1 == 0
 449  * Child  -->  %o0 == parents pid, %o1 == 1
 450  *
 451  * NOTE: We have a separate fork kpsr/kwim because
 452  *       the parent could change these values between
 453  *       sys_fork invocation and when we reach here
 454  *       if the parent should sleep while trying to
 455  *       allocate the task_struct and kernel stack in
 456  *       do_fork().
 457  */
 458 #ifdef CONFIG_SMP
 459 extern void ret_from_smpfork(void);
 460 #else
 461 extern void ret_from_syscall(void);
 462 #endif
 463
 464 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 465                 struct task_struct *p, struct pt_regs *regs)
 466 {
 467         struct pt_regs *childregs;
 468         struct reg_window *new_stack;
 469         unsigned long stack_offset;
 470
 471 #ifndef CONFIG_SMP
 472         if(last_task_used_math == current) {
 473 #else
 474         if(current->flags & PF_USEDFPU) {
 475 #endif
 476                 put_psr(get_psr() | PSR_EF);
 477                 fpsave(&p->thread.float_regs[0], &p->thread.fsr,
 478                        &p->thread.fpqueue[0], &p->thread.fpqdepth);
 479 #ifdef CONFIG_SMP
 480                 current->flags &= ~PF_USEDFPU;
 481 #endif
 482         }
 483
 484         /* Calculate offset to stack_frame & pt_regs */
 485         stack_offset = TASK_UNION_SIZE - TRACEREG_SZ;
 486
 487         if(regs->psr & PSR_PS)
 488                 stack_offset -= REGWIN_SZ;
 489         childregs = ((struct pt_regs *) (((unsigned long)p) + stack_offset));
 490         copy_regs(childregs, regs);
 491         new_stack = (((struct reg_window *) childregs) - 1);
 492         copy_regwin(new_stack, (((struct reg_window *) regs) - 1));
 493
 494         p->thread.ksp = (unsigned long) new_stack;
 495 #ifdef CONFIG_SMP
 496         p->thread.kpc = (((unsigned long) ret_from_smpfork) - 0x8);
 497         p->thread.kpsr = current->thread.fork_kpsr | PSR_PIL;
 498 #else
 499         p->thread.kpc = (((unsigned long) ret_from_syscall) - 0x8);
 500         p->thread.kpsr = current->thread.fork_kpsr;
 501 #endif
 502         p->thread.kwim = current->thread.fork_kwim;
 503
 504         /* This is used for sun4c only */
 505         atomic_set(&p->thread.refcount, 1);
 506
 507         if(regs->psr & PSR_PS) {
 508                 extern struct pt_regs fake_swapper_regs;
 509
 510                 p->thread.kregs = &fake_swapper_regs;
 511                 new_stack = (struct reg_window *)
 512                         ((((unsigned long)p) +
 513                           (TASK_UNION_SIZE)) -
 514                          (REGWIN_SZ));
 515                 childregs->u_regs[UREG_FP] = (unsigned long) new_stack;
 516                 p->thread.flags |= SPARC_FLAG_KTHREAD;
 517                 p->thread.current_ds = KERNEL_DS;
 518                 memcpy((void *)new_stack,
 519                        (void *)regs->u_regs[UREG_FP],
 520                        sizeof(struct reg_window));
 521                 childregs->u_regs[UREG_G6] = (unsigned long) p;
 522         } else {
 523                 p->thread.kregs = childregs;
 524                 childregs->u_regs[UREG_FP] = sp;
 525                 p->thread.flags &= ~SPARC_FLAG_KTHREAD;
 526                 p->thread.current_ds = USER_DS;
 527
 528                 if (sp != regs->u_regs[UREG_FP]) {
 529                         struct sparc_stackf *childstack;
 530                         struct sparc_stackf *parentstack;
 531
 532                         /*
 533                          * This is a clone() call with supplied user stack.
 534                          * Set some valid stack frames to give to the child.
 535                          */
 536                         childstack = (struct sparc_stackf *) (sp & ~0x7UL);
 537                         parentstack = (struct sparc_stackf *) regs->u_regs[UREG_FP];
 538
 539 #if 0
 540                         printk("clone: parent stack:\n");
 541                         show_stackframe(parentstack);
 542 #endif
 543
 544                         childstack = clone_stackframe(childstack, parentstack);
 545                         if (!childstack)
 546                                 return -EFAULT;
 547
 548 #if 0
 549                         printk("clone: child stack:\n");
 550                         show_stackframe(childstack);
 551 #endif
 552
 553                         childregs->u_regs[UREG_FP] = (unsigned long)childstack;
 554                 }
 555         }
 556
 557         /* Set the return value for the child. */
 558         childregs->u_regs[UREG_I0] = current->pid;
 559         childregs->u_regs[UREG_I1] = 1;
 560
 561         /* Set the return value for the parent. */
 562         regs->u_regs[UREG_I1] = 0;
 563
 564         return 0;
 565 }
 566
 567 /*
 568  * fill in the user structure for a core dump..
 569  */
 570 void dump_thread(struct pt_regs * regs, struct user * dump)
 571 {
 572         unsigned long first_stack_page;
 573
 574         dump->magic = SUNOS_CORE_MAGIC;
 575         dump->len = sizeof(struct user);
 576         dump->regs.psr = regs->psr;
 577         dump->regs.pc = regs->pc;
 578         dump->regs.npc = regs->npc;
 579         dump->regs.y = regs->y;
 580         /* fuck me plenty */
 581         memcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
 582         dump->uexec = current->thread.core_exec;
 583         dump->u_tsize = (((unsigned long) current->mm->end_code) -
 584                 ((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);
 585         dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));
 586         dump->u_dsize -= dump->u_tsize;
 587         dump->u_dsize &= ~(PAGE_SIZE - 1);
 588         first_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));
 589         dump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);
 590         memcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->thread.float_regs[0], (sizeof(unsigned long) * 32));
 591         dump->fpu.fpstatus.fsr = current->thread.fsr;
 592         dump->fpu.fpstatus.flags = dump->fpu.fpstatus.extra = 0;
 593         dump->fpu.fpstatus.fpq_count = current->thread.fpqdepth;
 594         memcpy(&dump->fpu.fpstatus.fpq[0], &current->thread.fpqueue[0],
 595                ((sizeof(unsigned long) * 2) * 16));
 596         dump->sigcode = 0;
 597 }
 598
 599 /*
 600  * fill in the fpu structure for a core dump.
 601  */
 602 int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
 603 {
 604         if (current->used_math == 0) {
 605                 memset(fpregs, 0, sizeof(*fpregs));
 606                 fpregs->pr_q_entrysize = 8;
 607                 return 1;
 608         }
 609 #ifdef CONFIG_SMP
 610         if (current->flags & PF_USEDFPU) {
 611                 put_psr(get_psr() | PSR_EF);
 612                 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 613                        &current->thread.fpqueue[0], &current->thread.fpqdepth);
 614                 regs->psr &= ~(PSR_EF);
 615                 current->flags &= ~(PF_USEDFPU);
 616         }
 617 #else
 618         if (current == last_task_used_math) {
 619                 put_psr(get_psr() | PSR_EF);
 620                 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 621                        &current->thread.fpqueue[0], &current->thread.fpqdepth);
 622                 last_task_used_math = 0;
 623                 regs->psr &= ~(PSR_EF);
 624         }
 625 #endif
 626         memcpy(&fpregs->pr_fr.pr_regs[0],
 627                &current->thread.float_regs[0],
 628                (sizeof(unsigned long) * 32));
 629         fpregs->pr_fsr = current->thread.fsr;
 630         fpregs->pr_qcnt = current->thread.fpqdepth;
 631         fpregs->pr_q_entrysize = 8;
 632         fpregs->pr_en = 1;
 633         if(fpregs->pr_qcnt != 0) {
 634                 memcpy(&fpregs->pr_q[0],
 635                        &current->thread.fpqueue[0],
 636                        sizeof(struct fpq) * fpregs->pr_qcnt);
 637         }
 638         /* Zero out the rest. */
 639         memset(&fpregs->pr_q[fpregs->pr_qcnt], 0,
 640                sizeof(struct fpq) * (32 - fpregs->pr_qcnt));
 641         return 1;
 642 }
 643
 644 /*
 645  * sparc_execve() executes a new program after the asm stub has set
 646  * things up for us.  This should basically do what I want it to.
 647  */
 648 asmlinkage int sparc_execve(struct pt_regs *regs)
 649 {
 650         int error, base = 0;
 651         char *filename;
 652
 653         /* Check for indirect call. */
 654         if(regs->u_regs[UREG_G1] == 0)
 655                 base = 1;
 656
 657         filename = getname((char *)regs->u_regs[base + UREG_I0]);
 658         error = PTR_ERR(filename);
 659         if(IS_ERR(filename))
 660                 goto out;
 661         error = do_execve(filename, (char **) regs->u_regs[base + UREG_I1],
 662                           (char **) regs->u_regs[base + UREG_I2], regs);
 663         putname(filename);
 664 out:
 665         return error;
 666 }
 667
 668 /*
 669  * This is the mechanism for creating a new kernel thread.
 670  *
 671  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
 672  * who haven't done an "execve()") should use this: it will work within
 673  * a system call from a "real" process, but the process memory space will
 674  * not be free'd until both the parent and the child have exited.
 675  */
 676 pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 677 {
 678         long retval;
 679
 680         __asm__ __volatile("mov %4, %%g2\n\t"    /* Set aside fn ptr... */
 681                            "mov %5, %%g3\n\t"    /* and arg. */
 682                            "mov %1, %%g1\n\t"
 683                            "mov %2, %%o0\n\t"    /* Clone flags. */
 684                            "mov 0, %%o1\n\t"     /* usp arg == 0 */
 685                            "t 0x10\n\t"          /* Linux/Sparc clone(). */
 686                            "cmp %%o1, 0\n\t"
 687                            "be 1f\n\t"           /* The parent, just return. */
 688                            " nop\n\t"            /* Delay slot. */
 689                            "jmpl %%g2, %%o7\n\t" /* Call the function. */
 690                            " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */
 691                            "mov %3, %%g1\n\t"
 692                            "t 0x10\n\t"          /* Linux/Sparc exit(). */
 693                            /* Notreached by child. */
 694                            "1: mov %%o0, %0\n\t" :
 695                            "=r" (retval) :
 696                            "i" (__NR_clone), "r" (flags | CLONE_VM),
 697                            "i" (__NR_exit),  "r" (fn), "r" (arg) :
 698                            "g1", "g2", "g3", "o0", "o1", "memory", "cc");
 699         return retval;
 700 }