Kernel: Change Ext2FS to be backed by a file instead of a block device

This ensures that we can mount image files as virtual disks without the
need of implementing gross hacks like loopback devices :)

8 files changed, 111 insertions, 85 deletions

diff --git a/Kernel/FileSystem/Ext2FileSystem.cpp b/Kernel/FileSystem/Ext2FileSystem.cpp
index 1e4004068d..9880e337aa 100644
--- a/Kernel/FileSystem/Ext2FileSystem.cpp
+++ b/Kernel/FileSystem/Ext2FileSystem.cpp
@@ -64,13 +64,13 @@ static u8 to_ext2_file_type(mode_t mode)
     return EXT2_FT_UNKNOWN;
 }
 
-NonnullRefPtr<Ext2FS> Ext2FS::create(BlockDevice& device)
+NonnullRefPtr<Ext2FS> Ext2FS::create(FileDescription& file_description)
 {
-    return adopt(*new Ext2FS(device));
+    return adopt(*new Ext2FS(file_description));
 }
 
-Ext2FS::Ext2FS(BlockDevice& device)
-    : DiskBackedFS(device)
+Ext2FS::Ext2FS(FileDescription& file_description)
+    : FileBackedFS(file_description)
 {
 }
 
@@ -81,7 +81,7 @@ Ext2FS::~Ext2FS()
 bool Ext2FS::flush_super_block()
 {
     LOCKER(m_lock);
-    bool success = device().write_blocks(2, 1, (const u8*)&m_super_block);
+    bool success = write_blocks(2, 1, (const u8*)&m_super_block, nullptr, true);
     ASSERT(success);
     return true;
 }
@@ -96,7 +96,7 @@ const ext2_group_desc& Ext2FS::group_descriptor(GroupIndex group_index) const
 bool Ext2FS::initialize()
 {
     LOCKER(m_lock);
-    bool success = const_cast<BlockDevice&>(device()).read_blocks(2, 1, (u8*)&m_super_block);
+    bool success = read_blocks(2, 1, (u8*)&m_super_block, nullptr, true, true);
     ASSERT(success);
 
     auto& super_block = this->super_block();
@@ -534,7 +534,7 @@ void Ext2FS::flush_writes()
         }
     }
 
-    DiskBackedFS::flush_writes();
+    FileBackedFS::flush_writes();
 
     // Uncache Inodes that are only kept alive by the index-to-inode lookup cache.
     // We don't uncache Inodes that are being watched by at least one InodeWatcher.
diff --git a/Kernel/FileSystem/Ext2FileSystem.h b/Kernel/FileSystem/Ext2FileSystem.h
index 526d40db87..ac69be96bc 100644
--- a/Kernel/FileSystem/Ext2FileSystem.h
+++ b/Kernel/FileSystem/Ext2FileSystem.h
@@ -28,7 +28,7 @@
 
 #include <AK/Bitmap.h>
 #include <AK/HashMap.h>
-#include <Kernel/FileSystem/DiskBackedFileSystem.h>
+#include <Kernel/FileSystem/FileBackedFileSystem.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/FileSystem/ext2_fs.h>
 #include <Kernel/KBuffer.h>
@@ -88,11 +88,12 @@ private:
     ext2_inode m_raw_inode;
 };
 
