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

Everywhere: Switch from (void) to [[maybe_unused]] (#4473)

Browse source 
Problem:
- `(void)` simply casts the expression to void. This is understood to
  indicate that it is ignored, but this is really a compiler trick to
  get the compiler to not generate a warning.

Solution:
- Use the `[[maybe_unused]]` attribute to indicate the value is unused.

Note:
- Functions taking a `(void)` argument list have also been changed to
  `()` because this is not needed and shows up in the same grep
  command.
This commit is contained in:
Lenny Maiorani 2020-12-20 16:09:48 -07:00 • committed by GitHub
parent 4421d98e30
commit 765936ebae
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
103 changed files with 219 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

21
Kernel/Arch/i386/CPU.cpp
View file

@ -64,9 +64,9 @@ static GenericInterruptHandler* s_interrupt_handler[GENERIC_INTERRUPT_HANDLERS_C
extern "C" void enter_thread_context(Thread* from_thread, Thread* to_thread);
extern "C" void context_first_init(Thread* from_thread, Thread* to_thread, TrapFrame* trap);
extern "C" u32 do_init_context(Thread* thread, u32 flags);
extern "C" void exit_kernel_thread(void);
extern "C" void pre_init_finished(void);
extern "C" void post_init_finished(void);
extern "C" void exit_kernel_thread();
extern "C" void pre_init_finished();
extern "C" void post_init_finished();
extern "C" void handle_interrupt(TrapFrame*);
#define EH_ENTRY(ec, title) \
@ -1490,13 +1490,10 @@ void Processor::switch_context(Thread*& from_thread, Thread*& to_thread)
#endif
}
extern "C" void context_first_init(Thread* from_thread, Thread* to_thread, TrapFrame* trap)
extern "C" void context_first_init([[maybe_unused]] Thread* from_thread, [[maybe_unused]] Thread* to_thread, [[maybe_unused]] TrapFrame* trap)
{
ASSERT(!are_interrupts_enabled());
ASSERT(is_kernel_mode());
(void)from_thread;
(void)to_thread;
(void)trap;
#ifdef CONTEXT_SWITCH_DEBUG
dbg() << "switch_context <-- from " << VirtualAddress(from_thread) << " " << *from_thread << " to " << VirtualAddress(to_thread) << " " << *to_thread << " (context_first_init)";
@ -1513,7 +1510,7 @@ extern "C" void context_first_init(Thread* from_thread, Thread* to_thread, TrapF
Scheduler::leave_on_first_switch(trap->regs->eflags);
}
extern "C" void thread_context_first_enter(void);
extern "C" void thread_context_first_enter();
asm(
// enter_thread_context returns to here first time a thread is executing
".globl thread_context_first_enter \n"
@ -1529,7 +1526,7 @@ asm(
" jmp common_trap_exit \n"
);
void exit_kernel_thread(void)
void exit_kernel_thread()
{
Thread::current()->exit();
}
@ -1674,7 +1671,7 @@ void Processor::assume_context(Thread& thread, u32 flags)
ASSERT_NOT_REACHED();
}
extern "C" void pre_init_finished(void)
extern "C" void pre_init_finished()
{
ASSERT(g_scheduler_lock.own_lock());
@ -1687,7 +1684,7 @@ extern "C" void pre_init_finished(void)
Scheduler::leave_on_first_switch(prev_flags);
}
extern "C" void post_init_finished(void)
extern "C" void post_init_finished()
{
// We need to re-acquire the scheduler lock before a context switch
// transfers control into the idle loop, which needs the lock held
@ -1731,7 +1728,7 @@ void Processor::initialize_context_switching(Thread& initial_thread)
[from_to_thread] "b" (&initial_thread),
[cpu] "c" (id())
);
ASSERT_NOT_REACHED();
}

2
Kernel/Assertions.h
View file

@ -31,7 +31,7 @@
#ifdef DEBUG
[[noreturn]] void __assertion_failed(const char* msg, const char* file, unsigned line, const char* func);
# define ASSERT(expr) (static_cast<bool>(expr) ? (void)0 : __assertion_failed(# expr, __FILE__, __LINE__, __PRETTY_FUNCTION__))
# define ASSERT(expr) (static_cast<bool>(expr) ? void(0) : __assertion_failed(# expr, __FILE__, __LINE__, __PRETTY_FUNCTION__))
# define ASSERT_NOT_REACHED() ASSERT(false)
#else
# define ASSERT(expr)

12
Kernel/CoreDump.cpp
View file

@ -116,7 +116,7 @@ void CoreDump::write_elf_header()
elf_file_header.e_shnum = 0;
elf_file_header.e_shstrndx = SHN_UNDEF;
(void)m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(Elf32_Ehdr));
[[maybe_unused]] auto rc = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(Elf32_Ehdr));
}
void CoreDump::write_program_headers(size_t notes_size)
@ -142,7 +142,7 @@ void CoreDump::write_program_headers(size_t notes_size)
offset += phdr.p_filesz;
(void)m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&phdr)), sizeof(Elf32_Phdr));
[[maybe_unused]] auto rc = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&phdr)), sizeof(Elf32_Phdr));
}
Elf32_Phdr notes_pheader {};
@ -155,7 +155,7 @@ void CoreDump::write_program_headers(size_t notes_size)
notes_pheader.p_align = 0;
notes_pheader.p_flags = 0;
(void)m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(Elf32_Phdr));
[[maybe_unused]] auto rc = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(Elf32_Phdr));
}
void CoreDump::write_regions()
@ -182,14 +182,14 @@ void CoreDump::write_regions()
// (A page may not be backed by a physical page because it has never been faulted in when the process ran).
src_buffer = UserOrKernelBuffer::for_kernel_buffer(zero_buffer);
}
(void)m_fd->write(src_buffer.value(), PAGE_SIZE);
[[maybe_unused]] auto rc = m_fd->write(src_buffer.value(), PAGE_SIZE);
}
}
}
void CoreDump::write_notes_segment(ByteBuffer& notes_segment)
{
(void)m_fd->write(UserOrKernelBuffer::for_kernel_buffer(notes_segment.data()), notes_segment.size());
[[maybe_unused]] auto rc = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(notes_segment.data()), notes_segment.size());
}
ByteBuffer CoreDump::create_notes_threads_data() const
@ -264,7 +264,7 @@ void CoreDump::write()
write_regions();
write_notes_segment(notes_segment);
(void)m_fd->chmod(0400); // Make coredump file readable
[[maybe_unused]] auto rc = m_fd->chmod(0400); // Make coredump file readable
}
}

