Kernel: Make syscall counters and page fault counters per-thread

Now that we show individual threads in SystemMonitor and "top",
it's also very nice to have individual counters for the threads. :^)

Applications/SystemMonitor/ProcessModel.cpp

@@ -237,10 +237,10 @@ void ProcessModel::update()
  ThreadState state;
  state.pid = it.value.pid;
  state.user = it.value.username;
- state.syscall_count = it.value.syscall_count;
- state.inode_faults = it.value.inode_faults;
- state.zero_faults = it.value.zero_faults;
- state.cow_faults = it.value.cow_faults;
+ state.syscall_count = thread.syscall_count;
+ state.inode_faults = thread.inode_faults;
+ state.zero_faults = thread.zero_faults;
+ state.cow_faults = thread.cow_faults;
  state.name = it.value.name;
  state.amount_virtual = it.value.amount_virtual;
  state.amount_resident = it.value.amount_resident;

Kernel/FileSystem/ProcFS.cpp

@@ -689,10 +689,6 @@ Optional<KBuffer> procfs$all(InodeIdentifier)
  process_object.add("amount_virtual", (u32)process.amount_virtual());
  process_object.add("amount_resident", (u32)process.amount_resident());
  process_object.add("amount_shared", (u32)process.amount_shared());
- process_object.add("syscall_count", process.syscall_count());
- process_object.add("inode_faults", process.inode_faults());
- process_object.add("zero_faults", process.zero_faults());
- process_object.add("cow_faults", process.cow_faults());
  process_object.add("icon_id", process.icon_id());
  auto thread_array = process_object.add_array("threads");
  process.for_each_thread([&](const Thread& thread) {
@@ -702,6 +698,10 @@ Optional<KBuffer> procfs$all(InodeIdentifier)
  thread_object.add("ticks", thread.ticks());
  thread_object.add("state", thread.state_string());
  thread_object.add("priority", to_string(thread.priority()));
+ thread_object.add("syscall_count", thread.syscall_count());
+ thread_object.add("inode_faults", thread.inode_faults());
+ thread_object.add("zero_faults", thread.zero_faults());
+ thread_object.add("cow_faults", thread.cow_faults());
  return IterationDecision::Continue;
  });
  };

Kernel/Process.h

@@ -286,15 +286,6 @@ class Process : public InlineLinkedListNode<Process>
 
  Lock& big_lock() { return m_big_lock; }
 
- unsigned syscall_count() const { return m_syscall_count; }
- void did_syscall() { ++m_syscall_count; }
- unsigned inode_faults() const { return m_inode_faults; }
- void did_inode_fault() { ++m_inode_faults; }
- unsigned zero_faults() const { return m_zero_faults; }
- void did_zero_fault() { ++m_zero_faults; }
- unsigned cow_faults() const { return m_cow_faults; }
- void did_cow_fault() { ++m_cow_faults; }
-
  const ELFLoader* elf_loader() const { return m_elf_loader.ptr(); }
 
  int icon_id() const { return m_icon_id; }
@@ -373,11 +364,6 @@ class Process : public InlineLinkedListNode<Process>
 
  int m_next_tid { 0 };
 
- unsigned m_syscall_count { 0 };
- unsigned m_inode_faults { 0 };
- unsigned m_zero_faults { 0 };
- unsigned m_cow_faults { 0 };
-
  RefPtr<ProcessTracer> m_tracer;
  OwnPtr<ELFLoader> m_elf_loader;
 

Kernel/Syscall.cpp

