beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-30 00:31:14 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Kernel: Resolve clang-tidy readability-implicit-bool-conversion warnings

Browse source 
... In files included from Kernel/Process.cpp and Kernel/Thread.cpp
This commit is contained in:
Andrew Kaster 2021-11-06 15:06:08 -06:00 committed by Andreas Kling
parent 6f580f2047
commit a92132e44a
Notes: sideshowbarker 2024-07-18 01:07:25 +09:00 
Author: https://github.com/ADKaster
Commit: https://github.com/SerenityOS/serenity/commit/a92132e44a6
Pull-request: https://github.com/SerenityOS/serenity/pull/10737
Reviewed-by: https://github.com/BenWiederhake
Reviewed-by: https://github.com/PeterBindels-TomTom
Reviewed-by: https://github.com/awesomekling
Reviewed-by: https://github.com/dascandy
Reviewed-by: https://github.com/trflynn89
17 changed files with 85 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Arch/x86/ASM_wrapper.h
View file

@ -100,7 +100,7 @@ ALWAYS_INLINE void write_gs_ptr(u32 offset, FlatPtr val)
ALWAYS_INLINE bool are_interrupts_enabled() ALWAYS_INLINE bool are_interrupts_enabled()
{ {
return cpu_flags() & 0x200; return (cpu_flags() & 0x200) != 0;
} }
FlatPtr read_cr0(); FlatPtr read_cr0();

2
Kernel/Arch/x86/InterruptDisabler.h
View file

@ -24,7 +24,7 @@ public:
~InterruptDisabler() ~InterruptDisabler()
{ {
if (m_flags & 0x200) if ((m_flags & 0x200) != 0)
sti(); sti();
} }

30
Kernel/Arch/x86/PageDirectory.h
View file

@ -39,28 +39,28 @@ public:
NoExecute = 0x8000000000000000ULL, NoExecute = 0x8000000000000000ULL,
}; };
bool is_present() const { return raw() & Present; } bool is_present() const { return (raw() & Present) == Present; }
void set_present(bool b) { set_bit(Present, b); } void set_present(bool b) { set_bit(Present, b); }
bool is_user_allowed() const { return raw() & UserSupervisor; } bool is_user_allowed() const { return (raw() & UserSupervisor) == UserSupervisor; }
void set_user_allowed(bool b) { set_bit(UserSupervisor, b); } void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
bool is_huge() const { return raw() & Huge; } bool is_huge() const { return (raw() & Huge) == Huge; }
void set_huge(bool b) { set_bit(Huge, b); } void set_huge(bool b) { set_bit(Huge, b); }
bool is_writable() const { return raw() & ReadWrite; } bool is_writable() const { return (raw() & ReadWrite) == ReadWrite; }
void set_writable(bool b) { set_bit(ReadWrite, b); } void set_writable(bool b) { set_bit(ReadWrite, b); }
bool is_write_through() const { return raw() & WriteThrough; } bool is_write_through() const { return (raw() & WriteThrough) == WriteThrough; }
void set_write_through(bool b) { set_bit(WriteThrough, b); } void set_write_through(bool b) { set_bit(WriteThrough, b); }
bool is_cache_disabled() const { return raw() & CacheDisabled; } bool is_cache_disabled() const { return (raw() & CacheDisabled) == CacheDisabled; }
void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); } void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); }
bool is_global() const { return raw() & Global; } bool is_global() const { return (raw() & Global) == Global; }
void set_global(bool b) { set_bit(Global, b); } void set_global(bool b) { set_bit(Global, b); }
bool is_execute_disabled() const { return raw() & NoExecute; } bool is_execute_disabled() const { return (raw() & NoExecute) == NoExecute; }
void set_execute_disabled(bool b) { set_bit(NoExecute, b); } void set_execute_disabled(bool b) { set_bit(NoExecute, b); }
void set_bit(u64 bit, bool value) void set_bit(u64 bit, bool value)
@ -96,25 +96,25 @@ public:
NoExecute = 0x8000000000000000ULL, NoExecute = 0x8000000000000000ULL,
}; };
bool is_present() const { return raw() & Present; } bool is_present() const { return (raw() & Present) == Present; }
void set_present(bool b) { set_bit(Present, b); } void set_present(bool b) { set_bit(Present, b); }
bool is_user_allowed() const { return raw() & UserSupervisor; } bool is_user_allowed() const { return (raw() & UserSupervisor) == UserSupervisor; }
void set_user_allowed(bool b) { set_bit(UserSupervisor, b); } void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
bool is_writable() const { return raw() & ReadWrite; } bool is_writable() const { return (raw() & ReadWrite) == ReadWrite; }
void set_writable(bool b) { set_bit(ReadWrite, b); } void set_writable(bool b) { set_bit(ReadWrite, b); }
bool is_write_through() const { return raw() & WriteThrough; } bool is_write_through() const { return (raw() & WriteThrough) == WriteThrough; }
void set_write_through(bool b) { set_bit(WriteThrough, b); } void set_write_through(bool b) { set_bit(WriteThrough, b); }
bool is_cache_disabled() const { return raw() & CacheDisabled; } bool is_cache_disabled() const { return (raw() & CacheDisabled) == CacheDisabled; }
void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); } void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); }
bool is_global() const { return raw() & Global; } bool is_global() const { return (raw() & Global) == Global; }
void set_global(bool b) { set_bit(Global, b); } void set_global(bool b) { set_bit(Global, b); }
bool is_execute_disabled() const { return raw() & NoExecute; } bool is_execute_disabled() const { return (raw() & NoExecute) == NoExecute; }
void set_execute_disabled(bool b) { set_bit(NoExecute, b); } void set_execute_disabled(bool b) { set_bit(NoExecute, b); }
bool is_null() const { return m_raw == 0; } bool is_null() const { return m_raw == 0; }