4
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -290,7 +290,7 @@ void BlockBasedFS::flush_specific_block_if_needed(unsigned index)
file_description().seek(base_offset, SEEK_SET);
// FIXME: Should this error path be surfaced somehow?
auto entry_data_buffer = UserOrKernelBuffer::for_kernel_buffer(entry.data);
(void)file_description().write(entry_data_buffer, block_size());
[[maybe_unused]] auto rc = file_description().write(entry_data_buffer, block_size());
cleaned_entries.append(&entry);
}
});
@ -311,7 +311,7 @@ void BlockBasedFS::flush_writes_impl()
file_description().seek(base_offset, SEEK_SET);
// FIXME: Should this error path be surfaced somehow?
auto entry_data_buffer = UserOrKernelBuffer::for_kernel_buffer(entry.data);
(void)file_description().write(entry_data_buffer, block_size());
[[maybe_unused]] auto rc = file_description().write(entry_data_buffer, block_size());
++count;
});
cache().mark_all_clean();

2
Kernel/FileSystem/FileDescription.cpp
View file

@ -71,7 +71,7 @@ FileDescription::~FileDescription()
if (is_fifo())
static_cast<FIFO*>(m_file.ptr())->detach(m_fifo_direction);
// FIXME: Should this error path be observed somehow?
(void)m_file->close();
[[maybe_unused]] auto rc = m_file->close();
m_inode = nullptr;
}