-class Ext2FS final : public DiskBackedFS {
+class Ext2FS final : public FileBackedFS {
     friend class Ext2FSInode;
 
 public:
-    static NonnullRefPtr<Ext2FS> create(BlockDevice&);
+    static NonnullRefPtr<Ext2FS> create(FileDescription&);
+
     virtual ~Ext2FS() override;
     virtual bool initialize() override;
 
@@ -109,7 +110,7 @@ private:
     typedef unsigned BlockIndex;
     typedef unsigned GroupIndex;
     typedef unsigned InodeIndex;
-    explicit Ext2FS(BlockDevice&);
+    explicit Ext2FS(FileDescription&);
 
     const ext2_super_block& super_block() const { return m_super_block; }
     const ext2_group_desc& group_descriptor(GroupIndex) const;
diff --git a/Kernel/FileSystem/DiskBackedFileSystem.cpp b/Kernel/FileSystem/FileBackedFileSystem.cpp
index 1e955b3633..a6a5cf8515 100644
--- a/Kernel/FileSystem/DiskBackedFileSystem.cpp
+++ b/Kernel/FileSystem/FileBackedFileSystem.cpp
@@ -27,12 +27,12 @@
 #include <AK/StringView.h>
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/Devices/BlockDevice.h>
-#include <Kernel/FileSystem/DiskBackedFileSystem.h>
+#include <Kernel/FileSystem/FileBackedFileSystem.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/KBuffer.h>
 #include <Kernel/Process.h>
 
-//#define DBFS_DEBUG
+//#define FBFS_DEBUG
 
 namespace Kernel {
 
@@ -46,7 +46,7 @@ struct CacheEntry {
 
 class DiskCache {
 public:
-    explicit DiskCache(DiskBackedFS& fs)
+    explicit DiskCache(FileBackedFS& fs)
         : m_fs(fs)
         , m_cached_block_data(KBuffer::create_with_size(m_entry_count * m_fs.block_size()))
         , m_entries(KBuffer::create_with_size(m_entry_count * sizeof(CacheEntry)))
@@ -81,8 +81,8 @@ public:
         }
         if (!oldest_clean_entry) {
             // Not a single clean entry! Flush writes and try again.
-            // NOTE: We want to make sure we only call DiskBackedFS flush here,
-            //       not some DiskBackedFS subclass flush!
+            // NOTE: We want to make sure we only call FileBackedFS flush here,
+            //       not some FileBackedFS subclass flush!
             m_fs.flush_writes_impl();
             return get(block_index);
         }
@@ -107,39 +107,52 @@ public:
     }
 
 private:
-    DiskBackedFS& m_fs;
+    FileBackedFS& m_fs;
     size_t m_entry_count { 10000 };
     KBuffer m_cached_block_data;
     KBuffer m_entries;
     bool m_dirty { false };
 };
 
-DiskBackedFS::DiskBackedFS(BlockDevice& device)
-    : m_device(device)
+FileBackedFS::FileBackedFS(FileDescription& file_description)
+    : m_file_description(file_description)
 {
+    ASSERT(m_file_description->file().is_seekable());
 }
 
-DiskBackedFS::~DiskBackedFS()
+FileBackedFS::~FileBackedFS()
 {
 }
 
-bool DiskBackedFS::write_block(unsigned index, const u8* data, FileDescription* description)
+bool FileBackedFS::write_block(unsigned index, const u8* data, FileDescription* description, bool use_logical_block_size)
 {
-#ifdef DBFS_DEBUG
-    klog() << "DiskBackedFileSystem::write_block " << index << ", size=" << data.size();
+    ASSERT(m_logical_block_size);
+#ifdef FBFS_DEBUG
+    klog() << "FileBackedFileSystem::write_block " << index << ", size=" << data.size();
 #endif
 
     bool allow_cache = !description || !description->is_direct();
 
+    /* We need to distinguish between "virtual disk reads" and "file system
+    reads". Previously, when we read the ext2 superblock for example, we called
+    device().read_raw() to fetch the superblock. Now we can't use that call
+    anymore because we are not backed by a BlockDevice, so the block size
+    (sector size) for reading the superblock is still 512 bytes like when we
+    used device().read_raw(), but we need to implement such functionality in the
+    FileBackedFileSystem layer instead. */
+    auto effective_block_size = use_logical_block_size ? m_logical_block_size : block_size();
+
     if (!allow_cache) {
         flush_specific_block_if_needed(index);
-        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(block_size());
-        device().write_raw(base_offset, block_size(), data);
+        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(effective_block_size);
+        m_file_description->seek(base_offset, SEEK_SET);
+        auto nwritten = m_file_description->write(data, effective_block_size);
+        ASSERT((size_t)nwritten == effective_block_size);
         return true;
     }
 
     auto& entry = cache().get(index);
-    memcpy(entry.data, data, block_size());
+    memcpy(entry.data, data, effective_block_size);
     entry.is_dirty = true;
     entry.has_data = true;
 
@@ -147,53 +160,68 @@ bool DiskBackedFS::write_block(unsigned index, const u8* data, FileDescription*
     return true;
 }
 
-bool DiskBackedFS::write_blocks(unsigned index, unsigned count, const u8* data, FileDescription* description)
+bool FileBackedFS::write_blocks(unsigned index, unsigned count, const u8* data, FileDescription* description, bool use_logical_block_size)
 {
-#ifdef DBFS_DEBUG
-    klog() << "DiskBackedFileSystem::write_blocks " << index << " x" << count;
+    ASSERT(m_logical_block_size);
+#ifdef FBFS_DEBUG
+    klog() << "FileBackedFileSystem::write_blocks " << index << " x" << count;
 #endif
     for (unsigned i = 0; i < count; ++i)
-        write_block(index + i, data + i * block_size(), description);
+        write_block(index + i, data + i * block_size(), description, use_logical_block_size);
     return true;
 }
 
-bool DiskBackedFS::read_block(unsigned index, u8* buffer, FileDescription* description) const
+bool FileBackedFS::read_block(unsigned index, u8* buffer, FileDescription* description, bool use_logical_block_size, bool cache_disabled) const
 {
-#ifdef DBFS_DEBUG
-    klog() << "DiskBackedFileSystem::read_block " << index;
+    ASSERT(m_logical_block_size);
+#ifdef FBFS_DEBUG
+    klog() << "FileBackedFileSystem::read_block " << index;
 #endif
 
     bool allow_cache = !description || !description->is_direct();
 
-    if (!allow_cache) {
-        const_cast<DiskBackedFS*>(this)->flush_specific_block_if_needed(index);
-        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(block_size());
-        bool success = device().read_raw(base_offset, block_size(), buffer);
-        ASSERT(success);
+    /* We need to distinguish between "virtual disk reads" and "file system
+    reads". Previously, when we read the ext2 superblock for example, we called
+    device().read_raw() to fetch the superblock. Now we can't use that call
+    anymore because we are not backed by a BlockDevice, so the block size
+    (sector size) for reading the superblock is still 512 bytes like when we
+    used device().read_raw(), but we need to implement such functionality in the
+    FileBackedFileSystem layer instead. */
+    auto effective_block_size = use_logical_block_size ? m_logical_block_size : block_size();
+
+    if (!allow_cache || cache_disabled) {
+        if (!cache_disabled)
+            const_cast<FileBackedFS*>(this)->flush_specific_block_if_needed(index);
+        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(effective_block_size);
+        const_cast<FileDescription&>(*m_file_description).seek(base_offset, SEEK_SET);
+        auto nread = const_cast<FileDescription&>(*m_file_description).read(buffer, effective_block_size);
+        ASSERT((size_t)nread == effective_block_size);
         return true;
     }
 
     auto& entry = cache().get(index);
     if (!entry.has_data) {
-        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(block_size());
-        bool success = device().read_raw(base_offset, block_size(), entry.data);
+        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(effective_block_size);
+        const_cast<FileDescription&>(*m_file_description).seek(base_offset, SEEK_SET);
+        auto nread = const_cast<FileDescription&>(*m_file_description).read(entry.data, effective_block_size);
         entry.has_data = true;
-        ASSERT(success);
+        ASSERT((size_t)nread == effective_block_size);
     }
-    memcpy(buffer, entry.data, block_size());
+    memcpy(buffer, entry.data, effective_block_size);
     return true;
 }
 
-bool DiskBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* description) const
+bool FileBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* description, bool use_logical_block_size, bool cache_disabled) const
 {
+    ASSERT(m_logical_block_size);
     if (!count)
         return false;
     if (count == 1)
-        return read_block(index, buffer, description);
+        return read_block(index, buffer, description, use_logical_block_size, cache_disabled);
     u8* out = buffer;
 
     for (unsigned i = 0; i < count; ++i) {
-        if (!read_block(index + i, out, description))
+        if (!read_block(index + i, out, description, use_logical_block_size, cache_disabled))
             return false;
         out += block_size();
     }
@@ -201,7 +229,7 @@ bool DiskBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileD
     return true;
 }
 
-void DiskBackedFS::flush_specific_block_if_needed(unsigned index)
+void FileBackedFS::flush_specific_block_if_needed(unsigned index)
 {
     LOCKER(m_lock);
     if (!cache().is_dirty())
@@ -209,13 +237,14 @@ void DiskBackedFS::flush_specific_block_if_needed(unsigned index)
     cache().for_each_entry([&](CacheEntry& entry) {
         if (entry.is_dirty && entry.block_index == index) {
             u32 base_offset = static_cast<u32>(entry.block_index) * static_cast<u32>(block_size());
-            device().write_raw(base_offset, block_size(), entry.data);
+            m_file_description->seek(base_offset, SEEK_SET);
+            m_file_description->write(entry.data, block_size());
             entry.is_dirty = false;
         }
     });
 }
 
-void DiskBackedFS::flush_writes_impl()
+void FileBackedFS::flush_writes_impl()
 {
     LOCKER(m_lock);
     if (!cache().is_dirty())
@@ -225,7 +254,8 @@ void DiskBackedFS::flush_writes_impl()
         if (!entry.is_dirty)
             return;
         u32 base_offset = static_cast<u32>(entry.block_index) * static_cast<u32>(block_size());
-        device().write_raw(base_offset, block_size(), entry.data);
+        m_file_description->seek(base_offset, SEEK_SET);
+        m_file_description->write(entry.data, block_size());
         ++count;
         entry.is_dirty = false;
     });
@@ -233,15 +263,15 @@ void DiskBackedFS::flush_writes_impl()
     dbg() << class_name() << ": Flushed " << count << " blocks to disk";
 }
 
