import org.ibex.nestedvm.util.*;
import java.io.*;
import java.util.*;
+import java.net.Socket;
+import java.net.ServerSocket;
// FEATURE: vfork
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_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);
}
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();
}
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;
}
}
- 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;
}
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();
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);
}
}
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; }
projects / nestedvm.git / blobdiff