Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Kernel/FileSystem/DiskBackedFileSystem.h

37 lines
1,015 B
C
Raw Normal View History

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;
Kernel: Fick infinite recursion when filling up disk cache We can't be calling the virtual FS::flush_writes() in order to flush the disk cache from within the disk cache, since an FS subclass may try to do cache stuff in its flush_writes() implementation. Instead, separate out the implementation of DiskBackedFS's flushing logic into a flush_writes_impl() and call that from the cache code.
2019-11-03 00:21:17 +01:00
void flush_writes_impl();
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: Implement O_DIRECT open() flag to bypass disk caches Files opened with O_DIRECT will now bypass the disk cache in read/write operations (though metadata operations will still hit the disk cache.) This will allow us to test actual disk performance instead of testing disk *cache* performance, if that's what we want. :^) There's room for improvment here, we're very aggressively flushing any dirty cache entries for the specific block before reading/writing that block. This is done by walking the entire cache, which may be slow.
2019-11-05 19:35:12 +01:00
bool read_block(unsigned index, u8* buffer, FileDescription* = nullptr) const;
bool read_blocks(unsigned index, unsigned count, u8* buffer, FileDescription* = nullptr) const;
Import all this stuff into a single repo called Serenity.
2018-10-10 11:53:07 +02:00
Kernel: Implement O_DIRECT open() flag to bypass disk caches Files opened with O_DIRECT will now bypass the disk cache in read/write operations (though metadata operations will still hit the disk cache.) This will allow us to test actual disk performance instead of testing disk *cache* performance, if that's what we want. :^) There's room for improvment here, we're very aggressively flushing any dirty cache entries for the specific block before reading/writing that block. This is done by walking the entire cache, which may be slow.
2019-11-05 19:35:12 +01:00
bool write_block(unsigned index, const u8*, FileDescription* = nullptr);
bool write_blocks(unsigned index, unsigned count, const u8*, FileDescription* = nullptr);
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;
Kernel: Implement O_DIRECT open() flag to bypass disk caches Files opened with O_DIRECT will now bypass the disk cache in read/write operations (though metadata operations will still hit the disk cache.) This will allow us to test actual disk performance instead of testing disk *cache* performance, if that's what we want. :^) There's room for improvment here, we're very aggressively flushing any dirty cache entries for the specific block before reading/writing that block. This is done by walking the entire cache, which may be slow.
2019-11-05 19:35:12 +01:00
void flush_specific_block_if_needed(unsigned index);
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
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
};
Reference in a new issue Copy permalink