Kernel: Rename region_from_foo() => find_region_from_foo()

Let's emphasize that these functions actually go out and find regions.
fleximus · Jul 30, 2020 · be7add6 · be7add6
1 parent 2e2de12
commit be7add6
Show file tree

Hide file tree

Showing 8 changed files with 21 additions and 21 deletions.
diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp
@@ -224,7 +224,7 @@ bool Process::deallocate_region(Region& region)
  return false;
 }
 
-Region* Process::region_from_range(const Range& range)
+Region* Process::find_region_from_range(const Range& range)
 {
  ScopedSpinLock lock(m_lock);
  if (m_region_lookup_cache.range == range && m_region_lookup_cache.region)
@@ -241,7 +241,7 @@ Region* Process::region_from_range(const Range& range)
  return nullptr;
 }
 
-Region* Process::region_containing(const Range& range)
+Region* Process::find_region_containing(const Range& range)
 {
  ScopedSpinLock lock(m_lock);
  for (auto& region : m_regions) {

diff --git a/Kernel/Process.h b/Kernel/Process.h
@@ -607,8 +607,8 @@ class Process : public InlineLinkedListNode<Process> {
 
  RefPtr<TTY> m_tty;
 
- Region* region_from_range(const Range&);
- Region* region_containing(const Range&);
+ Region* find_region_from_range(const Range&);
+ Region* find_region_containing(const Range&);
 
  NonnullOwnPtrVector<Region> m_regions;
  struct RegionLookupCache {

diff --git a/Kernel/Syscall.cpp b/Kernel/Syscall.cpp
@@ -148,7 +148,7 @@ void syscall_handler(TrapFrame* trap)
  ASSERT_NOT_REACHED();
  }
 
- auto* calling_region = MM.region_from_vaddr(process, VirtualAddress(regs.eip));
+ auto* calling_region = MM.find_region_from_vaddr(process, VirtualAddress(regs.eip));
  if (!calling_region) {
  dbg() << "Syscall from " << String::format("%p", regs.eip) << " which has no region";
  handle_crash(regs, "Syscall from unknown region", SIGSEGV);

diff --git a/Kernel/Syscalls/get_stack_bounds.cpp b/Kernel/Syscalls/get_stack_bounds.cpp
@@ -37,7 +37,7 @@ int Process::sys$get_stack_bounds(FlatPtr* user_stack_base, size_t* user_stack_s
  return -EFAULT;
 
  FlatPtr stack_pointer = Thread::current()->get_register_dump_from_stack().userspace_esp;
- auto* stack_region = MM.region_from_vaddr(*this, VirtualAddress(stack_pointer));
+ auto* stack_region = MM.find_region_from_vaddr(*this, VirtualAddress(stack_pointer));
  if (!stack_region) {
  ASSERT_NOT_REACHED();
  return -EINVAL;

diff --git a/Kernel/Syscalls/mmap.cpp b/Kernel/Syscalls/mmap.cpp
@@ -203,7 +203,7 @@ int Process::sys$mprotect(void* addr, size_t size, int prot)
 
  Range range_to_mprotect = { VirtualAddress(addr), size };
 
- if (auto* whole_region = region_from_range(range_to_mprotect)) {
+ if (auto* whole_region = find_region_from_range(range_to_mprotect)) {
  if (!whole_region->is_mmap())
  return -EPERM;
  if (!validate_mmap_prot(prot, whole_region->is_stack()))
@@ -222,7 +222,7 @@ int Process::sys$mprotect(void* addr, size_t size, int prot)
  }
 
  // Check if we can carve out the desired range from an existing region
- if (auto* old_region = region_containing(range_to_mprotect)) {
+ if (auto* old_region = find_region_containing(range_to_mprotect)) {
  if (!old_region->is_mmap())
  return -EPERM;
  if (!validate_mmap_prot(prot, old_region->is_stack()))
@@ -271,7 +271,7 @@ int Process::sys$madvise(void* address, size_t size, int advice)
  if (!is_user_range(VirtualAddress(address), size))
  return -EFAULT;
 
- auto* region = region_from_range({ VirtualAddress(address), size });
+ auto* region = find_region_from_range({ VirtualAddress(address), size });
  if (!region)
  return -EINVAL;
  if (!region->is_mmap())
@@ -309,7 +309,7 @@ int Process::sys$minherit(void* address, size_t size, int inherit)
 {
  REQUIRE_PROMISE(stdio);
 
- auto* region = region_from_range({ VirtualAddress(address), size });
+ auto* region = find_region_from_range({ VirtualAddress(address), size });
  if (!region)
  return -EINVAL;
 
@@ -346,7 +346,7 @@ int Process::sys$set_mmap_name(const Syscall::SC_set_mmap_name_params* user_para
  if (name.is_null())
  return -EFAULT;
 
- auto* region = region_from_range({ VirtualAddress(params.addr), params.size });
+ auto* region = find_region_from_range({ VirtualAddress(params.addr), params.size });
  if (!region)
  return -EINVAL;
  if (!region->is_mmap())
@@ -384,15 +384,15 @@ int Process::sys$munmap(void* addr, size_t size)
  return -EFAULT;
 
  Range range_to_unmap { VirtualAddress(addr), size };
- if (auto* whole_region = region_from_range(range_to_unmap)) {
+ if (auto* whole_region = find_region_from_range(range_to_unmap)) {
  if (!whole_region->is_mmap())
  return -EPERM;
  bool success = deallocate_region(*whole_region);
  ASSERT(success);
  return 0;
  }
 
- if (auto* old_region = region_containing(range_to_unmap)) {
+ if (auto* old_region = find_region_containing(range_to_unmap)) {
  if (!old_region->is_mmap())
  return -EPERM;
 

diff --git a/Kernel/Syscalls/ptrace.cpp b/Kernel/Syscalls/ptrace.cpp
@@ -84,7 +84,7 @@ KResult Process::poke_user_data(u32* address, u32 data)
  }
  ProcessPagingScope scope(*this);
  Range range = { VirtualAddress(address), sizeof(u32) };
- auto* region = region_containing(range);
+ auto* region = find_region_containing(range);
  ASSERT(region != nullptr);
  if (region->is_shared()) {
  // If the region is shared, we change its vmobject to a PrivateInodeVMObject

diff --git a/Kernel/VM/MemoryManager.cpp b/Kernel/VM/MemoryManager.cpp
@@ -244,23 +244,23 @@ Region* MemoryManager::user_region_from_vaddr(Process& process, VirtualAddress v
  return nullptr;
 }
 
-Region* MemoryManager::region_from_vaddr(Process& process, VirtualAddress vaddr)
+Region* MemoryManager::find_region_from_vaddr(Process& process, VirtualAddress vaddr)
 {
  ScopedSpinLock lock(s_mm_lock);
  if (auto* region = user_region_from_vaddr(process, vaddr))
  return region;
  return kernel_region_from_vaddr(vaddr);
 }
 
-const Region* MemoryManager::region_from_vaddr(const Process& process, VirtualAddress vaddr)
+const Region* MemoryManager::find_region_from_vaddr(const Process& process, VirtualAddress vaddr)
 {
  ScopedSpinLock lock(s_mm_lock);
  if (auto* region = user_region_from_vaddr(const_cast<Process&>(process), vaddr))
  return region;
  return kernel_region_from_vaddr(vaddr);
 }
 
-Region* MemoryManager::region_from_vaddr(VirtualAddress vaddr)
+Region* MemoryManager::find_region_from_vaddr(VirtualAddress vaddr)
 {
  ScopedSpinLock lock(s_mm_lock);
  if (auto* region = kernel_region_from_vaddr(vaddr))
@@ -285,7 +285,7 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
 #ifdef PAGE_FAULT_DEBUG
  dbg() << "MM: CPU[" << Processor::current().id() << "] handle_page_fault(" << String::format("%w", fault.code()) << ") at " << fault.vaddr();
 #endif
- auto* region = region_from_vaddr(fault.vaddr());
+ auto* region = find_region_from_vaddr(fault.vaddr());
  if (!region) {
  klog() << "CPU[" << Processor::current().id() << "] NP(error) fault at invalid address " << fault.vaddr();
  return PageFaultResponse::ShouldCrash;

diff --git a/Kernel/VM/MemoryManager.h b/Kernel/VM/MemoryManager.h
@@ -150,8 +150,8 @@ class MemoryManager {
  }
  }
 
- static Region* region_from_vaddr(Process&, VirtualAddress);
- static const Region* region_from_vaddr(const Process&, VirtualAddress);
+ static Region* find_region_from_vaddr(Process&, VirtualAddress);
+ static const Region* find_region_from_vaddr(const Process&, VirtualAddress);
 
  void dump_kernel_regions();
 
@@ -184,7 +184,7 @@ class MemoryManager {
  static Region* user_region_from_vaddr(Process&, VirtualAddress);
  static Region* kernel_region_from_vaddr(VirtualAddress);
 
- static Region* region_from_vaddr(VirtualAddress);
+ static Region* find_region_from_vaddr(VirtualAddress);
 
  RefPtr<PhysicalPage> find_free_user_physical_page();
  u8* quickmap_page(PhysicalPage&);