-void DiskBackedFS::flush_writes()
+void FileBackedFS::flush_writes()
 {
     flush_writes_impl();
 }
 
-DiskCache& DiskBackedFS::cache() const
+DiskCache& FileBackedFS::cache() const
 {
     if (!m_cache)
-        m_cache = make<DiskCache>(const_cast<DiskBackedFS&>(*this));
+        m_cache = make<DiskCache>(const_cast<FileBackedFS&>(*this));
     return *m_cache;
 }
 
diff --git a/Kernel/FileSystem/DiskBackedFileSystem.h b/Kernel/FileSystem/FileBackedFileSystem.h
index a5909eaf39..36c89e4af0 100644
--- a/Kernel/FileSystem/DiskBackedFileSystem.h
+++ b/Kernel/FileSystem/FileBackedFileSystem.h
@@ -26,38 +26,45 @@
 
 #pragma once
 
+#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/Forward.h>
 
 namespace Kernel {
 
-class DiskBackedFS : public FS {
+class FileBackedFS : public FS {
 public:
-    virtual ~DiskBackedFS() override;
+    virtual ~FileBackedFS() override;
 
-    virtual bool is_disk_backed() const override { return true; }
+    virtual bool is_file_backed() const override { return true; }
 
-    BlockDevice& device() { return *m_device; }
-    const BlockDevice& device() const { return *m_device; }
+    File& file() { return m_file_description->file(); }
+    FileDescription& file_description() { return *m_file_description; }
+    const File& file() const { return m_file_description->file(); }
+    const FileDescription& file_description() const { return *m_file_description; }
 
     virtual void flush_writes() override;
 
     void flush_writes_impl();
 
+    size_t logical_block_size() const { return m_logical_block_size; };
+
 protected:
-    explicit DiskBackedFS(BlockDevice&);
+    explicit FileBackedFS(FileDescription&);
+
+    bool read_block(unsigned index, u8* buffer, FileDescription* = nullptr, bool use_logical_block_size = false, bool cache_disabled = false) const;
+    bool read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* = nullptr, bool use_logical_block_size = false, bool cache_disabled = false) const;
 
-    bool read_block(unsigned index, u8* buffer, FileDescription* = nullptr) const;
-    bool read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* = nullptr) const;
+    bool write_block(unsigned index, const u8*, FileDescription* = nullptr, bool use_logical_block_size = false);
+    bool write_blocks(unsigned index, unsigned count, const u8*, FileDescription* = nullptr, bool use_logical_block_size = false);
 
-    bool write_block(unsigned index, const u8*, FileDescription* = nullptr);
-    bool write_blocks(unsigned index, unsigned count, const u8*, FileDescription* = nullptr);
+    size_t m_logical_block_size { 512 };
 
 private:
     DiskCache& cache() const;
     void flush_specific_block_if_needed(unsigned index);
 
-    NonnullRefPtr<BlockDevice> m_device;
+    NonnullRefPtr<FileDescription> m_file_description;
     mutable OwnPtr<DiskCache> m_cache;
 };
 
