mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-09-11 13:36:13 +03:00
179 lines
5.8 KiB
C++
179 lines
5.8 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <Kernel/FileSystem/Inode.h>
|
|
#include <Kernel/FileSystem/InodeWatcher.h>
|
|
#include <Kernel/Tasks/Process.h>
|
|
|
|
namespace Kernel {
|
|
|
|
ErrorOr<NonnullRefPtr<InodeWatcher>> InodeWatcher::try_create()
|
|
{
|
|
return adopt_nonnull_ref_or_enomem(new (nothrow) InodeWatcher);
|
|
}
|
|
|
|
InodeWatcher::~InodeWatcher()
|
|
{
|
|
(void)close();
|
|
}
|
|
|
|
bool InodeWatcher::can_read(OpenFileDescription const&, u64) const
|
|
{
|
|
return m_queue.with([](auto& queue) { return !queue.is_empty(); });
|
|
}
|
|
|
|
ErrorOr<size_t> InodeWatcher::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
|
|
{
|
|
auto event = TRY(m_queue.with([](auto& queue) -> ErrorOr<Event> {
|
|
if (queue.is_empty()) {
|
|
// can_read will catch the blocking case.
|
|
return EAGAIN;
|
|
}
|
|
|
|
return queue.dequeue();
|
|
}));
|
|
|
|
size_t bytes_to_write = sizeof(InodeWatcherEvent);
|
|
if (event.path)
|
|
bytes_to_write += event.path->length() + 1;
|
|
|
|
if (buffer_size < bytes_to_write)
|
|
return EINVAL;
|
|
|
|
auto result = buffer.write_buffered<MAXIMUM_EVENT_SIZE>(bytes_to_write, [&](Bytes bytes) {
|
|
size_t offset = 0;
|
|
|
|
memcpy(bytes.offset(offset), &event.wd, sizeof(InodeWatcherEvent::watch_descriptor));
|
|
offset += sizeof(InodeWatcherEvent::watch_descriptor);
|
|
memcpy(bytes.offset(offset), &event.type, sizeof(InodeWatcherEvent::type));
|
|
offset += sizeof(InodeWatcherEvent::type);
|
|
|
|
if (event.path) {
|
|
size_t name_length = event.path->length() + 1;
|
|
memcpy(bytes.offset(offset), &name_length, sizeof(InodeWatcherEvent::name_length));
|
|
offset += sizeof(InodeWatcherEvent::name_length);
|
|
memcpy(bytes.offset(offset), event.path->characters(), name_length);
|
|
} else {
|
|
memset(bytes.offset(offset), 0, sizeof(InodeWatcherEvent::name_length));
|
|
}
|
|
|
|
return bytes.size();
|
|
});
|
|
evaluate_block_conditions();
|
|
return result;
|
|
}
|
|
|
|
ErrorOr<void> InodeWatcher::close()
|
|
{
|
|
m_watch_maps.with([this](auto& watch_maps) {
|
|
for (auto& entry : watch_maps.wd_to_watches) {
|
|
auto& inode = const_cast<Inode&>(entry.value->inode);
|
|
inode.unregister_watcher({}, *this);
|
|
}
|
|
|
|
watch_maps.inode_to_watches.clear();
|
|
watch_maps.wd_to_watches.clear();
|
|
});
|
|
return {};
|
|
}
|
|
|
|
ErrorOr<NonnullOwnPtr<KString>> InodeWatcher::pseudo_path(OpenFileDescription const&) const
|
|
{
|
|
return m_watch_maps.with([](auto& watch_maps) -> ErrorOr<NonnullOwnPtr<KString>> {
|
|
return KString::formatted("InodeWatcher:({})", watch_maps.wd_to_watches.size());
|
|
});
|
|
}
|
|
|
|
void InodeWatcher::notify_inode_event(Badge<Inode>, InodeIdentifier inode_id, InodeWatcherEvent::Type event_type, StringView name)
|
|
{
|
|
m_watch_maps.with([this, inode_id, event_type, name](auto& watch_maps) {
|
|
auto it = watch_maps.inode_to_watches.find(inode_id);
|
|
if (it == watch_maps.inode_to_watches.end())
|
|
return;
|
|
|
|
auto& watcher = *it->value;
|
|
if (!(watcher.event_mask & static_cast<unsigned>(event_type)))
|
|
return;
|
|
|
|
m_queue.with([watcher, event_type, name](auto& queue) {
|
|
OwnPtr<KString> path;
|
|
if (!name.is_null())
|
|
path = KString::try_create(name).release_value_but_fixme_should_propagate_errors();
|
|
queue.enqueue({ watcher.wd, event_type, move(path) });
|
|
});
|
|
});
|
|
|
|
evaluate_block_conditions();
|
|
}
|
|
|
|
ErrorOr<int> InodeWatcher::register_inode(Inode& inode, unsigned event_mask)
|
|
{
|
|
return m_watch_maps.with([this, &inode, event_mask](auto& watch_maps) -> ErrorOr<int> {
|
|
if (watch_maps.inode_to_watches.find(inode.identifier()) != watch_maps.inode_to_watches.end())
|
|
return EEXIST;
|
|
|
|
int wd = -1;
|
|
do {
|
|
wd = m_wd_counter.value();
|
|
|
|
m_wd_counter++;
|
|
if (m_wd_counter.has_overflow())
|
|
m_wd_counter = 1;
|
|
} while (watch_maps.wd_to_watches.find(wd) != watch_maps.wd_to_watches.end());
|
|
|
|
auto description = TRY(WatchDescription::create(wd, inode, event_mask));
|
|
|
|
TRY(watch_maps.inode_to_watches.try_set(inode.identifier(), description.ptr()));
|
|
auto set_result = watch_maps.wd_to_watches.try_set(wd, move(description));
|
|
if (set_result.is_error()) {
|
|
watch_maps.inode_to_watches.remove(inode.identifier());
|
|
return set_result.release_error();
|
|
}
|
|
|
|
auto register_result = inode.register_watcher({}, *this);
|
|
if (register_result.is_error()) {
|
|
watch_maps.inode_to_watches.remove(inode.identifier());
|
|
watch_maps.wd_to_watches.remove(wd);
|
|
return register_result.release_error();
|
|
}
|
|
|
|
return wd;
|
|
});
|
|
}
|
|
|
|
ErrorOr<void> InodeWatcher::unregister_by_wd(int wd)
|
|
{
|
|
TRY(m_watch_maps.with([this, wd](auto& watch_maps) -> ErrorOr<void> {
|
|
auto it = watch_maps.wd_to_watches.find(wd);
|
|
if (it == watch_maps.wd_to_watches.end())
|
|
return ENOENT;
|
|
|
|
auto& inode = it->value->inode;
|
|
inode.unregister_watcher({}, *this);
|
|
|
|
watch_maps.inode_to_watches.remove(inode.identifier());
|
|
watch_maps.wd_to_watches.remove(it);
|
|
return {};
|
|
}));
|
|
return {};
|
|
}
|
|
|
|
void InodeWatcher::unregister_by_inode(Badge<Inode>, InodeIdentifier identifier)
|
|
{
|
|
m_watch_maps.with([identifier](auto& watch_maps) {
|
|
auto it = watch_maps.inode_to_watches.find(identifier);
|
|
if (it == watch_maps.inode_to_watches.end())
|
|
return;
|
|
|
|
// NOTE: no need to call unregister_watcher here, the Inode calls us.
|
|
watch_maps.inode_to_watches.remove(identifier);
|
|
watch_maps.wd_to_watches.remove(it->value->wd);
|
|
});
|
|
}
|
|
|
|
}
|