root/arch/alpha/kernel/process.c

/* */

DEFINITIONS

1. sys_sethae
2. sys_idle
3. hard_reset_now
4. show_regs
5. exit_thread
6. flush_thread
7. alpha_fork
8. copy_thread
9. dump_thread
10. sys_execve
11. sys_clone

   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,
     /*  */
  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)
     /*  */
  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)
     /*  */
  53 {
  54         halt();
  55 }
  56 
  57 void show_regs(struct pt_regs * regs)
     /*  */
  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)
     /*  */
  79 {
  80 }
  81 
  82 void flush_thread(void)
     /*  */
  83 {
  84 }
  85 
  86 /*
  87  * "alpha_fork()".. By the time we get here, the
  88  * non-volatile registers have also been saved on the
  89  * stack. We do some ugly pointer stuff here.. (see
  90  * also copy_thread)
  91  */
  92 int alpha_fork(struct switch_stack * swstack)
     /*  */
  93 {
  94         return do_fork(SIGCHLD, rdusp(), (struct pt_regs *) (swstack+1));
  95 }
  96 
  97 extern void ret_from_sys_call(void);
  98 /*
  99  * Copy an alpha thread..
 100  *
 101  * Note the "stack_offset" stuff: when returning to kernel mode, we need
 102  * to have some extra stack-space for the kernel stack that still exists
 103  * after the "ret_from_sys_call". When returning to user mode, we only
 104  * want the space needed by the syscall stack frame (ie "struct pt_regs").
 105  * Use the passed "regs" pointer to determine how much space we need
 106  * for a kernel fork().
 107  */
 108 void copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
     /*  */
 109         struct task_struct * p, struct pt_regs * regs)
 110 {
 111         struct pt_regs * childregs;
 112         struct switch_stack * childstack, *stack;
 113         unsigned long stack_offset;
 114 
 115         stack_offset = PAGE_SIZE - sizeof(struct pt_regs);
 116         if (!(regs->ps & 8))
 117                 stack_offset = (PAGE_SIZE-1) & (unsigned long) regs;
 118         childregs = (struct pt_regs *) (p->kernel_stack_page + stack_offset);
 119                 
 120         *childregs = *regs;
 121         childregs->r0 = 0;
 122         childregs->r19 = 0;
 123         childregs->r20 = 1;     /* OSF/1 has some strange fork() semantics.. */
 124         regs->r20 = 0;
 125         stack = ((struct switch_stack *) regs) - 1;
 126         childstack = ((struct switch_stack *) childregs) - 1;
 127         *childstack = *stack;
 128         childstack->r26 = (unsigned long) ret_from_sys_call;
 129         p->tss.usp = usp;
 130         p->tss.ksp = (unsigned long) childstack;
 131         p->tss.flags = 1;
 132 }
 133 
 134 /*
 135  * fill in the user structure for a core dump..
 136  */
 137 void dump_thread(struct pt_regs * regs, struct user * dump)
     /*  */
 138 {
 139 }
 140 
 141 /*
 142  * sys_execve() executes a new program.
 143  *
 144  * This works due to the alpha calling sequence: the first 6 args
 145  * are gotten from registers, while the rest is on the stack, so
 146  * we get a0-a5 for free, and then magically find "struct pt_regs"
 147  * on the stack for us..
 148  *
 149  * Don't do this at home.
 150  */
 151 asmlinkage int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
     /*  */
 152         unsigned long a3, unsigned long a4, unsigned long a5,
 153         struct pt_regs regs)
 154 {
 155         int error;
 156         char * filename;
 157 
 158         error = getname((char *) a0, &filename);
 159         if (error)
 160                 return error;
 161         error = do_execve(filename, (char **) a1, (char **) a2, &regs);
 162         putname(filename);
 163         return error;
 164 }
 165 
 166 /*
 167  * This doesn't actually work correctly like this: we need to do the
 168  * same stack setups that fork() does first.
 169  */
 170 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp, unsigned long a2,
     /*  */
 171         unsigned long a3, unsigned long a4, unsigned long a5,
 172         struct pt_regs regs)
 173 {
 174         if (!newsp)
 175                 newsp = rdusp();
 176         return do_fork(clone_flags, newsp, &regs);
 177 }

/* */