root/arch/alpha/kernel/process.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. sys_sethae
  2. sys_idle
  3. hard_reset_now
  4. show_regs
  5. exit_thread
  6. flush_thread
  7. release_thread
  8. alpha_clone
  9. copy_thread
  10. dump_thread
  11. sys_execve

   1 /*
   2  *  linux/arch/alpha/kernel/process.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  */
   6 
   7 /*
   8  * This file handles the architecture-dependent parts of process handling..
   9  */
  10 
  11 #include <linux/errno.h>
  12 #include <linux/sched.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/stddef.h>
  16 #include <linux/unistd.h>
  17 #include <linux/ptrace.h>
  18 #include <linux/malloc.h>
  19 #include <linux/ldt.h>
  20 #include <linux/user.h>
  21 #include <linux/a.out.h>
  22 #include <linux/utsname.h>
  23 #include <linux/time.h>
  24 #include <linux/major.h>
  25 #include <linux/stat.h>
  26 #include <linux/mman.h>
  27 
  28 #include <asm/segment.h>
  29 #include <asm/system.h>
  30 #include <asm/io.h>
  31 
  32 asmlinkage int sys_sethae(unsigned long hae, unsigned long a1, unsigned long a2,
     /* [previous][next][first][last][top][bottom][index][help] */
  33         unsigned long a3, unsigned long a4, unsigned long a5,
  34         struct pt_regs regs)
  35 {
  36         (&regs)->hae = hae;
  37         return 0;
  38 }
  39 
  40 asmlinkage int sys_idle(void)
     /* [previous][next][first][last][top][bottom][index][help] */
  41 {
  42         if (current->pid != 0)
  43                 return -EPERM;
  44 
  45         /* endless idle loop with no priority at all */
  46         current->counter = -100;
  47         for (;;) {
  48                 schedule();
  49         }
  50 }
  51 
  52 void hard_reset_now(void)
     /* [previous][next][first][last][top][bottom][index][help] */
  53 {
  54         halt();
  55 }
  56 
  57 void show_regs(struct pt_regs * regs)
     /* [previous][next][first][last][top][bottom][index][help] */
  58 {
  59         printk("\nps: %04lx pc: %016lx\n", regs->ps, regs->pc);
  60         printk("rp: %016lx sp: %p\n", regs->r26, regs+1);
  61         printk(" r0: %016lx  r1: %016lx  r2: %016lx  r3: %016lx\n",
  62                regs->r0, regs->r1, regs->r2, regs->r3);
  63         printk(" r4: %016lx  r5: %016lx  r6: %016lx  r7: %016lx\n",
  64                regs->r4, regs->r5, regs->r6, regs->r7);
  65         printk(" r8: %016lx r16: %016lx r17: %016lx r18: %016lx\n",
  66                regs->r8, regs->r16, regs->r17, regs->r18);
  67         printk("r19: %016lx r20: %016lx r21: %016lx r22: %016lx\n",
  68                regs->r19, regs->r20, regs->r21, regs->r22);
  69         printk("r23: %016lx r24: %016lx r25: %016lx r26: %016lx\n",
  70                regs->r23, regs->r24, regs->r25, regs->r26);
  71         printk("r27: %016lx r28: %016lx r29: %016lx hae: %016lx\n",
  72                regs->r27, regs->r28, regs->gp, regs->hae);
  73 }
  74 
  75 /*
  76  * Free current thread data structures etc..
  77  */
  78 void exit_thread(void)
     /* [previous][next][first][last][top][bottom][index][help] */
  79 {
  80 }
  81 
  82 void flush_thread(void)
     /* [previous][next][first][last][top][bottom][index][help] */
  83 {
  84 }
  85 
  86 void release_thread(struct task_struct *dead_task)
     /* [previous][next][first][last][top][bottom][index][help] */
  87 {
  88 }
  89 
  90 /*
  91  * "alpha_clone()".. By the time we get here, the
  92  * non-volatile registers have also been saved on the
  93  * stack. We do some ugly pointer stuff here.. (see
  94  * also copy_thread)
  95  *
  96  * Notice that "fork()" is implemented in terms of clone,
  97  * with parameters (SIGCHLD, 0).
  98  */
  99 int alpha_clone(unsigned long clone_flags, unsigned long usp,
     /* [previous][next][first][last][top][bottom][index][help] */
 100         struct switch_stack * swstack)
 101 {
 102         if (!usp)
 103                 usp = rdusp();
 104         return do_fork(clone_flags, usp, (struct pt_regs *) (swstack+1));
 105 }
 106 
 107 extern void ret_from_sys_call(void);
 108 /*
 109  * Copy an alpha thread..
 110  *
 111  * Note the "stack_offset" stuff: when returning to kernel mode, we need
 112  * to have some extra stack-space for the kernel stack that still exists
 113  * after the "ret_from_sys_call". When returning to user mode, we only
 114  * want the space needed by the syscall stack frame (ie "struct pt_regs").
 115  * Use the passed "regs" pointer to determine how much space we need
 116  * for a kernel fork().
 117  */
 118 void copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
     /* [previous][next][first][last][top][bottom][index][help] */
 119         struct task_struct * p, struct pt_regs * regs)
 120 {
 121         struct pt_regs * childregs;
 122         struct switch_stack * childstack, *stack;
 123         unsigned long stack_offset;
 124 
 125         stack_offset = PAGE_SIZE - sizeof(struct pt_regs);
 126         if (!(regs->ps & 8))
 127                 stack_offset = (PAGE_SIZE-1) & (unsigned long) regs;
 128         childregs = (struct pt_regs *) (p->kernel_stack_page + stack_offset);
 129                 
 130         *childregs = *regs;
 131         childregs->r0 = 0;
 132         childregs->r19 = 0;
 133         childregs->r20 = 1;     /* OSF/1 has some strange fork() semantics.. */
 134         regs->r20 = 0;
 135         stack = ((struct switch_stack *) regs) - 1;
 136         childstack = ((struct switch_stack *) childregs) - 1;
 137         *childstack = *stack;
 138         childstack->r26 = (unsigned long) ret_from_sys_call;
 139         p->tss.usp = usp;
 140         p->tss.ksp = (unsigned long) childstack;
 141         p->tss.flags = 1;
 142 }
 143 
 144 /*
 145  * fill in the user structure for a core dump..
 146  */
 147 void dump_thread(struct pt_regs * regs, struct user * dump)
     /* [previous][next][first][last][top][bottom][index][help] */
 148 {
 149 }
 150 
 151 /*
 152  * sys_execve() executes a new program.
 153  *
 154  * This works due to the alpha calling sequence: the first 6 args
 155  * are gotten from registers, while the rest is on the stack, so
 156  * we get a0-a5 for free, and then magically find "struct pt_regs"
 157  * on the stack for us..
 158  *
 159  * Don't do this at home.
 160  */
 161 asmlinkage int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
     /* [previous][next][first][last][top][bottom][index][help] */
 162         unsigned long a3, unsigned long a4, unsigned long a5,
 163         struct pt_regs regs)
 164 {
 165         int error;
 166         char * filename;
 167 
 168         error = getname((char *) a0, &filename);
 169         if (error)
 170                 return error;
 171         error = do_execve(filename, (char **) a1, (char **) a2, &regs);
 172         putname(filename);
 173         return error;
 174 }

/* [previous][next][first][last][top][bottom][index][help] */