6
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -710,7 +710,7 @@ Plan9FSInode::~Plan9FSInode()
Plan9FS::Message clunk_request { fs(), Plan9FS::Message::Type::Tclunk };
clunk_request << fid();
// FIXME: Should we observe this error somehow?
(void)fs().post_message_and_explicitly_ignore_reply(clunk_request);
[[maybe_unused]] auto rc = fs().post_message_and_explicitly_ignore_reply(clunk_request);
}
KResult Plan9FSInode::ensure_open_for_mode(int mode)
@ -909,7 +909,7 @@ KResult Plan9FSInode::traverse_as_directory(Function<bool(const FS::DirectoryEnt
Plan9FS::Message close_message { fs(), Plan9FS::Message::Type::Tclunk };
close_message << clone_fid;
// FIXME: Should we observe this error?
(void)fs().post_message_and_explicitly_ignore_reply(close_message);
[[maybe_unused]] auto rc = fs().post_message_and_explicitly_ignore_reply(close_message);
return result;
}
}
@ -942,7 +942,7 @@ KResult Plan9FSInode::traverse_as_directory(Function<bool(const FS::DirectoryEnt
Plan9FS::Message close_message { fs(), Plan9FS::Message::Type::Tclunk };
close_message << clone_fid;
// FIXME: Should we observe this error?
(void)fs().post_message_and_explicitly_ignore_reply(close_message);
[[maybe_unused]] auto rc = fs().post_message_and_explicitly_ignore_reply(close_message);
return result;
} else {
// TODO

3
Kernel/FileSystem/ProcFS.cpp
View file

@ -1647,9 +1647,8 @@ KResult ProcFSInode::add_child(Inode&, const StringView&, mode_t)
return KResult(-EPERM);
}
KResult ProcFSInode::remove_child(const StringView& name)
KResult ProcFSInode::remove_child([[maybe_unused]] const StringView& name)
{
(void)name;
return KResult(-EPERM);
}

2
Kernel/Interrupts/APIC.cpp
View file

@ -210,7 +210,7 @@ void APIC::write_icr(const ICRReg& icr)
#define APIC_LVT_TRIGGER_LEVEL (1 << 14)
#define APIC_LVT(iv, dm) (((iv)&0xff) | (((dm)&0x7) << 8))
extern "C" void apic_ap_start(void);
extern "C" void apic_ap_start();
extern "C" u16 apic_ap_start_size;
extern "C" u32 ap_cpu_init_stacks;
extern "C" u32 ap_cpu_init_processor_info_array;

2
Kernel/Net/E1000NetworkAdapter.cpp
View file

@ -150,7 +150,7 @@ void E1000NetworkAdapter::detect()
if (id != qemu_bochs_vbox_id)
return;
u8 irq = PCI::get_interrupt_line(address);
(void)adopt(*new E1000NetworkAdapter(address, irq)).leak_ref();
[[maybe_unused]] auto& unused = adopt(*new E1000NetworkAdapter(address, irq)).leak_ref();
});
}

5
Kernel/Net/IPv4Socket.cpp
View file

@ -203,11 +203,10 @@ int IPv4Socket::allocate_local_port_if_needed()
return port;
}
KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer& data, size_t data_length, int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
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());
(void)flags;
if (addr && addr_length != sizeof(sockaddr_in))
return KResult(-EINVAL);
@ -621,7 +620,7 @@ int IPv4Socket::ioctl(FileDescription&, unsigned request, FlatPtr arg)
KResult IPv4Socket::close()
{
(void)shutdown(SHUT_RDWR);
[[maybe_unused]] auto rc = shutdown(SHUT_RDWR);
return KSuccess;
}

