RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 10:48:11 +00:00
Code Issues Activity Actions

Kernel: Rename ProtectedValue<T> => MutexProtected<T>

Browse source 
Let's make it obvious what we're protecting it with.
This commit is contained in:
Andreas Kling 2021-08-21 23:31:15 +02:00
parent 81d990b551
commit c2fc33becd
18 changed files with 57 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kernel/FileSystem/BlockBasedFileSystem.h
View file

@ -7,7 +7,7 @@
#pragma once
#include <Kernel/FileSystem/FileBackedFileSystem.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
namespace Kernel {
@ -44,7 +44,7 @@ private:
DiskCache& cache() const;
void flush_specific_block_if_needed(BlockIndex index);
mutable ProtectedValue<OwnPtr<DiskCache>> m_cache;
mutable MutexProtected<OwnPtr<DiskCache>> m_cache;
};
}

6
Kernel/FileSystem/Custody.cpp
View file

@ -10,13 +10,13 @@
#include <AK/Vector.h>
#include <Kernel/FileSystem/Custody.h>
#include <Kernel/FileSystem/Inode.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
namespace Kernel {
static Singleton<ProtectedValue<Custody::AllCustodiesList>> s_all_custodies;
static Singleton<MutexProtected<Custody::AllCustodiesList>> s_all_custodies;
static ProtectedValue<Custody::AllCustodiesList>& all_custodies()
static MutexProtected<Custody::AllCustodiesList>& all_custodies()
{
return s_all_custodies;
}

4
Kernel/FileSystem/VirtualFileSystem.h
View file

@ -20,7 +20,7 @@
#include <Kernel/FileSystem/UnveilNode.h>
#include <Kernel/Forward.h>
#include <Kernel/KResult.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
namespace Kernel {
@ -93,7 +93,7 @@ private:
RefPtr<Inode> m_root_inode;
RefPtr<Custody> m_root_custody;
ProtectedValue<Vector<Mount, 16>> m_mounts;
MutexProtected<Vector<Mount, 16>> m_mounts;
};
}

8
Kernel/Locking/ContendedResource.h → Kernel/Locking/MutexContendedResource.h
View file

