--- /dev/null
+// Copyright 2003 Brian Alliet
+// Based on org.xwt.imp.MIPS by Adam Megacz
+// Portions Copyright 2003 Adam Megacz
+package org.xwt.mips;
+import java.io.*;
+
+public abstract class Runtime implements Syscalls, Errno,Registers {
+ /** Pages are 4k in size */
+ final static int PAGE_SIZE = 4096;
+ final static int PAGE_WORDS = (int)(PAGE_SIZE >>> 2);
+ final static int PAGE_SHIFT = 12;
+ /** There are 65536 pages available for a total of 256mb of addressable memory */
+ protected final static int TOTAL_PAGES = 65536;
+ /** The top 256 pages are reserved for the stack. Arguments and userdata info use up the first few pages */
+ protected final static int STACK_PAGES = 256;
+ /** This is the upper limit of the pages allocated by the brk() syscall. */
+ protected final static int BRK_LIMIT = TOTAL_PAGES - STACK_PAGES - 1024;
+
+ /* High memory layout
+ TOP
+ <-- ((TOTAL_PAGES-0)*PAGE_SIZE) -->
+ Empty Page
+ <-- ((TOTAL_PAGES-1)*PAGE_SIZE) -->
+ Args (1 page)
+ <-- ((TOTAL_PAGES-2)*PAGE_SIZE) -->
+ User info (1 page)
+ <-- ((TOTAL_PAGES-3)*PAGE_SIZE) -->
+ Empty page
+ <-- ((TOTAL_PAGES-4)*PAGE_SIZE) -->
+ Stack top
+ */
+
+ /** The base address for the args and user_info (this will be passed to crt0.c)
+ The args must be at STUFF_BASE+1 page and user_info must be at STUFF_BASE */
+ protected final static int STUFF_BASE = (TOTAL_PAGES-3)*PAGE_SIZE;
+ protected final static int ARGS_ADDR = STUFF_BASE + PAGE_SIZE;
+ protected final static int USER_INFO_ADDR = STUFF_BASE;
+
+ /** The initial stack pointer address */
+ protected final static int INITIAL_SP = STUFF_BASE - PAGE_SIZE;
+
+ /** True if we allow empty pages (_emptyPage) to exist in memory.
+ Empty pages are pages which are allocated by the program but do not contain any
+ data yet (they are all 0s). If empty pages are allowed subclasses must always
+ access main memory with the memRead and memWrite functions */
+ private final boolean allowEmptyPages;
+ /** the "empty page" */
+ private final static int[] _emptyPage = new int[0];
+
+ /** Returns a new empty page (_emptyPage is empty pages are enabled or a new zero'd page) */
+ private final int[] emptyPage() { return allowEmptyPages ? _emptyPage : new int[PAGE_WORDS]; }
+
+ /** Readable main memory pages */
+ protected final int[][] readPages;
+ /** Writable main memory pages.
+ If the page is writable writePages[x] == readPages[x]; if not writePages[x] == null. */
+ protected final int[][] writePages;
+
+ /** The current break between the heap and unallocated memory and the stack.
+ This is the page number NOT an address */
+ protected int brk;
+
+ /** The program's entry point */
+ protected int entryPoint;
+
+ /** State contant: There is no program loaded in memory */
+ public final static int UNINITIALIZED = 0;
+ /** Text/Data loaded in memory */
+ public final static int INITIALIZED = 1;
+ /** Program is executing instructions */
+ public final static int RUNNING = 2;
+ /** Prgram has been started but is paused */
+ public final static int PAUSED = 3;
+ /** Program has exited (it cannot currently be restarted) */
+ public final static int DONE = 4;
+
+ /** The current state (UNINITIALIZED, INITIALIZED, RUNNING, PAUSED, or DONE) */
+ protected int state = UNINITIALIZED;
+ /** @see Runtime#state state */
+ public final int getState() { return state; }
+
+ /** The exit status if the process (only valid if state==DONE)
+ @see Runtime#state */
+ protected int exitStatus;
+
+ /** Maximum number of open file descriptors */
+ private final static int OPEN_MAX = 256;
+ /** Table containing all open file descriptors. (Entries are null if the fd is not in use */
+ private FileDescriptor[] fds;
+
+ /** Temporary buffer for read/write operations */
+ private byte[] _byteBuf = null;
+ /** Max size of temporary buffer
+ @see Runtime#_byteBuf */
+ private final static int MAX_CHUNK = 4*1024*1024;
+
+ /** The pid of this "process" */
+ public static final int PID = 1;
+
+ /** Subclasses should actually execute program in this method. They should continue
+ executing until state != RUNNING. Only syscall() can modify state. It is safe
+ to only check the state attribyte after a call to syscall() */
+ protected abstract void _execute() throws ExecutionException;
+
+ /** This should setup the system to begin executing at pc and
+ initialize the cpu registers as follows
+ K0 (r26) = STUFF_BASE
+ K1 (r27) = PAGE_SIZE
+ SP (r29) = INITIAL_SP
+ RA (r31) = 0xdeadbeef
+ */
+ protected abstract void _start(int pc);
+
+ /** Initialize the Runtime with empty pages disabled
+ @see Runtime#Runtime(boolean) */
+ public Runtime() { this(false); }
+
+ /** Initialize the Runtime. Empty pages are enabled if <i>allowEmptyPages</i> is set */
+ public Runtime(boolean allowEmptyPages) {
+ this.allowEmptyPages = allowEmptyPages;
+ readPages = new int[TOTAL_PAGES][];
+ writePages = new int[TOTAL_PAGES][];
+ for(int i=0;i<STACK_PAGES;i++)
+ readPages[TOTAL_PAGES-1-i] = writePages[TOTAL_PAGES-1-i] = emptyPage();
+ }
+
+ /** Copy everything from <i>src</i> to <i>addr</i> initializing uninitialized pages if required.
+ Newly initalized pages will be marked read-only if <i>ro</i> is set */
+ protected final void initPages(int[] src, int addr, boolean ro) {
+ for(int i=0;i<src.length;) {
+ int page = addr >>> PAGE_SHIFT;
+ int start = (addr&(PAGE_SIZE-1))>>2;
+ int elements = min(PAGE_WORDS-start,src.length-i);
+ if(readPages[page]==null) {
+ initPage(page,ro);
+ } else if(!ro) {
+ if(writePages[page] == null) writePages[page] = readPages[page];
+ }
+ System.arraycopy(src,i,readPages[page],start,elements);
+ i += elements;
+ addr += elements*4;
+ }
+ }
+
+ /** Initialize <i>words</i> of pages starting at <i>addr</i> to 0 */
+ protected final void clearPages(int addr, int words) {
+ for(int i=0;i<words;) {
+ int page = addr >>> PAGE_SHIFT;
+ int start = (addr&(PAGE_SIZE-1))>>2;
+ int elements = min(PAGE_WORDS-start,words-i);
+ if(readPages[page]==null) {
+ readPages[page] = writePages[page] = emptyPage();
+ } else {
+ if(writePages[page] == null) writePages[page] = readPages[page];
+ for(int j=start;j<start+elements;j++) writePages[page][j] = 0;
+ }
+ i += elements;
+ addr += elements*4;
+ }
+ }
+
+ /** Copies <i>length</i> bytes from the processes memory space starting at
+ <i>addr</i> INTO a java byte array <i>a</i> */
+ public final void copyin(int addr, byte[] a, int length) throws ReadFaultException {
+ int n=0;
+ if((addr&3)!=0) {
+ int word = memRead(addr&~3);
+ switch(addr&3) {
+ case 1: a[n++] = (byte)((word>>>16)&0xff); if(length-n==0) break;
+ case 2: a[n++] = (byte)((word>>> 8)&0xff); if(length-n==0) break;
+ case 3: a[n++] = (byte)((word>>> 0)&0xff); if(length-n==0) break;
+ }
+ addr = (addr&~3)+4;
+ }
+ while(length-n > 3) {
+ int start = (addr&(PAGE_SIZE-1))>>2;
+ int end = start + (min(PAGE_SIZE-(addr&(PAGE_SIZE-1)),(length-n)&~3) >> 2);
+ int[] page = readPages[addr >>> PAGE_SHIFT];
+ if(page == null) throw new ReadFaultException(addr);
+ if(page == _emptyPage) { addr+=(end-start)<<2; n+=(end-start)<<2; continue; }
+ for(int i=start;i<end;i++,addr+=4) {
+ int word = page[i];
+ a[n++] = (byte)((word>>>24)&0xff); a[n++] = (byte)((word>>>16)&0xff);
+ a[n++] = (byte)((word>>> 8)&0xff); a[n++] = (byte)((word>>> 0)&0xff);
+ }
+ }
+ if(length-n > 0) {
+ int word = memRead(addr);
+ if(length-n >= 1) a[n+0] = (byte)((word>>>24)&0xff);
+ if(length-n >= 2) a[n+1] = (byte)((word>>>16)&0xff);
+ if(length-n >= 3) a[n+2] = (byte)((word>>> 8)&0xff);
+ }
+ }
+
+ /** Copies <i>length</i> bytes OUT OF the java array <i>a</i> into the processes memory
+ space at <i>addr</i> */
+ public final void copyout(byte[] a, int addr, int length) throws FaultException {
+ int n=0;
+ if((addr&3)!=0) {
+ int word = memRead(addr&~3);
+ switch(addr&3) {
+ case 1: word = (word&0xff00ffff)|((a[n]&0xff)<<16); n++; if(length-n==0) break;
+ case 2: word = (word&0xffff00ff)|((a[n]&0xff)<< 8); n++; if(length-n==0) break;
+ case 3: word = (word&0xffffff00)|((a[n]&0xff)<< 0); n++; if(length-n==0) break;
+ }
+ memWrite(addr&~3,word);
+ addr = (addr&~3)+4;
+ }
+
+ while(length-n > 3) {
+ int start = (addr&(PAGE_SIZE-1))>>2;
+ int end = start + (min(PAGE_SIZE-(addr&(PAGE_SIZE-1)),(length-n)&~3) >> 2);
+ int[] page = writePages[addr >>> PAGE_SHIFT];
+ if(page == null) throw new WriteFaultException(addr);
+ if(page == _emptyPage) { memWrite(addr,0); page = writePages[addr >>> PAGE_SHIFT]; }
+ for(int i=start;i<end;i++,addr+=4) {
+ int word = ((a[n+0]&0xff)<<24)|((a[n+1]&0xff)<<16)|((a[n+2]&0xff)<<8)|((a[n+3]&0xff)<<0); n+=4;
+ page[i] = word;
+ }
+ }
+ if(length-n > 0) {
+ int word = memRead(addr);
+ if(length-n >= 1) { word = (word&0x00ffffff)|((a[n+0]&0xff)<<24); }
+ if(length-n >= 2) { word = (word&0xff00ffff)|((a[n+1]&0xff)<<16); }
+ if(length-n >= 3) { word = (word&0xffff00ff)|((a[n+2]&0xff)<< 8); }
+ memWrite(addr,word);
+ }
+ }
+
+ /** Read a word from the processes memory at <i>addr</i> */
+ public final int memRead(int addr) throws ReadFaultException {
+ if((addr & 3) != 0) throw new ReadFaultException(addr);
+ int page = addr >>> PAGE_SHIFT;
+ int entry = (addr >>> 2) & (PAGE_WORDS-1);
+ try {
+ return readPages[page][entry];
+ } catch(ArrayIndexOutOfBoundsException e) {
+ if(page < 0) throw e; // should never happen
+ if(page > readPages.length) throw new ReadFaultException(addr);
+ if(readPages[page] != _emptyPage) throw e; // should never happen
+ initPage(page);
+ return 0;
+ } catch(NullPointerException e) {
+ throw new ReadFaultException(addr);
+ }
+ }
+
+ /** Writes a word to the processes memory at <i>addr</i> */
+ public final void memWrite(int addr, int value) throws WriteFaultException {
+ if((addr & 3) != 0) throw new WriteFaultException(addr);
+ int page = addr >>> PAGE_SHIFT;
+ int entry = (addr>>>2)&(PAGE_WORDS-1);
+ try {
+ writePages[page][entry] = value;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ if(page < 0) throw e;// should never happen
+ if(page > writePages.length) throw new WriteFaultException(addr);
+ if(readPages[page] != _emptyPage) throw e; // should never happen
+ initPage(page);
+ writePages[page][entry] = value;
+ } catch(NullPointerException e) {
+ throw new WriteFaultException(addr);
+ }
+ }
+
+ /** Created a new non-empty writable page at page number <i>page</i> */
+ private final void initPage(int page) { initPage(page,false); }
+ /** Created a new non-empty page at page number <i>page</i>. If <i>ro</i> is set the page will be read-only */
+ private final void initPage(int page, boolean ro) {
+ int[] buf = new int[PAGE_WORDS];
+ writePages[page] = ro ? null : buf;
+ readPages[page] = buf;
+ }
+
+ /** Returns the exit status of the process. (only valid if state == DONE)
+ @see Runtime#state */
+ public final int exitStatus() {
+ if(state != DONE) throw new IllegalStateException("exitStatus() called in an inappropriate state");
+ return exitStatus;
+ }
+
+ /** Runs the process until it exits and returns the exit status.
+ If the process executes the PAUSE syscall execution will be paused for 500ms and a warning will be displayed */
+ public final int run(String[] args) throws ExecutionException {
+ start(args);
+ for(;;) {
+ if(execute()) break;
+ System.err.println("WARNING: Pause requested while executing run()");
+ try { Thread.sleep(500); } catch(InterruptedException e) { }
+ }
+ return exitStatus();
+ }
+
+ /** Adds the String[] array, <i>args</i>, to the arguments page in main memory */
+ private void addArgs(String[] args) throws ExecutionException {
+ int count = args.length;
+ byte[] nullTerminator = new byte[1];
+ int total = 4; /* null last table entry */
+ for(int i=0;i<count;i++) total += args[i].length() + 1/*null terminator*/ + 4/*table entry*/;
+ if(total >= PAGE_SIZE-4) throw new ExecutionException("Arguments too large");
+ int start = ARGS_ADDR;
+ int addr = start + (count+1)*4;
+ int[] table = new int[count+1];
+ for(int i=0;i<count;i++) {
+ byte[] a;
+ try { a = args[i].getBytes("US-ASCII"); } catch(UnsupportedEncodingException e){ throw new Error(e.getMessage()); }
+ table[i] = addr;
+ copyout(a,addr,a.length);
+ addr += a.length;
+ copyout(nullTerminator,addr,1);
+ addr += 1;
+ }
+ addr=start;
+ for(int i=0;i<count;i++) {
+ memWrite(addr,table[i]);
+ addr += 4;
+ }
+ }
+
+ /** Sets word number <i>index</i> in the _user_info table to <i>word</i>
+ _user_info is a 4096 byte table in the process's memory. It contains 1024 32-bit entries. This
+ can be used by the process to communicate with the caller of the process. Each entry is 32-bit
+ wide and can be used to store integers or pointers */
+ public void setUserInfo(int index, int word) {
+ if(index < 0 || index >= 1024) throw new IllegalStateException("setUserInfo called with index >= 1024");
+ try {
+ memWrite(USER_INFO_ADDR+index*4,word);
+ } catch(FaultException e) { throw new Error("should never happen: " + e); }
+ }
+
+ /** Returns the word in the _user_info table entry <i>index</i>
+ @see Runtime#setUserInfo(int,int) setUserInfo */
+ public int getUserInfo(int index) {
+ if(index < 0 || index >= 1024) throw new IllegalStateException("setUserInfo called with index >= 1024");
+ try {
+ return memRead(USER_INFO_ADDR+index*4);
+ } catch(FaultException e) { throw new Error("should never happen: " + e); }
+ }
+
+ /** Executes the process until the PAUSE syscall is invoked or the process exits. Returns true if the process exited. */
+ public final boolean execute() throws ExecutionException {
+ if(state == PAUSED) state = RUNNING;
+ if(state != RUNNING) throw new IllegalStateException("execute() called in inappropriate state");
+ _execute();
+ if(state != PAUSED && state != DONE) throw new IllegalStateException("execute() ended up in an inappropriate state");
+ return state == DONE;
+ }
+
+ /** Initializes the process and prepairs it to be executed with execute() */
+ public final void start(String[] args) throws ExecutionException {
+ if(state != INITIALIZED) throw new IllegalStateException("start() called in inappropriate state");
+ _start(entryPoint);
+ addArgs(args);
+ fds = new FileDescriptor[OPEN_MAX];
+ fds[0] = new InputStreamFD(System.in) { public boolean isatty() { return true; } };
+ fds[1] = new OutputStreamFD(System.out) { public boolean isatty() { return true; } };
+ fds[2] = new OutputStreamFD(System.err) { public boolean isatty() { return true; } };
+ state = PAUSED;
+ }
+
+ /** Determines if the process can access <i>fileName</i>. The default implementation simply logs
+ the request and allows it */
+ protected boolean allowFileAccess(String fileName, boolean write) {
+ System.err.println("Allowing " + (write?"write":"read-only") + " to " + fileName);
+ return true;
+ }
+
+ /** Allocated an entry in the FileDescriptor table for <i>fd</i> and returns the number.
+ Returns -1 if the table is full. This can be used by subclasses to use custom file
+ descriptors */
+ protected int allocFDEnt(FileDescriptor fd) {
+ int i;
+ for(i=0;i<OPEN_MAX;i++) if(fds[i] == null) break;
+ if(i==OPEN_MAX) return -1;
+ fds[i] = fd;
+ return i;
+ }
+
+ /** The open syscall */
+ private int sys_open(int addr, int flags, int mode) {
+ final int O_RDONLY = 0;
+ final int O_WRONLY = 1;
+ final int O_RDWR = 2;
+ final int O_APPEND = 0x0008;
+ final int O_CREAT = 0x0200;
+ final int O_NONBLOCK = 0x4000;
+ final int O_EXCL = 0x0800;
+
+ if((flags & O_APPEND) != 0) {
+ System.err.println("WARNING: O_APPEND not supported");
+ return -EOPNOTSUPP;
+ }
+ if((flags & O_NONBLOCK) != 0) {
+ System.err.println("WARNING: O_NONBLOCK not supported");
+ return -EOPNOTSUPP;
+ }
+
+ try {
+ String fileName = cstring(addr);
+ if(!allowFileAccess(fileName,(flags&3)!=0)) return -EACCES;
+
+ File f = new File(fileName);
+ if((flags & O_EXCL) != 0 && (flags & O_CREAT) != 0)
+ if(!f.createNewFile()) return -EEXIST;
+ if(f.exists()) {
+ if(f.length() >= Integer.MAX_VALUE) return -EOPNOTSUPP;
+ } else {
+ if((flags & O_CREAT) == 0) return -ENOENT;
+ }
+ int fdn = allocFDEnt(new RegularFileDescriptor(f,flags&3));
+ return fdn == -1 ? -ENFILE : fdn;
+ } catch(FaultException e) {
+ return -EFAULT;
+ } catch(FileNotFoundException e) {
+ if(e.getMessage().indexOf("Permission denied") >= 0) return -EACCES;
+ return -ENOENT;
+ } catch(IOException e) {
+ return -EIO;
+ }
+ }
+
+ /** The write syscall */
+ private int sys_write(int fdn, int addr, int count) {
+ int n = 0;
+ int r;
+ FileDescriptor fd;
+ count = Math.min(count,MAX_CHUNK);
+ try {
+ fd = fds[fdn];
+ if(fd == null || !fd.writable()) return -EBADFD;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ return -EBADFD;
+ }
+ try {
+ byte[] buf = byteBuf(count);
+ copyin(addr,buf,count);
+ return fd.write(buf,0,count);
+ } catch(FaultException e) {
+ System.err.println(e);
+ return -EFAULT;
+ } catch(IOException e) {
+ System.err.println(e);
+ return -EIO;
+ }
+ }
+
+ /** The read syscall */
+ private int sys_read(int fdn, int addr, int count) {
+ FileDescriptor fd;
+ count = Math.min(count,MAX_CHUNK);
+ try {
+ fd = fds[fdn];
+ if(fd == null || !fd.readable()) return -EBADFD;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ return -EBADFD;
+ }
+ try {
+ byte[] buf = byteBuf(count);
+ int n = fd.read(buf,0,count);
+ copyout(buf,addr,n);
+ return n;
+ } catch(FaultException e) {
+ System.err.println(e);
+ return -EFAULT;
+ } catch(IOException e) {
+ System.err.println(e);
+ return -EIO;
+ }
+ }
+
+ /** The close syscall */
+ private int sys_close(int fdn) {
+ FileDescriptor fd;
+ try {
+ fd = fds[fdn];
+ if(fd == null) return -EBADFD;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ return -EBADFD;
+ }
+ fds[fdn] = null;
+ fd.close();
+ return 0;
+ }
+
+ /** The seek syscall */
+ private int sys_seek(int fdn, int offset, int whence) {
+ FileDescriptor fd;
+ try {
+ fd = fds[fdn];
+ if(fd == null || !fd.readable()) return -EBADFD;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ return -EBADFD;
+ }
+ if(whence != FileDescriptor.SEEK_SET && whence != FileDescriptor.SEEK_CUR && whence != FileDescriptor.SEEK_END) return -EINVAL;
+ try {
+ int n = fd.seek(offset,whence);
+ return n < 0 ? -ESPIPE : n;
+ } catch(IOException e) {
+ return -ESPIPE;
+ }
+ }
+
+ /** The stat/fstat syscall helper */
+ private int stat(FileInfo fi, int addr) {
+ int size = fi.size();
+ try {
+ memWrite(addr+0,(1<<16)|1); // st_dev (top 16), // st_ino (bottom 16)
+ memWrite(addr+4,(fi.type() & 0xf000)|0644); // st_mode
+ memWrite(addr+8,1<<16); // st_nlink (top 16) // st_uid (bottom 16)
+ memWrite(addr+12,0); // st_gid (top 16) // st_rdev (bottom 16)
+ memWrite(addr+16,size); // st_size
+ memWrite(addr+20,0); // st_atime
+ // memWrite(addr+24,0) // st_spare1
+ memWrite(addr+28,(int)(fi.modTime()/1000)); // st_mtime
+ // memWrite(addr+32,0) // st_spare2
+ memWrite(addr+36,0); // st_ctime
+ // memWrite(addr+40,0) // st_spare3
+ memWrite(addr+44,512); // st_bklsize;
+ memWrite(addr+48,(size+511)&(~511)); // st_blocks
+ // memWrite(addr+52,0) // st_spare4[0]
+ // memWrite(addr+56,0) // st_spare4[1]
+ } catch(FaultException e) {
+ System.err.println(e);
+ return -EFAULT;
+ }
+ return 0;
+ }
+
+ /** The fstat syscall */
+ private int sys_fstat(int fdn, int addr) {
+ FileDescriptor fd;
+ try {
+ fd = fds[fdn];
+ if(fd == null) return -EBADFD;
+ } catch(ArrayIndexOutOfBoundsException e) {
+ return -EBADFD;
+ }
+ return stat(fd.fileInfo(),addr);
+ }
+
+ /** The sbrk syscall. This can also be used by subclasses to allocate memory.
+ <i>incr</i> is how much to increase the break by */
+ public int sbrk(int incr) {
+ if(incr==0) return brk<<PAGE_SHIFT;
+ int oldBrk = brk;
+ int newBrk = oldBrk + ((incr+PAGE_SIZE-1)>>PAGE_SHIFT);
+ if(newBrk >= BRK_LIMIT) {
+ System.err.println("Hit BRK_LIMIT");
+ return -ENOMEM;
+ }
+ for(int i=oldBrk;i<newBrk;i++)
+ readPages[i] = writePages[i] = emptyPage();
+ brk = newBrk;
+ return oldBrk<<PAGE_SHIFT;
+ }
+
+ /** The kill syscall.
+ SIGSTOP, SIGTSTO, SIGTTIN, and SIGTTOUT pause the process.
+ SIGCONT, SIGCHLD, SIGIO, and SIGWINCH are ignored.
+ Anything else terminates the process. */
+ private int sys_kill(int pid, int signal) {
+ // This will only be called by raise() in newlib to invoke the default handler
+ // We don't have to worry about actually delivering the signal
+ if(pid != PID) return -ESRCH;
+ if(signal < 0 || signal >= 32) return -EINVAL;
+ switch(signal) {
+ case 0: return 0;
+ case 17: // SIGSTOP
+ case 18: // SIGTSTP
+ case 21: // SIGTTIN
+ case 22: // SIGTTOU
+ state = PAUSED;
+ break;
+ case 19: // SIGCONT
+ case 20: // SIGCHLD
+ case 23: // SIGIO
+ case 28: // SIGWINCH
+ break;
+ default: {
+ String msg = "Terminating on signal: " + signal + "\n";
+ exitStatus = 1;
+ state = DONE;
+ if(fds[2]==null) {
+ System.out.print(msg);
+ } else {
+ try {
+ byte[] b = msg.getBytes("US-ASCII");
+ fds[2].write(b,0,b.length);
+ }
+ catch(UnsupportedEncodingException e){ throw new Error(e.getMessage()); }
+ catch(IOException e) { }
+ }
+ }
+ }
+ return 0;
+ }
+
+ /** The getpid syscall */
+ private int sys_getpid() { return PID; }
+
+ /** The syscall dispatcher.
+ The should be called by subclasses when the syscall instruction is invoked.
+ <i>syscall</i> should be the contents of V0 and <i>a</i>, <i>b</i>, <i>c</i>, and <i>d</i> should be
+ the contenst of A0, A1, A2, and A3. The call MAY change the state
+ @see Runtime#state state */
+ protected int syscall(int syscall, int a, int b, int c, int d) {
+ switch(syscall) {
+ case SYS_null: return 0;
+ case SYS_exit: exitStatus = a; state = DONE; return 0;
+ case SYS_pause: state = PAUSED; return 0;
+ case SYS_write: return sys_write(a,b,c);
+ case SYS_fstat: return sys_fstat(a,b);
+ case SYS_sbrk: return sbrk(a);
+ case SYS_open: return sys_open(a,b,c);
+ case SYS_close: return sys_close(a);
+ case SYS_read: return sys_read(a,b,c);
+ case SYS_seek: return sys_seek(a,b,c);
+ case SYS_kill: return sys_kill(a,b);
+ case SYS_getpid: return sys_getpid();
+ default:
+ System.err.println("Attempted to use unknown syscall: " + syscall);
+ return -ENOSYS;
+ }
+ }
+
+ /** Helper function to read a cstring from main memory */
+ public String cstring(int addr) throws ReadFaultException {
+ StringBuffer sb = new StringBuffer();
+ for(;;) {
+ int word = memRead(addr&~3);
+ switch(addr&3) {
+ case 0: if(((word>>>24)&0xff)==0) return sb.toString(); sb.append((char)((word>>>24)&0xff)); addr++;
+ case 1: if(((word>>>16)&0xff)==0) return sb.toString(); sb.append((char)((word>>>16)&0xff)); addr++;
+ case 2: if(((word>>> 8)&0xff)==0) return sb.toString(); sb.append((char)((word>>> 8)&0xff)); addr++;
+ case 3: if(((word>>> 0)&0xff)==0) return sb.toString(); sb.append((char)((word>>> 0)&0xff)); addr++;
+ }
+ }
+ }
+
+ /** FileInfo class - used by stat */
+ public static class FileInfo {
+ public static final int S_IFIFO = 0010000;
+ public static final int S_FCHR = 0020000;
+ public static final int S_IFDIR = 0040000;
+ public static final int S_IFREG = 0100000;
+
+ public int size() { return 0; }
+ public int type() { return S_IFIFO; }
+ public long modTime() { return 0; }
+ }
+
+ /** FileInfo subclass for normal files */
+ public static class FileFileInfo extends FileInfo {
+ public File f;
+ public FileFileInfo(File f) { this.f = f; }
+ public int size() { return (int)f.length(); }
+ public int type() { return f.isDirectory() ? S_IFDIR : S_IFREG; }
+ public long modTime() { return f.lastModified(); }
+ }
+
+ /** File Descriptor class */
+ public static abstract class FileDescriptor {
+ protected final static int SEEK_SET = 0;
+ protected final static int SEEK_CUR = 1;
+ protected final static int SEEK_END = 2;
+
+ /** returns true if the fd is readable */
+ public boolean readable() { return false; }
+ /** returns true if the fd is writable */
+ public boolean writable() { return false; }
+
+ private static final FileInfo nullFi = new FileInfo();
+ private FileInfo fi;
+ public FileInfo fileInfo() { return fi; }
+
+ /** Initializes the FileDescriptor with no FileInfo struct */
+ FileDescriptor() { this(null); }
+ /** Initializes the FileDescriptor with the given FileInfo struct (used by fstat) */
+ FileDescriptor(FileInfo fi) { this.fi = fi==null ? nullFi : fi; }
+
+ /** Read some bytes. Should return the number of bytes read, 0 on EOF, or throw an IOException on error */
+ public int read(byte[] a, int off, int length) throws IOException { throw new IOException("no definition"); }
+ /** Write. Should return the number of bytes written or throw an IOException on error */
+ public int write(byte[] a, int off, int length) throws IOException { throw new IOException("no definition"); }
+
+ /** Seek in the filedescriptor. Whence is SEEK_SET, SEEK_CUR, or SEEK_END. Should return -1 on error or the new position. */
+ public int seek(int n, int whence) throws IOException { return -1; }
+
+ /** Should return true if this is a tty */
+ public boolean isatty() { return false; }
+
+ /** Closes the fd */
+ void close() { }
+ }
+
+ /** FileDescriptor class for normal files */
+ public static class RegularFileDescriptor extends FileDescriptor {
+ private int mode;
+ private RandomAccessFile raf;
+ public boolean readable() { return mode != 1; }
+ public boolean writable() { return mode != 0; }
+
+ RegularFileDescriptor(File f,int m) throws IOException {
+ super(new FileFileInfo(f));
+ String mode = m == 0 ? "r" : "rw";
+ this.mode = m;
+ raf = new RandomAccessFile(f,mode);
+ if(raf.length() >= Integer.MAX_VALUE) throw new IOException("File too large");
+ }
+
+ public int seek(int n_, int whence) throws IOException {
+ long n = n_;
+ switch(whence) {
+ case SEEK_SET: break;
+ case SEEK_CUR: n += raf.getFilePointer(); break;
+ case SEEK_END: n += raf.length(); break;
+ default: return -1;
+ }
+ raf.seek(n);
+ return (int)n;
+ }
+
+ public int write(byte[] a, int off, int length) throws IOException { raf.write(a,off,length); return length; }
+ public int read(byte[] a, int off, int length) throws IOException { int n = raf.read(a,off,length); return n < 0 ? 0 : n; }
+
+ void close() { try { raf.close(); } catch(Exception e) { } }
+ }
+
+ public class OutputStreamFD extends FileDescriptor {
+ private OutputStream os;
+ public boolean writable() { return true; }
+ public OutputStreamFD(OutputStream os) { this.os = os; }
+ public int write(byte[] a, int off, int length) throws IOException { os.write(a,off,length); return length; }
+ }
+
+ public class InputStreamFD extends FileDescriptor {
+ private InputStream is;
+ public boolean readable() { return true; }
+ public InputStreamFD(InputStream is) { this.is = is; }
+ public int read(byte[] a, int off, int length) throws IOException { int n = is.read(a,off,length); return n < 0 ? 0 : n; }
+ }
+
+ // Exceptions
+ public static class ReadFaultException extends FaultException {
+ public ReadFaultException(int addr) { super(addr); }
+ }
+ public static class WriteFaultException extends FaultException {
+ public WriteFaultException(int addr) { super(addr); }
+ }
+ public static abstract class FaultException extends ExecutionException {
+ private int addr;
+ public FaultException(int addr) { this.addr = addr; }
+ public String getMessage() { return "fault at: " + toHex(addr); }
+ }
+ public static class ExecutionException extends Exception {
+ public ExecutionException() { }
+ public ExecutionException(String s) { super(s); }
+ }
+
+ // Utility functions
+ private byte[] byteBuf(int size) {
+ if(_byteBuf==null) _byteBuf = new byte[size];
+ else if(_byteBuf.length < size)
+ _byteBuf = new byte[min(max(_byteBuf.length*2,size),MAX_CHUNK)];
+ return _byteBuf;
+ }
+
+ protected final static String toHex(int n) { return "0x" + Long.toString(n & 0xffffffffL, 16); }
+ protected final static int min(int a, int b) { return a < b ? a : b; }
+ protected final static int max(int a, int b) { return a > b ? a : b; }
+}
projects / org.ibex.core.git / blobdiff