Kernel/KCOV: Bring closer to typical SerenityOS coding style

- Remove a bunch of redundant `this->`
- Make class data members private and provide accessors instead

3 files changed, 43 insertions, 38 deletions

diff --git a/Kernel/Devices/KCOVDevice.cpp b/Kernel/Devices/KCOVDevice.cpp
index 4bc5161c45..82d433bda2 100644
--- a/Kernel/Devices/KCOVDevice.cpp
+++ b/Kernel/Devices/KCOVDevice.cpp
@@ -41,8 +41,8 @@ void KCOVDevice::free_thread()
         return;
 
     auto kcov_instance = maybe_kcov_instance.value();
-    VERIFY(kcov_instance->state == KCOVInstance::TRACING);
-    kcov_instance->state = KCOVInstance::OPENED;
+    VERIFY(kcov_instance->state() == KCOVInstance::TRACING);
+    kcov_instance->set_state(KCOVInstance::OPENED);
     thread_instance->remove(tid);
 }
 
@@ -55,8 +55,8 @@ void KCOVDevice::free_process()
         return;
 
     auto kcov_instance = maybe_kcov_instance.value();
-    VERIFY(kcov_instance->state == KCOVInstance::OPENED);
-    kcov_instance->state = KCOVInstance::UNUSED;
+    VERIFY(kcov_instance->state() == KCOVInstance::OPENED);
+    kcov_instance->set_state(KCOVInstance::UNUSED);
     proc_instance->remove(pid);
     delete kcov_instance;
 }
@@ -67,7 +67,7 @@ KResultOr<NonnullRefPtr<FileDescription>> KCOVDevice::open(int options)
     if (proc_instance->get(pid).has_value())
         return EBUSY; // This process already open()ed the kcov device
     auto kcov_instance = new KCOVInstance(pid);
-    kcov_instance->state = KCOVInstance::OPENED;
+    kcov_instance->set_state(KCOVInstance::OPENED);
     proc_instance->set(pid, kcov_instance);
 
     return File::open(options);
@@ -84,10 +84,10 @@ KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> a
         return ENXIO; // This proc hasn't opened the kcov dev yet
     auto kcov_instance = maybe_kcov_instance.value();
 
-    SpinlockLocker lock(kcov_instance->lock);
+    SpinlockLocker locker(kcov_instance->spinlock());
     switch (request) {
     case KCOV_SETBUFSIZE: {
-        if (kcov_instance->state >= KCOVInstance::TRACING) {
+        if (kcov_instance->state() >= KCOVInstance::TRACING) {
             return_value = EBUSY;
             break;
         }
@@ -95,7 +95,7 @@ KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> a
         break;
     }
     case KCOV_ENABLE: {
-        if (kcov_instance->state >= KCOVInstance::TRACING) {
+        if (kcov_instance->state() >= KCOVInstance::TRACING) {
             return_value = EBUSY;
             break;
         }
@@ -103,8 +103,8 @@ KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> a
             return_value = ENOBUFS;
             break;
         }
-        VERIFY(kcov_instance->state == KCOVInstance::OPENED);
-        kcov_instance->state = KCOVInstance::TRACING;
+        VERIFY(kcov_instance->state() == KCOVInstance::OPENED);
+        kcov_instance->set_state(KCOVInstance::TRACING);
         thread_instance->set(tid, kcov_instance);
         break;
     }
@@ -114,8 +114,8 @@ KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> a
             return_value = ENOENT;
             break;
         }
-        VERIFY(kcov_instance->state == KCOVInstance::TRACING);
-        kcov_instance->state = KCOVInstance::OPENED;
+        VERIFY(kcov_instance->state() == KCOVInstance::TRACING);
+        kcov_instance->set_state(KCOVInstance::OPENED);
         thread_instance->remove(tid);
         break;
     }
@@ -134,12 +134,11 @@ KResultOr<Memory::Region*> KCOVDevice::mmap(Process& process, FileDescription&,
     VERIFY(maybe_kcov_instance.has_value()); // Should happen on fd open()
     auto kcov_instance = maybe_kcov_instance.value();
 
-    if (!kcov_instance->vmobject) {
-        return ENOBUFS; // Mmaped, before KCOV_SETBUFSIZE
-    }
+    if (!kcov_instance->vmobject())
+        return ENOBUFS; // mmaped, before KCOV_SETBUFSIZE
 
     return process.address_space().allocate_region_with_vmobject(
-        range, *kcov_instance->vmobject, offset, {}, prot, shared);
+        range, *kcov_instance->vmobject(), offset, {}, prot, shared);
 }
 
 String KCOVDevice::device_name() const
