// Copyright 2000-2005 the Contributors, as shown in the revision logs.
-// Licensed under the Apache Public Source License 2.0 ("the License").
+// Licensed under the Apache License 2.0 ("the License").
// You may not use this file except in compliance with the License.
package org.ibex.nestedvm;
import org.ibex.nestedvm.util.*;
-// HACK: This is ugly, this stuff needs to be in org.ibex.util or something
-import org.ibex.classgen.util.Sort;
import java.io.*;
import java.util.*;
import java.net.*;
if(!exec) {
gs = defaultGS;
String userdir = Platform.getProperty("user.dir");
- cwd = (userdir == null || Platform.getProperty("nestedvm.root") != null) ? null : HostFS.reverseMap(userdir);
+ cwd = userdir == null ? null : gs.mapHostPath(userdir);
if(cwd == null) cwd = "/";
cwd = cwd.substring(1);
}
String tmp;
if(!envHas("USER",extra) && Platform.getProperty("user.name") != null)
defaults[n++] = "USER=" + Platform.getProperty("user.name");
- if(!envHas("HOME",extra) && (tmp=Platform.getProperty("user.home")) != null && (tmp=HostFS.reverseMap(tmp)) != null)
+ if(!envHas("HOME",extra) && (tmp=Platform.getProperty("user.home")) != null && (tmp=gs.mapHostPath(tmp)) != null)
defaults[n++] = "HOME=" + tmp;
- if(!envHas("TMPDIR",extra) && (tmp=Platform.getProperty("java.io.tmpdir")) != null && (tmp=HostFS.reverseMap(tmp)) != null)
+ if(!envHas("TMPDIR",extra) && (tmp=Platform.getProperty("java.io.tmpdir")) != null && (tmp=gs.mapHostPath(tmp)) != null)
defaults[n++] = "TMPDIR=" + tmp;
if(!envHas("SHELL",extra)) defaults[n++] = "SHELL=/bin/sh";
if(!envHas("TERM",extra) && !win32Hacks) defaults[n++] = "TERM=vt100";
}
}
- int _syscall(int syscall, int a, int b, int c, int d, int e, int f) throws ErrnoException, FaultException {
+ protected int _syscall(int syscall, int a, int b, int c, int d, int e, int f) throws ErrnoException, FaultException {
switch(syscall) {
case SYS_kill: return sys_kill(a,b);
case SYS_fork: return sys_fork();
case SYS_fchown: return sys_fchown(a,b,c);
case SYS_chmod: return sys_chmod(a,b,c);
case SYS_fchmod: return sys_fchmod(a,b,c);
+ case SYS_fcntl: return sys_fcntl_lock(a,b,c);
case SYS_umask: return sys_umask(a);
default: return super._syscall(syscall,a,b,c,d,e,f);
}
FD _open(String path, int flags, int mode) throws ErrnoException {
- return gs.open(this,normalizePath(path),flags,mode);
+ path = normalizePath(path);
+ FD fd = gs.open(this,path,flags,mode);
+ if (fd != null && path != null) fd.setNormalizedPath(path);
+ return fd;
}
private int sys_getppid() {
private int sys_access(int cstring, int mode) throws ErrnoException, ReadFaultException {
// FEATURE: sys_access
- return gs.stat(this,cstring(cstring)) == null ? -ENOENT : 0;
+ return gs.stat(this,normalizePath(cstring(cstring))) == null ? -ENOENT : 0;
}
private int sys_realpath(int inAddr, int outAddr) throws FaultException {
return 0;
}
- static class Pipe {
+ public static class Pipe {
private final byte[] pipebuf = new byte[PIPE_BUF*4];
private int readPos;
private int writePos;
copyout(buf,addr,n);
return n;
}
-
+
+ void _preCloseFD(FD fd) {
+ // release all fcntl locks on this file
+ Seekable s = fd.seekable();
+ if (s == null) return;
+
+ try {
+ for (int i=0; i < gs.locks.length; i++) {
+ Seekable.Lock l = gs.locks[i];
+ if (l == null) continue;
+ if (s.equals(l.seekable()) && l.getOwner() == this) {
+ l.release();
+ gs.locks[i] = null;
+ }
+ }
+ } catch (IOException e) { throw new RuntimeException(e); }
+ }
+
+ void _postCloseFD(FD fd) {
+ if (fd.isMarkedForDeleteOnClose()) {
+ try { gs.unlink(this, fd.getNormalizedPath()); }
+ catch (Throwable t) {}
+ }
+ }
+
+ /** Implements the F_GETLK and F_SETLK cases of fcntl syscall.
+ * If l_start = 0 and l_len = 0 the lock refers to the entire file.
+ * Uses GlobalState to ensure locking across processes in the same JVM.
+ struct flock {
+ short l_type; // lock type: F_UNLCK, F_RDLCK, F_WRLCK
+ short l_whence; // type of l_start: SEEK_SET, SEEK_CUR, SEEK_END
+ long l_start; // starting offset, bytes
+ long l_len; // len = 0 means until EOF
+ short l_pid; // lock owner
+ short l_xxx; // padding
+ };
+ */
+ private int sys_fcntl_lock(int fdn, int cmd, int arg) throws FaultException{
+ if (cmd != F_GETLK && cmd != F_SETLK) return sys_fcntl(fdn, cmd, arg);
+
+ if(fdn < 0 || fdn >= OPEN_MAX) return -EBADFD;
+ if(fds[fdn] == null) return -EBADFD;
+ FD fd = fds[fdn];
+
+ if (arg == 0) return -EINVAL;
+ int word = memRead(arg);
+ int l_start = memRead(arg+4);
+ int l_len = memRead(arg+8);
+ int l_type = word>>16;
+ int l_whence = word&0x00ff;
+
+ Seekable.Lock[] locks = gs.locks;
+ Seekable s = fd.seekable();
+ if (s == null) return -EINVAL;
+
+ try {
+
+ switch (l_whence) {
+ case SEEK_SET: break;
+ case SEEK_CUR: l_start += s.pos(); break;
+ case SEEK_END: l_start += s.length(); break;
+ default: return -1;
+ }
+
+ if (cmd == F_GETLK) {
+ // The simple Java file locking below will happily return
+ // a lock that overlaps one already held by the JVM. Thus
+ // we must check over all the locks held by other Runtimes
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+ if (!locks[i].overlaps(l_start, l_len))
+ continue;
+ if (locks[i].getOwner() == this)
+ continue;
+ if (locks[i].isShared() && l_type == F_RDLCK)
+ continue;
+
+ // overlapping lock held by another process
+ return 0;
+ }
+
+ // check if an area is lockable by attempting to obtain a lock
+ Seekable.Lock lock = s.lock(l_start, l_len, l_type == F_RDLCK);
+
+ if (lock != null) { // no lock exists
+ memWrite(arg, SEEK_SET|(F_UNLCK<<16));
+ lock.release();
+ }
+
+ return 0;
+ }
+
+ // now processing F_SETLK
+ if (cmd != F_SETLK) return -EINVAL;
+
+ if (l_type == F_UNLCK) {
+ // release all locks that fall within the boundaries given
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+ if (locks[i].getOwner() != this) continue;
+
+ int pos = (int)locks[i].position();
+ if (pos < l_start) continue;
+ if (l_start != 0 && l_len != 0) // start/len 0 means unlock all
+ if (pos + locks[i].size() > l_start + l_len)
+ continue;
+
+ locks[i].release();
+ locks[i] = null;
+ }
+ return 0;
+
+ } else if (l_type == F_RDLCK || l_type == F_WRLCK) {
+ // first see if a lock already exists
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+
+ if (locks[i].getOwner() == this) {
+ // if this Runtime owns an overlapping lock work with it
+ if (locks[i].contained(l_start, l_len)) {
+ locks[i].release();
+ locks[i] = null;
+ } else if (locks[i].contains(l_start, l_len)) {
+ if (locks[i].isShared() == (l_type == F_RDLCK)) {
+ // return this more general lock
+ memWrite(arg+4, (int)locks[i].position());
+ memWrite(arg+8, (int)locks[i].size());
+ return 0;
+ } else {
+ locks[i].release();
+ locks[i] = null;
+ }
+ }
+ } else {
+ // if another Runtime has an lock and it is exclusive or
+ // we want an exclusive lock then fail
+ if (locks[i].overlaps(l_start, l_len)
+ && (!locks[i].isShared() || l_type == F_WRLCK))
+ return -EAGAIN;
+ }
+ }
+
+ // create the lock
+ Seekable.Lock lock = s.lock(l_start, l_len, l_type == F_RDLCK);
+ if (lock == null) return -EAGAIN;
+ lock.setOwner(this);
+
+ int i;
+ for (i=0; i < locks.length; i++)
+ if (locks[i] == null) break;
+ if (i == locks.length) return -ENOLCK;
+ locks[i] = lock;
+ return 0;
+
+ } else {
+ return -EINVAL;
+ }
+
+ } catch (IOException e) { throw new RuntimeException(e); }
+ }
+
static class SocketFD extends FD {
public static final int TYPE_STREAM = 0;
public static final int TYPE_DGRAM = 1;
final UnixRuntime[] tasks;
int nextPID = 1;
+ /** Table of all current file locks held by this process. */
+ Seekable.Lock[] locks = new Seekable.Lock[16];
+
private MP[] mps = new MP[0];
private FS root;
public GlobalState(int maxProcs, boolean defaultMounts) {
tasks = new UnixRuntime[maxProcs+1];
if(defaultMounts) {
- addMount("/",new HostFS());
+ File root = null;
+ if(Platform.getProperty("nestedvm.root") != null) {
+ root = new File(Platform.getProperty("nestedvm.root"));
+ if(!root.isDirectory()) throw new IllegalArgumentException("nestedvm.root is not a directory");
+ } else {
+ String cwd = Platform.getProperty("user.dir");
+ root = Platform.getRoot(new File(cwd != null ? cwd : "."));
+ }
+
+ addMount("/",new HostFS(root));
+
+ if(Platform.getProperty("nestedvm.root") == null) {
+ File[] roots = Platform.listRoots();
+ for(int i=0;i<roots.length;i++) {
+ String name = roots[i].getPath();
+ if(name.endsWith(File.separator))
+ name = name.substring(0,name.length()-1);
+ if(name.length() == 0 || name.indexOf('/') != -1) continue;
+ addMount("/" + name.toLowerCase(),new HostFS(roots[i]));
+ }
+ }
+
addMount("/dev",new DevFS());
addMount("/resource",new ResourceFS());
+ addMount("/cygdrive",new CygdriveFS());
+ }
+ }
+
+ public String mapHostPath(String s) { return mapHostPath(new File(s)); }
+ public String mapHostPath(File f) {
+ MP[] list;
+ FS root;
+ synchronized(this) { mps = this.mps; root = this.root; }
+ if(!f.isAbsolute()) f = new File(f.getAbsolutePath());
+ for(int i=mps.length;i>=0;i--) {
+ FS fs = i == mps.length ? root : mps[i].fs;
+ String path = i == mps.length ? "" : mps[i].path;
+ if(!(fs instanceof HostFS)) continue;
+ File fsroot = ((HostFS)fs).getRoot();
+ if(!fsroot.isAbsolute()) fsroot = new File(fsroot.getAbsolutePath());
+ if(f.getPath().startsWith(fsroot.getPath())) {
+ char sep = File.separatorChar;
+ String child = f.getPath().substring(fsroot.getPath().length());
+ if(sep != '/') {
+ char[] child_ = child.toCharArray();
+ for(int j=0;j<child_.length;j++) {
+ if(child_[j] == '/') child_[j] = sep;
+ else if(child_[j] == sep) child_[j] = '/';
+ }
+ child = new String(child_);
+ }
+ String mapped = "/" + (path.length()==0?"":path+"/") + child;
+ return mapped;
+ }
}
+ return null;
}
static class MP implements Sort.Comparable {
System.arraycopy(mps,0,newMPS,index,mps.length-index-1);
mps = newMPS;
}
-
+
private Object fsop(int op, UnixRuntime r, String normalizedPath, int arg1, int arg2) throws ErrnoException {
int pl = normalizedPath.length();
if(pl != 0) {
public abstract void unlink(UnixRuntime r, String path) throws ErrnoException;
}
- // chroot support should go in here if it is ever implemented chroot support in here
+ // chroot support should go in here if it is ever implemented
private String normalizePath(String path) {
boolean absolute = path.startsWith("/");
int cwdl = cwd.length();
protected File root;
public File getRoot() { return root; }
- static File hostRootDir() {
- if(Platform.getProperty("nestedvm.root") != null) {
- File f = new File(Platform.getProperty("nestedvm.root"));
- if(f.isDirectory()) return f;
- // fall through to case below
- }
- String cwd = Platform.getProperty("user.dir");
- File f = new File(cwd != null ? cwd : ".");
- if(!f.exists()) throw new Error("Couldn't get File for cwd");
- f = new File(f.getAbsolutePath());
- while(f.getParent() != null) f = new File(f.getParent());
- // This works around a bug in some versions of ClassPath
- if(f.getPath().length() == 0) f = new File("/");
- return f;
- }
-
- static String reverseMap(String f) {
- if(f.startsWith("/") && File.separatorChar == '/') return f;
-
- Vector vec = new Vector();
- File root = HostFS.hostRootDir();
- String s = new File(f).getAbsolutePath();
- File d = new File(s);
- while(!d.equals(root)) {
- vec.addElement(d.getName());
- if((s = d.getParent()) == null) break;
- d = new File(s);
- }
- String ret = null;
- if(s != null) {
- ret="/";
- for(int i=vec.size()-1;i>=0;i--) ret += (String) vec.elementAt(i) + (i==0?"":"/");
- }
- return ret;
- }
-
- private File hostFile(String path) {
+ protected File hostFile(String path) {
char sep = File.separatorChar;
if(sep != '/') {
char buf[] = path.toCharArray();
return new File(root,path);
}
- public HostFS() { this(hostRootDir()); }
public HostFS(String root) { this(new File(root)); }
public HostFS(File root) { this.root = root; }
-
public FD open(UnixRuntime r, String path, int flags, int mode) throws ErrnoException {
final File f = hostFile(path);
return r.hostFSOpen(f,flags,mode,this);
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);
+ if(!f.delete()) {
+ // Can't delete file immediately, so mark for
+ // delete on close all matching FDs
+ boolean marked = false;
+ for(int i=0;i<OPEN_MAX;i++) {
+ if(r.fds[i] != null) {
+ String fdpath = r.fds[i].getNormalizedPath();
+ if(fdpath != null && fdpath.equals(path)) {
+ r.fds[i].markDeleteOnClose();
+ marked = true;
+ }
+ }
+ }
+ if(!marked) throw new ErrnoException(EPERM);
+ }
}
public FStat stat(UnixRuntime r, String path) throws ErrnoException {
public int myDev() { return devno; }
}
}
+
+ /* Implements the Cygwin notation for accessing MS Windows drive letters
+ * in a unix path. The path /cygdrive/c/myfile is converted to C:\file.
+ * As there is no POSIX standard for this, little checking is done. */
+ public static class CygdriveFS extends HostFS {
+ protected File hostFile(String path) {
+ final char drive = path.charAt(0);
+
+ if (drive < 'a' || drive > 'z' || path.charAt(1) != '/')
+ return null;
+
+ path = drive + ":" + path.substring(1).replace('/', '\\');
+ return new File(path);
+ }
+
+ public CygdriveFS() { super("/"); }
+ }
private static void putInt(byte[] buf, int off, int n) {
buf[off+0] = (byte)((n>>>24)&0xff);
if(path.startsWith("fd/")) {
int n;
try {
- n = Integer.parseInt(path.substring(4));
+ n = Integer.parseInt(path.substring(3));
} catch(NumberFormatException e) {
return null;
}
projects / nestedvm.git / blobdiff