RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 09:27:35 +00:00
Code Issues Activity Actions

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
Download patch file Download diff file Expand all files Collapse all files

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);