@ -36,15 +36,15 @@ private:
MutexLocker m_mutex_locker;
};
class ContendedResource {
class MutexContendedResource {
template<typename, LockMode>
friend class LockedResource;
AK_MAKE_NONCOPYABLE(ContendedResource);
AK_MAKE_NONMOVABLE(ContendedResource);
AK_MAKE_NONCOPYABLE(MutexContendedResource);
AK_MAKE_NONMOVABLE(MutexContendedResource);
public:
ContendedResource() = default;
MutexContendedResource() = default;
protected:
mutable Mutex m_mutex;

17
Kernel/Locking/ProtectedValue.h → Kernel/Locking/MutexProtected.h
View file

@ -6,28 +6,29 @@
#pragma once
#include <Kernel/Locking/ContendedResource.h>
#include <Kernel/Locking/LockLocation.h>
#include <Kernel/Locking/MutexContendedResource.h>
namespace Kernel {
template<typename T>
class ProtectedValue : private T
, public ContendedResource {
AK_MAKE_NONCOPYABLE(ProtectedValue);
AK_MAKE_NONMOVABLE(ProtectedValue);
class MutexProtected
: private T
, public MutexContendedResource {
AK_MAKE_NONCOPYABLE(MutexProtected);
AK_MAKE_NONMOVABLE(MutexProtected);
protected:
using LockedShared = LockedResource<T const, LockMode::Shared>;
using LockedExclusive = LockedResource<T, LockMode::Exclusive>;
LockedShared lock_shared(LockLocation const& location) const { return LockedShared(this, this->ContendedResource::m_mutex, location); }
LockedExclusive lock_exclusive(LockLocation const& location) { return LockedExclusive(this, this->ContendedResource::m_mutex, location); }
LockedShared lock_shared(LockLocation const& location) const { return LockedShared(this, this->MutexContendedResource::m_mutex, location); }
LockedExclusive lock_exclusive(LockLocation const& location) { return LockedExclusive(this, this->MutexContendedResource::m_mutex, location); }
public:
using T::T;
ProtectedValue() = default;
MutexProtected() = default;
template<typename Callback>
decltype(auto) with_shared(Callback callback, LockLocation const& location = LockLocation::current()) const

4
Kernel/Net/IPv4Socket.cpp
View file

@ -26,11 +26,11 @@
namespace Kernel {
static Singleton<ProtectedValue<IPv4Socket::List>> s_all_sockets;
static Singleton<MutexProtected<IPv4Socket::List>> s_all_sockets;
using BlockFlags = Thread::FileDescriptionBlocker::BlockFlags;
ProtectedValue<IPv4Socket::List>& IPv4Socket::all_sockets()
MutexProtected<IPv4Socket::List>& IPv4Socket::all_sockets()
{
return *s_all_sockets;
}

4
Kernel/Net/IPv4Socket.h
View file

@ -10,7 +10,7 @@
#include <AK/SinglyLinkedListWithCount.h>
#include <Kernel/DoubleBuffer.h>
#include <Kernel/KBuffer.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/IPv4.h>
#include <Kernel/Net/IPv4SocketTuple.h>
#include <Kernel/Net/Socket.h>
@ -135,7 +135,7 @@ private:
public:
using List = IntrusiveList<IPv4Socket, RawPtr<IPv4Socket>, &IPv4Socket::m_list_node>;
static ProtectedValue<IPv4Socket::List>& all_sockets();
static MutexProtected<IPv4Socket::List>& all_sockets();
};
}

6
Kernel/Net/LocalSocket.cpp
View file

@ -10,7 +10,7 @@
#include <Kernel/FileSystem/FileDescription.h>
#include <Kernel/FileSystem/VirtualFileSystem.h>
#include <Kernel/Locking/Mutex.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/LocalSocket.h>
#include <Kernel/Process.h>
#include <Kernel/StdLib.h>
@ -19,9 +19,9 @@
namespace Kernel {
static Singleton<ProtectedValue<LocalSocket::List>> s_list;
static Singleton<MutexProtected<LocalSocket::List>> s_list;
static ProtectedValue<LocalSocket::List>& all_sockets()
static MutexProtected<LocalSocket::List>& all_sockets()
{
return *s_list;
}

2
Kernel/Net/NetworkTask.cpp
View file

@ -6,7 +6,7 @@
#include <Kernel/Debug.h>
#include <Kernel/Locking/Mutex.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/ARP.h>
#include <Kernel/Net/EtherType.h>
#include <Kernel/Net/EthernetFrameHeader.h>

6
Kernel/Net/Routing.cpp
View file

@ -7,7 +7,7 @@
#include <AK/HashMap.h>
#include <AK/Singleton.h>
#include <Kernel/Debug.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/LoopbackAdapter.h>
#include <Kernel/Net/NetworkTask.h>
#include <Kernel/Net/NetworkingManagement.h>
@ -16,7 +16,7 @@
namespace Kernel {
static Singleton<ProtectedValue<HashMap<IPv4Address, MACAddress>>> s_arp_table;
static Singleton<MutexProtected<HashMap<IPv4Address, MACAddress>>> s_arp_table;
class ARPTableBlocker : public Thread::Blocker {
public:
@ -104,7 +104,7 @@ void ARPTableBlocker::not_blocking(bool timeout_in_past)
}
}
ProtectedValue<HashMap<IPv4Address, MACAddress>>& arp_table()
MutexProtected<HashMap<IPv4Address, MACAddress>>& arp_table()
{
return *s_arp_table;
}

4
Kernel/Net/Routing.h
View file

@ -6,7 +6,7 @@
#pragma once
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/NetworkAdapter.h>
#include <Kernel/Thread.h>
@ -27,6 +27,6 @@ enum class UpdateArp {
void update_arp_table(const IPv4Address&, const MACAddress&, UpdateArp update);
RoutingDecision route_to(const IPv4Address& target, const IPv4Address& source, const RefPtr<NetworkAdapter> through = nullptr);
ProtectedValue<HashMap<IPv4Address, MACAddress>>& arp_table();
MutexProtected<HashMap<IPv4Address, MACAddress>>& arp_table();
}

14
Kernel/Net/TCPSocket.cpp
View file

@ -9,7 +9,7 @@
#include <Kernel/Debug.h>
#include <Kernel/Devices/RandomDevice.h>
#include <Kernel/FileSystem/FileDescription.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/EthernetFrameHeader.h>
#include <Kernel/Net/IPv4.h>
#include <Kernel/Net/NetworkAdapter.h>
@ -56,16 +56,16 @@ void TCPSocket::set_state(State new_state)
evaluate_block_conditions();
}
static Singleton<ProtectedValue<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>> s_socket_closing;
static Singleton<MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>> s_socket_closing;
ProtectedValue<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_sockets()
MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_sockets()
{
return *s_socket_closing;
}
static Singleton<ProtectedValue<HashMap<IPv4SocketTuple, TCPSocket*>>> s_socket_tuples;
static Singleton<MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>> s_socket_tuples;
ProtectedValue<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
{
return *s_socket_tuples;
}
@ -512,9 +512,9 @@ KResult TCPSocket::close()
return result;
}
static Singleton<ProtectedValue<TCPSocket::RetransmitList>> s_sockets_for_retransmit;
static Singleton<MutexProtected<TCPSocket::RetransmitList>> s_sockets_for_retransmit;
ProtectedValue<TCPSocket::RetransmitList>& TCPSocket::sockets_for_retransmit()
MutexProtected<TCPSocket::RetransmitList>& TCPSocket::sockets_for_retransmit()
{
return *s_sockets_for_retransmit;
}

10
Kernel/Net/TCPSocket.h
View file

@ -11,7 +11,7 @@
#include <AK/SinglyLinkedList.h>
#include <AK/WeakPtr.h>
#include <Kernel/KResult.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/IPv4Socket.h>
namespace Kernel {
@ -142,10 +142,10 @@ public:
bool should_delay_next_ack() const;
static ProtectedValue<HashMap<IPv4SocketTuple, TCPSocket*>>& sockets_by_tuple();
static MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>& sockets_by_tuple();
static RefPtr<TCPSocket> from_tuple(const IPv4SocketTuple& tuple);
static ProtectedValue<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& closing_sockets();
static MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& closing_sockets();
RefPtr<TCPSocket> create_client(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port);
void set_originator(TCPSocket& originator) { m_originator = originator; }
@ -207,7 +207,7 @@ private:
size_t size { 0 };
};
ProtectedValue<UnackedPackets> m_unacked_packets;
MutexProtected<UnackedPackets> m_unacked_packets;
u32 m_duplicate_acks { 0 };
@ -226,7 +226,7 @@ private:
public:
using RetransmitList = IntrusiveList<TCPSocket, RawPtr<TCPSocket>, &TCPSocket::m_retransmit_list_node>;
static ProtectedValue<TCPSocket::RetransmitList>& sockets_for_retransmit();
static MutexProtected<TCPSocket::RetransmitList>& sockets_for_retransmit();
};
}

4
Kernel/Net/UDPSocket.cpp
View file

@ -22,9 +22,9 @@ void UDPSocket::for_each(Function<void(const UDPSocket&)> callback)
});
}
static Singleton<ProtectedValue<HashMap<u16, UDPSocket*>>> s_map;
static Singleton<MutexProtected<HashMap<u16, UDPSocket*>>> s_map;
ProtectedValue<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
MutexProtected<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
{
return *s_map;
}

