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

This reverts commit 6b59311d4bdc1447e085573f9bd2c42819e264dd.

Reverting these changes since they broke things.
Fixes #1608.

Kernel/FileSystem/FileBackedFileSystem.cpp → Kernel/FileSystem/DiskBackedFileSystem.cpp

@@ -27,12 +27,12 @@
 #include <AK/StringView.h>
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/Devices/BlockDevice.h>
-#include <Kernel/FileSystem/FileBackedFileSystem.h>
+#include <Kernel/FileSystem/DiskBackedFileSystem.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/KBuffer.h>
 #include <Kernel/Process.h>
 
-//#define FBFS_DEBUG
+//#define DBFS_DEBUG
 
 namespace Kernel {
 
@@ -46,7 +46,7 @@ struct CacheEntry {
 
 class DiskCache {
 public:
-    explicit DiskCache(FileBackedFS& fs)
+    explicit DiskCache(DiskBackedFS& 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 FileBackedFS flush here,
-            //       not some FileBackedFS subclass flush!
+            // NOTE: We want to make sure we only call DiskBackedFS flush here,
+            //       not some DiskBackedFS subclass flush!
             m_fs.flush_writes_impl();
             return get(block_index);
         }
@@ -107,52 +107,39 @@ public:
     }
 
 private:
-    FileBackedFS& m_fs;
+    DiskBackedFS& m_fs;
     size_t m_entry_count { 10000 };
     KBuffer m_cached_block_data;
     KBuffer m_entries;
     bool m_dirty { false };
 };
 
-FileBackedFS::FileBackedFS(FileDescription& file_description)
-    : m_file_description(file_description)
+DiskBackedFS::DiskBackedFS(BlockDevice& device)
+    : m_device(device)
 {
-    ASSERT(m_file_description->file().is_seekable());
 }
 
-FileBackedFS::~FileBackedFS()
+DiskBackedFS::~DiskBackedFS()
 {
 }
 
-bool FileBackedFS::write_block(unsigned index, const u8* data, FileDescription* description, bool use_logical_block_size)
+bool DiskBackedFS::write_block(unsigned index, const u8* data, FileDescription* description)
 {
-    ASSERT(m_logical_block_size);
-#ifdef FBFS_DEBUG
-    klog() << "FileBackedFileSystem::write_block " << index << ", size=" << data.size();
+#ifdef DBFS_DEBUG
+    klog() << "DiskBackedFileSystem::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>(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);
+        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(block_size());
+        device().write_raw(base_offset, block_size(), data);
         return true;
     }
 
     auto& entry = cache().get(index);
-    memcpy(entry.data, data, effective_block_size);
+    memcpy(entry.data, data, block_size());
     entry.is_dirty = true;
     entry.has_data = true;
 
@@ -160,68 +147,53 @@ bool FileBackedFS::write_block(unsigned index, const u8* data, FileDescription*
     return true;
 }
 
-bool FileBackedFS::write_blocks(unsigned index, unsigned count, const u8* data, FileDescription* description, bool use_logical_block_size)
+bool DiskBackedFS::write_blocks(unsigned index, unsigned count, const u8* data, FileDescription* description)
 {
-    ASSERT(m_logical_block_size);
-#ifdef FBFS_DEBUG
-    klog() << "FileBackedFileSystem::write_blocks " << index << " x" << count;
+#ifdef DBFS_DEBUG
+    klog() << "DiskBackedFileSystem::write_blocks " << index << " x" << count;
 #endif
     for (unsigned i = 0; i < count; ++i)
-        write_block(index + i, data + i * block_size(), description, use_logical_block_size);
+        write_block(index + i, data + i * block_size(), description);
     return true;
 }
 
-bool FileBackedFS::read_block(unsigned index, u8* buffer, FileDescription* description, bool use_logical_block_size, bool cache_disabled) const
+bool DiskBackedFS::read_block(unsigned index, u8* buffer, FileDescription* description) const
 {
-    ASSERT(m_logical_block_size);
-#ifdef FBFS_DEBUG
-    klog() << "FileBackedFileSystem::read_block " << index;
+#ifdef DBFS_DEBUG
+    klog() << "DiskBackedFileSystem::read_block " << index;
 #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 || 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);
+    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);
         return true;
     }
 
     auto& entry = cache().get(index);
     if (!entry.has_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);
+        u32 base_offset = static_cast<u32>(index) * static_cast<u32>(block_size());
+        bool success = device().read_raw(base_offset, block_size(), entry.data);
         entry.has_data = true;
-        ASSERT((size_t)nread == effective_block_size);
+        ASSERT(success);
     }
-    memcpy(buffer, entry.data, effective_block_size);
+    memcpy(buffer, entry.data, block_size());
     return true;
 }
 