37
Kernel/Net/NetworkTask.cpp
View file

@ -374,6 +374,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size());
[[maybe_unused]] int unused_rc {};
switch (socket->state()) {
case TCPSocket::State::Closed:
klog() << "handle_tcp: unexpected flags in Closed state";
@ -381,7 +382,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
case TCPSocket::State::TimeWait:
klog() << "handle_tcp: unexpected flags in TimeWait state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
case TCPSocket::State::Listen:
@ -403,46 +404,46 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
#endif
client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
[[maybe_unused]] auto rc2 = client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
client->set_state(TCPSocket::State::SynReceived);
return;
}
default:
klog() << "handle_tcp: unexpected flags in Listen state";
// (void)socket->send_tcp_packet(TCPFlags::RST);
// socket->send_tcp_packet(TCPFlags::RST);
return;
}
case TCPSocket::State::SynSent:
switch (tcp_packet.flags()) {
case TCPFlags::SYN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::SynReceived);
return;
case TCPFlags::ACK | TCPFlags::SYN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::Established);
socket->set_setup_state(Socket::SetupState::Completed);
socket->set_connected(true);
return;
case TCPFlags::ACK | TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::FINDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
case TCPFlags::ACK | TCPFlags::RST:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::RSTDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
default:
klog() << "handle_tcp: unexpected flags in SynSent state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
@ -457,7 +458,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
case TCPSocket::Direction::Incoming:
if (!socket->has_originator()) {
klog() << "handle_tcp: connection doesn't have an originating socket; maybe it went away?";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -473,7 +474,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: got ACK in SynReceived state but direction is invalid (" << TCPSocket::to_string(socket->direction()) << ")";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -481,7 +482,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: unexpected flags in SynReceived state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -489,7 +490,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
switch (tcp_packet.flags()) {
default:
klog() << "handle_tcp: unexpected flags in CloseWait state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -501,7 +502,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: unexpected flags in LastAck state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -517,7 +518,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: unexpected flags in FinWait1 state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -532,7 +533,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: unexpected flags in FinWait2 state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -544,7 +545,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
return;
default:
klog() << "handle_tcp: unexpected flags in Closing state";
(void)socket->send_tcp_packet(TCPFlags::RST);
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
@ -554,7 +555,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp);
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::CloseWait);
socket->set_connected(false);
return;
@ -568,7 +569,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
if (payload_size) {
if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp))
(void)socket->send_tcp_packet(TCPFlags::ACK);
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
}
}
}

2
Kernel/Net/RTL8139NetworkAdapter.cpp
View file

@ -135,7 +135,7 @@ void RTL8139NetworkAdapter::detect()
if (id != rtl8139_id)
return;
u8 irq = PCI::get_interrupt_line(address);
(void)adopt(*new RTL8139NetworkAdapter(address, irq)).leak_ref();
[[maybe_unused]] auto& unused = adopt(*new RTL8139NetworkAdapter(address, irq)).leak_ref();
});
}

9
Kernel/Net/TCPSocket.cpp
View file

@ -144,7 +144,7 @@ void TCPSocket::release_for_accept(RefPtr<TCPSocket> socket)
ASSERT(m_pending_release_for_accept.contains(socket->tuple()));
m_pending_release_for_accept.remove(socket->tuple());
// FIXME: Should we observe this error somehow?
(void)queue_connection_from(*socket);
[[maybe_unused]] auto rc = queue_connection_from(*socket);
}
TCPSocket::TCPSocket(int protocol)
@ -167,9 +167,8 @@ NonnullRefPtr<TCPSocket> TCPSocket::create(int protocol)
return adopt(*new TCPSocket(protocol));
}
KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags)
KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
{
(void)flags;
auto& ipv4_packet = *reinterpret_cast<const IPv4Packet*>(raw_ipv4_packet.data());
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
size_t payload_size = raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
@ -464,7 +463,7 @@ void TCPSocket::shut_down_for_writing()
#ifdef TCP_SOCKET_DEBUG
dbg() << " Sending FIN/ACK from Established and moving into FinWait1";
#endif
(void)send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
[[maybe_unused]] auto rc = send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
set_state(State::FinWait1);
} else {
dbg() << " Shutting down TCPSocket for writing but not moving to FinWait1 since state is " << to_string(state());
@ -479,7 +478,7 @@ KResult TCPSocket::close()
#ifdef TCP_SOCKET_DEBUG
dbg() << " Sending FIN from CloseWait and moving into LastAck";
#endif
(void)send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
[[maybe_unused]] auto rc = send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
set_state(State::LastAck);
}

