Subversion Repositories or1k

/*
 * This file handles the architecture-dependent parts of process handling..
 * Based on m86k.
 */
 
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/malloc.h>
#include <linux/user.h>
#include <linux/a.out.h>
 
#include <asm/segment.h>
#include <asm/system.h>
#include <asm/traps.h>
#include <asm/machdep.h>
#include <asm/board.h>
 
asmlinkage void ret_from_exception(void);
 
/*
 * The idle loop on an or32..
 */
asmlinkage int sys_idle(void)
{
	if (current->pid != 0)
		return -EPERM;
 
 
	/* endless idle loop with no priority at all */
	current->counter = -100;
	for (;;) {
		schedule();
	}
}
 
void hard_reset_now(void)
{
	HARD_RESET_NOW();
}
 
void show_regs(struct pt_regs * regs)
{
	printk("\n");
	printk("PC: %08lx  Status: %08lx\n",
	       regs->pc, regs->sr);
	printk("R0 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
	       	0L,            regs->sp,      regs->gprs[0], regs->gprs[1], 
		regs->gprs[2], regs->gprs[3], regs->gprs[4], regs->gprs[5]);
	printk("R8 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
	       	regs->gprs[6], regs->gprs[7], regs->gprs[8], regs->gprs[9], 
		regs->gprs[10], regs->gprs[11], regs->gprs[12], regs->gprs[13]);
	printk("R16: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
	       	regs->gprs[14], regs->gprs[15], regs->gprs[16], regs->gprs[17], 
		regs->gprs[18], regs->gprs[19], regs->gprs[20], regs->gprs[21]);
	printk("R24: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
	       	regs->gprs[22], regs->gprs[23], regs->gprs[24], regs->gprs[25], 
		regs->gprs[26], regs->gprs[27], regs->gprs[28], regs->gprs[29]);
}
 
/*
 * Free current thread data structures etc..
 */
void exit_thread(void)
{
}
 
void flush_thread(void)
{
	set_fs(USER_DS);
	current->tss.fs = USER_DS;
}
 
asmlinkage int sys_fork(int p1, int p2, int p3, int p4, int p5, struct pt_regs *regs)
{
	return do_fork(SIGCHLD|CLONE_WAIT, regs->sp, regs);
}
 
asmlinkage int sys_clone(int p1, int p2, int p3, int p4, int p5, struct pt_regs *regs)
{
	unsigned long clone_flags = (unsigned long)p1;
	return do_fork(clone_flags, regs->sp, regs);
}
 
void release_thread(struct task_struct *dead_task)
{
}
 
void copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
		 struct task_struct * p, struct pt_regs * regs)
{
	struct pt_regs * childregs;
 
        /* Copy registers */
        childregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
        *childregs = *regs;     /* STRUCT COPY */
        childregs->gprs[9] = 0x0;  /* Result from fork() */
        p->tss.ksp = childregs;
 
	/* If this is kernel thread, than we can use kernel stack also as 
	   "user" stack, if not, we use user stack from parent which should be a sleep
	   till we execute execve or exit (that is why sys_fork has CLONE_WAIT
	   flag allway set ) */
	if(regs->sr & SPR_SR_SM) {
		childregs->sp = (unsigned long)(childregs+1);
        	p->tss.usp = (unsigned long)(childregs+1);
	}
	else {
		childregs->sp = usp;
        	p->tss.usp = usp;
	}
}
 
/* Fill in the fpu structure for a core dump.  */
 
int dump_fpu (struct pt_regs *regs, struct user_or32fp_struct *fpu)
{
  return 0;
} 
 
void switch_to(struct task_struct *prev, struct task_struct *new) 
{
        struct pt_regs *regs;
        struct thread_struct *new_tss, *old_tss;
        long flags;
 
	save_flags(flags);
        cli();
 
        regs = (struct pt_regs *)new->tss.ksp;
        new_tss = &new->tss;
        old_tss = &current->tss;
        current_set[0] = new;   /* FIX ME! */
        _switch(old_tss, new_tss);
	restore_flags(flags);
} 
 
/*
 * fill in the user structure for a core dump..
 */
void dump_thread(struct pt_regs * regs, struct user * dump)
{
/* changed the size calculations - should hopefully work better. lbt */
	dump->magic = CMAGIC;
	dump->start_code = 0;
	dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
	dump->u_dsize = ((unsigned long) (current->mm->brk +
					  (PAGE_SIZE-1))) >> PAGE_SHIFT;
	dump->u_dsize -= dump->u_tsize;
	dump->u_ssize = 0;
 
 
	dump->u_ar0 = (struct pt_regs *)(((int)(&dump->regs)) -((int)(dump)));
	dump->regs = *regs;
	/* dump floating point stuff */
	dump->u_fpvalid = dump_fpu (regs, &dump->or32fp);
}
 
/*
 * sys_execve() executes a new program.
 */
asmlinkage int sys_execve(char *name, char **argv, char **envp,
		int dummy1, int dummy2, unsigned long sp)
{
	int error;
	char * filename;
	struct pt_regs *regs = (struct pt_regs *) sp;
 
_print("%s - %s:%d\n",__FILE__,__FUNCTION__,__LINE__);
	error = getname(name, &filename);
_print("%s - %s:%d\n",__FILE__,__FUNCTION__,__LINE__);
	if (error)
		return error;
_print("%s - %s:%d\n",__FILE__,__FUNCTION__,__LINE__);
	error = do_execve(filename, argv, envp, regs);
_print("%s - %s:%d\n",__FILE__,__FUNCTION__,__LINE__);
	putname(filename);
#if ICACHE
	ic_invalidate();
#endif
_print("%s - %s:%d\n",__FILE__,__FUNCTION__,__LINE__);
	return error;
}