mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-22 17:31:58 -05:00
Code Issues Projects Releases Packages Wiki Activity

Kernel: Remove the now defunct LOCKER(..) macro.

Browse source
This commit is contained in:
Brian Gianforcaro 2021-04-24 15:27:32 -07:00 committed by Andreas Kling
parent 0d5827f865
commit 8d6e9fad40
31 changed files with 196 additions and 198 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Kernel/DoubleBuffer.cpp
View file

@ -45,7 +45,7 @@ ssize_t DoubleBuffer::write(const UserOrKernelBuffer& data, size_t size)
if (!size || m_storage.is_null())
return 0;
VERIFY(size > 0);
LOCKER(m_lock);
Locker locker(m_lock);
size_t bytes_to_write = min(size, m_space_for_writing);
u8* write_ptr = m_write_buffer->data + m_write_buffer->size;
m_write_buffer->size += bytes_to_write;
@ -62,7 +62,7 @@ ssize_t DoubleBuffer::read(UserOrKernelBuffer& data, size_t size)
if (!size || m_storage.is_null())
return 0;
VERIFY(size > 0);
LOCKER(m_lock);
Locker locker(m_lock);
if (m_read_buffer_index >= m_read_buffer->size && m_write_buffer->size != 0)
flip();
if (m_read_buffer_index >= m_read_buffer->size)

