import org.ibex.nestedvm.util.*;
import java.io.*;
import java.util.*;
+import java.net.Socket;
+import java.net.ServerSocket;
+
+// FEATURE: vfork
public abstract class UnixRuntime extends Runtime implements Cloneable {
/** The pid of this "process" */
// 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];
UnixRuntime[] tasks = gs.tasks;
synchronized(gs) {
if(pid != 0) {
- if(tasks[pid] == null || tasks[pid].pid != pid) throw new Error("should never happen");
+ UnixRuntime prev = tasks[pid];
+ if(prev == null || prev == this || prev.pid != pid || prev.parent != parent)
+ throw new Error("should never happen");
+ synchronized(parent.children) {
+ int i = parent.activeChildren.indexOf(prev);
+ if(i == -1) throw new Error("should never happen");
+ parent.activeChildren.set(i,this);
+ }
} else {
int newpid = -1;
int nextPID = gs.nextPID;
- for(int i=nextPID;i<tasks.length;i++) if(tasks[i] == null) { newpid = i; break; }
- if(newpid == -1) for(int i=1;i<nextPID;i++) if(tasks[i] == null) { newpid = i; break; }
- if(newpid == -1) throw new ProcessTableFullExn();
- pid = newpid;
+ for(int i=nextPID;i<tasks.length;i++) if(tasks[i] == null) { newpid = i; break; }
+ if(newpid == -1) for(int i=1;i<nextPID;i++) if(tasks[i] == null) { newpid = i; break; }
+ if(newpid == -1) throw new ProcessTableFullExn();
+ pid = newpid;
gs.nextPID = newpid + 1;
}
tasks[pid] = this;
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);
+ case SYS_getppid: return sys_getppid();
+ case SYS_opensocket: return sys_opensocket(a,b);
+ case SYS_listensocket: return sys_listensocket(a);
+ case SYS_accept: return sys_accept(a);
default: return super._syscall(syscall,a,b,c,d);
}
FD _open(String path, int flags, int mode) throws ErrnoException {
return gs.open(this,normalizePath(path),flags,mode);
}
+
+ private int sys_getppid() {
+ return parent == null ? 1 : parent.pid;
+ }
/** The kill syscall.
SIGSTOP, SIGTSTO, SIGTTIN, and SIGTTOUT pause the process.
if(parent == null) {
gs.tasks[pid] = null;
} else {
- parent.activeChildren.remove(this);
+ if(!parent.activeChildren.remove(this)) throw new Error("should never happen _exited: pid: " + pid);
parent.exitedChildren.add(this);
parent.children.notify();
}
private int exec(String normalizedPath, String[] argv, String[] envp) throws ErrnoException {
if(argv.length == 0) argv = new String[]{""};
+ // NOTE: For this little hack to work nestedvm.root MUST be "."
+ /*try {
+ System.err.println("Execing normalized path: " + normalizedPath);
+ if(true) return exec(new Interpreter(normalizedPath),argv,envp);
+ } catch(IOException e) { throw new Error(e); }*/
+
Object o = gs.exec(this,normalizedPath);
if(o == null) return -ENOENT;
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;
return n;
}
+ private static class SocketFD extends InputOutputStreamFD {
+ private final Socket s;
+
+ public SocketFD(Socket s) throws IOException {
+ super(s.getInputStream(),s.getOutputStream());
+ this.s = s;
+ }
+
+ public void _close() { try { s.close(); } catch(IOException e) { } }
+ }
+
+ public int sys_opensocket(int cstring, int port) throws FaultException, ErrnoException {
+ String hostname = cstring(cstring);
+ try {
+ FD fd = new SocketFD(new Socket(hostname,port));
+ int n = addFD(fd);
+ if(n == -1) fd.close();
+ return n;
+ } catch(IOException e) {
+ return -EIO;
+ }
+ }
+
+ private static class ListenSocketFD extends FD {
+ ServerSocket s;
+ public ListenSocketFD(ServerSocket s) { this.s = s; }
+ public int flags() { return 0; }
+ // FEATURE: What should these be?
+ public FStat _fstat() { return new FStat(); }
+ public void _close() { try { s.close(); } catch(IOException e) { } }
+ }
+
+ public int sys_listensocket(int port) {
+ try {
+ ListenSocketFD fd = new ListenSocketFD(new ServerSocket(port));
+ int n = addFD(fd);
+ if(n == -1) fd.close();
+ return n;
+ } catch(IOException e) {
+ return -EIO;
+ }
+ }
+
+ public int sys_accept(int fdn) {
+ if(fdn < 0 || fdn >= OPEN_MAX) return -EBADFD;
+ if(fds[fdn] == null) return -EBADFD;
+ if(!(fds[fdn] instanceof ListenSocketFD)) return -EBADFD;
+ try {
+ ServerSocket s = ((ListenSocketFD)fds[fdn]).s;
+ SocketFD fd = new SocketFD(s.accept());
+ int n = addFD(fd);
+ if(n == -1) fd.close();
+ return n;
+ } catch(IOException e) {
+ return -EIO;
+ }
+ }
+
// FEATURE: Run through the fork/wait stuff one more time
public static class GlobalState {
protected static final int OPEN = 1;
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;
}
}
- private static class MP {
+ private static class MP implements Comparable {
public MP(String path, FS fs) { this.path = path; this.fs = fs; }
public String path;
public FS fs;
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 {
}
public synchronized Object exec(UnixRuntime r, String path) throws ErrnoException {
+ // FIXME: Hideous hack to make a standalone busybox possible
+ if(path.equals("bin/busybox") && Boolean.valueOf(getSystemProperty("nestedvm.busyboxhack")).booleanValue())
+ return r.getClass();
FStat fstat = stat(r,path);
if(fstat == null) return null;
long mtime = fstat.mtime();
// 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++;
}
public FD open(UnixRuntime r, String path, int flags, int mode) throws ErrnoException {
+ // FIXME: horrendous, ugly hack needed by TeX... sorry Brian...
+ path = path.trim();
final File f = hostFile(path);
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);
}
private FD devZeroFD = new FD() {
- public boolean readable() { return true; }
- public boolean writable() { return true; }
public int read(byte[] a, int off, int length) { Arrays.fill(a,off,off+length,(byte)0); return length; }
public int write(byte[] a, int off, int length) { return length; }
public int seek(int n, int whence) { return 0; }
public FStat _fstat() { return new DevFStat(){ public int inode() { return ZERO_INODE; } }; }
};
private FD devNullFD = new FD() {
- public boolean readable() { return true; }
- public boolean writable() { return true; }
public int read(byte[] a, int off, int length) { return 0; }
public int write(byte[] a, int off, int length) { return length; }
public int seek(int n, int whence) { return 0; }
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); }
+ }
}
projects / nestedvm.git / blobdiff