ByteArrayOutputStream baos = new ByteArrayOutputStream();
ClassFileCompiler c = new ClassFileCompiler(data,className,baos);
// FEATURE: make this Optional, pass options on compile arguments
- c.parseOptions("unixruntime,nosupportcall");
+ c.parseOptions("unixruntime,nosupportcall,maxinsnpermethod=512");
c.go();
baos.close();
byte[] bytecode = baos.toByteArray();
private static class SingleClassLoader extends ClassLoader {
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
- System.err.println(this + ": loadClass(\"" + name + "," + resolve + ");");
+ //System.err.println(this + ": loadClass(\"" + name + "," + resolve + ");");
return super.loadClass(name,resolve);
}
public Class fromBytes(String name, byte[] b) { return fromBytes(name,b,0,b.length); }
}
public static void main(String[] args) throws Exception {
- if(args.length == 0) {
- System.err.println("Usage: RuntimeCompiler mipsbinary");
+ if(args.length == 0) {
+ System.err.println("Usage: RuntimeCompiler mipsbinary");
System.exit(1);
}
UnixRuntime r = (UnixRuntime) compile(new Seekable.File(args[0])).newInstance();
System.err.println("Instansiated: "+ r);
- System.exit(r.run(args));
+ System.exit(UnixRuntime.runAndExec(r,args));
}
private RuntimeCompiler() { }
// FEATURE: Do the proper mangling for non-unix hosts
String userdir = getSystemProperty("user.dir");
cwd =
- userdir != null && userdir.startsWith("/") && File.separatorChar == '/' && HostFS.hostRootDir().getParent() == null
+ userdir != null && userdir.startsWith("/") && File.separatorChar == '/' && getSystemProperty("nestedvm.root") == null
? userdir.substring(1) : "";
}
}
String[] createEnv(String[] extra) {
- String[] defaults = new String[5];
+ String[] defaults = new String[6];
int n=0;
if(extra == null) extra = new String[0];
if(!envHas("USER",extra) && getSystemProperty("user.name") != null)
if(!envHas("SHELL",extra)) defaults[n++] = "SHELL=/bin/sh";
if(!envHas("TERM",extra)) defaults[n++] = "TERM=vt100";
if(!envHas("TZ",extra)) defaults[n++] = "TZ=" + posixTZ();
+ if(!envHas("PATH",extra)) defaults[n++] = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin";
String[] env = new String[extra.length+n];
for(int i=0;i<n;i++) env[i] = defaults[i];
for(int i=0;i<extra.length;i++) env[n++] = extra[i];
case SYS_chdir: return sys_chdir(a);
case SYS_exec: return sys_exec(a,b,c);
case SYS_getdents: return sys_getdents(a,b,c,d);
+ case SYS_unlink: return sys_unlink(a);
default: return super._syscall(syscall,a,b,c,d);
}
if(o instanceof Class) {
Class c = (Class) o;
try {
- return exec((UnixRuntime) c.newInstance(),argv,envp);
+ return exec((UnixRuntime) c.newInstance(),argv,envp);
} catch(Exception e) {
- e.printStackTrace();
+ e.printStackTrace();
return -ENOEXEC;
}
} else {
return 0;
}
+ private int sys_unlink(int cstring) throws FaultException, ErrnoException {
+ gs.unlink(this,normalizePath(cstring(cstring)));
+ return 0;
+ }
+
private int sys_getcwd(int addr, int size) throws FaultException, ErrnoException {
byte[] b = getBytes(cwd);
if(size == 0) return -EINVAL;
protected static final int STAT = 2;
protected static final int LSTAT = 3;
protected static final int MKDIR = 4;
+ protected static final int UNLINK = 5;
final UnixRuntime[] tasks;
int nextPID = 1;
case STAT: return fs.stat(r,path);
case LSTAT: return fs.lstat(r,path);
case MKDIR: fs.mkdir(r,path,arg1); return null;
+ case UNLINK: fs.unlink(r,path); return null;
default: throw new Error("should never happen");
}
}
public final FStat stat(UnixRuntime r, String path) throws ErrnoException { return (FStat) fsop(STAT,r,path,0,0); }
public final FStat lstat(UnixRuntime r, String path) throws ErrnoException { return (FStat) fsop(LSTAT,r,path,0,0); }
public final void mkdir(UnixRuntime r, String path, int mode) throws ErrnoException { fsop(MKDIR,r,path,mode,0); }
+ public final void unlink(UnixRuntime r, String path) throws ErrnoException { fsop(UNLINK,r,path,0,0); }
private Hashtable execCache = new Hashtable();
private static class CacheEnt {
// If this returns null it'll be turned into an ENOENT
public abstract FStat stat(UnixRuntime r, String path) throws ErrnoException;
public abstract void mkdir(UnixRuntime r, String path, int mode) throws ErrnoException;
+ public abstract void unlink(UnixRuntime r, String path) throws ErrnoException;
}
// FEATURE: chroot support in here
path.getChars(0,path.length(),in,0);
while(in[inp] != 0) {
- if(inp != 0) {
+ if(inp != 0 || cwdl==0) {
if(in[inp] != '/') { out[outp++] = in[inp++]; continue; }
while(in[inp] == '/') inp++;
}
return r.hostFSOpen(f,flags,mode,this);
}
+ public void unlink(UnixRuntime r, String path) throws ErrnoException {
+ File f = hostFile(path);
+ if(r.sm != null && !r.sm.allowUnlink(f)) throw new ErrnoException(EPERM);
+ if(!f.exists()) throw new ErrnoException(ENOENT);
+ if(!f.delete()) throw new ErrnoException(EPERM);
+ }
+
public FStat stat(UnixRuntime r, String path) throws ErrnoException {
File f = hostFile(path);
if(r.sm != null && !r.sm.allowStat(f)) throw new ErrnoException(EACCES);
return null;
}
- public void mkdir(UnixRuntime r, String path, int mode) throws ErrnoException { throw new ErrnoException(EACCES); }
- }
+ public void mkdir(UnixRuntime r, String path, int mode) throws ErrnoException { throw new ErrnoException(EROFS); }
+ public void unlink(UnixRuntime r, String path) throws ErrnoException { throw new ErrnoException(EROFS); }
+ }
}