diff --git a/Kernel/FileSystem/FileDescription.cpp b/Kernel/FileSystem/FileDescription.cpp
index dfe169f582..88ff913ca7 100644
--- a/Kernel/FileSystem/FileDescription.cpp
+++ b/Kernel/FileSystem/FileDescription.cpp
@@ -98,13 +98,6 @@ off_t FileDescription::seek(off_t offset, int whence)
     if (!m_file->is_seekable())
         return -EINVAL;
 
-    auto metadata = this->metadata();
-    if (!metadata.is_valid())
-        return -EIO;
-
-    if (metadata.is_socket() || metadata.is_fifo())
-        return -ESPIPE;
-
     off_t new_offset;
 
     switch (whence) {
@@ -115,7 +108,9 @@ off_t FileDescription::seek(off_t offset, int whence)
         new_offset = m_current_offset + offset;
         break;
     case SEEK_END:
-        new_offset = metadata.size;
+        if (!metadata().is_valid())
+            return -EIO;
+        new_offset = metadata().size;
         break;
     default:
         return -EINVAL;
diff --git a/Kernel/FileSystem/FileSystem.h b/Kernel/FileSystem/FileSystem.h
index 32e9fbf47e..4eb70fd89e 100644
--- a/Kernel/FileSystem/FileSystem.h
+++ b/Kernel/FileSystem/FileSystem.h
@@ -87,7 +87,7 @@ public:
 
     int block_size() const { return m_block_size; }
 
-    virtual bool is_disk_backed() const { return false; }
+    virtual bool is_file_backed() const { return false; }
 
 protected:
     FS();
diff --git a/Kernel/FileSystem/ProcFS.cpp b/Kernel/FileSystem/ProcFS.cpp
index 765e7e4bbf..4bf628c1fe 100644
--- a/Kernel/FileSystem/ProcFS.cpp
+++ b/Kernel/FileSystem/ProcFS.cpp
@@ -35,7 +35,7 @@
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/DiskBackedFileSystem.h>
+#include <Kernel/FileSystem/FileBackedFileSystem.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/Heap/kmalloc.h>
@@ -746,10 +746,10 @@ Optional<KBuffer> procfs$df(InodeIdentifier)
         fs_object.add("readonly", fs.is_readonly());
         fs_object.add("mount_flags", mount.flags());
 
-        if (fs.is_disk_backed())
-            fs_object.add("device", static_cast<const DiskBackedFS&>(fs).device().absolute_path());
+        if (fs.is_file_backed())
+            fs_object.add("source", static_cast<const FileBackedFS&>(fs).file_description().absolute_path());
         else
-            fs_object.add("device", fs.class_name());
+            fs_object.add("source", fs.class_name());
     });
     array.finish();
     return builder.build();
