arch/parisc/kernel/process.c

   1 /*
   2  *    PARISC Architecture-dependent parts of process handling
   3  *    based on the work for i386
   4  *
   5  *    Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
   6  *    Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
   7  *    Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
   8  *    Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
   9  *    Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
  10  *    Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
  11  *    Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
  12  *    Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org>
  13  *    Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
  14  *    Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
  15  *    Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
  16  *    Copyright (C) 2001-2002 Helge Deller <deller at parisc-linux.org>
  17  *    Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
  18  *
  19  *
  20  *    This program is free software; you can redistribute it and/or modify
  21  *    it under the terms of the GNU General Public License as published by
  22  *    the Free Software Foundation; either version 2 of the License, or
  23  *    (at your option) any later version.
  24  *
  25  *    This program is distributed in the hope that it will be useful,
  26  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *    GNU General Public License for more details.
  29  *
  30  *    You should have received a copy of the GNU General Public License
  31  *    along with this program; if not, write to the Free Software
  32  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  33  */
  34
  35 #include <stdarg.h>
  36
  37 #include <linux/elf.h>
  38 #include <linux/errno.h>
  39 #include <linux/kernel.h>
  40 #include <linux/mm.h>
  41 #include <linux/module.h>
  42 #include <linux/personality.h>
  43 #include <linux/ptrace.h>
  44 #include <linux/sched.h>
  45 #include <linux/stddef.h>
  46 #include <linux/unistd.h>
  47 #include <linux/kallsyms.h>
  48
  49 #include <asm/io.h>
  50 #include <asm/asm-offsets.h>
  51 #include <asm/pdc.h>
  52 #include <asm/pdc_chassis.h>
  53 #include <asm/pgalloc.h>
  54 #include <asm/uaccess.h>
  55 #include <asm/unwind.h>
  56
  57 /*
  58  * Power off function, if any
  59  */
  60 void (*pm_power_off)(void);
  61 EXPORT_SYMBOL(pm_power_off);
  62
  63 void default_idle(void)
  64 {
  65         barrier();
  66 }
  67
  68 /*
  69  * The idle thread. There's no useful work to be
  70  * done, so just try to conserve power and have a
  71  * low exit latency (ie sit in a loop waiting for
  72  * somebody to say that they'd like to reschedule)
  73  */
  74 void cpu_idle(void)
  75 {
  76         set_thread_flag(TIF_POLLING_NRFLAG);
  77
  78         /* endless idle loop with no priority at all */
  79         while (1) {
  80                 while (!need_resched())
  81                         barrier();
  82                 preempt_enable_no_resched();
  83                 schedule();
  84                 preempt_disable();
  85                 check_pgt_cache();
  86         }
  87 }
  88
  89
  90 #define COMMAND_GLOBAL  F_EXTEND(0xfffe0030)
  91 #define CMD_RESET       5       /* reset any module */
  92
  93 /*
  94 ** The Wright Brothers and Gecko systems have a H/W problem
  95 ** (Lasi...'nuf said) may cause a broadcast reset to lockup
  96 ** the system. An HVERSION dependent PDC call was developed
  97 ** to perform a "safe", platform specific broadcast reset instead
  98 ** of kludging up all the code.
  99 **
 100 ** Older machines which do not implement PDC_BROADCAST_RESET will
 101 ** return (with an error) and the regular broadcast reset can be
 102 ** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
 103 ** the PDC call will not return (the system will be reset).
 104 */
 105 void machine_restart(char *cmd)
 106 {
 107 #ifdef FASTBOOT_SELFTEST_SUPPORT
 108         /*
 109          ** If user has modified the Firmware Selftest Bitmap,
 110          ** run the tests specified in the bitmap after the
 111          ** system is rebooted w/PDC_DO_RESET.
 112          **
 113          ** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
 114          **
 115          ** Using "directed resets" at each processor with the MEM_TOC
 116          ** vector cleared will also avoid running destructive
 117          ** memory self tests. (Not implemented yet)
 118          */
 119         if (ftc_bitmap) {
 120                 pdc_do_firm_test_reset(ftc_bitmap);
 121         }
 122 #endif
 123         /* set up a new led state on systems shipped with a LED State panel */
 124         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
 125
 126         /* "Normal" system reset */
 127         pdc_do_reset();
 128
 129         /* Nope...box should reset with just CMD_RESET now */
 130         gsc_writel(CMD_RESET, COMMAND_GLOBAL);
 131
 132         /* Wait for RESET to lay us to rest. */
 133         while (1) ;
 134
 135 }
 136
 137 void machine_halt(void)
 138 {
 139         /*
 140         ** The LED/ChassisCodes are updated by the led_halt()
 141         ** function, called by the reboot notifier chain.
 142         */
 143 }
 144
 145
 146 /*
 147  * This routine is called from sys_reboot to actually turn off the
 148  * machine
 149  */
 150 void machine_power_off(void)
 151 {
 152         /* If there is a registered power off handler, call it. */
 153         if(pm_power_off)
 154                 pm_power_off();
 155
 156         /* Put the soft power button back under hardware control.
 157          * If the user had already pressed the power button, the
 158          * following call will immediately power off. */
 159         pdc_soft_power_button(0);
 160
 161         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
 162
 163         /* It seems we have no way to power the system off via
 164          * software. The user has to press the button himself. */
 165
 166         printk(KERN_EMERG "System shut down completed.\n"
 167                KERN_EMERG "Please power this system off now.");
 168 }
 169
 170
 171 /*
 172  * Create a kernel thread
 173  */
 174
 175 extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 176 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 177 {
 178
 179         /*
 180          * FIXME: Once we are sure we don't need any debug here,
 181          *        kernel_thread can become a #define.
 182          */
 183
 184         return __kernel_thread(fn, arg, flags);
 185 }
 186 EXPORT_SYMBOL(kernel_thread);
 187
 188 /*
 189  * Free current thread data structures etc..
 190  */
 191 void exit_thread(void)
 192 {
 193 }
 194
 195 void flush_thread(void)
 196 {
 197         /* Only needs to handle fpu stuff or perf monitors.
 198         ** REVISIT: several arches implement a "lazy fpu state".
 199         */
 200         set_fs(USER_DS);
 201 }
 202
 203 void release_thread(struct task_struct *dead_task)
 204 {
 205 }
 206
 207 /*
 208  * Fill in the FPU structure for a core dump.
 209  */
 210
 211 int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
 212 {
 213         if (regs == NULL)
 214                 return 0;
 215
 216         memcpy(r, regs->fr, sizeof *r);
 217         return 1;
 218 }
 219
 220 int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
 221 {
 222         memcpy(r, tsk->thread.regs.fr, sizeof(*r));
 223         return 1;
 224 }
 225
 226 /* Note that "fork()" is implemented in terms of clone, with
 227    parameters (SIGCHLD, regs->gr[30], regs). */
 228 int
 229 sys_clone(unsigned long clone_flags, unsigned long usp,
 230           struct pt_regs *regs)
 231 {
 232         /* Arugments from userspace are:
 233            r26 = Clone flags.
 234            r25 = Child stack.
 235            r24 = parent_tidptr.
 236            r23 = Is the TLS storage descriptor
 237            r22 = child_tidptr
 238
 239            However, these last 3 args are only examined
 240            if the proper flags are set. */
 241         int __user *child_tidptr;
 242         int __user *parent_tidptr;
 243
 244         /* usp must be word aligned.  This also prevents users from
 245          * passing in the value 1 (which is the signal for a special
 246          * return for a kernel thread) */
 247         usp = ALIGN(usp, 4);
 248
 249         /* A zero value for usp means use the current stack */
 250         if (usp == 0)
 251           usp = regs->gr[30];
 252
 253         if (clone_flags & CLONE_PARENT_SETTID)
 254           parent_tidptr = (int __user *)regs->gr[24];
 255         else
 256           parent_tidptr = NULL;
 257
 258         if (clone_flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID))
 259           child_tidptr = (int __user *)regs->gr[22];
 260         else
 261           child_tidptr = NULL;
 262
 263         return do_fork(clone_flags, usp, regs, 0, parent_tidptr, child_tidptr);
 264 }
 265
 266 int
 267 sys_vfork(struct pt_regs *regs)
 268 {
 269         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
 270 }
 271
 272 int
 273 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 274             unsigned long unused,       /* in ia64 this is "user_stack_size" */
 275             struct task_struct * p, struct pt_regs * pregs)
 276 {
 277         struct pt_regs * cregs = &(p->thread.regs);
 278         void *stack = task_stack_page(p);
 279
 280         /* We have to use void * instead of a function pointer, because
 281          * function pointers aren't a pointer to the function on 64-bit.
 282          * Make them const so the compiler knows they live in .text */
 283         extern void * const ret_from_kernel_thread;
 284         extern void * const child_return;
 285 #ifdef CONFIG_HPUX
 286         extern void * const hpux_child_return;
 287 #endif
 288
 289         *cregs = *pregs;
 290
 291         /* Set the return value for the child.  Note that this is not
 292            actually restored by the syscall exit path, but we put it
 293            here for consistency in case of signals. */
 294         cregs->gr[28] = 0; /* child */
 295
 296         /*
 297          * We need to differentiate between a user fork and a
 298          * kernel fork. We can't use user_mode, because the
 299          * the syscall path doesn't save iaoq. Right now
 300          * We rely on the fact that kernel_thread passes
 301          * in zero for usp.
 302          */
 303         if (usp == 1) {
 304                 /* kernel thread */
 305                 cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN;
 306                 /* Must exit via ret_from_kernel_thread in order
 307                  * to call schedule_tail()
 308                  */
 309                 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
 310                 /*
 311                  * Copy function and argument to be called from
 312                  * ret_from_kernel_thread.
 313                  */
 314 #ifdef __LP64__
 315                 cregs->gr[27] = pregs->gr[27];
 316 #endif
 317                 cregs->gr[26] = pregs->gr[26];
 318                 cregs->gr[25] = pregs->gr[25];
 319         } else {
 320                 /* user thread */
 321                 /*
 322                  * Note that the fork wrappers are responsible
 323                  * for setting gr[21].
 324                  */
 325
 326                 /* Use same stack depth as parent */
 327                 cregs->ksp = (unsigned long)stack
 328                         + (pregs->gr[21] & (THREAD_SIZE - 1));
 329                 cregs->gr[30] = usp;
 330                 if (p->personality == PER_HPUX) {
 331 #ifdef CONFIG_HPUX
 332                         cregs->kpc = (unsigned long) &hpux_child_return;
 333 #else
 334                         BUG();
 335 #endif
 336                 } else {
 337                         cregs->kpc = (unsigned long) &child_return;
 338                 }
 339                 /* Setup thread TLS area from the 4th parameter in clone */
 340                 if (clone_flags & CLONE_SETTLS)
 341                   cregs->cr27 = pregs->gr[23];
 342
 343         }
 344
 345         return 0;
 346 }
 347
 348 unsigned long thread_saved_pc(struct task_struct *t)
 349 {
 350         return t->thread.regs.kpc;
 351 }
 352
 353 /*
 354  * sys_execve() executes a new program.
 355  */
 356
 357 asmlinkage int sys_execve(struct pt_regs *regs)
 358 {
 359         int error;
 360         char *filename;
 361
 362         filename = getname((const char __user *) regs->gr[26]);
 363         error = PTR_ERR(filename);
 364         if (IS_ERR(filename))
 365                 goto out;
 366         error = do_execve(filename, (char __user **) regs->gr[25],
 367                 (char __user **) regs->gr[24], regs);
 368         if (error == 0) {
 369                 task_lock(current);
 370                 current->ptrace &= ~PT_DTRACE;
 371                 task_unlock(current);
 372         }
 373         putname(filename);
 374 out:
 375
 376         return error;
 377 }
 378
 379 unsigned long
 380 get_wchan(struct task_struct *p)
 381 {
 382         struct unwind_frame_info info;
 383         unsigned long ip;
 384         int count = 0;
 385         /*
 386          * These bracket the sleeping functions..
 387          */
 388
 389         unwind_frame_init_from_blocked_task(&info, p);
 390         do {
 391                 if (unwind_once(&info) < 0)
 392                         return 0;
 393                 ip = info.ip;
 394                 if (!in_sched_functions(ip))
 395                         return ip;
 396         } while (count++ < 16);
 397         return 0;
 398 }