ladybird/Kernel/FileSystem/DiskBackedFileSystem.h

#pragma once

#include "FileSystem.h"
#include <AK/ByteBuffer.h>

class DiskCache;

class DiskBackedFS : public FS {
public:
    virtual ~DiskBackedFS() override;

    virtual bool is_disk_backed() const override { return true; }

    DiskDevice& device() { return *m_device; }
    const DiskDevice& device() const { return *m_device; }

    virtual void flush_writes() override;

protected:
    explicit DiskBackedFS(NonnullRefPtr<DiskDevice>&&);

    bool read_block(unsigned index, u8* buffer) const;
    bool read_blocks(unsigned index, unsigned count, u8* buffer) const;

    bool write_block(unsigned index, const u8*);
    bool write_blocks(unsigned index, unsigned count, const u8*);

private:
    DiskCache& cache() const;

    NonnullRefPtr<DiskDevice> m_device;
    mutable OwnPtr<DiskCache> m_cache;
};
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00			`#pragma once`

			`#include "FileSystem.h"`
			`#include <AK/ByteBuffer.h>`

Kernel: Implement a simpler, bigger cache for DiskBackedFS The hashmap cache was ridiculously slow and hurt us more than it helped us. This patch replaces it with a flat memory cache that keeps up to 10'000 blocks in cache with a simple dirty bit. The syncd task will wake up periodically and call flush_writes() on all file systems, which now causes us to traverse the cache and write all dirty blocks to disk. There's a ton of room for improvement here, but this itself is already drastically better when doing repeated GCC invocations. 2019-09-30 10:31:06 +02:00			`class DiskCache;`

Some more renaming: FileSystem -> FS SyntheticFileSystem -> SynthFS ProcFileSystem -> ProcFS Ext2FileSystem -> Ext2FS Ext2Inode -> Ext2FSInode 2018-11-15 17:13:10 +01:00			`class DiskBackedFS : public FS {`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00			`public:`
Some more renaming: FileSystem -> FS SyntheticFileSystem -> SynthFS ProcFileSystem -> ProcFS Ext2FileSystem -> Ext2FS Ext2Inode -> Ext2FSInode 2018-11-15 17:13:10 +01:00			`virtual ~DiskBackedFS() override;`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00
Kernel: Expose info about source devices of mounts in /proc/df 2019-08-17 12:17:36 +03:00			`virtual bool is_disk_backed() const override { return true; }`

BlockDevice -> DiskDevice. BlockDevice was the wrong name for this abstraction, since a block device is a type of file in a unix system, and we should use that name for that concept in the fs implementation. 2018-10-16 11:21:49 +02:00			`DiskDevice& device() { return *m_device; }`
			`const DiskDevice& device() const { return *m_device; }`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00
Kernel: Add a write cache to DiskBackedFS. This way you can spam small write()s on a file without the kernel writing to disk every single time. Flushes are included in the FS::sync() operation and will get triggered regularly by syncd. :^) 2019-04-25 22:05:53 +02:00			`virtual void flush_writes() override;`

Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00			`protected:`
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr. 2019-06-21 18:37:47 +02:00			`explicit DiskBackedFS(NonnullRefPtr<DiskDevice>&&);`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00
Kernel: Make DiskBackedFS::read_block() write to client-provided memory Instead of having DiskBackedFS allocate a ByteBuffer, leave it to each client to provide buffer space. This is significantly faster in many cases where we can use a stack buffer and avoid heap allocation entirely. 2019-09-30 11:04:30 +02:00			`bool read_block(unsigned index, u8* buffer) const;`
			`bool read_blocks(unsigned index, unsigned count, u8* buffer) const;`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00
Kernel: Convert the DiskBackedFS write API to take "const u8*" This way clients are not required to have instantiated ByteBuffers and can choose whatever memory scheme works best for them. Also converted some of the Ext2FS code to use stack buffers instead. 2019-09-30 11:20:51 +02:00			`bool write_block(unsigned index, const u8*);`
			`bool write_blocks(unsigned index, unsigned count, const u8*);`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00
			`private:`
Kernel: Implement a simpler, bigger cache for DiskBackedFS The hashmap cache was ridiculously slow and hurt us more than it helped us. This patch replaces it with a flat memory cache that keeps up to 10'000 blocks in cache with a simple dirty bit. The syncd task will wake up periodically and call flush_writes() on all file systems, which now causes us to traverse the cache and write all dirty blocks to disk. There's a ton of room for improvement here, but this itself is already drastically better when doing repeated GCC invocations. 2019-09-30 10:31:06 +02:00			`DiskCache& cache() const;`

AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr. 2019-06-21 18:37:47 +02:00			`NonnullRefPtr<DiskDevice> m_device;`
Kernel: Implement a simpler, bigger cache for DiskBackedFS The hashmap cache was ridiculously slow and hurt us more than it helped us. This patch replaces it with a flat memory cache that keeps up to 10'000 blocks in cache with a simple dirty bit. The syncd task will wake up periodically and call flush_writes() on all file systems, which now causes us to traverse the cache and write all dirty blocks to disk. There's a ton of room for improvement here, but this itself is already drastically better when doing repeated GCC invocations. 2019-09-30 10:31:06 +02:00			`mutable OwnPtr<DiskCache> m_cache;`
Import all this stuff into a single repo called Serenity. 2018-10-10 11:53:07 +02:00			`};`