import java.util.Arrays;
public abstract class Runtime implements UsermodeConstants,Registers,Cloneable {
+ public static final String VERSION = "1.0";
+
+ /** True to write useful diagnostic information to stderr when things go wrong */
+ final static boolean STDERR_DIAG = true;
+
/** Number of bits to shift to get the page number (1<<<pageShift == pageSize) */
protected final int pageShift;
/** Bottom of region of memory allocated to the stack */
protected abstract void setCPUState(CPUState state);
protected Object clone() throws CloneNotSupportedException {
- Runtime r = (Runtime) super.clone();
+ Runtime r = (Runtime) super.clone();
r._byteBuf = null;
r.startTime = 0;
r.fds = new FD[OPEN_MAX];
r.readPages = new int[totalPages][];
r.writePages = new int[totalPages][];
for(int i=0;i<totalPages;i++) {
- if(readPages[i] == null) continue;
+ if(readPages[i] == null) continue;
if(writePages[i] == null) r.readPages[i] = readPages[i];
else r.readPages[i] = r.writePages[i] = (int[])writePages[i].clone();
}
stackSize = max(stackSize,pageSize);
stackSize = (stackSize + pageSize - 1) & ~(pageSize-1);
stackPages = stackSize >>> pageShift;
- heapStart = (heapStart + pageSize) & ~(pageSize-1);
+ heapStart = (heapStart + pageSize - 1) & ~(pageSize-1);
if(stackPages + STACK_GUARD_PAGES + (heapStart >>> pageShift) >= totalPages)
throw new IllegalArgumentException("total pages too small");
} else {
if(totalPages == 1) {
readPages[0] = writePages[0] = new int[pageSize>>2];
} else {
- for(int i=(stackBottom >>> pageShift);i<writePages.length;i++) {
- readPages[i] = writePages[i] = new int[pageSize>>2];
+ for(int i=(stackBottom >>> pageShift);i<writePages.length;i++) {
+ readPages[i] = writePages[i] = new int[pageSize>>2];
}
}
- addFD(new StdinFD(System.in));
- addFD(new StdoutFD(System.out));
- addFD(new StdoutFD(System.err));
+ InputStream stdin = Boolean.valueOf(getSystemProperty("nestedvm.textstdin")).booleanValue() ? new TextInputStream(System.in) : System.in;
+ addFD(new TerminalFD(stdin));
+ addFD(new TerminalFD(System.out));
+ addFD(new TerminalFD(System.err));
}
/** Copy everything from <i>src</i> to <i>addr</i> initializing uninitialized pages if required.
addr += 4;
}
} catch(FaultException e) {
- // should never happen
- throw new Error(e.toString());
+ throw new RuntimeException(e.toString());
}
return start;
}
}
/** Calls _execute() (subclass's execute()) and catches exceptions */
+ // FEATURE: Have these call kill() so we get a pretty message to stdout
private void __execute() {
try {
_execute();
} catch(FaultException e) {
- e.printStackTrace();
+ if(STDERR_DIAG) e.printStackTrace();
sys_exit(128+11); // SIGSEGV
exitException = e;
} catch(ExecutionException e) {
- e.printStackTrace();
- System.err.println(e);
+ if(STDERR_DIAG) e.printStackTrace();
sys_exit(128+4); // SIGILL
exitException = e;
}
}
static String[] concatArgv(String argv0, String[] rest) {
- String[] argv = new String[rest.length+1];
- System.arraycopy(rest,0,argv,1,rest.length);
+ String[] argv = new String[rest.length+1];
+ System.arraycopy(rest,0,argv,1,rest.length);
argv[0] = argv0;
return argv;
}
start(args,env);
for(;;) {
if(execute()) break;
- System.err.println("WARNING: Pause requested while executing run()");
+ if(STDERR_DIAG) System.err.println("WARNING: Pause requested while executing run()");
}
- if(state == EXECED) System.err.println("WARNING: Process exec()ed while being run under run()");
+ if(state == EXECED && STDERR_DIAG) System.err.println("WARNING: Process exec()ed while being run under run()");
return state == EXITED ? exitStatus() : 0;
}
sp = top = writePages.length*(1<<pageShift);
try {
- sp = argsAddr = addStringArray(args,sp);
- sp = envAddr = addStringArray(createEnv(environ),sp);
+ sp = argsAddr = addStringArray(args,sp);
+ sp = envAddr = addStringArray(createEnv(environ),sp);
} catch(FaultException e) {
throw new IllegalArgumentException("args/environ too big");
}
sp &= ~15;
if(top - sp > ARG_MAX) throw new IllegalArgumentException("args/environ too big");
+ // HACK: heapStart() isn't always available when the constructor
+ // is run and this sometimes doesn't get initialized
+ if(heapEnd == 0) {
+ heapEnd = heapStart();
+ if(heapEnd == 0) throw new Error("heapEnd == 0");
+ int pageSize = writePages.length == 1 ? 4096 : (1<<pageShift);
+ heapEnd = (heapEnd + pageSize - 1) & ~(pageSize-1);
+ }
+
CPUState cpuState = new CPUState();
cpuState.r[A0] = argsAddr;
cpuState.r[A1] = envAddr;
int sp = state.r[SP];
int[] ia = new int[args.length];
for(int i=0;i<args.length;i++) {
- Object o = args[i];
+ Object o = args[i];
byte[] buf = null;
if(o instanceof String) {
- buf = getBytes((String)o);
+ buf = getBytes((String)o);
} else if(o instanceof byte[]) {
- buf = (byte[]) o;
+ buf = (byte[]) o;
} else if(o instanceof Number) {
- ia[i] = ((Number)o).intValue();
+ ia[i] = ((Number)o).intValue();
}
if(buf != null) {
- sp -= buf.length;
+ sp -= buf.length;
copyout(buf,sp,buf.length);
ia[i] = sp;
}
/** Duplicates the file descriptor <i>fdn</i> and returns the new fs */
public final int dupFD(int fdn) {
- int i;
- if(fdn < 0 || fdn >= OPEN_MAX) return -1;
- if(fds[fdn] == null) return -1;
- for(i=0;i<OPEN_MAX;i++) if(fds[i] == null) break;
+ int i;
+ if(fdn < 0 || fdn >= OPEN_MAX) return -1;
+ if(fds[fdn] == null) return -1;
+ for(i=0;i<OPEN_MAX;i++) if(fds[i] == null) break;
if(i==OPEN_MAX) return -1;
fds[i] = fds[fdn].dup();
return i;
public static final int O_APPEND = 0x0008;
public static final int O_TRUNC = 0x0400;
public static final int O_NONBLOCK = 0x4000;
+ public static final int O_NOCTTY = 0x8000;
+
FD hostFSOpen(final File f, int flags, int mode, final Object data) throws ErrnoException {
if((flags & ~(3|O_CREAT|O_EXCL|O_APPEND|O_TRUNC)) != 0) {
- System.err.println("WARNING: Unsupported flags passed to open(): " + toHex(flags & ~(3|O_CREAT|O_EXCL|O_APPEND|O_TRUNC)));
+ if(STDERR_DIAG)
+ System.err.println("WARNING: Unsupported flags passed to open(\"" + f + "\"): " + toHex(flags & ~(3|O_CREAT|O_EXCL|O_APPEND|O_TRUNC)));
+
throw new ErrnoException(ENOTSUP);
}
boolean write = (flags&3) != RD_ONLY;
return hostFSDirFD(f,data);
}
+ // FIXME: Truncate
final Seekable.File sf;
try {
sf = new Seekable.File(f,write);
/** The open syscall */
private int sys_open(int addr, int flags, int mode) throws ErrnoException, FaultException {
+ flags &= ~O_NOCTTY; // this is meaningless under nestedvm
FD fd = _open(cstring(addr),flags,mode);
if(fd == null) return -ENOENT;
int fdn = addFD(fd);
/** The write syscall */
- // FIXME: Handle pipe closed exception
private int sys_write(int fdn, int addr, int count) throws FaultException, ErrnoException {
count = Math.min(count,MAX_CHUNK);
if(fdn < 0 || fdn >= OPEN_MAX) return -EBADFD;
if(fds[fdn] == null) return -EBADFD;
byte[] buf = byteBuf(count);
copyin(addr,buf,count);
- return fds[fdn].write(buf,0,count);
+ try {
+ return fds[fdn].write(buf,0,count);
+ } catch(ErrnoException e) {
+ if(e.errno == EPIPE) sys_exit(128+13);
+ throw e;
+ }
}
/** The read syscall */
}
/** The stat/fstat syscall helper */
+ // FIXME: Populate uid/gid/nlink
int stat(FStat fs, int addr) throws FaultException {
memWrite(addr+0,(fs.dev()<<16)|(fs.inode()&0xffff)); // st_dev (top 16), // st_ino (bottom 16)
memWrite(addr+4,((fs.type()&0xf000))|(fs.mode()&0xfff)); // st_mode
private int sys_sysconf(int n) {
switch(n) {
case _SC_CLK_TCK: return 1000;
+ case _SC_PAGESIZE: return writePages.length == 1 ? 4096 : (1<<pageShift);
+ case _SC_PHYS_PAGES: return writePages.length == 1 ? (1<<pageShift)/4096 : writePages.length;
default:
- System.err.println("WARNING: Attempted to use unknown sysconf key: " + n);
+ if(STDERR_DIAG) System.err.println("WARNING: Attempted to use unknown sysconf key: " + n);
return -EINVAL;
}
}
try {
for(int i=start;i<end;i++) readPages[i] = writePages[i] = new int[pageWords];
} catch(OutOfMemoryError e) {
- System.err.println("WARNING: Caught OOM Exception in sbrk: " + e);
+ if(STDERR_DIAG) System.err.println("WARNING: Caught OOM Exception in sbrk: " + e);
return -ENOMEM;
}
}
ret = callJavaCB.call(a,b,c,d);
} catch(RuntimeException e) {
System.err.println("Error while executing callJavaCB");
- e.printStackTrace();
+ e.printStackTrace();
ret = 0;
}
state = RUNNING;
return ret;
} else {
- System.err.println("WARNING: calljava syscall invoked without a calljava callback set");
- return 0;
+ if(STDERR_DIAG) System.err.println("WARNING: calljava syscall invoked without a calljava callback set");
+ return 0;
}
}
case F_GETFL:
return fd.flags();
case F_SETFD:
- closeOnExec[fdn] = arg != 0;
+ closeOnExec[fdn] = arg != 0;
return 0;
case F_GETFD:
return closeOnExec[fdn] ? 1 : 0;
default:
- System.err.println("WARNING: Unknown fcntl command: " + cmd);
+ if(STDERR_DIAG) System.err.println("WARNING: Unknown fcntl command: " + cmd);
return -ENOSYS;
}
}
<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 final int syscall(int syscall, int a, int b, int c, int d) {
+ protected final int syscall(int syscall, int a, int b, int c, int d, int e, int f) {
try {
- return _syscall(syscall,a,b,c,d);
- } catch(ErrnoException e) {
- e.printStackTrace();
- return -e.errno;
- } catch(FaultException e) {
- return -EFAULT;
- } catch(RuntimeException e) {
- e.printStackTrace();
- throw new Error("Internal Error in _syscall()");
+ int n = _syscall(syscall,a,b,c,d,e,f);
+ //if(n < 0) System.err.println("syscall: " + syscall + " returned " + n);
+ return n;
+ } catch(ErrnoException ex) {
+ //ex.printStackTrace();
+ return -ex.errno;
+ } catch(FaultException ex) {
+ return -EFAULT;
+ } catch(RuntimeException ex) {
+ ex.printStackTrace();
+ throw new Error("Internal Error in _syscall()");
}
}
- int _syscall(int syscall, int a, int b, int c, int d) throws ErrnoException, FaultException {
+ int _syscall(int syscall, int a, int b, int c, int d, int e, int f) throws ErrnoException, FaultException {
switch(syscall) {
case SYS_null: return 0;
case SYS_exit: return sys_exit(a);
case SYS_mkdir:
case SYS_getcwd:
case SYS_chdir:
- System.err.println("Attempted to use a UnixRuntime syscall in Runtime (" + syscall + ")");
+ if(STDERR_DIAG) System.err.println("Attempted to use a UnixRuntime syscall in Runtime (" + syscall + ")");
return -ENOSYS;
default:
- System.err.println("Attempted to use unknown syscall: " + syscall);
+ if(STDERR_DIAG) System.err.println("Attempted to use unknown syscall: " + syscall);
return -ENOSYS;
}
}
public int seek(int n, int whence) throws ErrnoException {
try {
- switch(whence) {
- case SEEK_SET: break;
- case SEEK_CUR: n += data.pos(); break;
- case SEEK_END: n += data.length(); break;
- default: return -1;
- }
- data.seek(n);
- return n;
+ switch(whence) {
+ case SEEK_SET: break;
+ case SEEK_CUR: n += data.pos(); break;
+ case SEEK_END: n += data.length(); break;
+ default: return -1;
+ }
+ data.seek(n);
+ return n;
} catch(IOException e) {
- throw new ErrnoException(ESPIPE);
+ throw new ErrnoException(ESPIPE);
}
}
// NOTE: There is race condition here but we can't fix it in pure java
if((flags&O_APPEND) != 0) seek(0,SEEK_END);
try {
- return data.write(a,off,length);
+ return data.write(a,off,length);
} catch(IOException e) {
- throw new ErrnoException(EIO);
+ throw new ErrnoException(EIO);
}
}
public int read(byte[] a, int off, int length) throws ErrnoException {
if((flags&3) == WR_ONLY) throw new ErrnoException(EBADFD);
try {
- int n = data.read(a,off,length);
- return n < 0 ? 0 : n;
+ int n = data.read(a,off,length);
+ return n < 0 ? 0 : n;
} catch(IOException e) {
- throw new ErrnoException(EIO);
+ throw new ErrnoException(EIO);
}
}
protected void _close() { try { data.close(); } catch(IOException e) { /*ignore*/ } }
}
- public static class OutputStreamFD extends FD {
- private OutputStream os;
- public int flags() { return O_WRONLY; }
- public OutputStreamFD(OutputStream os) { this.os = os; }
- public int write(byte[] a, int off, int length) throws ErrnoException {
- try {
- os.write(a,off,length);
- return length;
- } catch(IOException e) {
- throw new ErrnoException(EIO);
- }
+ public static class InputOutputStreamFD extends FD {
+ private final InputStream is;
+ private final OutputStream os;
+
+ public InputOutputStreamFD(InputStream is) { this(is,null); }
+ public InputOutputStreamFD(OutputStream os) { this(null,os); }
+ public InputOutputStreamFD(InputStream is, OutputStream os) {
+ this.is = is;
+ this.os = os;
+ if(is == null && os == null) throw new IllegalArgumentException("at least one stream must be supplied");
}
- public void _close() { try { os.close(); } catch(IOException e) { /*ignore*/ } }
- public FStat _fstat() { return new FStat(); }
- }
-
- public static class InputStreamFD extends FD {
- private InputStream is;
- public int flags() { return O_RDONLY; }
- public InputStreamFD(InputStream is) { this.is = is; }
+
+ public int flags() {
+ if(is != null && os != null) return O_RDWR;
+ if(is != null) return O_RDONLY;
+ if(os != null) return O_WRONLY;
+ throw new Error("should never happen");
+ }
+
+ public void _close() {
+ if(is != null) try { is.close(); } catch(IOException e) { /*ignore*/ }
+ if(os != null) try { os.close(); } catch(IOException e) { /*ignore*/ }
+ }
+
public int read(byte[] a, int off, int length) throws ErrnoException {
+ if(is == null) return super.read(a,off,length);
try {
int n = is.read(a,off,length);
return n < 0 ? 0 : n;
} catch(IOException e) {
throw new ErrnoException(EIO);
}
+ }
+
+ public int write(byte[] a, int off, int length) throws ErrnoException {
+ if(os == null) return super.write(a,off,length);
+ try {
+ os.write(a,off,length);
+ return length;
+ } catch(IOException e) {
+ throw new ErrnoException(EIO);
+ }
}
- public void _close() { try { is.close(); } catch(IOException e) { /*ignore*/ } }
+
public FStat _fstat() { return new FStat(); }
}
- static class StdinFD extends InputStreamFD {
- public StdinFD(InputStream is) { super(is); }
+ static class TerminalFD extends InputOutputStreamFD {
+ public TerminalFD(InputStream is) { this(is,null); }
+ public TerminalFD(OutputStream os) { this(null,os); }
+ public TerminalFD(InputStream is, OutputStream os) { super(is,os); }
public void _close() { /* noop */ }
public FStat _fstat() { return new FStat() { public int type() { return S_IFCHR; } }; }
}
- static class StdoutFD extends OutputStreamFD {
- public StdoutFD(OutputStream os) { super(os); }
- public void _close() { /* noop */ }
- public FStat _fstat() { return new FStat() { public int type() { return S_IFCHR; } }; }
+ // FEATURE: TextInputStream: This is pretty inefficient but it is only used for reading from the console on win32
+ static class TextInputStream extends InputStream {
+ private int pushedBack = -1;
+ private final InputStream parent;
+ public TextInputStream(InputStream parent) { this.parent = parent; }
+ public int read() throws IOException {
+ if(pushedBack != -1) { int c = pushedBack; pushedBack = -1; return c; }
+ int c = parent.read();
+ if(c == '\r' && (c = parent.read()) != '\n') { pushedBack = c; return '\r'; }
+ return c;
+ }
+ public int read(byte[] buf, int pos, int len) throws IOException {
+ boolean pb = false;
+ if(pushedBack != -1 && len > 0) {
+ buf[0] = (byte) pushedBack;
+ pushedBack = -1;
+ pos++; len--; pb = true;
+ }
+ int n = parent.read(buf,pos,len);
+ if(n == -1) return -1;
+ for(int i=0;i<n;i++) {
+ if(buf[pos+i] == '\r') {
+ if(i==n-1) {
+ int c = parent.read();
+ if(c == '\n') buf[pos+i] = '\n';
+ else pushedBack = c;
+ } else if(buf[pos+i+1] == '\n') {
+ System.arraycopy(buf,pos+i+1,buf,pos+i,len-i-1);
+ n--;
+ }
+ }
+ }
+ return n + (pb ? 1 : 0);
+ }
}
public static class FStat {
public int pc;
public CPUState dup() {
- CPUState c = new CPUState();
+ CPUState c = new CPUState();
c.hi = hi;
c.lo = lo;
c.fcsr = fcsr;
c.pc = pc;
for(int i=0;i<32;i++) {
- c.r[i] = r[i];
+ c.r[i] = r[i];
c.f[i] = f[i];
}
return c;
}
public static class SecurityManager {
- public boolean allowRead(File f) { return true; }
+ public boolean allowRead(File f) { return true; }
public boolean allowWrite(File f) { return true; }
public boolean allowStat(File f) { return true; }
+ public boolean allowUnlink(File f) { return true; }
}
// Null pointer check helper function
}
}
+ static byte[] getNullTerminatedBytes(String s) {
+ byte[] buf1 = getBytes(s);
+ byte[] buf2 = new byte[buf1.length+1];
+ System.arraycopy(buf1,0,buf2,0,buf1.length);
+ return buf2;
+ }
+
final static String toHex(int n) { return "0x" + Long.toString(n & 0xffffffffL, 16); }
final static int min(int a, int b) { return a < b ? a : b; }
final static int max(int a, int b) { return a > b ? a : b; }