20
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -116,7 +116,7 @@ BlockBasedFS::~BlockBasedFS()
KResult BlockBasedFS::write_block(BlockIndex index, const UserOrKernelBuffer& data, size_t count, size_t offset, bool allow_cache)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_logical_block_size);
VERIFY(offset + count <= block_size());
dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::write_block {}, size={}", index, count);
@ -151,7 +151,7 @@ KResult BlockBasedFS::write_block(BlockIndex index, const UserOrKernelBuffer& da
bool BlockBasedFS::raw_read(BlockIndex index, UserOrKernelBuffer& buffer)
{
LOCKER(m_lock);
Locker locker(m_lock);
u32 base_offset = index.value() * m_logical_block_size;
auto seek_result = file_description().seek(base_offset, SEEK_SET);
VERIFY(!seek_result.is_error());
@ -163,7 +163,7 @@ bool BlockBasedFS::raw_read(BlockIndex index, UserOrKernelBuffer& buffer)
bool BlockBasedFS::raw_write(BlockIndex index, const UserOrKernelBuffer& buffer)
{
LOCKER(m_lock);
Locker locker(m_lock);
size_t base_offset = index.value() * m_logical_block_size;
auto seek_result = file_description().seek(base_offset, SEEK_SET);
VERIFY(!seek_result.is_error());
@ -175,7 +175,7 @@ bool BlockBasedFS::raw_write(BlockIndex index, const UserOrKernelBuffer& buffer)
bool BlockBasedFS::raw_read_blocks(BlockIndex index, size_t count, UserOrKernelBuffer& buffer)
{
LOCKER(m_lock);
Locker locker(m_lock);
auto current = buffer;
for (unsigned block = index.value(); block < (index.value() + count); block++) {
if (!raw_read(BlockIndex { block }, current))
@ -187,7 +187,7 @@ bool BlockBasedFS::raw_read_blocks(BlockIndex index, size_t count, UserOrKernelB
bool BlockBasedFS::raw_write_blocks(BlockIndex index, size_t count, const UserOrKernelBuffer& buffer)
{
LOCKER(m_lock);
Locker locker(m_lock);
auto current = buffer;
for (unsigned block = index.value(); block < (index.value() + count); block++) {
if (!raw_write(block, current))
@ -199,7 +199,7 @@ bool BlockBasedFS::raw_write_blocks(BlockIndex index, size_t count, const UserOr
KResult BlockBasedFS::write_blocks(BlockIndex index, unsigned count, const UserOrKernelBuffer& data, bool allow_cache)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_logical_block_size);
dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::write_blocks {}, count={}", index, count);
for (unsigned i = 0; i < count; ++i) {
@ -212,7 +212,7 @@ KResult BlockBasedFS::write_blocks(BlockIndex index, unsigned count, const UserO
KResult BlockBasedFS::read_block(BlockIndex index, UserOrKernelBuffer* buffer, size_t count, size_t offset, bool allow_cache) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_logical_block_size);
VERIFY(offset + count <= block_size());
dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::read_block {}", index);
@ -250,7 +250,7 @@ KResult BlockBasedFS::read_block(BlockIndex index, UserOrKernelBuffer* buffer, s
KResult BlockBasedFS::read_blocks(BlockIndex index, unsigned count, UserOrKernelBuffer& buffer, bool allow_cache) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_logical_block_size);
if (!count)
return EINVAL;
@ -269,7 +269,7 @@ KResult BlockBasedFS::read_blocks(BlockIndex index, unsigned count, UserOrKernel
void BlockBasedFS::flush_specific_block_if_needed(BlockIndex index)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (!cache().is_dirty())
return;
Vector<CacheEntry*, 32> cleaned_entries;
@ -292,7 +292,7 @@ void BlockBasedFS::flush_specific_block_if_needed(BlockIndex index)
void BlockBasedFS::flush_writes_impl()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (!cache().is_dirty())
return;
u32 count = 0;

46
Kernel/FileSystem/DevFS.cpp
View file

@ -20,7 +20,7 @@ NonnullRefPtr<DevFS> DevFS::create()
DevFS::DevFS()
: m_root_inode(adopt_ref(*new DevFSRootDirectoryInode(*this)))
{
LOCKER(m_lock);
Locker locker(m_lock);
Device::for_each([&](Device& device) {
// FIXME: Find a better way to not add MasterPTYs or SlavePTYs!
if (device.is_master_pty() || (device.is_character_device() && device.major() == 201))
@ -31,7 +31,7 @@ DevFS::DevFS()
void DevFS::notify_new_device(Device& device)
{
LOCKER(m_lock);
Locker locker(m_lock);
auto new_device_inode = adopt_ref(*new DevFSDeviceInode(*this, device));
m_nodes.append(new_device_inode);
m_root_inode->m_devices.append(new_device_inode);
@ -39,7 +39,7 @@ void DevFS::notify_new_device(Device& device)
size_t DevFS::allocate_inode_index()
{
LOCKER(m_lock);
Locker locker(m_lock);
m_next_inode_index = m_next_inode_index.value() + 1;
VERIFY(m_next_inode_index > 0);
return 1 + m_next_inode_index.value();
@ -66,7 +66,7 @@ NonnullRefPtr<Inode> DevFS::root_inode() const
RefPtr<Inode> DevFS::get_inode(InodeIdentifier inode_id) const
{
LOCKER(m_lock);
Locker locker(m_lock);
if (inode_id.index() == 1)
return m_root_inode;
for (auto& node : m_nodes) {
@ -153,7 +153,7 @@ DevFSLinkInode::DevFSLinkInode(DevFS& fs, String name)
}
ssize_t DevFSLinkInode::read_bytes(off_t offset, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(offset == 0);
VERIFY(!m_link.is_null());
if (!buffer.write(((const u8*)m_link.substring_view(0).characters_without_null_termination()) + offset, m_link.length()))
@ -162,7 +162,7 @@ ssize_t DevFSLinkInode::read_bytes(off_t offset, ssize_t, UserOrKernelBuffer& bu
}
InodeMetadata DevFSLinkInode::metadata() const
{
LOCKER(m_lock);
Locker locker(m_lock);
InodeMetadata metadata;
metadata.inode = { fsid(), index() };
metadata.mode = S_IFLNK | 0555;
@ -174,7 +174,7 @@ InodeMetadata DevFSLinkInode::metadata() const
}
ssize_t DevFSLinkInode::write_bytes(off_t offset, ssize_t count, const UserOrKernelBuffer& buffer, FileDescription*)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(offset == 0);
VERIFY(buffer.is_kernel_buffer());
m_link = buffer.copy_into_string(count);
@ -190,7 +190,7 @@ DevFSDirectoryInode::~DevFSDirectoryInode()
}
InodeMetadata DevFSDirectoryInode::metadata() const
{
LOCKER(m_lock);
Locker locker(m_lock);
InodeMetadata metadata;
metadata.inode = { fsid(), 1 };
metadata.mode = 0040555;
@ -202,17 +202,17 @@ InodeMetadata DevFSDirectoryInode::metadata() const
}
KResult DevFSDirectoryInode::traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const
{
LOCKER(m_lock);
Locker locker(m_lock);
return EINVAL;
}
RefPtr<Inode> DevFSDirectoryInode::lookup(StringView)
{
LOCKER(m_lock);
Locker locker(m_lock);
return nullptr;
}
KResultOr<size_t> DevFSDirectoryInode::directory_entry_count() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_devices.size();
}
@ -223,7 +223,7 @@ DevFSRootDirectoryInode::DevFSRootDirectoryInode(DevFS& fs)
}
KResult DevFSRootDirectoryInode::traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)> callback) const
{
LOCKER(m_parent_fs.m_lock);
Locker locker(m_parent_fs.m_lock);
callback({ ".", identifier(), 0 });
callback({ "..", identifier(), 0 });
@ -244,7 +244,7 @@ KResult DevFSRootDirectoryInode::traverse_as_directory(Function<bool(const FS::D
}
RefPtr<Inode> DevFSRootDirectoryInode::lookup(StringView name)
{
LOCKER(m_parent_fs.m_lock);
Locker locker(m_parent_fs.m_lock);
for (auto& subfolder : m_subfolders) {
if (subfolder.name() == name)
return subfolder;
@ -263,7 +263,7 @@ RefPtr<Inode> DevFSRootDirectoryInode::lookup(StringView name)
}
KResultOr<NonnullRefPtr<Inode>> DevFSRootDirectoryInode::create_child(const String& name, mode_t mode, dev_t, uid_t, gid_t)
{
LOCKER(m_parent_fs.m_lock);
Locker locker(m_parent_fs.m_lock);
InodeMetadata metadata;
metadata.mode = mode;
@ -297,7 +297,7 @@ DevFSRootDirectoryInode::~DevFSRootDirectoryInode()
}
InodeMetadata DevFSRootDirectoryInode::metadata() const
{
LOCKER(m_parent_fs.m_lock);
Locker locker(m_parent_fs.m_lock);
InodeMetadata metadata;
metadata.inode = { fsid(), 1 };
metadata.mode = 0040555;
@ -309,7 +309,7 @@ InodeMetadata DevFSRootDirectoryInode::metadata() const
}
KResultOr<size_t> DevFSRootDirectoryInode::directory_entry_count() const
{
LOCKER(m_parent_fs.m_lock);
Locker locker(m_parent_fs.m_lock);
return m_devices.size() + DevFSDirectoryInode::directory_entry_count().value();
}
@ -323,7 +323,7 @@ DevFSDeviceInode::~DevFSDeviceInode()
}
KResult DevFSDeviceInode::chown(uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_uid = uid;
m_gid = gid;
return KSuccess;
@ -331,7 +331,7 @@ KResult DevFSDeviceInode::chown(uid_t uid, gid_t gid)
String DevFSDeviceInode::name() const
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_cached_name.is_null() || m_cached_name.is_empty())
const_cast<DevFSDeviceInode&>(*this).m_cached_name = m_attached_device->device_name();
return m_cached_name;
@ -339,7 +339,7 @@ String DevFSDeviceInode::name() const
ssize_t DevFSDeviceInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!!description);
if (!m_attached_device->can_read(*description, offset))
return 0;
@ -351,7 +351,7 @@ ssize_t DevFSDeviceInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBu
InodeMetadata DevFSDeviceInode::metadata() const
{
LOCKER(m_lock);
Locker locker(m_lock);
InodeMetadata metadata;
metadata.inode = { fsid(), index() };
metadata.mode = (m_attached_device->is_block_device() ? S_IFBLK : S_IFCHR) | m_attached_device->required_mode();
@ -365,7 +365,7 @@ InodeMetadata DevFSDeviceInode::metadata() const
}
ssize_t DevFSDeviceInode::write_bytes(off_t offset, ssize_t count, const UserOrKernelBuffer& buffer, FileDescription* description)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!!description);
if (!m_attached_device->can_write(*description, offset))
return 0;
@ -381,7 +381,7 @@ DevFSPtsDirectoryInode::DevFSPtsDirectoryInode(DevFS& fs)
}
KResult DevFSPtsDirectoryInode::traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)> callback) const
{
LOCKER(m_lock);
Locker locker(m_lock);
callback({ ".", identifier(), 0 });
callback({ "..", identifier(), 0 });
return KSuccess;
@ -395,7 +395,7 @@ DevFSPtsDirectoryInode::~DevFSPtsDirectoryInode()
}
InodeMetadata DevFSPtsDirectoryInode::metadata() const
{
LOCKER(m_lock);
Locker locker(m_lock);
InodeMetadata metadata;
metadata.inode = { fsid(), index() };
metadata.mode = 0040555;

74
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -69,7 +69,7 @@ Ext2FS::~Ext2FS()
bool Ext2FS::flush_super_block()
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY((sizeof(ext2_super_block) % logical_block_size()) == 0);
auto super_block_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&m_super_block);
bool success = raw_write_blocks(2, (sizeof(ext2_super_block) / logical_block_size()), super_block_buffer);
@ -87,7 +87,7 @@ const ext2_group_desc& Ext2FS::group_descriptor(GroupIndex group_index) const
bool Ext2FS::initialize()
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY((sizeof(ext2_super_block) % logical_block_size()) == 0);
auto super_block_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&m_super_block);
bool success = raw_read_blocks(2, (sizeof(ext2_super_block) / logical_block_size()), super_block_buffer);
@ -387,7 +387,7 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFS::BlockIndex block
KResult Ext2FSInode::flush_block_list()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_block_list.is_empty()) {
m_raw_inode.i_blocks = 0;
@ -628,7 +628,7 @@ Vector<Ext2FS::BlockIndex> Ext2FSInode::compute_block_list_impl_internal(const e
void Ext2FS::free_inode(Ext2FSInode& inode)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(inode.m_raw_inode.i_links_count == 0);
dbgln_if(EXT2_DEBUG, "Ext2FS[{}]::free_inode(): Inode {} has no more links, time to delete!", fsid(), inode.index());
@ -662,7 +662,7 @@ void Ext2FS::free_inode(Ext2FSInode& inode)
void Ext2FS::flush_block_group_descriptor_table()
{
LOCKER(m_lock);
Locker locker(m_lock);
unsigned blocks_to_write = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size());
unsigned first_block_of_bgdt = block_size() == 1024 ? 2 : 1;
auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)block_group_descriptors());
@ -672,7 +672,7 @@ void Ext2FS::flush_block_group_descriptor_table()
void Ext2FS::flush_writes()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_super_block_dirty) {
flush_super_block();
m_super_block_dirty = false;
@ -732,7 +732,7 @@ u64 Ext2FSInode::size() const
InodeMetadata Ext2FSInode::metadata() const
{
LOCKER(m_lock);
Locker locker(m_lock);
InodeMetadata metadata;
metadata.inode = identifier();
metadata.size = size();
@ -759,7 +759,7 @@ InodeMetadata Ext2FSInode::metadata() const
void Ext2FSInode::flush_metadata()
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::flush_metadata(): Flushing inode", identifier());
fs().write_ext2_inode(index(), m_raw_inode);
if (is_directory()) {
@ -774,7 +774,7 @@ void Ext2FSInode::flush_metadata()
RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(inode.fsid() == fsid());
{
@ -1049,7 +1049,7 @@ Ext2FS::FeaturesReadOnly Ext2FS::get_features_readonly() const
KResult Ext2FSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)> callback) const
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(is_directory());
auto buffer_or = read_entire();
@ -1073,7 +1073,7 @@ KResult Ext2FSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntr
KResult Ext2FSInode::write_directory(const Vector<Ext2FSDirectoryEntry>& entries)
{
LOCKER(m_lock);
Locker locker(m_lock);
int directory_size = 0;
for (auto& entry : entries)
@ -1130,7 +1130,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FSInode::create_child(const String& name, mo
KResult Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(is_directory());
if (name.length() > EXT2_NAME_LEN)
@ -1173,7 +1173,7 @@ KResult Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode
KResult Ext2FSInode::remove_child(const StringView& name)
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::remove_child(): Removing '{}'", identifier(), name);
VERIFY(is_directory());
@ -1239,7 +1239,7 @@ bool Ext2FS::write_ext2_inode(InodeIndex inode, const ext2_inode& e2inode)
auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) -> KResultOr<Vector<BlockIndex>>
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_blocks(preferred group: {}, count {})", preferred_group_index, count);
if (count == 0)
return Vector<BlockIndex> {};
@ -1304,7 +1304,7 @@ auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) ->
KResultOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
{
dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_inode(preferred_group: {})", preferred_group);
LOCKER(m_lock);
Locker locker(m_lock);
// FIXME: We shouldn't refuse to allocate an inode if there is no group that can house the whole thing.
// In those cases we should just spread it across multiple groups.
@ -1380,7 +1380,7 @@ auto Ext2FS::group_index_from_inode(InodeIndex inode) const -> GroupIndex
KResultOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
{
LOCKER(m_lock);
Locker locker(m_lock);
if (index == 0)
return EINVAL;
auto group_index = group_index_from_inode(index);
@ -1423,7 +1423,7 @@ KResult Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, b
KResult Ext2FS::set_inode_allocation_state(InodeIndex inode_index, bool new_state)
{
LOCKER(m_lock);
Locker locker(m_lock);
auto group_index = group_index_from_inode(inode_index);
unsigned index_in_group = inode_index.value() - ((group_index.value() - 1) * inodes_per_group());
unsigned bit_index = (index_in_group - 1) % inodes_per_group();
@ -1458,7 +1458,7 @@ KResultOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_bloc
KResult Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_state)
{
VERIFY(block_index != 0);
LOCKER(m_lock);
Locker locker(m_lock);
auto group_index = group_index_from_block_index(block_index);
unsigned index_in_group = (block_index.value() - first_block_index().value()) - ((group_index.value() - 1) * blocks_per_group());
@ -1471,7 +1471,7 @@ KResult Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_stat
KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, const String& name, mode_t mode, uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(is_directory(mode));
auto inode_or_error = create_inode(parent_inode, name, mode, 0, uid, gid);
@ -1546,7 +1546,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode,
bool Ext2FSInode::populate_lookup_cache() const
{
LOCKER(m_lock);
Locker locker(m_lock);
if (!m_lookup_cache.is_empty())
return true;
HashMap<String, InodeIndex> children;
@ -1571,7 +1571,7 @@ RefPtr<Inode> Ext2FSInode::lookup(StringView name)
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]:lookup(): Looking up '{}'", identifier(), name);
if (!populate_lookup_cache())
return {};
LOCKER(m_lock);
Locker locker(m_lock);
auto it = m_lookup_cache.find(name.hash(), [&](auto& entry) { return entry.key == name; });
if (it != m_lookup_cache.end())
return fs().get_inode({ fsid(), (*it).value });
@ -1586,7 +1586,7 @@ void Ext2FSInode::one_ref_left()
int Ext2FSInode::set_atime(time_t t)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return -EROFS;
m_raw_inode.i_atime = t;
@ -1596,7 +1596,7 @@ int Ext2FSInode::set_atime(time_t t)
int Ext2FSInode::set_ctime(time_t t)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return -EROFS;
m_raw_inode.i_ctime = t;
@ -1606,7 +1606,7 @@ int Ext2FSInode::set_ctime(time_t t)
int Ext2FSInode::set_mtime(time_t t)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return -EROFS;
m_raw_inode.i_mtime = t;
@ -1616,7 +1616,7 @@ int Ext2FSInode::set_mtime(time_t t)
KResult Ext2FSInode::increment_link_count()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return EROFS;
if (m_raw_inode.i_links_count == max_link_count)
@ -1628,7 +1628,7 @@ KResult Ext2FSInode::increment_link_count()
KResult Ext2FSInode::decrement_link_count()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return EROFS;
VERIFY(m_raw_inode.i_links_count);
@ -1641,21 +1641,21 @@ KResult Ext2FSInode::decrement_link_count()
void Ext2FS::uncache_inode(InodeIndex index)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_inode_cache.remove(index);
}
KResultOr<size_t> Ext2FSInode::directory_entry_count() const
{
VERIFY(is_directory());
LOCKER(m_lock);
Locker locker(m_lock);
populate_lookup_cache();
return m_lookup_cache.size();
}
KResult Ext2FSInode::chmod(mode_t mode)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_raw_inode.i_mode == mode)
return KSuccess;
m_raw_inode.i_mode = mode;
@ -1665,7 +1665,7 @@ KResult Ext2FSInode::chmod(mode_t mode)
KResult Ext2FSInode::chown(uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_raw_inode.i_uid == uid && m_raw_inode.i_gid == gid)
return KSuccess;
m_raw_inode.i_uid = uid;
@ -1676,7 +1676,7 @@ KResult Ext2FSInode::chown(uid_t uid, gid_t gid)
KResult Ext2FSInode::truncate(u64 size)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (static_cast<u64>(m_raw_inode.i_size) == size)
return KSuccess;
if (auto result = resize(size); result.is_error())
@ -1687,7 +1687,7 @@ KResult Ext2FSInode::truncate(u64 size)
KResultOr<int> Ext2FSInode::get_block_address(int index)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_block_list.is_empty())
m_block_list = compute_block_list();
@ -1700,31 +1700,31 @@ KResultOr<int> Ext2FSInode::get_block_address(int index)
unsigned Ext2FS::total_block_count() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return super_block().s_blocks_count;
}
unsigned Ext2FS::free_block_count() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return super_block().s_free_blocks_count;
}
unsigned Ext2FS::total_inode_count() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return super_block().s_inodes_count;
}
unsigned Ext2FS::free_inode_count() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return super_block().s_free_inodes_count;
}
KResult Ext2FS::prepare_to_unmount() const
{
LOCKER(m_lock);
Locker locker(m_lock);
for (auto& it : m_inode_cache) {
if (it.value->ref_count() > 1)

4
Kernel/FileSystem/FIFO.cpp
View file

@ -74,7 +74,7 @@ KResultOr<NonnullRefPtr<FileDescription>> FIFO::open_direction_blocking(FIFO::Di
FIFO::FIFO(uid_t uid)
: m_uid(uid)
{
LOCKER(all_fifos().lock());
Locker locker(all_fifos().lock());
all_fifos().resource().set(this);
m_fifo_id = ++s_next_fifo_id;
@ -86,7 +86,7 @@ FIFO::FIFO(uid_t uid)
FIFO::~FIFO()
{
LOCKER(all_fifos().lock());
Locker locker(all_fifos().lock());
all_fifos().resource().remove(this);
}

20
Kernel/FileSystem/FileDescription.cpp
View file

@ -99,7 +99,7 @@ Thread::FileBlocker::BlockFlags FileDescription::should_unblock(Thread::FileBloc
KResult FileDescription::stat(::stat& buffer)
{
LOCKER(m_lock);
Locker locker(m_lock);
// FIXME: This is a little awkward, why can't we always forward to File::stat()?
if (m_inode)
return metadata().stat(buffer);
@ -108,7 +108,7 @@ KResult FileDescription::stat(::stat& buffer)
KResultOr<off_t> FileDescription::seek(off_t offset, int whence)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (!m_file->is_seekable())
return ESPIPE;
@ -147,7 +147,7 @@ KResultOr<off_t> FileDescription::seek(off_t offset, int whence)
KResultOr<size_t> FileDescription::read(UserOrKernelBuffer& buffer, size_t count)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (Checked<off_t>::addition_would_overflow(m_current_offset, count))
return EOVERFLOW;
auto nread_or_error = m_file->read(*this, offset(), buffer, count);
@ -161,7 +161,7 @@ KResultOr<size_t> FileDescription::read(UserOrKernelBuffer& buffer, size_t count
KResultOr<size_t> FileDescription::write(const UserOrKernelBuffer& data, size_t size)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (Checked<off_t>::addition_would_overflow(m_current_offset, size))
return EOVERFLOW;
auto nwritten_or_error = m_file->write(*this, offset(), data, size);
@ -193,7 +193,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> FileDescription::read_entire_file()
ssize_t FileDescription::get_dir_entries(UserOrKernelBuffer& buffer, ssize_t size)
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
if (!is_directory())
return -ENOTDIR;
@ -309,13 +309,13 @@ InodeMetadata FileDescription::metadata() const
KResultOr<Region*> FileDescription::mmap(Process& process, const Range& range, u64 offset, int prot, bool shared)
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_file->mmap(process, *this, range, offset, prot, shared);
}
KResult FileDescription::truncate(u64 length)
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_file->truncate(length);
}
@ -352,7 +352,7 @@ const Socket* FileDescription::socket() const
void FileDescription::set_file_flags(u32 flags)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_is_blocking = !(flags & O_NONBLOCK);
m_should_append = flags & O_APPEND;
m_direct = flags & O_DIRECT;
@ -361,13 +361,13 @@ void FileDescription::set_file_flags(u32 flags)
KResult FileDescription::chmod(mode_t mode)
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_file->chmod(*this, mode);
}
KResult FileDescription::chown(uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_file->chown(*this, uid, gid);
}

26
Kernel/FileSystem/Inode.cpp
View file

@ -112,7 +112,7 @@ Inode::~Inode()
void Inode::will_be_destroyed()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_metadata_dirty)
flush_metadata();
}
@ -144,13 +144,13 @@ KResult Inode::decrement_link_count()
void Inode::set_shared_vmobject(SharedInodeVMObject& vmobject)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_shared_vmobject = vmobject;
}
bool Inode::bind_socket(LocalSocket& socket)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_socket)
return false;
m_socket = socket;
@ -159,7 +159,7 @@ bool Inode::bind_socket(LocalSocket& socket)
bool Inode::unbind_socket()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (!m_socket)
return false;
m_socket = nullptr;
@ -168,21 +168,21 @@ bool Inode::unbind_socket()
void Inode::register_watcher(Badge<InodeWatcher>, InodeWatcher& watcher)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!m_watchers.contains(&watcher));
m_watchers.set(&watcher);
}
void Inode::unregister_watcher(Badge<InodeWatcher>, InodeWatcher& watcher)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_watchers.contains(&watcher));
m_watchers.remove(&watcher);
}
NonnullRefPtr<FIFO> Inode::fifo()
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(metadata().is_fifo());
// FIXME: Release m_fifo when it is closed by all readers and writers
@ -195,7 +195,7 @@ NonnullRefPtr<FIFO> Inode::fifo()
void Inode::set_metadata_dirty(bool metadata_dirty)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (metadata_dirty) {
// Sanity check.
@ -217,7 +217,7 @@ void Inode::set_metadata_dirty(bool metadata_dirty)
void Inode::did_add_child(const InodeIdentifier& child_id)
{
LOCKER(m_lock);
Locker locker(m_lock);
for (auto& watcher : m_watchers) {
watcher->notify_child_added({}, child_id);
}
@ -225,7 +225,7 @@ void Inode::did_add_child(const InodeIdentifier& child_id)
void Inode::did_remove_child(const InodeIdentifier& child_id)
{
LOCKER(m_lock);
Locker locker(m_lock);
for (auto& watcher : m_watchers) {
watcher->notify_child_removed({}, child_id);
}
@ -235,7 +235,7 @@ KResult Inode::prepare_to_write_data()
{
// FIXME: It's a poor design that filesystems are expected to call this before writing out data.
// We should funnel everything through an interface at the VFS layer so this can happen from a single place.
LOCKER(m_lock);
Locker locker(m_lock);
if (fs().is_readonly())
return EROFS;
auto metadata = this->metadata();
@ -248,13 +248,13 @@ KResult Inode::prepare_to_write_data()
RefPtr<SharedInodeVMObject> Inode::shared_vmobject() const
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_shared_vmobject.strong_ref();
}
bool Inode::is_shared_vmobject(const SharedInodeVMObject& other) const
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_shared_vmobject.unsafe_ptr() == &other;
}

8
Kernel/FileSystem/InodeWatcher.cpp
View file

@ -39,7 +39,7 @@ bool InodeWatcher::can_write(const FileDescription&, size_t) const
KResultOr<size_t> InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!m_queue.is_empty() || !m_inode);
if (!m_inode)
@ -76,21 +76,21 @@ String InodeWatcher::absolute_path(const FileDescription&) const
void InodeWatcher::notify_inode_event(Badge<Inode>, InodeWatcherEvent::Type event_type)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_queue.enqueue({ event_type });
evaluate_block_conditions();
}
void InodeWatcher::notify_child_added(Badge<Inode>, const InodeIdentifier& child_id)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_queue.enqueue({ InodeWatcherEvent::Type::ChildAdded, child_id.index().value() });
evaluate_block_conditions();
}
void InodeWatcher::notify_child_removed(Badge<Inode>, const InodeIdentifier& child_id)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_queue.enqueue({ InodeWatcherEvent::Type::ChildRemoved, child_id.index().value() });
evaluate_block_conditions();
}