-bool FileBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* description, bool use_logical_block_size, bool cache_disabled) const
+bool DiskBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* description) const
 {
-    ASSERT(m_logical_block_size);
     if (!count)
         return false;
     if (count == 1)
-        return read_block(index, buffer, description, use_logical_block_size, cache_disabled);
+        return read_block(index, buffer, description);
     u8* out = buffer;
 
     for (unsigned i = 0; i < count; ++i) {
-        if (!read_block(index + i, out, description, use_logical_block_size, cache_disabled))
+        if (!read_block(index + i, out, description))
             return false;
         out += block_size();
     }
@@ -229,7 +201,7 @@ bool FileBackedFS::read_blocks(unsigned index, unsigned count, u8* buffer, FileD
     return true;
 }
 
-void FileBackedFS::flush_specific_block_if_needed(unsigned index)
+void DiskBackedFS::flush_specific_block_if_needed(unsigned index)
 {
     LOCKER(m_lock);
     if (!cache().is_dirty())
@@ -237,14 +209,13 @@ void FileBackedFS::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());
-            m_file_description->seek(base_offset, SEEK_SET);
-            m_file_description->write(entry.data, block_size());
+            device().write_raw(base_offset, block_size(), entry.data);
             entry.is_dirty = false;
         }
     });
 }
 
-void FileBackedFS::flush_writes_impl()
+void DiskBackedFS::flush_writes_impl()
 {
     LOCKER(m_lock);
     if (!cache().is_dirty())
@@ -254,8 +225,7 @@ void FileBackedFS::flush_writes_impl()
         if (!entry.is_dirty)
             return;
         u32 base_offset = static_cast<u32>(entry.block_index) * static_cast<u32>(block_size());
-        m_file_description->seek(base_offset, SEEK_SET);
-        m_file_description->write(entry.data, block_size());
+        device().write_raw(base_offset, block_size(), entry.data);
         ++count;
         entry.is_dirty = false;
     });
@@ -263,15 +233,15 @@ void FileBackedFS::flush_writes_impl()
     dbg() << class_name() << ": Flushed " << count << " blocks to disk";
 }
 
-void FileBackedFS::flush_writes()
+void DiskBackedFS::flush_writes()
 {
     flush_writes_impl();
 }
 
-DiskCache& FileBackedFS::cache() const
+DiskCache& DiskBackedFS::cache() const
 {
     if (!m_cache)
-        m_cache = make<DiskCache>(const_cast<FileBackedFS&>(*this));
+        m_cache = make<DiskCache>(const_cast<DiskBackedFS&>(*this));
     return *m_cache;
 }
 

Kernel/FileSystem/FileBackedFileSystem.h → Kernel/FileSystem/DiskBackedFileSystem.h

@@ -26,45 +26,38 @@
 
 #pragma once
 
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/Forward.h>
 
 namespace Kernel {
 
-class FileBackedFS : public FS {
+class DiskBackedFS : public FS {
 public:
-    virtual ~FileBackedFS() override;
+    virtual ~DiskBackedFS() override;
 
-    virtual bool is_file_backed() const override { return true; }
+    virtual bool is_disk_backed() const override { return true; }
 
-    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; }
+    BlockDevice& device() { return *m_device; }
+    const BlockDevice& device() const { return *m_device; }
 
     virtual void flush_writes() override;
 
     void flush_writes_impl();
 
-    size_t logical_block_size() const { return m_logical_block_size; };
-
 protected:
-    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;
+    explicit DiskBackedFS(BlockDevice&);
 
-    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 read_block(unsigned index, u8* buffer, FileDescription* = nullptr) const;
+    bool read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* = nullptr) const;
 
-    size_t m_logical_block_size { 512 };
+    bool write_block(unsigned index, const u8*, FileDescription* = nullptr);
+    bool write_blocks(unsigned index, unsigned count, const u8*, FileDescription* = nullptr);
 
 private:
     DiskCache& cache() const;
     void flush_specific_block_if_needed(unsigned index);
 
-    NonnullRefPtr<FileDescription> m_file_description;
+    NonnullRefPtr<BlockDevice> m_device;
     mutable OwnPtr<DiskCache> m_cache;
 };
 

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(FileDescription& file_description)
+NonnullRefPtr<Ext2FS> Ext2FS::create(BlockDevice& device)
 {
-    return adopt(*new Ext2FS(file_description));
+    return adopt(*new Ext2FS(device));
 }
 
-Ext2FS::Ext2FS(FileDescription& file_description)
-    : FileBackedFS(file_description)
+Ext2FS::Ext2FS(BlockDevice& device)
+    : DiskBackedFS(device)
 {
 }
 