3
Kernel/Net/UDPSocket.cpp
View file

@ -79,9 +79,8 @@ NonnullRefPtr<UDPSocket> UDPSocket::create(int protocol)
return adopt(*new UDPSocket(protocol));
}
KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags)
KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
{
(void)flags;
auto& ipv4_packet = *(const IPv4Packet*)(raw_ipv4_packet.data());
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
ASSERT(udp_packet.length() >= sizeof(UDPPacket)); // FIXME: This should be rejected earlier.

8
Kernel/Process.cpp
View file

@ -401,8 +401,8 @@ void Process::dump_regions()
}
// Make sure the compiler doesn't "optimize away" this function:
extern void signal_trampoline_dummy(void);
void signal_trampoline_dummy(void)
extern void signal_trampoline_dummy();
void signal_trampoline_dummy()
{
// The trampoline preserves the current eax, pushes the signal code and
// then calls the signal handler. We do this because, when interrupting a
@ -426,8 +426,8 @@ void signal_trampoline_dummy(void)
".att_syntax" ::"i"(Syscall::SC_sigreturn));
}
extern "C" void asm_signal_trampoline(void);
extern "C" void asm_signal_trampoline_end(void);
extern "C" void asm_signal_trampoline();
extern "C" void asm_signal_trampoline_end();
void create_signal_trampolines()
{

3
Kernel/Scheduler.cpp
View file

@ -253,14 +253,13 @@ bool Scheduler::yield()
return true;
}
bool Scheduler::donate_to_and_switch(Thread* beneficiary, const char* reason)
bool Scheduler::donate_to_and_switch(Thread* beneficiary, [[maybe_unused]] const char* reason)
{
ASSERT(g_scheduler_lock.own_lock());
auto& proc = Processor::current();
ASSERT(proc.in_critical() == 1);
(void)reason;
unsigned ticks_left = Thread::current()->ticks_left();
if (!beneficiary || beneficiary->state() != Thread::Runnable || ticks_left <= 1)
return Scheduler::yield();

2
Kernel/Syscalls/alarm.cpp
View file

@ -49,7 +49,7 @@ unsigned Process::sys$alarm(unsigned seconds)
auto deadline = TimeManagement::the().current_time(CLOCK_REALTIME).value();
timespec_add(deadline, { seconds, 0 }, deadline);
m_alarm_timer = TimerQueue::the().add_timer_without_id(CLOCK_REALTIME, deadline, [this]() {
(void)send_signal(SIGALRM, nullptr);
[[maybe_unused]] auto rc = send_signal(SIGALRM, nullptr);
});
}
return previous_alarm_remaining;

2
Kernel/Syscalls/execve.cpp
View file

@ -371,7 +371,7 @@ int Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Ve
new_main_thread->set_state(Thread::State::Runnable);
}
u32 lock_count_to_restore;
(void)big_lock().force_unlock_if_locked(lock_count_to_restore);
[[maybe_unused]] auto rc = big_lock().force_unlock_if_locked(lock_count_to_restore);
ASSERT_INTERRUPTS_DISABLED();
ASSERT(Processor::current().in_critical());
return 0;

8
Kernel/TTY/TTY.cpp
View file

