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-lixux.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         int __user *user_tid = (int __user *)regs->gr[26];
 249
 250         /* usp must be word aligned.  This also prevents users from
 251          * passing in the value 1 (which is the signal for a special
 252          * return for a kernel thread) */
 253         usp = ALIGN(usp, 4);
 254
 255         /* A zero value for usp means use the current stack */
 256         if(usp == 0)
 257                 usp = regs->gr[30];
 258
 259         return do_fork(clone_flags, usp, regs, 0, user_tid, NULL);
 260 }
 261
 262 int
 263 sys_vfork(struct pt_regs *regs)
 264 {
 265         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
 266 }
 267
 268 int
 269 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 270             unsigned long unused,       /* in ia64 this is "user_stack_size" */
 271             struct task_struct * p, struct pt_regs * pregs)
 272 {
 273         struct pt_regs * cregs = &(p->thread.regs);
 274         struct thread_info *ti = p->thread_info;
 275
 276         /* We have to use void * instead of a function pointer, because
 277          * function pointers aren't a pointer to the function on 64-bit.
 278          * Make them const so the compiler knows they live in .text */
 279         extern void * const ret_from_kernel_thread;
 280         extern void * const child_return;
 281 #ifdef CONFIG_HPUX
 282         extern void * const hpux_child_return;
 283 #endif
 284
 285         *cregs = *pregs;
 286
 287         /* Set the return value for the child.  Note that this is not
 288            actually restored by the syscall exit path, but we put it
 289            here for consistency in case of signals. */
 290         cregs->gr[28] = 0; /* child */
 291
 292         /*
 293          * We need to differentiate between a user fork and a
 294          * kernel fork. We can't use user_mode, because the
 295          * the syscall path doesn't save iaoq. Right now
 296          * We rely on the fact that kernel_thread passes
 297          * in zero for usp.
 298          */
 299         if (usp == 1) {
 300                 /* kernel thread */
 301                 cregs->ksp = (((unsigned long)(ti)) + THREAD_SZ_ALGN);
 302                 /* Must exit via ret_from_kernel_thread in order
 303                  * to call schedule_tail()
 304                  */
 305                 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
 306                 /*
 307                  * Copy function and argument to be called from
 308                  * ret_from_kernel_thread.
 309                  */
 310 #ifdef __LP64__
 311                 cregs->gr[27] = pregs->gr[27];
 312 #endif
 313                 cregs->gr[26] = pregs->gr[26];
 314                 cregs->gr[25] = pregs->gr[25];
 315         } else {
 316                 /* user thread */
 317                 /*
 318                  * Note that the fork wrappers are responsible
 319                  * for setting gr[21].
 320                  */
 321
 322                 /* Use same stack depth as parent */
 323                 cregs->ksp = ((unsigned long)(ti))
 324                         + (pregs->gr[21] & (THREAD_SIZE - 1));
 325                 cregs->gr[30] = usp;
 326                 if (p->personality == PER_HPUX) {
 327 #ifdef CONFIG_HPUX
 328                         cregs->kpc = (unsigned long) &hpux_child_return;
 329 #else
 330                         BUG();
 331 #endif
 332                 } else {
 333                         cregs->kpc = (unsigned long) &child_return;
 334                 }
 335         }
 336
 337         return 0;
 338 }
 339
 340 unsigned long thread_saved_pc(struct task_struct *t)
 341 {
 342         return t->thread.regs.kpc;
 343 }
 344
 345 /*
 346  * sys_execve() executes a new program.
 347  */
 348
 349 asmlinkage int sys_execve(struct pt_regs *regs)
 350 {
 351         int error;
 352         char *filename;
 353
 354         filename = getname((const char __user *) regs->gr[26]);
 355         error = PTR_ERR(filename);
 356         if (IS_ERR(filename))
 357                 goto out;
 358         error = do_execve(filename, (char __user **) regs->gr[25],
 359                 (char __user **) regs->gr[24], regs);
 360         if (error == 0) {
 361                 task_lock(current);
 362                 current->ptrace &= ~PT_DTRACE;
 363                 task_unlock(current);
 364         }
 365         putname(filename);
 366 out:
 367
 368         return error;
 369 }
 370
 371 unsigned long
 372 get_wchan(struct task_struct *p)
 373 {
 374         struct unwind_frame_info info;
 375         unsigned long ip;
 376         int count = 0;
 377         /*
 378          * These bracket the sleeping functions..
 379          */
 380
 381         unwind_frame_init_from_blocked_task(&info, p);
 382         do {
 383                 if (unwind_once(&info) < 0)
 384                         return 0;
 385                 ip = info.ip;
 386                 if (!in_sched_functions(ip))
 387                         return ip;
 388         } while (count++ < 16);
 389         return 0;
 390 }