6
Kernel/Arch/x86/Processor.h
View file

@ -304,12 +304,12 @@ private:
{ {
VERIFY(m_in_critical > 0); VERIFY(m_in_critical > 0);
if (m_in_critical == 1) { if (m_in_critical == 1) {
if (!m_in_irq) { if (m_in_irq == 0) {
deferred_call_execute_pending(); deferred_call_execute_pending();
VERIFY(m_in_critical == 1); VERIFY(m_in_critical == 1);
} }
m_in_critical = 0; m_in_critical = 0;
if (!m_in_irq) if (m_in_irq == 0)
check_invoke_scheduler(); check_invoke_scheduler();
} else { } else {
m_in_critical = m_in_critical - 1; m_in_critical = m_in_critical - 1;
@ -327,7 +327,7 @@ public:
auto prev_critical = in_critical(); auto prev_critical = in_critical();
write_gs_ptr(__builtin_offsetof(Processor, m_in_critical), 0); write_gs_ptr(__builtin_offsetof(Processor, m_in_critical), 0);
auto& proc = current(); auto& proc = current();
if (!proc.m_in_irq) if (proc.m_in_irq == 0)
proc.check_invoke_scheduler(); proc.check_invoke_scheduler();
return prev_critical; return prev_critical;
} }

4
Kernel/Arch/x86/Spinlock.h
View file

@ -39,7 +39,7 @@ public:
VERIFY(is_locked()); VERIFY(is_locked());
track_lock_release(m_rank); track_lock_release(m_rank);
m_lock.store(0, AK::memory_order_release); m_lock.store(0, AK::memory_order_release);
if (prev_flags & 0x200) if ((prev_flags & 0x200) != 0)
sti(); sti();
else else
cli(); cli();
@ -101,7 +101,7 @@ public:
track_lock_release(m_rank); track_lock_release(m_rank);
m_lock.store(0, AK::memory_order_release); m_lock.store(0, AK::memory_order_release);
} }
if (prev_flags & 0x200) if ((prev_flags & 0x200) != 0)
sti(); sti();
else else
cli(); cli();

2
Kernel/FileSystem/File.h
View file