12
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -475,7 +475,7 @@ void Plan9FS::Plan9FSBlockCondition::try_unblock(Plan9FS::Blocker& blocker)
bool Plan9FS::is_complete(const ReceiveCompletion& completion)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_completions.contains(completion.tag)) {
// If it's still in the map then it can't be complete
VERIFY(!completion.completed);
@ -495,12 +495,12 @@ KResult Plan9FS::post_message(Message& message, RefPtr<ReceiveCompletion> comple
size_t size = buffer.size();
auto& description = file_description();
LOCKER(m_send_lock);
Locker locker(m_send_lock);
if (completion) {
// Save the completion record *before* we send the message. This
// ensures that it exists when the thread reads the response
LOCKER(m_lock);
Locker locker(m_lock);
auto tag = completion->tag;
m_completions.set(tag, completion.release_nonnull());
// TODO: What if there is a collision? Do we need to wait until
@ -569,7 +569,7 @@ KResult Plan9FS::read_and_dispatch_one_message()
if (result.is_error())
return result;
LOCKER(m_lock);
Locker locker(m_lock);
auto optional_completion = m_completions.get(header.tag);
if (optional_completion.has_value()) {
@ -647,7 +647,7 @@ void Plan9FS::thread_main()
auto result = read_and_dispatch_one_message();
if (result.is_error()) {
// If we fail to read, wake up everyone with an error.
LOCKER(m_lock);
Locker locker(m_lock);
for (auto& it : m_completions) {
it.value->result = result;
@ -698,7 +698,7 @@ KResult Plan9FSInode::ensure_open_for_mode(int mode)
u8 p9_mode = 0;
{
LOCKER(m_lock);
Locker locker(m_lock);
// If it's already open in this mode, we're done.
if ((m_open_mode & mode) == mode)

14
Kernel/FileSystem/ProcFS.cpp
View file

@ -503,7 +503,7 @@ static bool procfs$net_adapters(InodeIdentifier, KBufferBuilder& builder)
static bool procfs$net_arp(InodeIdentifier, KBufferBuilder& builder)
{
JsonArraySerializer array { builder };
LOCKER(arp_table().lock(), Lock::Mode::Shared);
Locker locker(arp_table().lock(), Lock::Mode::Shared);
for (auto& it : arp_table().resource()) {
auto obj = array.add_object();
obj.add("mac_address", it.value.to_string());
@ -884,7 +884,7 @@ static bool read_sys_bool(InodeIdentifier inode_id, KBufferBuilder& builder)
u8 buffer[2];
auto* lockable_bool = reinterpret_cast<Lockable<bool>*>(variable.address);
{
LOCKER(lockable_bool->lock(), Lock::Mode::Shared);
Locker locker(lockable_bool->lock(), Lock::Mode::Shared);
buffer[0] = lockable_bool->resource() ? '1' : '0';
}
buffer[1] = '\n';
@ -914,7 +914,7 @@ static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer
auto* lockable_bool = reinterpret_cast<Lockable<bool>*>(variable.address);
{
LOCKER(lockable_bool->lock());
Locker locker(lockable_bool->lock());
lockable_bool->resource() = value == '1';
}
variable.notify();
@ -927,7 +927,7 @@ static bool read_sys_string(InodeIdentifier inode_id, KBufferBuilder& builder)
VERIFY(variable.type == SysVariable::Type::String);
auto* lockable_string = reinterpret_cast<Lockable<String>*>(variable.address);
LOCKER(lockable_string->lock(), Lock::Mode::Shared);
Locker locker(lockable_string->lock(), Lock::Mode::Shared);
builder.append_bytes(lockable_string->resource().bytes());
return true;
}
@ -943,7 +943,7 @@ static ssize_t write_sys_string(InodeIdentifier inode_id, const UserOrKernelBuff
{
auto* lockable_string = reinterpret_cast<Lockable<String>*>(variable.address);
LOCKER(lockable_string->lock());
Locker locker(lockable_string->lock());
lockable_string->resource() = move(string_copy);
}
variable.notify();
@ -1012,7 +1012,7 @@ RefPtr<Inode> ProcFS::get_inode(InodeIdentifier inode_id) const
if (inode_id == root_inode()->identifier())
return m_root_inode;
LOCKER(m_inodes_lock);
Locker locker(m_inodes_lock);
auto it = m_inodes.find(inode_id.index().value());
if (it != m_inodes.end()) {
// It's possible that the ProcFSInode ref count was dropped to 0 or
@ -1037,7 +1037,7 @@ ProcFSInode::ProcFSInode(ProcFS& fs, InodeIndex index)
ProcFSInode::~ProcFSInode()
{
LOCKER(fs().m_inodes_lock);
Locker locker(fs().m_inodes_lock);
auto it = fs().m_inodes.find(index().value());
if (it != fs().m_inodes.end() && it->value == this)
fs().m_inodes.remove(it);

38
Kernel/FileSystem/TmpFS.cpp
View file

@ -39,7 +39,7 @@ NonnullRefPtr<Inode> TmpFS::root_inode() const
void TmpFS::register_inode(TmpFSInode& inode)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(inode.identifier().fsid() == fsid());
auto index = inode.identifier().index();
@ -48,7 +48,7 @@ void TmpFS::register_inode(TmpFSInode& inode)
void TmpFS::unregister_inode(InodeIdentifier identifier)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(identifier.fsid() == fsid());
m_inodes.remove(identifier.index());
@ -56,14 +56,14 @@ void TmpFS::unregister_inode(InodeIdentifier identifier)
unsigned TmpFS::next_inode_index()
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_next_inode_index++;
}
RefPtr<Inode> TmpFS::get_inode(InodeIdentifier identifier) const
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
VERIFY(identifier.fsid() == fsid());
auto it = m_inodes.find(identifier.index());
@ -104,14 +104,14 @@ NonnullRefPtr<TmpFSInode> TmpFSInode::create_root(TmpFS& fs)
InodeMetadata TmpFSInode::metadata() const
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
return m_metadata;
}
KResult TmpFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)> callback) const
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
if (!is_directory())
return ENOTDIR;
@ -128,7 +128,7 @@ KResult TmpFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry
ssize_t TmpFSInode::read_bytes(off_t offset, ssize_t size, UserOrKernelBuffer& buffer, FileDescription*) const
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
VERIFY(!is_directory());
VERIFY(size >= 0);
VERIFY(offset >= 0);
@ -149,7 +149,7 @@ ssize_t TmpFSInode::read_bytes(off_t offset, ssize_t size, UserOrKernelBuffer& b
ssize_t TmpFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelBuffer& buffer, FileDescription*)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!is_directory());
VERIFY(offset >= 0);
@ -193,7 +193,7 @@ ssize_t TmpFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelBu
RefPtr<Inode> TmpFSInode::lookup(StringView name)
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
VERIFY(is_directory());
if (name == ".")
@ -209,7 +209,7 @@ RefPtr<Inode> TmpFSInode::lookup(StringView name)
KResultOr<size_t> TmpFSInode::directory_entry_count() const
{
LOCKER(m_lock, Lock::Mode::Shared);
Locker locker(m_lock, Lock::Mode::Shared);
VERIFY(is_directory());
return 2 + m_children.size();
}
@ -232,7 +232,7 @@ void TmpFSInode::flush_metadata()
KResult TmpFSInode::chmod(mode_t mode)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_metadata.mode = mode;
notify_watchers();
@ -241,7 +241,7 @@ KResult TmpFSInode::chmod(mode_t mode)
KResult TmpFSInode::chown(uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_metadata.uid = uid;
m_metadata.gid = gid;
@ -251,7 +251,7 @@ KResult TmpFSInode::chown(uid_t uid, gid_t gid)
KResultOr<NonnullRefPtr<Inode>> TmpFSInode::create_child(const String& name, mode_t mode, dev_t dev, uid_t uid, gid_t gid)
{
LOCKER(m_lock);
Locker locker(m_lock);
// TODO: Support creating devices on TmpFS.
if (dev != 0)
@ -276,7 +276,7 @@ KResultOr<NonnullRefPtr<Inode>> TmpFSInode::create_child(const String& name, mod
KResult TmpFSInode::add_child(Inode& child, const StringView& name, mode_t)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(is_directory());
VERIFY(child.fsid() == fsid());
@ -290,7 +290,7 @@ KResult TmpFSInode::add_child(Inode& child, const StringView& name, mode_t)
KResult TmpFSInode::remove_child(const StringView& name)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(is_directory());
if (name == "." || name == "..")
@ -307,7 +307,7 @@ KResult TmpFSInode::remove_child(const StringView& name)
KResult TmpFSInode::truncate(u64 size)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(!is_directory());
if (size == 0)
@ -337,7 +337,7 @@ KResult TmpFSInode::truncate(u64 size)
int TmpFSInode::set_atime(time_t time)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_metadata.atime = time;
set_metadata_dirty(true);
@ -347,7 +347,7 @@ int TmpFSInode::set_atime(time_t time)
int TmpFSInode::set_ctime(time_t time)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_metadata.ctime = time;
notify_watchers();
@ -356,7 +356,7 @@ int TmpFSInode::set_ctime(time_t time)
int TmpFSInode::set_mtime(time_t time)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_metadata.mtime = time;
notify_watchers();

8
Kernel/FileSystem/VirtualFileSystem.cpp
View file

@ -50,7 +50,7 @@ InodeIdentifier VFS::root_inode_id() const
KResult VFS::mount(FS& file_system, Custody& mount_point, int flags)
{
LOCKER(m_lock);
Locker locker(m_lock);
auto& inode = mount_point.inode();
dbgln("VFS: Mounting {} at {} (inode: {}) with flags {}",
@ -66,7 +66,7 @@ KResult VFS::mount(FS& file_system, Custody& mount_point, int flags)
KResult VFS::bind_mount(Custody& source, Custody& mount_point, int flags)
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln("VFS: Bind-mounting {} at {}", source.absolute_path(), mount_point.absolute_path());
// FIXME: check that this is not already a mount point
@ -77,7 +77,7 @@ KResult VFS::bind_mount(Custody& source, Custody& mount_point, int flags)
KResult VFS::remount(Custody& mount_point, int new_flags)
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln("VFS: Remounting {}", mount_point.absolute_path());
@ -91,7 +91,7 @@ KResult VFS::remount(Custody& mount_point, int new_flags)
KResult VFS::unmount(Inode& guest_inode)
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln("VFS: unmount called with inode {}", guest_inode.identifier());
for (size_t i = 0; i < m_mounts.size(); ++i) {

4
Kernel/Lock.h
View file

@ -127,8 +127,6 @@ private:
bool m_locked { true };
};
#define LOCKER(...) Locker locker(__VA_ARGS__)
template<typename T>
class Lockable {
public:
@ -142,7 +140,7 @@ public:
[[nodiscard]] T lock_and_copy()
{
LOCKER(m_lock);
Locker locker(m_lock);
return m_resource;
}

10
Kernel/Net/IPv4Socket.cpp
View file

@ -53,13 +53,13 @@ IPv4Socket::IPv4Socket(int type, int protocol)
if (m_buffer_mode == BufferMode::Bytes) {
m_scratch_buffer = KBuffer::create_with_size(65536);
}
LOCKER(all_sockets().lock());
Locker locker(all_sockets().lock());
all_sockets().resource().set(this);
}
IPv4Socket::~IPv4Socket()
{
LOCKER(all_sockets().lock());
Locker locker(all_sockets().lock());
all_sockets().resource().remove(this);
}
@ -108,7 +108,7 @@ KResult IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t addr
KResult IPv4Socket::listen(size_t backlog)
{
LOCKER(lock());
Locker locker(lock());
int rc = allocate_local_port_if_needed();
if (rc < 0)
return EADDRINUSE;
@ -172,7 +172,7 @@ int IPv4Socket::allocate_local_port_if_needed()
KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
{
LOCKER(lock());
Locker locker(lock());
if (addr && addr_length != sizeof(sockaddr_in))
return EINVAL;
@ -357,7 +357,7 @@ KResultOr<size_t> IPv4Socket::recvfrom(FileDescription& description, UserOrKerne
bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, KBuffer&& packet, const Time& packet_timestamp)
{
LOCKER(lock());
Locker locker(lock());
if (is_shut_down_for_reading())
return false;

12
Kernel/Net/LocalSocket.cpp
View file

@ -26,7 +26,7 @@ Lockable<InlineLinkedList<LocalSocket>>& LocalSocket::all_sockets()
void LocalSocket::for_each(Function<void(const LocalSocket&)> callback)
{
LOCKER(all_sockets().lock(), Lock::Mode::Shared);
Locker locker(all_sockets().lock(), Lock::Mode::Shared);
for (auto& socket : all_sockets().resource())
callback(socket);
}
@ -39,7 +39,7 @@ KResultOr<NonnullRefPtr<Socket>> LocalSocket::create(int type)
LocalSocket::LocalSocket(int type)
: Socket(AF_LOCAL, type, 0)
{
LOCKER(all_sockets().lock());
Locker locker(all_sockets().lock());
all_sockets().resource().append(this);
auto current_process = Process::current();
@ -59,7 +59,7 @@ LocalSocket::LocalSocket(int type)
LocalSocket::~LocalSocket()
{
LOCKER(all_sockets().lock());
Locker locker(all_sockets().lock());
all_sockets().resource().remove(this);
}
@ -182,7 +182,7 @@ KResult LocalSocket::connect(FileDescription& description, Userspace<const socka
KResult LocalSocket::listen(size_t backlog)
{
LOCKER(lock());
Locker locker(lock());
if (type() != SOCK_STREAM)
return EOPNOTSUPP;
set_backlog(backlog);
@ -433,7 +433,7 @@ NonnullRefPtrVector<FileDescription>& LocalSocket::sendfd_queue_for(const FileDe
KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescription& passing_description)
{
LOCKER(lock());
Locker locker(lock());
auto role = this->role(socket_description);
if (role != Role::Connected && role != Role::Accepted)
return EINVAL;
@ -447,7 +447,7 @@ KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescr
KResultOr<NonnullRefPtr<FileDescription>> LocalSocket::recvfd(const FileDescription& socket_description)
{
LOCKER(lock());
Locker locker(lock());
auto role = this->role(socket_description);
if (role != Role::Connected && role != Role::Accepted)
return EINVAL;

4
Kernel/Net/NetworkAdapter.cpp
View file

@ -28,14 +28,14 @@ static Lockable<HashTable<NetworkAdapter*>>& all_adapters()
void NetworkAdapter::for_each(Function<void(NetworkAdapter&)> callback)
{
LOCKER(all_adapters().lock());
Locker locker(all_adapters().lock());
for (auto& it : all_adapters().resource())
callback(*it);
}
RefPtr<NetworkAdapter> NetworkAdapter::from_ipv4_address(const IPv4Address& address)
{
LOCKER(all_adapters().lock());
Locker locker(all_adapters().lock());
for (auto* adapter : all_adapters().resource()) {
if (adapter->ipv4_address() == address)
return adapter;

6
Kernel/Net/NetworkTask.cpp
View file

@ -196,7 +196,7 @@ void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet,
{
NonnullRefPtrVector<IPv4Socket> icmp_sockets;
{
LOCKER(IPv4Socket::all_sockets().lock(), Lock::Mode::Shared);
Locker locker(IPv4Socket::all_sockets().lock(), Lock::Mode::Shared);
for (auto* socket : IPv4Socket::all_sockets().resource()) {
if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
continue;
@ -330,7 +330,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
return;
}
LOCKER(socket->lock());
Locker locker(socket->lock());
VERIFY(socket->type() == SOCK_STREAM);
VERIFY(socket->local_port() == tcp_packet.destination_port());
@ -361,7 +361,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
dmesgln("handle_tcp: couldn't create client socket");
return;
}
LOCKER(client->lock());
Locker locker(client->lock());
dbgln_if(TCP_DEBUG, "handle_tcp: created new client socket with tuple {}", client->tuple().to_string());
client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);

4
Kernel/Net/Routing.cpp
View file

@ -104,7 +104,7 @@ Lockable<HashMap<IPv4Address, MACAddress>>& arp_table()
void update_arp_table(const IPv4Address& ip_addr, const MACAddress& addr)
{
LOCKER(arp_table().lock());
Locker locker(arp_table().lock());
arp_table().resource().set(ip_addr, addr);
s_arp_table_block_condition->unblock(ip_addr, addr);
@ -196,7 +196,7 @@ RoutingDecision route_to(const IPv4Address& target, const IPv4Address& source, c
return { adapter, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
{
LOCKER(arp_table().lock());
Locker locker(arp_table().lock());
auto addr = arp_table().resource().get(next_hop_ip);
if (addr.has_value()) {
dbgln_if(ROUTING_DEBUG, "Routing: Using cached ARP entry for {} ({})", next_hop_ip, addr.value().to_string());

8
Kernel/Net/Socket.cpp
View file

@ -51,7 +51,7 @@ void Socket::set_setup_state(SetupState new_setup_state)
RefPtr<Socket> Socket::accept()
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_pending.is_empty())
return nullptr;
dbgln_if(SOCKET_DEBUG, "Socket({}) de-queueing connection", this);
@ -69,7 +69,7 @@ RefPtr<Socket> Socket::accept()
KResult Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
{
dbgln_if(SOCKET_DEBUG, "Socket({}) queueing connection", this);
LOCKER(m_lock);
Locker locker(m_lock);
if (m_pending.size() >= m_backlog)
return ECONNREFUSED;
m_pending.append(peer);
@ -240,7 +240,7 @@ KResultOr<size_t> Socket::write(FileDescription& description, u64, const UserOrK
KResult Socket::shutdown(int how)
{
LOCKER(lock());
Locker locker(lock());
if (type() == SOCK_STREAM && !is_connected())
return ENOTCONN;
if (m_role == Role::Listener)
@ -263,7 +263,7 @@ KResult Socket::stat(::stat& st) const
void Socket::set_connected(bool connected)
{
LOCKER(lock());
Locker locker(lock());
if (m_connected == connected)
return;
m_connected = connected;

22
Kernel/Net/TCPSocket.cpp
View file

@ -20,7 +20,7 @@ namespace Kernel {
void TCPSocket::for_each(Function<void(const TCPSocket&)> callback)
{
LOCKER(sockets_by_tuple().lock(), Lock::Mode::Shared);
Locker locker(sockets_by_tuple().lock(), Lock::Mode::Shared);
for (auto& it : sockets_by_tuple().resource())
callback(*it.value);
}
@ -38,7 +38,7 @@ void TCPSocket::set_state(State new_state)
m_role = Role::Connected;
if (new_state == State::Closed) {
LOCKER(closing_sockets().lock());
Locker locker(closing_sockets().lock());
closing_sockets().resource().remove(tuple());
}
@ -62,7 +62,7 @@ Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
{
LOCKER(sockets_by_tuple().lock(), Lock::Mode::Shared);
Locker locker(sockets_by_tuple().lock(), Lock::Mode::Shared);
auto exact_match = sockets_by_tuple().resource().get(tuple);
if (exact_match.has_value())
@ -90,7 +90,7 @@ RefPtr<TCPSocket> TCPSocket::create_client(const IPv4Address& new_local_address,
{
auto tuple = IPv4SocketTuple(new_local_address, new_local_port, new_peer_address, new_peer_port);
LOCKER(sockets_by_tuple().lock());
Locker locker(sockets_by_tuple().lock());
if (sockets_by_tuple().resource().contains(tuple))
return {};
@ -131,7 +131,7 @@ TCPSocket::TCPSocket(int protocol)
TCPSocket::~TCPSocket()
{
LOCKER(sockets_by_tuple().lock());
Locker locker(sockets_by_tuple().lock());
sockets_by_tuple().resource().remove(tuple());
dbgln_if(TCP_SOCKET_DEBUG, "~TCPSocket in state {}", to_string(state()));
@ -190,7 +190,7 @@ KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload,
tcp_packet.set_checksum(compute_tcp_checksum(local_address(), peer_address(), tcp_packet, payload_size));
if (tcp_packet.has_syn() || payload_size > 0) {
LOCKER(m_not_acked_lock);
Locker locker(m_not_acked_lock);
m_not_acked.append({ m_sequence_number, move(buffer) });
send_outgoing_packets();
return KSuccess;
@ -218,7 +218,7 @@ void TCPSocket::send_outgoing_packets()
auto now = kgettimeofday();
LOCKER(m_not_acked_lock, Lock::Mode::Shared);
Locker locker(m_not_acked_lock, Lock::Mode::Shared);
for (auto& packet : m_not_acked) {
auto diff = now - packet.tx_time;
if (diff <= Time::from_nanoseconds(500'000'000))
@ -274,7 +274,7 @@ void TCPSocket::receive_tcp_packet(const TCPPacket& packet, u16 size)
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: receive_tcp_packet: {}", ack_number);
int removed = 0;
LOCKER(m_not_acked_lock);
Locker locker(m_not_acked_lock);
while (!m_not_acked.is_empty()) {
auto& packet = m_not_acked.first();
@ -349,7 +349,7 @@ KResult TCPSocket::protocol_bind()
KResult TCPSocket::protocol_listen()
{
LOCKER(sockets_by_tuple().lock());
Locker locker(sockets_by_tuple().lock());
if (sockets_by_tuple().resource().contains(tuple()))
return EADDRINUSE;
sockets_by_tuple().resource().set(tuple(), this);
@ -408,7 +408,7 @@ int TCPSocket::protocol_allocate_local_port()
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
LOCKER(sockets_by_tuple().lock());
Locker locker(sockets_by_tuple().lock());
for (u16 port = first_scan_port;;) {
IPv4SocketTuple proposed_tuple(local_address(), port, peer_address(), peer_port());
@ -468,7 +468,7 @@ KResult TCPSocket::close()
set_state(State::LastAck);
}
LOCKER(closing_sockets().lock());
Locker locker(closing_sockets().lock());
closing_sockets().resource().set(tuple(), *this);
return result;
}

10
Kernel/Net/UDPSocket.cpp
View file

@ -17,7 +17,7 @@ namespace Kernel {
void UDPSocket::for_each(Function<void(const UDPSocket&)> callback)
{
LOCKER(sockets_by_port().lock(), Lock::Mode::Shared);
Locker locker(sockets_by_port().lock(), Lock::Mode::Shared);
for (auto it : sockets_by_port().resource())
callback(*it.value);
}
@ -33,7 +33,7 @@ SocketHandle<UDPSocket> UDPSocket::from_port(u16 port)
{
RefPtr<UDPSocket> socket;
{
LOCKER(sockets_by_port().lock(), Lock::Mode::Shared);
Locker locker(sockets_by_port().lock(), Lock::Mode::Shared);
auto it = sockets_by_port().resource().find(port);
if (it == sockets_by_port().resource().end())
return {};
@ -50,7 +50,7 @@ UDPSocket::UDPSocket(int protocol)
UDPSocket::~UDPSocket()
{
LOCKER(sockets_by_port().lock());
Locker locker(sockets_by_port().lock());
sockets_by_port().resource().remove(local_port());
}
@ -104,7 +104,7 @@ int UDPSocket::protocol_allocate_local_port()
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
LOCKER(sockets_by_port().lock());
Locker locker(sockets_by_port().lock());
for (u16 port = first_scan_port;;) {
auto it = sockets_by_port().resource().find(port);
if (it == sockets_by_port().resource().end()) {
@ -123,7 +123,7 @@ int UDPSocket::protocol_allocate_local_port()
KResult UDPSocket::protocol_bind()
{
LOCKER(sockets_by_port().lock());
Locker locker(sockets_by_port().lock());
if (sockets_by_port().resource().contains(local_port()))
return EADDRINUSE;
sockets_by_port().resource().set(local_port(), this);

2
Kernel/Random.cpp
View file

@ -125,7 +125,7 @@ bool get_good_random_bytes(u8* buffer, size_t buffer_size, bool allow_wait, bool
if (can_wait && allow_wait) {
for (;;) {
{
LOCKER(KernelRng::the().lock());
Locker locker(KernelRng::the().lock());
if (kernel_rng.resource().get_random_bytes(buffer, buffer_size)) {
result = true;
break;

12
Kernel/Storage/AHCIPort.cpp
View file

@ -105,7 +105,7 @@ void AHCIPort::handle_interrupt()
} else {
g_io_work->queue([this]() {
dbgln_if(AHCI_DEBUG, "AHCI Port {}: Request handled", representative_port_index());
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_current_request);
VERIFY(m_current_scatter_list);
if (m_current_request->request_type() == AsyncBlockDeviceRequest::Read) {
@ -133,7 +133,7 @@ bool AHCIPort::is_interrupts_enabled() const
void AHCIPort::recover_from_fatal_error()
{
LOCKER(m_lock);
Locker locker(m_lock);
ScopedSpinLock lock(m_hard_lock);
dmesgln("{}: AHCI Port {} fatal error, shutting down!", m_parent_handler->hba_controller()->pci_address(), representative_port_index());
dmesgln("{}: AHCI Port {} fatal error, SError {}", m_parent_handler->hba_controller()->pci_address(), representative_port_index(), (u32)m_port_registers.serr);
@ -217,7 +217,7 @@ void AHCIPort::eject()
bool AHCIPort::reset()
{
LOCKER(m_lock);
Locker locker(m_lock);
ScopedSpinLock lock(m_hard_lock);
dbgln_if(AHCI_DEBUG, "AHCI Port {}: Resetting", representative_port_index());
@ -242,7 +242,7 @@ bool AHCIPort::reset()
bool AHCIPort::initialize_without_reset()
{
LOCKER(m_lock);
Locker locker(m_lock);
ScopedSpinLock lock(m_hard_lock);
dmesgln("AHCI Port {}: {}", representative_port_index(), try_disambiguate_sata_status());
return initialize(lock);
@ -454,7 +454,7 @@ Optional<AsyncDeviceRequest::RequestResult> AHCIPort::prepare_and_set_scatter_li
void AHCIPort::start_request(AsyncBlockDeviceRequest& request)
{
LOCKER(m_lock);
Locker locker(m_lock);
dbgln_if(AHCI_DEBUG, "AHCI Port {}: Request start", representative_port_index());
VERIFY(!m_current_request);
VERIFY(!m_current_scatter_list);
@ -657,7 +657,7 @@ bool AHCIPort::identify_device(ScopedSpinLock<SpinLock<u8>>& main_lock)
bool AHCIPort::shutdown()
{
LOCKER(m_lock);
Locker locker(m_lock);
ScopedSpinLock lock(m_hard_lock);
rebase();
set_interface_state(AHCI::DeviceDetectionInitialization::DisableInterface);

6
Kernel/Storage/IDEChannel.cpp
View file

@ -90,7 +90,7 @@ UNMAP_AFTER_INIT IDEChannel::~IDEChannel()
void IDEChannel::start_request(AsyncBlockDeviceRequest& request, bool is_slave, u16 capabilities)
{
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_current_request.is_null());
dbgln_if(PATA_DEBUG, "IDEChannel::start_request");
@ -117,7 +117,7 @@ void IDEChannel::complete_current_request(AsyncDeviceRequest::RequestResult resu
// before Processor::deferred_call_queue returns!
g_io_work->queue([this, result]() {
dbgln_if(PATA_DEBUG, "IDEChannel::complete_current_request result: {}", (int)result);
LOCKER(m_lock);
Locker locker(m_lock);
VERIFY(m_current_request);
auto current_request = m_current_request;
m_current_request.clear();
@ -205,7 +205,7 @@ void IDEChannel::handle_irq(const RegisterState&)
// This is important so that we can safely access the buffers, which could
// trigger page faults
g_io_work->queue([this]() {
LOCKER(m_lock);
Locker locker(m_lock);
ScopedSpinLock lock(m_request_lock);
if (m_current_request->request_type() == AsyncBlockDeviceRequest::Read) {
dbgln_if(PATA_DEBUG, "IDEChannel: Read block {}/{}", m_current_request_block_index, m_current_request->block_count());

2
Kernel/Storage/RamdiskDevice.cpp
View file

@ -35,7 +35,7 @@ const char* RamdiskDevice::class_name() const
void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request)
{
LOCKER(m_lock);
Locker locker(m_lock);
u8* base = m_region->vaddr().as_ptr();
size_t size = m_region->size();

4
Kernel/Syscalls/hostname.cpp
View file

@ -16,7 +16,7 @@ KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, ssize_t size)
REQUIRE_PROMISE(stdio);
if (size < 0)
return EINVAL;
LOCKER(*g_hostname_lock, Lock::Mode::Shared);
Locker locker(*g_hostname_lock, Lock::Mode::Shared);
if ((size_t)size < (g_hostname->length() + 1))
return ENAMETOOLONG;
if (!copy_to_user(buffer, g_hostname->characters(), g_hostname->length() + 1))
@ -31,7 +31,7 @@ KResultOr<int> Process::sys$sethostname(Userspace<const char*> hostname, ssize_t
return EPERM;
if (length < 0)
return EINVAL;
LOCKER(*g_hostname_lock, Lock::Mode::Exclusive);
Locker locker(*g_hostname_lock, Lock::Mode::Exclusive);
if (length > 64)
return ENAMETOOLONG;
auto copied_hostname = copy_string_from_user(hostname, length);

2
Kernel/Syscalls/uname.cpp
View file

@ -15,7 +15,7 @@ KResultOr<int> Process::sys$uname(Userspace<utsname*> user_buf)
REQUIRE_PROMISE(stdio);
LOCKER(*g_hostname_lock, Lock::Mode::Shared);
Locker locker(*g_hostname_lock, Lock::Mode::Shared);
if (g_hostname->length() + 1 > sizeof(utsname::nodename))
return ENAMETOOLONG;

4
Kernel/TTY/PTYMultiplexer.cpp
View file

@ -36,7 +36,7 @@ UNMAP_AFTER_INIT PTYMultiplexer::~PTYMultiplexer()
KResultOr<NonnullRefPtr<FileDescription>> PTYMultiplexer::open(int options)
{
LOCKER(m_lock);
Locker locker(m_lock);
if (m_freelist.is_empty())
return EBUSY;
auto master_index = m_freelist.take_last();
@ -52,7 +52,7 @@ KResultOr<NonnullRefPtr<FileDescription>> PTYMultiplexer::open(int options)
void PTYMultiplexer::notify_master_destroyed(Badge<MasterPTY>, unsigned index)
{
LOCKER(m_lock);
Locker locker(m_lock);
m_freelist.append(index);
dbgln_if(PTMX_DEBUG, "PTYMultiplexer: {} added to freelist", index);
}

2
Kernel/VM/AnonymousVMObject.cpp
View file

@ -161,7 +161,7 @@ AnonymousVMObject::~AnonymousVMObject()
int AnonymousVMObject::purge()
{
LOCKER(m_paging_lock);
Locker locker(m_paging_lock);
return purge_impl();
}

2
Kernel/VM/InodeVMObject.cpp
View file

@ -53,7 +53,7 @@ size_t InodeVMObject::amount_dirty() const
int InodeVMObject::release_all_clean_pages()
{
LOCKER(m_paging_lock);
Locker locker(m_paging_lock);
return release_all_clean_pages_impl();
}

4
Kernel/VM/Region.cpp
View file

@ -451,7 +451,7 @@ PageFaultResponse Region::handle_zero_fault(size_t page_index_in_region)
VERIFY_INTERRUPTS_DISABLED();
VERIFY(vmobject().is_anonymous());
LOCKER(vmobject().m_paging_lock);
Locker locker(vmobject().m_paging_lock);
auto& page_slot = physical_page_slot(page_index_in_region);
auto page_index_in_vmobject = translate_to_vmobject_page(page_index_in_region);
@ -514,7 +514,7 @@ PageFaultResponse Region::handle_inode_fault(size_t page_index_in_region, Scoped
VERIFY(!s_mm_lock.own_lock());
VERIFY(!g_scheduler_lock.own_lock());
LOCKER(vmobject().m_paging_lock);
Locker locker(vmobject().m_paging_lock);
mm_lock.lock();