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