@ -57,7 +57,7 @@ KResultOr<size_t> TTY::read(FileDescription&, size_t, UserOrKernelBuffer& buffer
{
if (Process::current()->pgid() != pgid()) {
// FIXME: Should we propagate this error path somehow?
(void)Process::current()->send_signal(SIGTTIN, nullptr);
[[maybe_unused]] auto rc = Process::current()->send_signal(SIGTTIN, nullptr);
return KResult(-EINTR);
}
@ -104,7 +104,7 @@ KResultOr<size_t> TTY::read(FileDescription&, size_t, UserOrKernelBuffer& buffer
KResultOr<size_t> TTY::write(FileDescription&, size_t, const UserOrKernelBuffer& buffer, size_t size)
{
if (Process::current()->pgid() != pgid()) {
(void)Process::current()->send_signal(SIGTTOU, nullptr);
[[maybe_unused]] auto rc = Process::current()->send_signal(SIGTTOU, nullptr);
return KResult(-EINTR);
}
@ -172,7 +172,7 @@ void TTY::emit(u8 ch, bool do_evaluate_block_conditions)
dbg() << tty_name() << ": VSUSP pressed!";
generate_signal(SIGTSTP);
if (auto original_process_parent = m_original_process_parent.strong_ref())
(void)original_process_parent->send_signal(SIGCHLD, nullptr);
[[maybe_unused]] auto rc = original_process_parent->send_signal(SIGCHLD, nullptr);
// TODO: Else send it to the session leader maybe?
return;
}
@ -288,7 +288,7 @@ void TTY::generate_signal(int signal)
Process::for_each_in_pgrp(pgid(), [&](auto& process) {
dbg() << tty_name() << ": Send signal " << signal << " to " << process;
// FIXME: Should this error be propagated somehow?
(void)process.send_signal(signal, nullptr);
[[maybe_unused]] auto rc = process.send_signal(signal, nullptr);
return IterationDecision::Continue;
});
}

4
Kernel/Thread.cpp
View file

@ -213,7 +213,7 @@ void Thread::die_if_needed()
return;
u32 unlock_count;
(void)unlock_process_if_locked(unlock_count);
[[maybe_unused]] auto rc = unlock_process_if_locked(unlock_count);
ScopedCritical critical;
set_should_die();
@ -240,7 +240,7 @@ void Thread::exit(void* exit_value)
m_join_condition.thread_did_exit(exit_value);
set_should_die();
u32 unlock_count;
(void)unlock_process_if_locked(unlock_count);
[[maybe_unused]] auto rc = unlock_process_if_locked(unlock_count);
die_if_needed();
}

9
Kernel/Time/APICTimer.cpp
View file

@ -165,21 +165,18 @@ void APICTimer::reset_to_default_ticks_per_second()
{
}
bool APICTimer::try_to_set_frequency(size_t frequency)
bool APICTimer::try_to_set_frequency([[maybe_unused]] size_t frequency)
{
(void)frequency;
return true;
}
bool APICTimer::is_capable_of_frequency(size_t frequency) const
bool APICTimer::is_capable_of_frequency([[maybe_unused]] size_t frequency) const
{
(void)frequency;
return false;
}
size_t APICTimer::calculate_nearest_possible_frequency(size_t frequency) const
size_t APICTimer::calculate_nearest_possible_frequency([[maybe_unused]] size_t frequency) const
{
(void)frequency;
return 0;
}

4
Kernel/VM/InodeVMObject.cpp
View file

@ -89,10 +89,8 @@ void InodeVMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new
});
}
void InodeVMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t size, const UserOrKernelBuffer& data)
void InodeVMObject::inode_contents_changed(Badge<Inode>, off_t offset, [[maybe_unused]] ssize_t size, [[maybe_unused]] const UserOrKernelBuffer& data)
{
(void)size;
(void)data;
InterruptDisabler disabler;
ASSERT(offset >= 0);