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));
+ InputStream stdin = Boolean.valueOf(getSystemProperty("nestedvm.textstdin")).booleanValue() ? new TextInputStream(System.in) : System.in;
+ addFD(new StdinFD(stdin));
addFD(new StdoutFD(System.out));
addFD(new StdoutFD(System.err));
}
}
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;
}
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) {
- if(STDERR_DIAG) 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);
byte[] buf = byteBuf(count);
copyin(addr,buf,count);
try {
- return fds[fdn].write(buf,0,count);
+ return fds[fdn].write(buf,0,count);
} catch(ErrnoException e) {
- if(e.errno == EPIPE) sys_exit(128+13);
+ if(e.errno == EPIPE) sys_exit(128+13);
throw e;
}
}
}
/** 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:
if(STDERR_DIAG) System.err.println("WARNING: Attempted to use unknown sysconf key: " + n);
return -EINVAL;
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 {
- if(STDERR_DIAG) 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;
@see Runtime#state state */
protected final int syscall(int syscall, int a, int b, int c, int d) {
try {
- return _syscall(syscall,a,b,c,d);
+ return _syscall(syscall,a,b,c,d);
} catch(ErrnoException e) {
- return -e.errno;
+ return -e.errno;
} catch(FaultException e) {
- return -EFAULT;
+ return -EFAULT;
} catch(RuntimeException e) {
e.printStackTrace();
- throw new Error("Internal Error in _syscall()");
+ throw new Error("Internal Error in _syscall()");
}
}
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);
}
}
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;
+ os.write(a,off,length);
+ return length;
} catch(IOException e) {
- throw new ErrnoException(EIO);
+ throw new ErrnoException(EIO);
}
}
public void _close() { try { os.close(); } catch(IOException e) { /*ignore*/ } }
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 static final int S_IFIFO = 0010000;
public static final int S_IFCHR = 0020000;
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
projects / nestedvm.git / blobdiff