diff --git a/Kernel/Devices/KCOVInstance.cpp b/Kernel/Devices/KCOVInstance.cpp
index e4613b6588..a602dacc18 100644
--- a/Kernel/Devices/KCOVInstance.cpp
+++ b/Kernel/Devices/KCOVInstance.cpp
@@ -12,7 +12,6 @@ namespace Kernel {
 KCOVInstance::KCOVInstance(ProcessID pid)
 {
     m_pid = pid;
-    state = UNUSED;
 }
 
 KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
@@ -21,27 +20,27 @@ KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
         return EINVAL;
 
     // first entry contains index of last PC
-    this->m_buffer_size_in_entries = buffer_size_in_entries - 1;
-    this->m_buffer_size_in_bytes = Memory::page_round_up(buffer_size_in_entries * KCOV_ENTRY_SIZE);
+    m_buffer_size_in_entries = buffer_size_in_entries - 1;
+    m_buffer_size_in_bytes = Memory::page_round_up(buffer_size_in_entries * KCOV_ENTRY_SIZE);
 
     // one single vmobject is representing the buffer
     // - we allocate one kernel region using that vmobject
     // - when an mmap call comes in, we allocate another userspace region,
     //   backed by the same vmobject
     auto maybe_vmobject = Memory::AnonymousVMObject::try_create_with_size(
-        this->m_buffer_size_in_bytes, AllocationStrategy::AllocateNow);
+        m_buffer_size_in_bytes, AllocationStrategy::AllocateNow);
     if (maybe_vmobject.is_error())
         return maybe_vmobject.error();
-    this->vmobject = maybe_vmobject.release_value();
+    m_vmobject = maybe_vmobject.release_value();
 
-    this->m_kernel_region = MM.allocate_kernel_region_with_vmobject(
-        *this->vmobject, this->m_buffer_size_in_bytes, String::formatted("kcov_{}", this->m_pid),
+    m_kernel_region = MM.allocate_kernel_region_with_vmobject(
+        *m_vmobject, m_buffer_size_in_bytes, String::formatted("kcov_{}", m_pid),
         Memory::Region::Access::ReadWrite);
-    if (!this->m_kernel_region)
+    if (!m_kernel_region)
         return ENOMEM;
 
-    this->m_buffer = (u64*)this->m_kernel_region->vaddr().as_ptr();
-    if (!this->has_buffer())
+    m_buffer = (u64*)m_kernel_region->vaddr().as_ptr();
+    if (!has_buffer())
         return ENOMEM;
 
     return KSuccess;
@@ -49,14 +48,14 @@ KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
 
 void KCOVInstance::buffer_add_pc(u64 pc)
 {
-    auto idx = (u64)this->m_buffer[0];
-    if (idx >= this->m_buffer_size_in_entries) {
+    auto idx = (u64)m_buffer[0];
+    if (idx >= m_buffer_size_in_entries) {
         // the buffer is already full
         return;
     }
 
-    this->m_buffer[idx + 1] = pc;
-    this->m_buffer[0] = idx + 1;
+    m_buffer[idx + 1] = pc;
+    m_buffer[0] = idx + 1;
 }
 
 }
diff --git a/Kernel/Devices/KCOVInstance.h b/Kernel/Devices/KCOVInstance.h
index 8a5ecfc86b..b9099ff601 100644
--- a/Kernel/Devices/KCOVInstance.h
+++ b/Kernel/Devices/KCOVInstance.h
@@ -35,23 +35,30 @@ public:
     bool has_buffer() const { return m_buffer != nullptr; }
     void buffer_add_pc(u64 pc);
 
-    Spinlock lock;
-    enum {
+    enum State {
         UNUSED = 0,
         OPENED = 1,
         TRACING = 2,
-    } state;
+    } m_state { UNUSED };
 
-    RefPtr<Memory::AnonymousVMObject> vmobject;
+    State state() const { return m_state; }
+    void set_state(State state) { m_state = state; }
+
+    Memory::VMObject* vmobject() { return m_vmobject; }
+
+    Spinlock& spinlock() { return m_lock; }
 
 private:
-    ProcessID m_pid = { 0 };
-    u64 m_buffer_size_in_entries = { 0 };
-    size_t m_buffer_size_in_bytes = { 0 };
-    kcov_pc_t* m_buffer = { nullptr };
+    ProcessID m_pid { 0 };
+    u64 m_buffer_size_in_entries { 0 };
+    size_t m_buffer_size_in_bytes { 0 };
+    kcov_pc_t* m_buffer { nullptr };
+    RefPtr<Memory::AnonymousVMObject> m_vmobject;
 
     // Here to ensure it's not garbage collected at the end of open()
     OwnPtr<Memory::Region> m_kernel_region;
+
+    Spinlock m_lock;
 };
 
 }