Kernel: Add convenience values to the Memory::Region::Access enum

Instead of `Memory::Region::Access::Read | Memory::Region::AccessWrite`
you can now say `Memory::Region::Access::ReadWrite`.

Kernel/Bus/PCI/MMIOAccess.cpp

@@ -57,7 +57,7 @@ UNMAP_AFTER_INIT MMIOAccess::MMIOAccess(PhysicalAddress p_mcfg)
 {
  dmesgln("PCI: Using MMIO for PCI configuration space access");
 
- auto checkup_region = MM.allocate_kernel_region(p_mcfg.page_base(), (PAGE_SIZE * 2), "PCI MCFG Checkup", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ auto checkup_region = MM.allocate_kernel_region(p_mcfg.page_base(), (PAGE_SIZE * 2), "PCI MCFG Checkup", Memory::Region::Access::ReadWrite);
  dbgln_if(PCI_DEBUG, "PCI: Checking MCFG Table length to choose the correct mapping size");
  auto* sdt = (ACPI::Structures::SDTHeader*)checkup_region->vaddr().offset(p_mcfg.offset_in_page()).as_ptr();
  u32 length = sdt->length;
@@ -66,7 +66,7 @@ UNMAP_AFTER_INIT MMIOAccess::MMIOAccess(PhysicalAddress p_mcfg)
  dbgln("PCI: MCFG, length: {}, revision: {}", length, revision);
  checkup_region->unmap();
 
- auto mcfg_region = MM.allocate_kernel_region(p_mcfg.page_base(), Memory::page_round_up(length) + PAGE_SIZE, "PCI Parsing MCFG", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ auto mcfg_region = MM.allocate_kernel_region(p_mcfg.page_base(), Memory::page_round_up(length) + PAGE_SIZE, "PCI Parsing MCFG", Memory::Region::Access::ReadWrite);
 
  auto& mcfg = *(ACPI::Structures::MCFG*)mcfg_region->vaddr().offset(p_mcfg.offset_in_page()).as_ptr();
  dbgln_if(PCI_DEBUG, "PCI: Checking MCFG @ {}, {}", VirtualAddress(&mcfg), PhysicalAddress(p_mcfg.get()));
@@ -89,7 +89,7 @@ UNMAP_AFTER_INIT MMIOAccess::MMIOAccess(PhysicalAddress p_mcfg)
  // PCI::PhysicalID objects to the vector, because get_capabilities calls
  // PCI::read16 which will need this region to be mapped.
  u8 start_bus = m_segments.get(0).value().get_start_bus();
- m_mapped_region = MM.allocate_kernel_region(determine_memory_mapped_bus_region(0, start_bus), MEMORY_RANGE_PER_BUS, "PCI ECAM", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_mapped_region = MM.allocate_kernel_region(determine_memory_mapped_bus_region(0, start_bus), MEMORY_RANGE_PER_BUS, "PCI ECAM", Memory::Region::Access::ReadWrite);
  m_mapped_bus = start_bus;
  dbgln_if(PCI_DEBUG, "PCI: First PCI ECAM Mapped region for starting bus {} @ {} {}", start_bus, m_mapped_region->vaddr(), m_mapped_region->physical_page(0)->paddr());
 
@@ -102,7 +102,7 @@ void MMIOAccess::map_bus_region(u32 segment, u8 bus)
  VERIFY(m_access_lock.is_locked());
  if (m_mapped_bus == bus)
  return;
- m_mapped_region = MM.allocate_kernel_region(determine_memory_mapped_bus_region(segment, bus), MEMORY_RANGE_PER_BUS, "PCI ECAM", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_mapped_region = MM.allocate_kernel_region(determine_memory_mapped_bus_region(segment, bus), MEMORY_RANGE_PER_BUS, "PCI ECAM", Memory::Region::Access::ReadWrite);
  m_mapped_bus = bus;
  dbgln_if(PCI_DEBUG, "PCI: New PCI ECAM Mapped region for bus {} @ {} {}", bus, m_mapped_region->vaddr(), m_mapped_region->physical_page(0)->paddr());
 }

Kernel/Bus/PCI/WindowedMMIOAccess.cpp

@@ -18,7 +18,7 @@ namespace PCI {
 
 UNMAP_AFTER_INIT DeviceConfigurationSpaceMapping::DeviceConfigurationSpaceMapping(Address device_address, const MMIOAccess::MMIOSegment& mmio_segment)
  : m_device_address(device_address)
- , m_mapped_region(MM.allocate_kernel_region(Memory::page_round_up(PCI_MMIO_CONFIG_SPACE_SIZE), "PCI MMIO Device Access", Memory::Region::Access::Read | Memory::Region::Access::Write).release_nonnull())
+ , m_mapped_region(MM.allocate_kernel_region(Memory::page_round_up(PCI_MMIO_CONFIG_SPACE_SIZE), "PCI MMIO Device Access", Memory::Region::Access::ReadWrite).release_nonnull())
 {
  PhysicalAddress segment_lower_addr = mmio_segment.get_paddr();
  PhysicalAddress device_physical_mmio_space = segment_lower_addr.offset(

Kernel/Bus/USB/USBTransfer.cpp

@@ -24,7 +24,7 @@ Transfer::Transfer(Pipe& pipe, u16 len, Memory::AnonymousVMObject& vmobject)
 {
  // Initialize data buffer for transfer
  // This will definitely need to be refactored in the future, I doubt this will scale well...
- m_data_buffer = MM.allocate_kernel_region_with_vmobject(vmobject, PAGE_SIZE, "USB Transfer Buffer", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_data_buffer = MM.allocate_kernel_region_with_vmobject(vmobject, PAGE_SIZE, "USB Transfer Buffer", Memory::Region::Access::ReadWrite);
 }
 
 Transfer::~Transfer()

Kernel/Devices/KCOVInstance.cpp

@@ -35,7 +35,7 @@ KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
 
  this->m_kernel_region = MM.allocate_kernel_region_with_vmobject(
  *this->vmobject, this->m_buffer_size_in_bytes, String::formatted("kcov_{}", this->m_pid),
- Memory::Region::Access::Read | Memory::Region::Access::Write);
+ Memory::Region::Access::ReadWrite);
  if (!this->m_kernel_region)
  return ENOMEM;
 

Kernel/DoubleBuffer.cpp

@@ -19,7 +19,7 @@ inline void DoubleBuffer::compute_lockfree_metadata()
 
 OwnPtr<DoubleBuffer> DoubleBuffer::try_create(size_t capacity)
 {
- auto storage = KBuffer::try_create_with_size(capacity * 2, Memory::Region::Access::Read | Memory::Region::Access::Write, "DoubleBuffer");
+ auto storage = KBuffer::try_create_with_size(capacity * 2, Memory::Region::Access::ReadWrite, "DoubleBuffer");
  if (!storage)
  return {};
 

Kernel/FileSystem/Ext2FileSystem.cpp

@@ -132,7 +132,7 @@ bool Ext2FS::initialize()
 
  auto blocks_to_read = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size());
  BlockIndex first_block_of_bgdt = block_size() == 1024 ? 2 : 1;
- m_cached_group_descriptor_table = KBuffer::try_create_with_size(block_size() * blocks_to_read, Memory::Region::Access::Read | Memory::Region::Access::Write, "Ext2FS: Block group descriptors");
+ m_cached_group_descriptor_table = KBuffer::try_create_with_size(block_size() * blocks_to_read, Memory::Region::Access::ReadWrite, "Ext2FS: Block group descriptors");
  if (!m_cached_group_descriptor_table) {
  dbgln("Ext2FS: Failed to allocate memory for group descriptor table");
  return false;
@@ -1505,7 +1505,7 @@ KResultOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_bloc
  return cached_bitmap;
  }
 
- auto block = KBuffer::try_create_with_size(block_size(), Memory::Region::Access::Read | Memory::Region::Access::Write, "Ext2FS: Cached bitmap block");
+ auto block = KBuffer::try_create_with_size(block_size(), Memory::Region::Access::ReadWrite, "Ext2FS: Cached bitmap block");
  if (!block)
  return ENOMEM;
  auto buffer = UserOrKernelBuffer::for_kernel_buffer(block->data());

Kernel/FileSystem/Plan9FileSystem.cpp

@@ -560,7 +560,7 @@ KResult Plan9FS::read_and_dispatch_one_message()
  if (result.is_error())
  return result;
 
- auto buffer = KBuffer::try_create_with_size(header.size, Memory::Region::Access::Read | Memory::Region::Access::Write);
+ auto buffer = KBuffer::try_create_with_size(header.size, Memory::Region::Access::ReadWrite);
  if (!buffer)
  return ENOMEM;
  // Copy the already read header into the buffer.

Kernel/Graphics/Console/ContiguousFramebufferConsole.cpp

@@ -28,7 +28,7 @@ void ContiguousFramebufferConsole::set_resolution(size_t width, size_t height, s
  m_pitch = pitch;
 
  dbgln("Framebuffer Console: taking {} bytes", Memory::page_round_up(pitch * height));
- m_framebuffer_region = MM.allocate_kernel_region(m_framebuffer_address, Memory::page_round_up(pitch * height), "Framebuffer Console", Memory::Region::Access::Read | Memory::Region::Access::Write, Memory::Region::Cacheable::Yes);
+ m_framebuffer_region = MM.allocate_kernel_region(m_framebuffer_address, Memory::page_round_up(pitch * height), "Framebuffer Console", Memory::Region::Access::ReadWrite, Memory::Region::Cacheable::Yes);
  VERIFY(m_framebuffer_region);
 
  // Just to start cleanly, we clean the entire framebuffer

Kernel/Graphics/Console/VGAConsole.cpp

@@ -11,7 +11,7 @@ namespace Kernel::Graphics {
 
 UNMAP_AFTER_INIT VGAConsole::VGAConsole(const VGACompatibleAdapter& adapter, Mode mode, size_t width, size_t height)
  : Console(width, height)
- , m_vga_region(MM.allocate_kernel_region(PhysicalAddress(0xa0000), Memory::page_round_up(0xc0000 - 0xa0000), "VGA Display", Memory::Region::Access::Read | Memory::Region::Access::Write).release_nonnull())
+ , m_vga_region(MM.allocate_kernel_region(PhysicalAddress(0xa0000), Memory::page_round_up(0xc0000 - 0xa0000), "VGA Display", Memory::Region::Access::ReadWrite).release_nonnull())
  , m_adapter(adapter)
  , m_mode(mode)
 {

Kernel/Graphics/FramebufferDevice.cpp

@@ -49,11 +49,11 @@ KResultOr<Memory::Region*> FramebufferDevice::mmap(Process& process, FileDescrip
  if (!m_swapped_framebuffer_vmobject)
  return ENOMEM;
 
- m_real_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_real_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer", Memory::Region::Access::ReadWrite);
  if (!m_real_framebuffer_region)
  return ENOMEM;
 
- m_swapped_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer Swap (Blank)", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_swapped_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer Swap (Blank)", Memory::Region::Access::ReadWrite);
  if (!m_swapped_framebuffer_region)
  return ENOMEM;
 
@@ -111,11 +111,11 @@ UNMAP_AFTER_INIT void FramebufferDevice::initialize()
 {
  m_real_framebuffer_vmobject = Memory::AnonymousVMObject::try_create_for_physical_range(m_framebuffer_address, Memory::page_round_up(framebuffer_size_in_bytes()));
  VERIFY(m_real_framebuffer_vmobject);
- m_real_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_real_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer", Memory::Region::Access::ReadWrite);
  VERIFY(m_real_framebuffer_region);
  m_swapped_framebuffer_vmobject = Memory::AnonymousVMObject::try_create_with_size(Memory::page_round_up(framebuffer_size_in_bytes()), AllocationStrategy::AllocateNow);
  VERIFY(m_swapped_framebuffer_vmobject);
- m_swapped_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer Swap (Blank)", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_swapped_framebuffer_region = MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, Memory::page_round_up(framebuffer_size_in_bytes()), "Framebuffer Swap (Blank)", Memory::Region::Access::ReadWrite);
  VERIFY(m_swapped_framebuffer_region);
 }
 

Kernel/Graphics/GraphicsManagement.cpp

@@ -32,7 +32,7 @@ bool GraphicsManagement::is_initialized()
 }
 
 UNMAP_AFTER_INIT GraphicsManagement::GraphicsManagement()
- : m_vga_font_region(MM.allocate_kernel_region(PAGE_SIZE, "VGA font", Memory::Region::Access::Read | Memory::Region::Access::Write, AllocationStrategy::AllocateNow).release_nonnull())
+ : m_vga_font_region(MM.allocate_kernel_region(PAGE_SIZE, "VGA font", Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow).release_nonnull())
  , m_framebuffer_devices_allowed(!kernel_command_line().is_no_framebuffer_devices_mode())
 {
 }

Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp

@@ -189,7 +189,7 @@ IntelNativeGraphicsAdapter::IntelNativeGraphicsAdapter(PCI::Address address)
  VERIFY(bar0_space_size == 0x80000);
  dmesgln("Intel Native Graphics Adapter @ {}, MMIO @ {}, space size is {:x} bytes", address, PhysicalAddress(PCI::get_BAR0(address)), bar0_space_size);
  dmesgln("Intel Native Graphics Adapter @ {}, framebuffer @ {}", address, PhysicalAddress(PCI::get_BAR2(address)));
- m_registers_region = MM.allocate_kernel_region(PhysicalAddress(PCI::get_BAR0(address)).page_base(), bar0_space_size, "Intel Native Graphics Registers", Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_registers_region = MM.allocate_kernel_region(PhysicalAddress(PCI::get_BAR0(address)).page_base(), bar0_space_size, "Intel Native Graphics Registers", Memory::Region::Access::ReadWrite);
  PCI::enable_bus_mastering(address);
  {
  ScopedSpinLock control_lock(m_control_lock);

Kernel/Graphics/VirtIOGPU/FrameBufferDevice.cpp

@@ -32,7 +32,7 @@ void FrameBufferDevice::create_framebuffer()
  // Allocate frame buffer for both front and back
  auto& info = display_info();
  m_buffer_size = calculate_framebuffer_size(info.rect.width, info.rect.height);
- m_framebuffer = MM.allocate_kernel_region(m_buffer_size * 2, String::formatted("VirtGPU FrameBuffer #{}", m_scanout.value()), Memory::Region::Access::Read | Memory::Region::Access::Write, AllocationStrategy::AllocateNow);
+ m_framebuffer = MM.allocate_kernel_region(m_buffer_size * 2, String::formatted("VirtGPU FrameBuffer #{}", m_scanout.value()), Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow);
  auto write_sink_page = MM.allocate_user_physical_page(Memory::MemoryManager::ShouldZeroFill::No).release_nonnull();
  auto num_needed_pages = m_framebuffer->vmobject().page_count();
 

Kernel/Graphics/VirtIOGPU/GPU.cpp

@@ -17,7 +17,7 @@ namespace Kernel::Graphics::VirtIOGPU {
 
 GPU::GPU(PCI::Address address)
  : VirtIODevice(address, "GPU")
- , m_scratch_space(MM.allocate_contiguous_kernel_region(32 * PAGE_SIZE, "VirtGPU Scratch Space", Memory::Region::Access::Read | Memory::Region::Access::Write))
+ , m_scratch_space(MM.allocate_contiguous_kernel_region(32 * PAGE_SIZE, "VirtGPU Scratch Space", Memory::Region::Access::ReadWrite))
 {
  VERIFY(!!m_scratch_space);
  if (auto cfg = get_config(ConfigurationType::Device)) {

Kernel/Heap/kmalloc.cpp

@@ -99,7 +99,7 @@ struct KmallocGlobalHeap {
  // allocations not including the original allocation_request
  // that triggered heap expansion. If we don't allocate
  memory_size += 1 * MiB;
- region = MM.allocate_kernel_region(memory_size, "kmalloc subheap", Memory::Region::Access::Read | Memory::Region::Access::Write, AllocationStrategy::AllocateNow);
+ region = MM.allocate_kernel_region(memory_size, "kmalloc subheap", Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow);
  if (region) {
  dbgln("kmalloc: Adding even more memory to heap at {}, bytes: {}", region->vaddr(), region->size());
 
@@ -173,7 +173,7 @@ struct KmallocGlobalHeap {
  {
  if (m_backup_memory)
  return;
- m_backup_memory = MM.allocate_kernel_region(1 * MiB, "kmalloc subheap", Memory::Region::Access::Read | Memory::Region::Access::Write, AllocationStrategy::AllocateNow);
+ m_backup_memory = MM.allocate_kernel_region(1 * MiB, "kmalloc subheap", Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow);
  }
 
  size_t backup_memory_bytes() const

Kernel/Interrupts/APIC.cpp

@@ -229,7 +229,7 @@ UNMAP_AFTER_INIT bool APIC::init_bsp()
  dbgln_if(APIC_DEBUG, "Initializing APIC, base: {}", apic_base);
  set_base(apic_base);
 
- m_apic_base = MM.allocate_kernel_region(apic_base.page_base(), PAGE_SIZE, {}, Memory::Region::Access::Read | Memory::Region::Access::Write);
+ m_apic_base = MM.allocate_kernel_region(apic_base.page_base(), PAGE_SIZE, {}, Memory::Region::Access::ReadWrite);
  if (!m_apic_base) {
  dbgln("APIC: Failed to allocate memory for APIC base");
  return false;
@@ -283,7 +283,7 @@ UNMAP_AFTER_INIT static NonnullOwnPtr<Memory::Region> create_identity_mapped_reg
  Memory::VirtualRange { VirtualAddress { static_cast<FlatPtr>(paddr.get()) }, size },
  vmobject.release_nonnull(),
  {},
- Memory::Region::Access::Read | Memory::Region::Access::Write | Memory::Region::Access::Execute);
+ Memory::Region::Access::ReadWriteExecute);
  VERIFY(region);
  return region.release_nonnull();
 }
@@ -303,7 +303,7 @@ UNMAP_AFTER_INIT void APIC::do_boot_aps()
  // Allocate enough stacks for all APs
  Vector<OwnPtr<Memory::Region>> apic_ap_stacks;
  for (u32 i = 0; i < aps_to_enable; i++) {
- auto stack_region = MM.allocate_kernel_region(Thread::default_kernel_stack_size, {}, Memory::Region::Access::Read | Memory::Region::Access::Write, AllocationStrategy::AllocateNow);
+ auto stack_region = MM.allocate_kernel_region(Thread::default_kernel_stack_size, {}, Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow);
  if (!stack_region) {
  dbgln("APIC: Failed to allocate stack for AP #{}", i);
  return;

Kernel/KBuffer.h

@@ -104,23 +104,23 @@ class [[nodiscard]] KBuffer {
  {
  }
 
- [[nodiscard]] static OwnPtr<KBuffer> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::Read | Memory::Region::Access::Write, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
+ [[nodiscard]] static OwnPtr<KBuffer> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
  {
  auto impl = KBufferImpl::try_create_with_size(size, access, name, strategy);
  if (!impl)
  return {};
  return adopt_own_if_nonnull(new (nothrow) KBuffer(impl.release_nonnull()));
  }
 
- [[nodiscard]] static OwnPtr<KBuffer> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::Read | Memory::Region::Access::Write, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
+ [[nodiscard]] static OwnPtr<KBuffer> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
  {
  auto impl = KBufferImpl::try_create_with_bytes(bytes, access, name, strategy);
  if (!impl)
  return {};
  return adopt_own_if_nonnull(new (nothrow) KBuffer(impl.release_nonnull()));
  }
 
- [[nodiscard]] static KBuffer copy(const void* data, size_t size, Memory::Region::Access access = Memory::Region::Access::Read | Memory::Region::Access::Write, StringView name = "KBuffer")
+ [[nodiscard]] static KBuffer copy(const void* data, size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer")
  {
  return KBuffer(KBufferImpl::copy(data, size, access, name));
  }
@@ -141,7 +141,7 @@ class [[nodiscard]] KBuffer {
  [[nodiscard]] const KBufferImpl& impl() const { return *m_impl; }
  [[nodiscard]] RefPtr<KBufferImpl> take_impl() { return move(m_impl); }
 
- KBuffer(const ByteBuffer& buffer, Memory::Region::Access access = Memory::Region::Access::Read | Memory::Region::Access::Write, StringView name = "KBuffer")
+ KBuffer(const ByteBuffer& buffer, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer")
  : m_impl(KBufferImpl::copy(buffer.data(), buffer.size(), access, name))
  {
  }

Kernel/KBufferBuilder.cpp

@@ -41,7 +41,7 @@ OwnPtr<KBuffer> KBufferBuilder::build()
 }
 
 KBufferBuilder::KBufferBuilder()
- : m_buffer(KBufferImpl::try_create_with_size(4 * MiB, Memory::Region::Access::Read | Memory::Region::Access::Write))
+ : m_buffer(KBufferImpl::try_create_with_size(4 * MiB, Memory::Region::Access::ReadWrite))
 {
 }
 

Kernel/Memory/Region.h

@@ -39,6 +39,9 @@ class Region final
  HasBeenReadable = 16,
  HasBeenWritable = 32,
  HasBeenExecutable = 64,
+ ReadOnly = Read,
+ ReadWrite = Read | Write,
+ ReadWriteExecute = Read | Write | Execute,
  };
 
  enum class Cacheable {