diff --git a/Kernel/FileSystem/VirtualFileSystem.cpp b/Kernel/FileSystem/VirtualFileSystem.cpp
index ebf3a69100..586d3f6181 100644
--- a/Kernel/FileSystem/VirtualFileSystem.cpp
+++ b/Kernel/FileSystem/VirtualFileSystem.cpp
@@ -28,7 +28,7 @@
 #include <AK/StringBuilder.h>
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/DiskBackedFileSystem.h>
+#include <Kernel/FileSystem/FileBackedFileSystem.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
@@ -126,14 +126,7 @@ bool VFS::mount_root(FS& file_system)
     }
 
     m_root_inode = move(root_inode);
-    char device_name[32];
-    if (m_root_inode->fs().is_disk_backed()) {
-        auto& device = static_cast<DiskBackedFS&>(m_root_inode->fs()).device();
-        sprintf(device_name, "%d,%d", device.major(), device.minor());
-    } else {
-        sprintf(device_name, "not-a-disk");
-    }
-    klog() << "VFS: mounted root on " << m_root_inode->fs().class_name() << " (" << device_name << ")";
+    klog() << "VFS: mounted root from " << m_root_inode->fs().class_name() << " (" << static_cast<FileBackedFS&>(m_root_inode->fs()).file_description().absolute_path() << ")";
 
     m_mounts.append(move(mount));
     return true;