import the prex 0.9.0 VFS

Various changes to fit into the OSv environment.  This also includes
a ramfs in-memory full filesystem.  Bootfs is rewritten as a simple
unpacker into ramfs, and the fs class is modified to wrap the VFS
instead of being an abstract subclass.

Author: Christoph Hellwig

build.mak

@@ -57,8 +57,18 @@ loader.bin: arch/x64/boot32.o arch/x64/loader32.ld
 
 arch/x64/boot32.o: loader.elf
 
-fs = fs/fs.o fs/bootfs.o bootfs.o
-fs += fs/stdio.o
+fs = fs/fs.o bootfs.o
+
+fs +=	fs/vfs/main.o \
+	fs/vfs/vfs_conf.o \
+	fs/vfs/vfs_lookup.o \
+	fs/vfs/vfs_mount.o \
+	fs/vfs/vfs_vnode.o \
+	fs/vfs/vfs_task.o \
+	fs/vfs/vfs_syscalls.o
+
+fs +=	fs/ramfs/ramfs_vfsops.o \
+	fs/ramfs/ramfs_vnops.o
 
 drivers = drivers/vga.o drivers/console.o drivers/isa-serial.o
 drivers += $(fs)

fs/bootfs.cc

@@ -1,26 +1,16 @@
 #include "fs.hh"
+#include <fcntl.h>
+#include <sys/stat.h>
 
-filesystem* rootfs;
-
-namespace std {
-
-template <>
-struct hash<file::cache_key> {
-    size_t operator()(file::cache_key k) const {
-        return reinterpret_cast<uintptr_t>(k.first.get())
-               ^ std::hash<std::string>()(k.second);
-    }
-};
-
-}
-
-file::file()
-    : _refs(0)
+file::file(int fd)
+    : _fd(fd)
+    , _refs(0)
 {
 }
 
 file::~file()
 {
+    close(_fd);
 }
 
 void file::ref()
@@ -35,51 +25,35 @@ void file::unref()
     }
 }
 
-filesystem::~filesystem()
+uint64_t file::size()
 {
-}
+    struct stat st;
 
-fileref filesystem::open(std::string name)
-{
-    dirref d = root();
-    size_t s = 0, e;
-    while (d && (e = name.find('/', s)) != name.npos) {
-        if (s != e) {
-            d = d->subdir(name.substr(s, e - s));
-        }
-        s = e + 1;
-    }
-    if (!d) {
-        return fileref();
-    }
-    return d->open(name.substr(s, name.npos));
+    ::__fxstat(1, _fd, &st);
+    return st.st_size;
 }
-    
-int file::getdent(struct dirent *d, int idx)
+
+void file::read(void *buffer, uint64_t offset, uint64_t len)
 {
-	return -1;
+    ::lseek(_fd, offset, SEEK_SET);
+    ::read(_fd, buffer, len);
 }
 
-fileref dir::open(std::string name)
+void file::write(const void* buffer, uint64_t offset, uint64_t len)
 {
-    cache_key key(this, name);
-    auto ret = _cache.find(key);
-    if (ret == _cache.end()) {
-        auto f = do_open(name);
-        ret = _cache.insert(cache_type::value_type(key, f)).first;
-    }
-    return ret->second;
+    ::lseek(_fd, offset, SEEK_SET);
+    ::write(_fd, buffer, len);
 }
 
-dirref dir::subdir(std::string name)
+filesystem::~filesystem()
 {
-    // trivial implementation, can be overridden
-    return boost::dynamic_pointer_cast<dir>(open(name));
 }
 
-void dir::write(const void* buffer, uint64_t offset, uint64_t len)
+fileref filesystem::open(std::string name)
 {
-    abort();
-}
+    int fd = ::open(name.c_str(), O_RDONLY);
+    if (fd < 0)
+        return fileref();
 
-file::cache_type file::_cache;
+    return fileref(new file(fd));
+}

fs/bootfs.hh

@@ -8,53 +8,30 @@
 #include <unordered_map>
 
 class file;
-class dir;
 
 typedef boost::intrusive_ptr<file> fileref;
-typedef boost::intrusive_ptr<dir> dirref;
 
 class file {
 public:
-    file();
-    virtual ~file();
-    virtual uint64_t size() = 0;
-    virtual void read(void *buffer, uint64_t offset, uint64_t len) = 0;
-    virtual void write(const void* buffer, uint64_t offset, uint64_t len) = 0;
-    virtual int getdent(struct dirent *d, int idx);
+    file(int fd);
+    ~file();
+    uint64_t size();
+    void read(void *buffer, uint64_t offset, uint64_t len);
+    void write(const void* buffer, uint64_t offset, uint64_t len);
 private:
     void ref();
     void unref();
+    int _fd;
 private:
     unsigned _refs; // FIXME: make atomic
     friend void intrusive_ptr_add_ref(file* f) { f->ref(); }
     friend void intrusive_ptr_release(file* f) { f->unref(); }
-    friend class dir;
-private:
-    typedef std::pair<dirref, std::string> cache_key;
-    // FIXME: an intrusive container
-    typedef std::unordered_map<cache_key, fileref> cache_type;
-    static cache_type _cache;
-    friend struct std::hash<cache_key>;
-};
-
-class dir : public file {
-public:
-    fileref open(std::string name);
-    virtual fileref do_open(std::string name) = 0;
-    dirref subdir(std::string name);
-    virtual void write(const void* buffer, uint64_t offset, uint64_t len);
-private:
-    dirref _parent;
-    std::string _name;
 };
 
 class filesystem {
 public:
     virtual ~filesystem();
-    virtual dirref root() = 0;
     fileref open(std::string name);
 };
 
-extern filesystem* rootfs;
-
 #endif