@ -124,7 +124,7 @@ protected:
void evaluate_block_conditions() void evaluate_block_conditions()
{ {
if (Processor::current_in_irq()) { if (Processor::current_in_irq() != 0) {
// If called from an IRQ handler we need to delay evaluation // If called from an IRQ handler we need to delay evaluation
// and unblocking of waiting threads. Note that this File // and unblocking of waiting threads. Note that this File
// instance may be deleted until the deferred call is executed! // instance may be deleted until the deferred call is executed!

24
Kernel/FileSystem/InodeMetadata.h
View file

@ -30,9 +30,9 @@ inline bool is_regular_file(mode_t mode) { return (mode & S_IFMT) == S_IFREG; }
inline bool is_fifo(mode_t mode) { return (mode & S_IFMT) == S_IFIFO; } inline bool is_fifo(mode_t mode) { return (mode & S_IFMT) == S_IFIFO; }
inline bool is_symlink(mode_t mode) { return (mode & S_IFMT) == S_IFLNK; } inline bool is_symlink(mode_t mode) { return (mode & S_IFMT) == S_IFLNK; }
inline bool is_socket(mode_t mode) { return (mode & S_IFMT) == S_IFSOCK; } inline bool is_socket(mode_t mode) { return (mode & S_IFMT) == S_IFSOCK; }
inline bool is_sticky(mode_t mode) { return mode & S_ISVTX; } inline bool is_sticky(mode_t mode) { return (mode & S_ISVTX) == S_ISVTX; }
inline bool is_setuid(mode_t mode) { return mode & S_ISUID; } inline bool is_setuid(mode_t mode) { return (mode & S_ISUID) == S_ISUID; }
inline bool is_setgid(mode_t mode) { return mode & S_ISGID; } inline bool is_setgid(mode_t mode) { return (mode & S_ISGID) == S_ISGID; }
struct InodeMetadata { struct InodeMetadata {
bool is_valid() const { return inode.is_valid(); } bool is_valid() const { return inode.is_valid(); }
@ -46,10 +46,10 @@ struct InodeMetadata {
if (u == 0) if (u == 0)
return true; return true;
if (uid == u) if (uid == u)
return mode & S_IRUSR; return (mode & S_IRUSR) == S_IRUSR;
if (gid == g || eg.contains_slow(gid)) if (gid == g || eg.contains_slow(gid))
return mode & S_IRGRP; return (mode & S_IRGRP) == S_IRGRP;
return mode & S_IROTH; return (mode & S_IROTH) == S_IROTH;
} }
bool may_write(UserID u, GroupID g, Span<GroupID const> eg) const bool may_write(UserID u, GroupID g, Span<GroupID const> eg) const
@ -57,10 +57,10 @@ struct InodeMetadata {
if (u == 0) if (u == 0)
return true; return true;
if (uid == u) if (uid == u)
return mode & S_IWUSR; return (mode & S_IWUSR) == S_IWUSR;
if (gid == g || eg.contains_slow(gid)) if (gid == g || eg.contains_slow(gid))
return mode & S_IWGRP; return (mode & S_IWGRP) == S_IWGRP;
return mode & S_IWOTH; return (mode & S_IWOTH) == S_IWOTH;
} }
bool may_execute(UserID u, GroupID g, Span<GroupID const> eg) const bool may_execute(UserID u, GroupID g, Span<GroupID const> eg) const
@ -68,10 +68,10 @@ struct InodeMetadata {
if (u == 0) if (u == 0)
return true; return true;
if (uid == u) if (uid == u)
return mode & S_IXUSR; return (mode & S_IXUSR) == S_IXUSR;
if (gid == g || eg.contains_slow(gid)) if (gid == g || eg.contains_slow(gid))
return mode & S_IXGRP; return (mode & S_IXGRP) == S_IXGRP;
return mode & S_IXOTH; return (mode & S_IXOTH) == S_IXOTH;
} }
bool is_directory() const { return Kernel::is_directory(mode); } bool is_directory() const { return Kernel::is_directory(mode); }

4
Kernel/FileSystem/OpenFileDescription.h
View file

@ -40,8 +40,8 @@ public:
void set_rw_mode(int options) void set_rw_mode(int options)
{ {
set_readable(options & O_RDONLY); set_readable((options & O_RDONLY) == O_RDONLY);
set_writable(options & O_WRONLY); set_writable((options & O_WRONLY) == O_WRONLY);
} }
ErrorOr<void> close(); ErrorOr<void> close();

14
Kernel/Library/ThreadSafeRefPtr.h
View file

@ -35,7 +35,7 @@ struct RefPtrTraits {
ALWAYS_INLINE static FlatPtr as_bits(T* ptr) ALWAYS_INLINE static FlatPtr as_bits(T* ptr)
{ {
VERIFY(!((FlatPtr)ptr & 1)); VERIFY(((FlatPtr)ptr & 1) == 0);
return (FlatPtr)ptr; return (FlatPtr)ptr;
} }
@ -49,13 +49,13 @@ struct RefPtrTraits {
ALWAYS_INLINE static bool is_null(FlatPtr bits) ALWAYS_INLINE static bool is_null(FlatPtr bits)
{ {
return !(bits & ~(FlatPtr)1); return (bits & ~(FlatPtr)1) == 0;
} }
ALWAYS_INLINE static FlatPtr exchange(Atomic<FlatPtr>& atomic_var, FlatPtr new_value) ALWAYS_INLINE static FlatPtr exchange(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
{ {
// Only exchange when lock is not held // Only exchange when lock is not held
VERIFY(!(new_value & 1)); VERIFY((new_value & 1) == 0);
FlatPtr expected = atomic_var.load(AK::MemoryOrder::memory_order_relaxed); FlatPtr expected = atomic_var.load(AK::MemoryOrder::memory_order_relaxed);
for (;;) { for (;;) {
expected &= ~(FlatPtr)1; // only if lock bit is not set expected &= ~(FlatPtr)1; // only if lock bit is not set
@ -71,7 +71,7 @@ struct RefPtrTraits {
ALWAYS_INLINE static bool exchange_if_null(Atomic<FlatPtr>& atomic_var, FlatPtr new_value) ALWAYS_INLINE static bool exchange_if_null(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
{ {
// Only exchange when lock is not held // Only exchange when lock is not held
VERIFY(!(new_value & 1)); VERIFY((new_value & 1) == 0);
for (;;) { for (;;) {
FlatPtr expected = default_null_value; // only if lock bit is not set FlatPtr expected = default_null_value; // only if lock bit is not set
if (atomic_var.compare_exchange_strong(expected, new_value, AK::MemoryOrder::memory_order_acq_rel)) if (atomic_var.compare_exchange_strong(expected, new_value, AK::MemoryOrder::memory_order_acq_rel))
@ -95,19 +95,19 @@ struct RefPtrTraits {
FlatPtr bits; FlatPtr bits;
for (;;) { for (;;) {
bits = atomic_var.fetch_or(1, AK::MemoryOrder::memory_order_acq_rel); bits = atomic_var.fetch_or(1, AK::MemoryOrder::memory_order_acq_rel);
if (!(bits & 1)) if ((bits & 1) == 0)
break; break;
#ifdef KERNEL #ifdef KERNEL
Kernel::Processor::wait_check(); Kernel::Processor::wait_check();
#endif #endif
} }
VERIFY(!(bits & 1)); VERIFY((bits & 1) == 0);
return bits; return bits;
} }
ALWAYS_INLINE static void unlock(Atomic<FlatPtr>& atomic_var, FlatPtr new_value) ALWAYS_INLINE static void unlock(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
{ {
VERIFY(!(new_value & 1)); VERIFY((new_value & 1) == 0);
atomic_var.store(new_value, AK::MemoryOrder::memory_order_release); atomic_var.store(new_value, AK::MemoryOrder::memory_order_release);
} }

2
Kernel/Memory/PhysicalZone.h
View file

@ -33,7 +33,7 @@ public:
void dump() const; void dump() const;
size_t available() const { return m_page_count - (m_used_chunks / 2); } size_t available() const { return m_page_count - (m_used_chunks / 2); }
bool is_empty() const { return !available(); } bool is_empty() const { return available() == 0; }
PhysicalAddress base() const { return m_base_address; } PhysicalAddress base() const { return m_base_address; }
bool contains(PhysicalAddress paddr) const bool contains(PhysicalAddress paddr) const

28
Kernel/Memory/Region.h
View file

@ -57,13 +57,13 @@ public:
[[nodiscard]] VirtualRange const& range() const { return m_range; } [[nodiscard]] VirtualRange const& range() const { return m_range; }
[[nodiscard]] VirtualAddress vaddr() const { return m_range.base(); } [[nodiscard]] VirtualAddress vaddr() const { return m_range.base(); }
[[nodiscard]] size_t size() const { return m_range.size(); } [[nodiscard]] size_t size() const { return m_range.size(); }
[[nodiscard]] bool is_readable() const { return m_access & Access::Read; } [[nodiscard]] bool is_readable() const { return (m_access & Access::Read) == Access::Read; }
[[nodiscard]] bool is_writable() const { return m_access & Access::Write; } [[nodiscard]] bool is_writable() const { return (m_access & Access::Write) == Access::Write; }
[[nodiscard]] bool is_executable() const { return m_access & Access::Execute; } [[nodiscard]] bool is_executable() const { return (m_access & Access::Execute) == Access::Execute; }
[[nodiscard]] bool has_been_readable() const { return m_access & Access::HasBeenReadable; } [[nodiscard]] bool has_been_readable() const { return (m_access & Access::HasBeenReadable) == Access::HasBeenReadable; }
[[nodiscard]] bool has_been_writable() const { return m_access & Access::HasBeenWritable; } [[nodiscard]] bool has_been_writable() const { return (m_access & Access::HasBeenWritable) == Access::HasBeenWritable; }
[[nodiscard]] bool has_been_executable() const { return m_access & Access::HasBeenExecutable; } [[nodiscard]] bool has_been_executable() const { return (m_access & Access::HasBeenExecutable) == Access::HasBeenExecutable; }
[[nodiscard]] bool is_cacheable() const { return m_cacheable; } [[nodiscard]] bool is_cacheable() const { return m_cacheable; }
[[nodiscard]] StringView name() const { return m_name ? m_name->view() : StringView {}; } [[nodiscard]] StringView name() const { return m_name ? m_name->view() : StringView {}; }
@ -223,26 +223,26 @@ public:
AK_ENUM_BITWISE_OPERATORS(Region::Access) AK_ENUM_BITWISE_OPERATORS(Region::Access)
inline Region::Access prot_to_region_access_flags(int prot) inline constexpr Region::Access prot_to_region_access_flags(int prot)
{ {
Region::Access access = Region::Access::None; Region::Access access = Region::Access::None;
if (prot & PROT_READ) if ((prot & PROT_READ) == PROT_READ)
access |= Region::Access::Read; access |= Region::Access::Read;
if (prot & PROT_WRITE) if ((prot & PROT_WRITE) == PROT_WRITE)
access |= Region::Access::Write; access |= Region::Access::Write;
if (prot & PROT_EXEC) if ((prot & PROT_EXEC) == PROT_EXEC)
access |= Region::Access::Execute; access |= Region::Access::Execute;
return access; return access;
} }
inline int region_access_flags_to_prot(Region::Access access) inline constexpr int region_access_flags_to_prot(Region::Access access)
{ {
int prot = 0; int prot = 0;
if (access & Region::Access::Read) if ((access & Region::Access::Read) == Region::Access::Read)
prot |= PROT_READ; prot |= PROT_READ;
if (access & Region::Access::Write) if ((access & Region::Access::Write) == Region::Access::Write)
prot |= PROT_WRITE; prot |= PROT_WRITE;
if (access & Region::Access::Execute) if ((access & Region::Access::Execute) == Region::Access::Execute)
prot |= PROT_EXEC; prot |= PROT_EXEC;
return prot; return prot;
} }

4
Kernel/Process.cpp
View file

@ -509,7 +509,7 @@ siginfo_t Process::wait_info()
siginfo.si_pid = pid().value(); siginfo.si_pid = pid().value();
siginfo.si_uid = uid().value(); siginfo.si_uid = uid().value();
if (m_protected_values.termination_signal) { if (m_protected_values.termination_signal != 0) {
siginfo.si_status = m_protected_values.termination_signal; siginfo.si_status = m_protected_values.termination_signal;
siginfo.si_code = CLD_KILLED; siginfo.si_code = CLD_KILLED;
} else { } else {
@ -633,7 +633,7 @@ void Process::finalize()
{ {
// FIXME: PID/TID BUG // FIXME: PID/TID BUG
if (auto parent_thread = Thread::from_tid(ppid().value())) { if (auto parent_thread = Thread::from_tid(ppid().value())) {
if (!(parent_thread->m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT)) if ((parent_thread->m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT) != SA_NOCLDWAIT)
parent_thread->send_signal(SIGCHLD, this); parent_thread->send_signal(SIGCHLD, this);
} }
} }

4
Kernel/Process.h
View file

@ -155,7 +155,7 @@ public:
inline static bool has_current() inline static bool has_current()
{ {
return Processor::current_thread(); return Processor::current_thread() != nullptr;
} }
template<typename EntryFunction> template<typename EntryFunction>
@ -459,7 +459,7 @@ public:
Mutex& ptrace_lock() { return m_ptrace_lock; } Mutex& ptrace_lock() { return m_ptrace_lock; }
bool has_promises() const { return m_protected_values.has_promises; } bool has_promises() const { return m_protected_values.has_promises; }
bool has_promised(Pledge pledge) const { return m_protected_values.promises & (1u << (u32)pledge); } bool has_promised(Pledge pledge) const { return (m_protected_values.promises & (1U << (u32)pledge)) != 0; }
VeilState veil_state() const VeilState veil_state() const
{ {

8
Kernel/TTY/TTY.h
View file

@ -41,10 +41,10 @@ public:
} }
ErrorOr<void> set_termios(const termios&); ErrorOr<void> set_termios(const termios&);
bool should_generate_signals() const { return m_termios.c_lflag & ISIG; } bool should_generate_signals() const { return (m_termios.c_lflag & ISIG) == ISIG; }
bool should_flush_on_signal() const { return !(m_termios.c_lflag & NOFLSH); } bool should_flush_on_signal() const { return (m_termios.c_lflag & NOFLSH) != NOFLSH; }
bool should_echo_input() const { return m_termios.c_lflag & ECHO; } bool should_echo_input() const { return (m_termios.c_lflag & ECHO) == ECHO; }
bool in_canonical_mode() const { return m_termios.c_lflag & ICANON; } bool in_canonical_mode() const { return (m_termios.c_lflag & ICANON) == ICANON; }
void set_default_termios(); void set_default_termios();
void hang_up(); void hang_up();

31
Kernel/Thread.cpp
View file

@ -246,7 +246,7 @@ u32 Thread::unblock_from_lock(Kernel::Mutex& lock)
VERIFY(m_state != Thread::Runnable && m_state != Thread::Running); VERIFY(m_state != Thread::Runnable && m_state != Thread::Running);
set_state(Thread::Runnable); set_state(Thread::Runnable);
}; };
if (Processor::current_in_irq()) { if (Processor::current_in_irq() != 0) {
Processor::deferred_call_queue([do_unblock = move(do_unblock), self = make_weak_ptr()]() { Processor::deferred_call_queue([do_unblock = move(do_unblock), self = make_weak_ptr()]() {
if (auto this_thread = self.strong_ref()) if (auto this_thread = self.strong_ref())
do_unblock(); do_unblock();
@ -267,7 +267,7 @@ void Thread::unblock_from_blocker(Blocker& blocker)
if (!should_be_stopped() && !is_stopped()) if (!should_be_stopped() && !is_stopped())
unblock(); unblock();
}; };
if (Processor::current_in_irq()) { if (Processor::current_in_irq() != 0) {
Processor::deferred_call_queue([do_unblock = move(do_unblock), self = make_weak_ptr()]() { Processor::deferred_call_queue([do_unblock = move(do_unblock), self = make_weak_ptr()]() {
if (auto this_thread = self.strong_ref()) if (auto this_thread = self.strong_ref())
do_unblock(); do_unblock();
@ -580,7 +580,8 @@ bool Thread::tick()
++m_process->m_ticks_in_user; ++m_process->m_ticks_in_user;
++m_ticks_in_user; ++m_ticks_in_user;
} }
return --m_ticks_left; --m_ticks_left;
return m_ticks_left != 0;
} }
void Thread::check_dispatch_pending_signal() void Thread::check_dispatch_pending_signal()
@ -588,7 +589,7 @@ void Thread::check_dispatch_pending_signal()
auto result = DispatchSignalResult::Continue; auto result = DispatchSignalResult::Continue;
{ {
SpinlockLocker scheduler_lock(g_scheduler_lock); SpinlockLocker scheduler_lock(g_scheduler_lock);
if (pending_signals_for_state()) { if (pending_signals_for_state() != 0) {
SpinlockLocker lock(m_lock); SpinlockLocker lock(m_lock);
result = dispatch_one_pending_signal(); result = dispatch_one_pending_signal();
} }
@ -633,11 +634,11 @@ void Thread::send_signal(u8 signal, [[maybe_unused]] Process* sender)
} }
m_pending_signals |= 1 << (signal - 1); m_pending_signals |= 1 << (signal - 1);
m_have_any_unmasked_pending_signals.store(pending_signals_for_state() & ~m_signal_mask, AK::memory_order_release); m_have_any_unmasked_pending_signals.store((pending_signals_for_state() & ~m_signal_mask) != 0, AK::memory_order_release);
if (m_state == Stopped) { if (m_state == Stopped) {
SpinlockLocker lock(m_lock); SpinlockLocker lock(m_lock);
if (pending_signals_for_state()) { if (pending_signals_for_state() != 0) {
dbgln_if(SIGNAL_DEBUG, "Signal: Resuming stopped {} to deliver signal {}", *this, signal); dbgln_if(SIGNAL_DEBUG, "Signal: Resuming stopped {} to deliver signal {}", *this, signal);
resume_from_stopped(); resume_from_stopped();
} }
@ -653,7 +654,7 @@ u32 Thread::update_signal_mask(u32 signal_mask)
SpinlockLocker lock(g_scheduler_lock); SpinlockLocker lock(g_scheduler_lock);
auto previous_signal_mask = m_signal_mask; auto previous_signal_mask = m_signal_mask;
m_signal_mask = signal_mask; m_signal_mask = signal_mask;
m_have_any_unmasked_pending_signals.store(pending_signals_for_state() & ~m_signal_mask, AK::memory_order_release); m_have_any_unmasked_pending_signals.store((pending_signals_for_state() & ~m_signal_mask) != 0, AK::memory_order_release);
return previous_signal_mask; return previous_signal_mask;
} }
@ -671,7 +672,7 @@ u32 Thread::signal_mask_block(sigset_t signal_set, bool block)
m_signal_mask &= ~signal_set; m_signal_mask &= ~signal_set;
else else
m_signal_mask |= signal_set; m_signal_mask |= signal_set;
m_have_any_unmasked_pending_signals.store(pending_signals_for_state() & ~m_signal_mask, AK::memory_order_release); m_have_any_unmasked_pending_signals.store((pending_signals_for_state() & ~m_signal_mask) != 0, AK::memory_order_release);
return previous_signal_mask; return previous_signal_mask;
} }
@ -711,7 +712,7 @@ DispatchSignalResult Thread::dispatch_one_pending_signal()
u8 signal = 1; u8 signal = 1;
for (; signal < 32; ++signal) { for (; signal < 32; ++signal) {
if (signal_candidates & (1 << (signal - 1))) { if ((signal_candidates & (1 << (signal - 1))) != 0) {
break; break;
} }
} }
@ -724,7 +725,7 @@ DispatchSignalResult Thread::try_dispatch_one_pending_signal(u8 signal)
SpinlockLocker scheduler_lock(g_scheduler_lock); SpinlockLocker scheduler_lock(g_scheduler_lock);
SpinlockLocker lock(m_lock); SpinlockLocker lock(m_lock);
u32 signal_candidates = pending_signals_for_state() & ~m_signal_mask; u32 signal_candidates = pending_signals_for_state() & ~m_signal_mask;
if (!(signal_candidates & (1 << (signal - 1)))) if ((signal_candidates & (1 << (signal - 1))) == 0)
return DispatchSignalResult::Continue; return DispatchSignalResult::Continue;
return dispatch_signal(signal); return dispatch_signal(signal);
} }
@ -853,7 +854,7 @@ DispatchSignalResult Thread::dispatch_signal(u8 signal)
// Mark this signal as handled. // Mark this signal as handled.
m_pending_signals &= ~(1 << (signal - 1)); m_pending_signals &= ~(1 << (signal - 1));
m_have_any_unmasked_pending_signals.store(m_pending_signals & ~m_signal_mask, AK::memory_order_release); m_have_any_unmasked_pending_signals.store((m_pending_signals & ~m_signal_mask) != 0, AK::memory_order_release);
auto& process = this->process(); auto& process = this->process();
auto tracer = process.tracer(); auto tracer = process.tracer();
@ -914,13 +915,13 @@ DispatchSignalResult Thread::dispatch_signal(u8 signal)
u32 old_signal_mask = m_signal_mask; u32 old_signal_mask = m_signal_mask;
u32 new_signal_mask = action.mask; u32 new_signal_mask = action.mask;
if (action.flags & SA_NODEFER) if ((action.flags & SA_NODEFER) == SA_NODEFER)
new_signal_mask &= ~(1 << (signal - 1)); new_signal_mask &= ~(1 << (signal - 1));
else else
new_signal_mask |= 1 << (signal - 1); new_signal_mask |= 1 << (signal - 1);
m_signal_mask |= new_signal_mask; m_signal_mask |= new_signal_mask;
m_have_any_unmasked_pending_signals.store(m_pending_signals & ~m_signal_mask, AK::memory_order_release); m_have_any_unmasked_pending_signals.store((m_pending_signals & ~m_signal_mask) != 0, AK::memory_order_release);
auto setup_stack = [&](RegisterState& state) { auto setup_stack = [&](RegisterState& state) {
FlatPtr stack = state.userspace_sp(); FlatPtr stack = state.userspace_sp();
@ -1121,7 +1122,7 @@ struct RecognizedSymbol {
static bool symbolicate(RecognizedSymbol const& symbol, Process& process, StringBuilder& builder) static bool symbolicate(RecognizedSymbol const& symbol, Process& process, StringBuilder& builder)
{ {
if (!symbol.address) if (symbol.address == 0)
return false; return false;
bool mask_kernel_addresses = !process.is_superuser(); bool mask_kernel_addresses = !process.is_superuser();
@ -1201,7 +1202,7 @@ ErrorOr<void> Thread::make_thread_specific_region(Badge<Process>)
m_thread_specific_data = VirtualAddress(thread_specific_data); m_thread_specific_data = VirtualAddress(thread_specific_data);
thread_specific_data->self = thread_specific_data; thread_specific_data->self = thread_specific_data;
if (process().m_master_tls_size) if (process().m_master_tls_size != 0)
memcpy(thread_local_storage, process().m_master_tls_region.unsafe_ptr()->vaddr().as_ptr(), process().m_master_tls_size); memcpy(thread_local_storage, process().m_master_tls_region.unsafe_ptr()->vaddr().as_ptr(), process().m_master_tls_size);
return {}; return {};

2
Kernel/Thread.h
View file

@ -714,7 +714,7 @@ public:
virtual bool setup_blocker() override; virtual bool setup_blocker() override;
bool unblock(Process& process, UnblockFlags flags, u8 signal, bool from_add_blocker); bool unblock(Process& process, UnblockFlags flags, u8 signal, bool from_add_blocker);
bool is_wait() const { return !(m_wait_options & WNOWAIT); } bool is_wait() const { return (m_wait_options & WNOWAIT) != WNOWAIT; }
private: private:
void do_was_disowned(); void do_was_disowned();

2
Kernel/ThreadTracer.h
View file

@ -18,7 +18,7 @@ public:
static ErrorOr<NonnullOwnPtr<ThreadTracer>> try_create(ProcessID tracer) { return adopt_nonnull_own_or_enomem(new (nothrow) ThreadTracer(tracer)); } static ErrorOr<NonnullOwnPtr<ThreadTracer>> try_create(ProcessID tracer) { return adopt_nonnull_own_or_enomem(new (nothrow) ThreadTracer(tracer)); }
ProcessID tracer_pid() const { return m_tracer_pid; } ProcessID tracer_pid() const { return m_tracer_pid; }
bool has_pending_signal(u32 signal) const { return m_pending_signals & (1 << (signal - 1)); } bool has_pending_signal(u32 signal) const { return (m_pending_signals & (1 << (signal - 1))) != 0; }
void set_signal(u32 signal) { m_pending_signals |= (1 << (signal - 1)); } void set_signal(u32 signal) { m_pending_signals |= (1 << (signal - 1)); }
void unset_signal(u32 signal) { m_pending_signals &= ~(1 << (signal - 1)); } void unset_signal(u32 signal) { m_pending_signals &= ~(1 << (signal - 1)); }