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/Inode.h

129 lines
4.4 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
Kernel: Implement multi-watch InodeWatcher :^) This patch modifies InodeWatcher to switch to a one watcher, multiple watches architecture. The following changes have been made: - The watch_file syscall is removed, and in its place the create_iwatcher, iwatcher_add_watch and iwatcher_remove_watch calls have been added. - InodeWatcher now holds multiple WatchDescriptions for each file that is being watched. - The InodeWatcher file descriptor can be read from to receive events on all watched files. Co-authored-by: Gunnar Beutner <gunnar@beutner.name>
2021-05-12 19:17:51 +00:00
* Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
#pragma once
#include <AK/Function.h>
Kernel: Use a FixedArray for a process's extra GIDs There's not really enough of these to justify using a HashTable.
2020-02-18 10:19:32 +01:00
#include <AK/HashTable.h>
Kernel: Switch Inode to IntrusiveList from InlineLinkedList
2021-05-26 02:18:23 -07:00
#include <AK/IntrusiveList.h>
AK: Rename Retainable.h => RefCounted.h.
2019-06-21 18:58:45 +02:00
#include <AK/RefCounted.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 01:27:42 +01:00
#include <AK/String.h>
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
#include <AK/WeakPtr.h>
Kernel: Implement FIFOs/named pipes
2020-07-16 15:23:03 -06:00
#include <Kernel/FileSystem/FIFO.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 11:53:16 +02:00
#include <Kernel/FileSystem/FileSystem.h>
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
#include <Kernel/FileSystem/InodeIdentifier.h>
#include <Kernel/FileSystem/InodeMetadata.h>
Kernel: Add forward declaration header
2020-02-16 01:50:16 +01:00
#include <Kernel/Forward.h>
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
#include <Kernel/KResult.h>
#include <Kernel/Lock.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 01:27:42 +01:00
namespace Kernel {
Kernel: Turns global Custody and Inode tables into InlineLinkedLists Yet more of this same thing. Each one of these patches has a small but noticeable impact on the steady-state kmalloc numbers. :^)
2019-08-08 11:08:27 +02:00
class Inode : public RefCounted<Inode>
Kernel: Switch Inode to IntrusiveList from InlineLinkedList
2021-05-26 02:18:23 -07:00
, public Weakable<Inode> {
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
friend class VFS;
friend class FS;
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 11:53:16 +02:00
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
public:
virtual ~Inode();
Kernel: Clang format file system in prep for changes.
2020-05-26 00:35:11 -07:00
virtual void one_ref_left() { }
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
FS& fs() { return m_fs; }
const FS& fs() const { return m_fs; }
Kernel: Inline Inode::fsid()
2020-05-18 21:46:02 +03:00
unsigned fsid() const { return m_fs.fsid(); }
Kernel: Add distinct InodeIndex type Use the DistinctNumeric mechanism to make InodeIndex a strongly typed integer type.
2021-02-12 09:18:47 +01:00
InodeIndex index() const { return m_index; }
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
size_t size() const { return metadata().size; }
bool is_symlink() const { return metadata().is_symlink(); }
bool is_directory() const { return metadata().is_directory(); }
bool is_character_device() const { return metadata().is_character_device(); }
mode_t mode() const { return metadata().mode; }
InodeIdentifier identifier() const { return { fsid(), index() }; }
virtual InodeMetadata metadata() const = 0;
Kernel: Move KBufferBuilder to the fallible KBuffer API KBufferBuilder::build() now returns an OwnPtr<KBuffer> and can fail. Clients of the API have been updated to handle that situation.
2020-12-18 14:10:10 +01:00
KResultOr<NonnullOwnPtr<KBuffer>> read_entire(FileDescription* = nullptr) const;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
Kernel: Improve ProcFS behavior in low memory conditions When ProcFS could no longer allocate KBuffer objects to serve calls to read, it would just return 0, indicating EOF. This then triggered parsing errors because code assumed it read the file. Because read isn't supposed to return ENOMEM, change ProcFS to populate the file data upon file open or seek to the beginning. This also means that calls to open can now return ENOMEM if needed. This allows the caller to either be able to successfully open the file and read it, or fail to open it in the first place.
2020-09-17 13:51:09 -06:00
virtual KResult attach(FileDescription&) { return KSuccess; }
virtual void detach(FileDescription&) { }
virtual void did_seek(FileDescription&, off_t) { }
Kernel: Change Inode::{read/write}_bytes interface to KResultOr<ssize_t> The error handling in all these cases was still using the old style negative values to indicate errors. We have a nicer solution for this now with KResultOr<T>. This change switches the interface and then all implementers to use the new style.
2021-05-01 14:29:39 -07:00
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const = 0;
Kernel: Add DirectoryEntryView for VFS directory traversal Unlike DirectoryEntry (which is used when constructing directories), DirectoryEntryView does not manage storage for file names. Names are just StringViews. This is much more suited to the directory traversal API and makes it easier to implement this in file system classes since they no longer need to create temporary name copies while traversing.
2020-08-18 12:41:27 +02:00
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const = 0;
Kernel: Make Inode::lookup() return a RefPtr<Inode> Previously this API would return an InodeIdentifier, which meant that there was a race in path resolution where an inode could be unlinked in between finding the InodeIdentifier for a path component, and actually resolving that to an Inode object. Attaching a test that would quickly trip an assertion before. Test: Kernel/path-resolution-race.cpp
2020-02-01 09:23:46 +01:00
virtual RefPtr<Inode> lookup(StringView name) = 0;
Kernel: Change Inode::{read/write}_bytes interface to KResultOr<ssize_t> The error handling in all these cases was still using the old style negative values to indicate errors. We have a nicer solution for this now with KResultOr<T>. This change switches the interface and then all implementers to use the new style.
2021-05-01 14:29:39 -07:00
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& data, FileDescription*) = 0;
Kernel: Deemphasize inode identifiers These APIs were clearly modeled after Ext2FS internals, and make perfect sense in Ext2FS context. The new APIs are more generic, and map better to the semantics exported to the userspace, where inode identifiers only appear in stat() and readdir() output, but never in any input. This will also hopefully reduce the potential for races (see commit https://github.com/SerenityOS/serenity/commit/c44b4d61f350703fcf1bbd8f6e353b9c6c4210c2). Lastly, this makes it way more viable to implement a filesystem that only synthesizes its inodes lazily when queried, and destroys them when they are no longer in use. With inode identifiers being used to reference inodes, the only choice for such a filesystem is to persist any inode it has given out the identifier for, because it might be queried at any later time. With direct references to inodes, the filesystem will know when the last reference is dropped and the inode can be safely destroyed.
2020-06-24 23:35:56 +03:00
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) = 0;
virtual KResult add_child(Inode&, const StringView& name, mode_t) = 0;
Kernel: Use StringView more in Inode and subclasses.
2019-06-09 10:25:19 +02:00
virtual KResult remove_child(const StringView& name) = 0;
Kernel: Make Inode::directory_entry_count errors observable. Certain implementations of Inode::directory_entry_count were calling functions which returned errors, but had no way of surfacing them. Switch the return type to KResultOr<size_t> and start observing these error paths.
2020-08-05 01:00:18 -07:00
virtual KResultOr<size_t> directory_entry_count() const = 0;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
virtual KResult chmod(mode_t) = 0;
virtual KResult chown(uid_t, gid_t) = 0;
Kernel: Make File::truncate() take a u64 No point in taking a signed type here. We validate at the syscall layer and then pass around a u64 from then on.
2020-02-08 12:07:04 +01:00
virtual KResult truncate(u64) { return KSuccess; }
Kernel: Remove default arguments from Inode::resolve_as_link() Nobody was calling it without specifying all arguments anyway.
2021-02-12 09:06:03 +01:00
virtual KResultOr<NonnullRefPtr<Custody>> resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
Kernel: Don't return -EFOO when return type is KResultOr<...>
2021-03-15 09:04:04 +01:00
virtual KResultOr<int> get_block_address(int) { return ENOTSUP; }
Kernel: Add FIBMAP ioctl to Ext2FileSystem FIBMAP is a linux ioctl that gives the location on disk of a specific block of a file
2021-01-30 13:12:49 -07:00
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
LocalSocket* socket() { return m_socket.ptr(); }
const LocalSocket* socket() const { return m_socket.ptr(); }
bool bind_socket(LocalSocket&);
bool unbind_socket();
Kernel: Let inodes provide pre-open file descriptions Some magical inodes, such as /proc/pid/fd/fileno, are going to want to open() to a custom FileDescription, so add a hook for that.
2020-01-15 14:03:14 +03:00
virtual FileDescription* preopen_fd() { return nullptr; };
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
bool is_metadata_dirty() const { return m_metadata_dirty; }
Kernel: Make Inode::set_{a,c,m}time return KResult This exposed some missing error propagation, which this patch also takes care of.
2021-04-30 15:51:06 +02:00
virtual KResult set_atime(time_t);
virtual KResult set_ctime(time_t);
virtual KResult set_mtime(time_t);
Ext2FS: Fail with EMFILE if we would overflow i_links_count
2020-02-08 02:26:33 +01:00
virtual KResult increment_link_count();
virtual KResult decrement_link_count();
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
virtual void flush_metadata() = 0;
void will_be_destroyed();
Kernel: Rename InodeVMObject => SharedInodeVMObject
2020-02-28 20:07:51 +01:00
void set_shared_vmobject(SharedInodeVMObject&);
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 16:26:13 -06:00
RefPtr<SharedInodeVMObject> shared_vmobject() const;
bool is_shared_vmobject(const SharedInodeVMObject&) const;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
static void sync();
Ext2FS: Don't uncache inodes while they are being watched If an inode is observed by watch_file(), we won't uncache it. This allows a program to watch a file without keeping it open.
2019-11-04 16:31:46 +01:00
bool has_watchers() const { return !m_watchers.is_empty(); }
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 20:01:11 +02:00
void register_watcher(Badge<InodeWatcher>, InodeWatcher&);
void unregister_watcher(Badge<InodeWatcher>, InodeWatcher&);
Kernel: Sprinkle some lockers in Inode It did look pretty suspicious the way we were accessing members in some of these functions without taking the lock first.
2020-12-31 02:10:31 +01:00
NonnullRefPtr<FIFO> fifo();
Kernel: Implement FIFOs/named pipes
2020-07-16 15:23:03 -06:00
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
protected:
Kernel: Add distinct InodeIndex type Use the DistinctNumeric mechanism to make InodeIndex a strongly typed integer type.
2021-02-12 09:18:47 +01:00
Inode(FS& fs, InodeIndex);
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 20:01:11 +02:00
void set_metadata_dirty(bool);
Kernel: Strip SUID+SGID bits from file when written to or chowned Fixes #1624.
2020-04-04 19:46:55 +02:00
KResult prepare_to_write_data();
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
Kernel: Implement multi-watch InodeWatcher :^) This patch modifies InodeWatcher to switch to a one watcher, multiple watches architecture. The following changes have been made: - The watch_file syscall is removed, and in its place the create_iwatcher, iwatcher_add_watch and iwatcher_remove_watch calls have been added. - InodeWatcher now holds multiple WatchDescriptions for each file that is being watched. - The InodeWatcher file descriptor can be read from to receive events on all watched files. Co-authored-by: Gunnar Beutner <gunnar@beutner.name>
2021-05-12 19:17:51 +00:00
void did_add_child(InodeIdentifier const& child_id, String const& name);
void did_remove_child(InodeIdentifier const& child_id, String const& name);
void did_modify_contents();
void did_delete_self();
Kernel: Add "child added" and "child removed" InodeWatcher events The child name is not yet accessible to userspace, but will be in a future patch.
2020-07-04 13:36:55 +02:00
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
mutable Lock m_lock { "Inode" };
private:
FS& m_fs;
Kernel: Add distinct InodeIndex type Use the DistinctNumeric mechanism to make InodeIndex a strongly typed integer type.
2021-02-12 09:18:47 +01:00
InodeIndex m_index { 0 };
Kernel: Rename InodeVMObject => SharedInodeVMObject
2020-02-28 20:07:51 +01:00
WeakPtr<SharedInodeVMObject> m_shared_vmobject;
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 18:37:47 +02:00
RefPtr<LocalSocket> m_socket;
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 20:01:11 +02:00
HashTable<InodeWatcher*> m_watchers;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
bool m_metadata_dirty { false };
Kernel: Implement FIFOs/named pipes
2020-07-16 15:23:03 -06:00
RefPtr<FIFO> m_fifo;
Kernel: Switch Inode to IntrusiveList from InlineLinkedList
2021-05-26 02:18:23 -07:00
IntrusiveListNode<Inode> m_inode_list_node;
public:
using List = IntrusiveList<Inode, RawPtr<Inode>, &Inode::m_inode_list_node>;
Kernel: Move Inode to its own files.
2019-05-16 03:02:37 +02:00
};
Kernel: Move all code into the Kernel namespace
2020-02-16 01:27:42 +01:00
}
Reference in a new issue Copy permalink