@@ -60,7 +60,7 @@ int handle(RegisterDump& regs, u32 function, u32 arg1, u32 arg2, u32 arg3)
 {
  ASSERT_INTERRUPTS_ENABLED();
  auto& process = current->process();
- process.did_syscall();
+ current->did_syscall();
 
  if (function == SC_exit || function == SC_exit_thread) {
  // These syscalls need special handling since they never return to the caller.

Kernel/Thread.h

@@ -331,6 +331,15 @@ class Thread {
 
  void make_thread_specific_region(Badge<Process>);
 
+ unsigned syscall_count() const { return m_syscall_count; }
+ void did_syscall() { ++m_syscall_count; }
+ unsigned inode_faults() const { return m_inode_faults; }
+ void did_inode_fault() { ++m_inode_faults; }
+ unsigned zero_faults() const { return m_zero_faults; }
+ void did_zero_fault() { ++m_zero_faults; }
+ unsigned cow_faults() const { return m_cow_faults; }
+ void did_cow_fault() { ++m_cow_faults; }
+
  Thread* clone(Process&);
 
  template<typename Callback>
@@ -376,6 +385,11 @@ class Thread {
  Thread* m_joinee { nullptr };
  void* m_exit_value { nullptr };
 
+ unsigned m_syscall_count { 0 };
+ unsigned m_inode_faults { 0 };
+ unsigned m_zero_faults { 0 };
+ unsigned m_cow_faults { 0 };
+
  FPUState* m_fpu_state { nullptr };
  State m_state { Invalid };
  ThreadPriority m_priority { ThreadPriority::Normal };

Kernel/VM/Region.cpp

@@ -308,7 +308,7 @@ PageFaultResponse Region::handle_zero_fault(size_t page_index_in_region)
  }
 
  if (current)
- current->process().did_zero_fault();
+ current->did_zero_fault();
 
  auto physical_page = MM.allocate_user_physical_page(MemoryManager::ShouldZeroFill::Yes);
  if (physical_page.is_null()) {
@@ -338,7 +338,7 @@ PageFaultResponse Region::handle_cow_fault(size_t page_index_in_region)
  }
 
  if (current)
- current->process().did_cow_fault();
+ current->did_cow_fault();
 
 #ifdef PAGE_FAULT_DEBUG
  dbgprintf(" >> It's a COW page and it's time to COW!\n");
@@ -382,7 +382,7 @@ PageFaultResponse Region::handle_inode_fault(size_t page_index_in_region)
  }
 
  if (current)
- current->process().did_inode_fault();
+ current->did_inode_fault();
 
 #ifdef MM_DEBUG
  dbgprintf("MM: page_in_from_inode ready to read from inode\n");

Libraries/LibCore/CProcessStatisticsReader.cpp

@@ -38,10 +38,6 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
  process.amount_virtual = process_object.get("amount_virtual").to_u32();
  process.amount_resident = process_object.get("amount_resident").to_u32();
  process.amount_shared = process_object.get("amount_shared").to_u32();
- process.syscall_count = process_object.get("syscall_count").to_u32();
- process.inode_faults = process_object.get("inode_faults").to_u32();
- process.zero_faults = process_object.get("zero_faults").to_u32();
- process.cow_faults = process_object.get("cow_faults").to_u32();
  process.icon_id = process_object.get("icon_id").to_int();
 
  auto thread_array = process_object.get("threads").as_array();
@@ -53,6 +49,10 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
  thread.state = thread_object.get("state").to_string();
  thread.ticks = thread_object.get("ticks").to_u32();
  thread.priority = thread_object.get("priority").to_string();
+ thread.syscall_count = thread_object.get("syscall_count").to_u32();
+ thread.inode_faults = thread_object.get("inode_faults").to_u32();
+ thread.zero_faults = thread_object.get("zero_faults").to_u32();
+ thread.cow_faults = thread_object.get("cow_faults").to_u32();
  process.threads.append(move(thread));
  });
 

Libraries/LibCore/CProcessStatisticsReader.h

@@ -8,6 +8,10 @@ struct CThreadStatistics {
  int tid;
  unsigned times_scheduled;
  unsigned ticks;
+ unsigned syscall_count;
+ unsigned inode_faults;
+ unsigned zero_faults;
+ unsigned cow_faults;
  String state;
  String priority;
 };
@@ -28,10 +32,6 @@ struct CProcessStatistics {
  size_t amount_virtual;
  size_t amount_resident;
  size_t amount_shared;
- unsigned syscall_count;
- unsigned inode_faults;
- unsigned zero_faults;
- unsigned cow_faults;
  int icon_id;
 
  Vector<CThreadStatistics> threads;

Userland/top.cpp

@@ -88,10 +88,10 @@ static Snapshot get_snapshot()
  thread_data.amount_virtual = stats.amount_virtual;
  thread_data.amount_resident = stats.amount_resident;
  thread_data.amount_shared = stats.amount_shared;
- thread_data.syscall_count = stats.syscall_count;
- thread_data.inode_faults = stats.inode_faults;
- thread_data.zero_faults = stats.zero_faults;
- thread_data.cow_faults = stats.cow_faults;
+ thread_data.syscall_count = thread.syscall_count;
+ thread_data.inode_faults = thread.inode_faults;
+ thread_data.zero_faults = thread.zero_faults;
+ thread_data.cow_faults = thread.cow_faults;
  thread_data.icon_id = stats.icon_id;
  thread_data.times_scheduled = thread.times_scheduled;
  thread_data.priority = thread.priority;