4
Kernel/Net/UDPSocket.h
View file

@ -7,7 +7,7 @@
#pragma once
#include <Kernel/KResult.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/IPv4Socket.h>
namespace Kernel {
@ -23,7 +23,7 @@ public:
private:
explicit UDPSocket(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
virtual StringView class_name() const override { return "UDPSocket"; }
static ProtectedValue<HashMap<u16, UDPSocket*>>& sockets_by_port();
static MutexProtected<HashMap<u16, UDPSocket*>>& sockets_by_port();
virtual KResultOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;

8
Kernel/Process.cpp
View file

@ -44,18 +44,18 @@ static void create_signal_trampoline();
RecursiveSpinLock g_profiling_lock;
static Atomic<pid_t> next_pid;
static Singleton<ProtectedValue<Process::List>> s_processes;
static Singleton<MutexProtected<Process::List>> s_processes;
READONLY_AFTER_INIT HashMap<String, OwnPtr<Module>>* g_modules;
READONLY_AFTER_INIT Memory::Region* g_signal_trampoline_region;
static Singleton<ProtectedValue<String>> s_hostname;
static Singleton<MutexProtected<String>> s_hostname;
ProtectedValue<String>& hostname()
MutexProtected<String>& hostname()
{
return *s_hostname;
}
ProtectedValue<Process::List>& processes()
MutexProtected<Process::List>& processes()
{
return *s_processes;
}

6
Kernel/Process.h
View file

@ -24,7 +24,7 @@
#include <Kernel/Forward.h>
#include <Kernel/FutexQueue.h>
#include <Kernel/Locking/Mutex.h>
#include <Kernel/Locking/ProtectedValue.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Memory/AddressSpace.h>
#include <Kernel/PerformanceEventBuffer.h>
#include <Kernel/ProcessExposed.h>
@ -37,7 +37,7 @@
namespace Kernel {
ProtectedValue<String>& hostname();
MutexProtected<String>& hostname();
Time kgettimeofday();
#define ENUMERATE_PLEDGE_PROMISES \
@ -814,7 +814,7 @@ static_assert(sizeof(Process) == (PAGE_SIZE * 2));
extern RecursiveSpinLock g_profiling_lock;
ProtectedValue<Process::List>& processes();
MutexProtected<Process::List>& processes();
template<IteratorFunction<Process&> Callback>
inline void Process::for_each(Callback callback)

2
Kernel/TTY/PTYMultiplexer.h
View file

@ -44,7 +44,7 @@ private:
virtual StringView class_name() const override { return "PTYMultiplexer"; }
static constexpr size_t max_pty_pairs = 64;
ProtectedValue<Vector<unsigned, max_pty_pairs>> m_freelist;
MutexProtected<Vector<unsigned, max_pty_pairs>> m_freelist;
};
}