@@ -81,7 +81,7 @@ Ext2FS::~Ext2FS()
 bool Ext2FS::flush_super_block()
 {
     LOCKER(m_lock);
-    bool success = write_blocks(2, 1, (const u8*)&m_super_block, nullptr, true);
+    bool success = device().write_blocks(2, 1, (const u8*)&m_super_block);
     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 = read_blocks(2, 1, (u8*)&m_super_block, nullptr, true, true);
+    bool success = const_cast<BlockDevice&>(device()).read_blocks(2, 1, (u8*)&m_super_block);
     ASSERT(success);
 
     auto& super_block = this->super_block();
@@ -534,7 +534,7 @@ void Ext2FS::flush_writes()
         }
     }
 
-    FileBackedFS::flush_writes();
+    DiskBackedFS::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.

Kernel/FileSystem/Ext2FileSystem.h

@@ -28,7 +28,7 @@
 
 #include <AK/Bitmap.h>
 #include <AK/HashMap.h>
-#include <Kernel/FileSystem/FileBackedFileSystem.h>
+#include <Kernel/FileSystem/DiskBackedFileSystem.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/FileSystem/ext2_fs.h>
 #include <Kernel/KBuffer.h>
@@ -88,12 +88,11 @@ private:
     ext2_inode m_raw_inode;
 };
 
-class Ext2FS final : public FileBackedFS {
+class Ext2FS final : public DiskBackedFS {
     friend class Ext2FSInode;
 
 public:
-    static NonnullRefPtr<Ext2FS> create(FileDescription&);
-
+    static NonnullRefPtr<Ext2FS> create(BlockDevice&);
     virtual ~Ext2FS() override;
     virtual bool initialize() override;
 
@@ -110,7 +109,7 @@ private:
     typedef unsigned BlockIndex;
     typedef unsigned GroupIndex;
     typedef unsigned InodeIndex;
-    explicit Ext2FS(FileDescription&);
+    explicit Ext2FS(BlockDevice&);
 
     const ext2_super_block& super_block() const { return m_super_block; }
     const ext2_group_desc& group_descriptor(GroupIndex) const;

Kernel/FileSystem/FileDescription.cpp

@@ -98,6 +98,13 @@ 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) {
@@ -108,9 +115,7 @@ off_t FileDescription::seek(off_t offset, int whence)
         new_offset = m_current_offset + offset;
         break;
     case SEEK_END:
-        if (!metadata().is_valid())
-            return -EIO;
-        new_offset = metadata().size;
+        new_offset = metadata.size;
         break;
     default:
         return -EINVAL;

Kernel/FileSystem/FileSystem.h

@@ -87,7 +87,7 @@ public:
 
     int block_size() const { return m_block_size; }
 
-    virtual bool is_file_backed() const { return false; }
+    virtual bool is_disk_backed() const { return false; }
 
 protected:
     FS();

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/FileBackedFileSystem.h>
+#include <Kernel/FileSystem/DiskBackedFileSystem.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_file_backed())
-            fs_object.add("source", static_cast<const FileBackedFS&>(fs).file_description().absolute_path());
+        if (fs.is_disk_backed())
+            fs_object.add("device", static_cast<const DiskBackedFS&>(fs).device().absolute_path());
         else
-            fs_object.add("source", fs.class_name());
+            fs_object.add("device", fs.class_name());
     });
     array.finish();
     return builder.build();

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/FileBackedFileSystem.h>
+#include <Kernel/FileSystem/DiskBackedFileSystem.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
@@ -126,7 +126,14 @@ bool VFS::mount_root(FS& file_system)
     }
 
     m_root_inode = move(root_inode);
-    klog() << "VFS: mounted root from " << m_root_inode->fs().class_name() << " (" << static_cast<FileBackedFS&>(m_root_inode->fs()).file_description().absolute_path() << ")";
+    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 << ")";
 
     m_mounts.append(move(mount));
     return true;

Kernel/Makefile

@@ -56,8 +56,8 @@ OBJS = \
     DoubleBuffer.o \
     FileSystem/Custody.o \
     FileSystem/DevPtsFS.o \
+    FileSystem/DiskBackedFileSystem.o \
     FileSystem/Ext2FileSystem.o \
-    FileSystem/FileBackedFileSystem.o \
     FileSystem/FIFO.o \
     FileSystem/File.o \
     FileSystem/FileDescription.o \

Kernel/init.cpp

@@ -292,7 +292,7 @@ void init_stage2()
             }
         }
     }
-    auto e2fs = Ext2FS::create(*FileDescription::create(root_dev));
+    auto e2fs = Ext2FS::create(root_dev);
     if (!e2fs->initialize()) {
         klog() << "init_stage2: couldn't open root filesystem";
         hang();