RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 20:37:36 +00:00
Code Issues Activity Actions

Kernel: Make self-contained locking smart pointers their own classes

Browse source 
Until now, our kernel has reimplemented a number of AK classes to
provide automatic internal locking:

- RefPtr
- NonnullRefPtr
- WeakPtr
- Weakable

This patch renames the Kernel classes so that they can coexist with
the original AK classes:

- RefPtr => LockRefPtr
- NonnullRefPtr => NonnullLockRefPtr
- WeakPtr => LockWeakPtr
- Weakable => LockWeakable

The goal here is to eventually get rid of the Lock* classes in favor of
using external locking.
This commit is contained in:
Andreas Kling 2022-08-19 20:53:40 +02:00
parent e475263113
commit 11eee67b85
360 changed files with 1703 additions and 1672 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Graphics/Bochs/DisplayConnector.cpp
View file

@ -14,7 +14,7 @@
namespace Kernel {
NonnullRefPtr<BochsDisplayConnector> BochsDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, bool virtual_box_hardware)
NonnullLockRefPtr<BochsDisplayConnector> BochsDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, bool virtual_box_hardware)
{
auto device_or_error = DeviceManagement::try_create_device<BochsDisplayConnector>(framebuffer_address, framebuffer_resource_size);
VERIFY(!device_or_error.is_error());

6
Kernel/Graphics/Bochs/DisplayConnector.h
View file

@ -6,11 +6,11 @@
#pragma once
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <Kernel/Graphics/Bochs/Definitions.h>
#include <Kernel/Graphics/Console/GenericFramebufferConsole.h>
#include <Kernel/Graphics/DisplayConnector.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Locking/Spinlock.h>
#include <Kernel/Memory/TypedMapping.h>
@ -24,7 +24,7 @@ class BochsDisplayConnector
public:
AK_TYPEDEF_DISTINCT_ORDERED_ID(u16, IndexID);
static NonnullRefPtr<BochsDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, bool virtual_box_hardware);
static NonnullLockRefPtr<BochsDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, bool virtual_box_hardware);
virtual IndexID index_id() const;
@ -50,6 +50,6 @@ protected:
virtual void enable_console() override final;
virtual void disable_console() override final;
RefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
LockRefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
};
}

4
Kernel/Graphics/Bochs/GraphicsAdapter.cpp
View file

@ -22,11 +22,11 @@
namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<BochsGraphicsAdapter> BochsGraphicsAdapter::initialize(PCI::DeviceIdentifier const& pci_device_identifier)
UNMAP_AFTER_INIT NonnullLockRefPtr<BochsGraphicsAdapter> BochsGraphicsAdapter::initialize(PCI::DeviceIdentifier const& pci_device_identifier)
{
PCI::HardwareID id = pci_device_identifier.hardware_id();
VERIFY((id.vendor_id == PCI::VendorID::QEMUOld && id.device_id == 0x1111) || (id.vendor_id == PCI::VendorID::VirtualBox && id.device_id == 0xbeef));
auto adapter = adopt_ref(*new BochsGraphicsAdapter(pci_device_identifier));
auto adapter = adopt_lock_ref(*new BochsGraphicsAdapter(pci_device_identifier));
MUST(adapter->initialize_adapter(pci_device_identifier));
return adapter;
}

4
Kernel/Graphics/Bochs/GraphicsAdapter.h
View file

@ -25,7 +25,7 @@ class BochsGraphicsAdapter final : public GenericGraphicsAdapter
friend class GraphicsManagement;
public:
static NonnullRefPtr<BochsGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
static NonnullLockRefPtr<BochsGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
virtual ~BochsGraphicsAdapter() = default;
private:
@ -33,6 +33,6 @@ private:
explicit BochsGraphicsAdapter(PCI::DeviceIdentifier const&);
RefPtr<BochsDisplayConnector> m_display_connector;
LockRefPtr<BochsDisplayConnector> m_display_connector;
};
}

2
Kernel/Graphics/Bochs/QEMUDisplayConnector.cpp
View file

@ -12,7 +12,7 @@
namespace Kernel {
NonnullRefPtr<QEMUDisplayConnector> QEMUDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, Memory::TypedMapping<BochsDisplayMMIORegisters volatile> registers_mapping)
NonnullLockRefPtr<QEMUDisplayConnector> QEMUDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, Memory::TypedMapping<BochsDisplayMMIORegisters volatile> registers_mapping)
{
auto device_or_error = DeviceManagement::try_create_device<QEMUDisplayConnector>(framebuffer_address, framebuffer_resource_size, move(registers_mapping));
VERIFY(!device_or_error.is_error());

4
Kernel/Graphics/Bochs/QEMUDisplayConnector.h
View file

@ -6,10 +6,10 @@
#pragma once
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <Kernel/Graphics/Bochs/DisplayConnector.h>
#include <Kernel/Graphics/Console/GenericFramebufferConsole.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Locking/Spinlock.h>
#include <Kernel/Memory/TypedMapping.h>
@ -22,7 +22,7 @@ class QEMUDisplayConnector final
friend class DeviceManagement;
public:
static NonnullRefPtr<QEMUDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, Memory::TypedMapping<BochsDisplayMMIORegisters volatile>);
static NonnullLockRefPtr<QEMUDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, Memory::TypedMapping<BochsDisplayMMIORegisters volatile>);
virtual IndexID index_id() const override;

4
Kernel/Graphics/Console/ContiguousFramebufferConsole.cpp
View file

@ -9,9 +9,9 @@
namespace Kernel::Graphics {
NonnullRefPtr<ContiguousFramebufferConsole> ContiguousFramebufferConsole::initialize(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch)
NonnullLockRefPtr<ContiguousFramebufferConsole> ContiguousFramebufferConsole::initialize(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch)
{
return adopt_ref(*new ContiguousFramebufferConsole(framebuffer_address, width, height, pitch));
return adopt_lock_ref(*new ContiguousFramebufferConsole(framebuffer_address, width, height, pitch));
}
ContiguousFramebufferConsole::ContiguousFramebufferConsole(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch)

2
Kernel/Graphics/Console/ContiguousFramebufferConsole.h
View file

@ -12,7 +12,7 @@ namespace Kernel::Graphics {
class ContiguousFramebufferConsole final : public GenericFramebufferConsole {
public:
static NonnullRefPtr<ContiguousFramebufferConsole> initialize(PhysicalAddress, size_t width, size_t height, size_t pitch);
static NonnullLockRefPtr<ContiguousFramebufferConsole> initialize(PhysicalAddress, size_t width, size_t height, size_t pitch);
virtual void set_resolution(size_t width, size_t height, size_t pitch) override;
virtual void flush(size_t, size_t, size_t, size_t) override { }

4
Kernel/Graphics/Console/VGATextModeConsole.cpp
View file

@ -11,11 +11,11 @@
namespace Kernel::Graphics {
UNMAP_AFTER_INIT NonnullRefPtr<VGATextModeConsole> VGATextModeConsole::initialize()
UNMAP_AFTER_INIT NonnullLockRefPtr<VGATextModeConsole> VGATextModeConsole::initialize()
{
auto vga_window_size = MUST(Memory::page_round_up(0xc0000 - 0xa0000));
auto vga_window_region = MUST(MM.allocate_kernel_region(PhysicalAddress(0xa0000), vga_window_size, "VGA Display"sv, Memory::Region::Access::ReadWrite));
return adopt_ref(*new (nothrow) VGATextModeConsole(move(vga_window_region)));
return adopt_lock_ref(*new (nothrow) VGATextModeConsole(move(vga_window_region)));
}
UNMAP_AFTER_INIT VGATextModeConsole::VGATextModeConsole(NonnullOwnPtr<Memory::Region> vga_window_region)

2
Kernel/Graphics/Console/VGATextModeConsole.h
View file

@ -13,7 +13,7 @@
namespace Kernel::Graphics {
class VGATextModeConsole final : public Console {
public:
static NonnullRefPtr<VGATextModeConsole> initialize();
static NonnullLockRefPtr<VGATextModeConsole> initialize();
virtual size_t chars_per_line() const override { return width(); };
virtual bool has_hardware_cursor() const override { return true; }

6
Kernel/Graphics/DisplayConnector.h
View file

@ -162,11 +162,11 @@ protected:
size_t const m_framebuffer_resource_size;
private:
RefPtr<Memory::SharedFramebufferVMObject> m_shared_framebuffer_vmobject;
LockRefPtr<Memory::SharedFramebufferVMObject> m_shared_framebuffer_vmobject;
WeakPtr<Process> m_responsible_process;
LockWeakPtr<Process> m_responsible_process;
Spinlock m_responsible_process_lock { LockRank::None };
IntrusiveListNode<DisplayConnector, RefPtr<DisplayConnector>> m_list_node;
IntrusiveListNode<DisplayConnector, LockRefPtr<DisplayConnector>> m_list_node;
};
}

2
Kernel/Graphics/Generic/DisplayConnector.cpp
View file

@ -13,7 +13,7 @@
namespace Kernel {
NonnullRefPtr<GenericDisplayConnector> GenericDisplayConnector::must_create_with_preset_resolution(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch)
NonnullLockRefPtr<GenericDisplayConnector> GenericDisplayConnector::must_create_with_preset_resolution(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch)
{
auto device_or_error = DeviceManagement::try_create_device<GenericDisplayConnector>(framebuffer_address, width, height, pitch);
VERIFY(!device_or_error.is_error());

6
Kernel/Graphics/Generic/DisplayConnector.h
View file

@ -6,10 +6,10 @@
#pragma once
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <Kernel/Graphics/Console/GenericFramebufferConsole.h>
#include <Kernel/Graphics/DisplayConnector.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Locking/Spinlock.h>
#include <Kernel/Memory/TypedMapping.h>
@ -20,7 +20,7 @@ class GenericDisplayConnector
friend class DeviceManagement;
public:
static NonnullRefPtr<GenericDisplayConnector> must_create_with_preset_resolution(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch);
static NonnullLockRefPtr<GenericDisplayConnector> must_create_with_preset_resolution(PhysicalAddress framebuffer_address, size_t width, size_t height, size_t pitch);
protected:
ErrorOr<void> create_attached_framebuffer_console();
@ -47,6 +47,6 @@ protected:
virtual void enable_console() override final;
virtual void disable_console() override final;
RefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
LockRefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
};
}

4
Kernel/Graphics/GenericGraphicsAdapter.h
View file

@ -7,15 +7,15 @@
#pragma once
#include <AK/Types.h>
#include <AK/Weakable.h>
#include <Kernel/Bus/PCI/Definitions.h>
#include <Kernel/Devices/BlockDevice.h>
#include <Kernel/Library/LockWeakable.h>
#include <Kernel/PhysicalAddress.h>
namespace Kernel {
class GenericGraphicsAdapter
: public AtomicRefCounted<GenericGraphicsAdapter>
, public Weakable<GenericGraphicsAdapter> {
, public LockWeakable<GenericGraphicsAdapter> {
public:
virtual ~GenericGraphicsAdapter() = default;

2
Kernel/Graphics/GraphicsManagement.cpp
View file

@ -126,7 +126,7 @@ static inline bool is_display_controller_pci_device(PCI::DeviceIdentifier const&
UNMAP_AFTER_INIT bool GraphicsManagement::determine_and_initialize_graphics_device(PCI::DeviceIdentifier const& device_identifier)
{
VERIFY(is_vga_compatible_pci_device(device_identifier) || is_display_controller_pci_device(device_identifier));
RefPtr<GenericGraphicsAdapter> adapter;
LockRefPtr<GenericGraphicsAdapter> adapter;
if (!adapter) {
switch (device_identifier.hardware_id().vendor_id) {

12
Kernel/Graphics/GraphicsManagement.h
View file

@ -7,8 +7,6 @@
#pragma once
#include <AK/NonnullOwnPtr.h>
#include <AK/NonnullRefPtr.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/Types.h>
#include <Kernel/Bus/PCI/Definitions.h>
#include <Kernel/Graphics/Console/Console.h>
@ -16,6 +14,8 @@
#include <Kernel/Graphics/Generic/DisplayConnector.h>
#include <Kernel/Graphics/GenericGraphicsAdapter.h>
#include <Kernel/Graphics/VirtIOGPU/GraphicsAdapter.h>
#include <Kernel/Library/NonnullLockRefPtr.h>
#include <Kernel/Library/NonnullLockRefPtrVector.h>
#include <Kernel/Memory/Region.h>
namespace Kernel {
@ -37,7 +37,7 @@ public:
void disable_vga_text_mode_console_cursor();
void disable_vga_emulation_access_permanently();
RefPtr<Graphics::Console> console() const { return m_console; }
LockRefPtr<Graphics::Console> console() const { return m_console; }
void set_console(Graphics::Console&);
void deactivate_graphical_mode();
@ -50,11 +50,11 @@ private:
void initialize_preset_resolution_generic_display_connector();
NonnullRefPtrVector<GenericGraphicsAdapter> m_graphics_devices;
RefPtr<Graphics::Console> m_console;
NonnullLockRefPtrVector<GenericGraphicsAdapter> m_graphics_devices;
LockRefPtr<Graphics::Console> m_console;
// Note: This is only used when booting with kernel commandline that includes "graphics_subsystem_mode=limited"
RefPtr<GenericDisplayConnector> m_preset_resolution_generic_display_connector;
LockRefPtr<GenericDisplayConnector> m_preset_resolution_generic_display_connector;
unsigned m_current_minor_number { 0 };

2
Kernel/Graphics/Intel/NativeDisplayConnector.cpp
View file

@ -175,7 +175,7 @@ Optional<IntelGraphics::PLLSettings> IntelNativeDisplayConnector::create_pll_set
return {};
}
NonnullRefPtr<IntelNativeDisplayConnector> IntelNativeDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, PhysicalAddress registers_region_address, size_t registers_region_length)
NonnullLockRefPtr<IntelNativeDisplayConnector> IntelNativeDisplayConnector::must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, PhysicalAddress registers_region_address, size_t registers_region_length)
{
auto registers_region = MUST(MM.allocate_kernel_region(PhysicalAddress(registers_region_address), registers_region_length, "Intel Native Graphics Registers"sv, Memory::Region::Access::ReadWrite));
auto device_or_error = DeviceManagement::try_create_device<IntelNativeDisplayConnector>(framebuffer_address, framebuffer_resource_size, move(registers_region));

6
Kernel/Graphics/Intel/NativeDisplayConnector.h
View file

@ -6,11 +6,11 @@
#pragma once
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <Kernel/Graphics/Console/GenericFramebufferConsole.h>
#include <Kernel/Graphics/Definitions.h>
#include <Kernel/Graphics/DisplayConnector.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Memory/TypedMapping.h>
namespace Kernel {
@ -81,7 +81,7 @@ class IntelNativeDisplayConnector final
friend class DeviceManagement;
public:
static NonnullRefPtr<IntelNativeDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, PhysicalAddress registers_region_address, size_t registers_region_length);
static NonnullLockRefPtr<IntelNativeDisplayConnector> must_create(PhysicalAddress framebuffer_address, size_t framebuffer_resource_size, PhysicalAddress registers_region_address, size_t registers_region_length);
private:
// ^DisplayConnector
@ -155,7 +155,7 @@ private:
Optional<IntelGraphics::PLLSettings> create_pll_settings(u64 target_frequency, u64 reference_clock, IntelGraphics::PLLMaxSettings const&);
mutable Spinlock m_registers_lock { LockRank::None };
RefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
LockRefPtr<Graphics::GenericFramebufferConsole> m_framebuffer_console;
const PhysicalAddress m_registers;
NonnullOwnPtr<Memory::Region> m_registers_region;

4
Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp
View file

@ -27,12 +27,12 @@ static bool is_supported_model(u16 device_id)
return false;
}
RefPtr<IntelNativeGraphicsAdapter> IntelNativeGraphicsAdapter::initialize(PCI::DeviceIdentifier const& pci_device_identifier)
LockRefPtr<IntelNativeGraphicsAdapter> IntelNativeGraphicsAdapter::initialize(PCI::DeviceIdentifier const& pci_device_identifier)
{
VERIFY(pci_device_identifier.hardware_id().vendor_id == 0x8086);
if (!is_supported_model(pci_device_identifier.hardware_id().device_id))
return {};
auto adapter = adopt_ref(*new IntelNativeGraphicsAdapter(pci_device_identifier.address()));
auto adapter = adopt_lock_ref(*new IntelNativeGraphicsAdapter(pci_device_identifier.address()));
MUST(adapter->initialize_adapter());
return adapter;
}

4
Kernel/Graphics/Intel/NativeGraphicsAdapter.h
View file

@ -20,7 +20,7 @@ class IntelNativeGraphicsAdapter final
, public PCI::Device {
public:
static RefPtr<IntelNativeGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
static LockRefPtr<IntelNativeGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
virtual ~IntelNativeGraphicsAdapter() = default;
@ -29,6 +29,6 @@ private:
explicit IntelNativeGraphicsAdapter(PCI::Address);
RefPtr<IntelNativeDisplayConnector> m_display_connector;
LockRefPtr<IntelNativeDisplayConnector> m_display_connector;
};
}

6
Kernel/Graphics/VMWare/Console.cpp
View file

@ -11,10 +11,10 @@ namespace Kernel {
constexpr static AK::Time refresh_interval = AK::Time::from_milliseconds(16);
NonnullRefPtr<VMWareFramebufferConsole> VMWareFramebufferConsole::initialize(VMWareDisplayConnector& parent_display_connector)
NonnullLockRefPtr<VMWareFramebufferConsole> VMWareFramebufferConsole::initialize(VMWareDisplayConnector& parent_display_connector)
{
auto current_resolution = parent_display_connector.current_mode_setting();
return adopt_ref(*new (nothrow) VMWareFramebufferConsole(parent_display_connector, current_resolution));
return adopt_lock_ref(*new (nothrow) VMWareFramebufferConsole(parent_display_connector, current_resolution));
}
VMWareFramebufferConsole::VMWareFramebufferConsole(VMWareDisplayConnector const& parent_display_connector, DisplayConnector::ModeSetting current_resolution)
@ -39,7 +39,7 @@ void VMWareFramebufferConsole::flush(size_t, size_t, size_t, size_t)
void VMWareFramebufferConsole::enqueue_refresh_timer()
{
NonnullRefPtr<Timer> refresh_timer = adopt_ref(*new (nothrow) Timer());
NonnullLockRefPtr<Timer> refresh_timer = adopt_lock_ref(*new (nothrow) Timer());
refresh_timer->setup(CLOCK_MONOTONIC, refresh_interval, [this]() {
if (m_enabled.load() && m_dirty) {
MUST(g_io_work->try_queue([this]() {

4
Kernel/Graphics/VMWare/Console.h
View file

@ -14,7 +14,7 @@ namespace Kernel {
class VMWareFramebufferConsole final : public Graphics::GenericFramebufferConsole {
public:
static NonnullRefPtr<VMWareFramebufferConsole> initialize(VMWareDisplayConnector& parent_display_connector);
static NonnullLockRefPtr<VMWareFramebufferConsole> initialize(VMWareDisplayConnector& parent_display_connector);
virtual void set_resolution(size_t width, size_t height, size_t pitch) override;
virtual void flush(size_t x, size_t y, size_t width, size_t height) override;
@ -25,7 +25,7 @@ private:
virtual u8* framebuffer_data() override;
VMWareFramebufferConsole(VMWareDisplayConnector const& parent_display_connector, DisplayConnector::ModeSetting current_resolution);
RefPtr<VMWareDisplayConnector> m_parent_display_connector;
LockRefPtr<VMWareDisplayConnector> m_parent_display_connector;
bool m_dirty { false };
};

2
Kernel/Graphics/VMWare/DisplayConnector.cpp
View file

@ -12,7 +12,7 @@
namespace Kernel {
NonnullRefPtr<VMWareDisplayConnector> VMWareDisplayConnector::must_create(VMWareGraphicsAdapter const& parent_adapter, PhysicalAddress framebuffer_address, size_t framebuffer_resource_size)
NonnullLockRefPtr<VMWareDisplayConnector> VMWareDisplayConnector::must_create(VMWareGraphicsAdapter const& parent_adapter, PhysicalAddress framebuffer_address, size_t framebuffer_resource_size)
{
auto connector = MUST(DeviceManagement::try_create_device<VMWareDisplayConnector>(parent_adapter, framebuffer_address, framebuffer_resource_size));
MUST(connector->create_attached_framebuffer_console());

8
Kernel/Graphics/VMWare/DisplayConnector.h
View file

@ -6,11 +6,11 @@
#pragma once
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <Kernel/Graphics/Console/GenericFramebufferConsole.h>
#include <Kernel/Graphics/DisplayConnector.h>
#include <Kernel/Graphics/VMWare/GraphicsAdapter.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Locking/Spinlock.h>
#include <Kernel/Memory/TypedMapping.h>
@ -23,7 +23,7 @@ class VMWareDisplayConnector : public DisplayConnector {
friend class DeviceManagement;
public:
static NonnullRefPtr<VMWareDisplayConnector> must_create(VMWareGraphicsAdapter const& parent_adapter, PhysicalAddress framebuffer_address, size_t framebuffer_resource_size);
static NonnullLockRefPtr<VMWareDisplayConnector> must_create(VMWareGraphicsAdapter const& parent_adapter, PhysicalAddress framebuffer_address, size_t framebuffer_resource_size);
private:
VMWareDisplayConnector(VMWareGraphicsAdapter const& parent_adapter, PhysicalAddress framebuffer_address, size_t framebuffer_resource_size);
@ -48,7 +48,7 @@ private:
virtual void disable_console() override;
private:
NonnullRefPtr<VMWareGraphicsAdapter> m_parent_adapter;
RefPtr<VMWareFramebufferConsole> m_framebuffer_console;
NonnullLockRefPtr<VMWareGraphicsAdapter> m_parent_adapter;
LockRefPtr<VMWareFramebufferConsole> m_framebuffer_console;
};
}

4
Kernel/Graphics/VMWare/GraphicsAdapter.cpp
View file

@ -21,14 +21,14 @@
namespace Kernel {
UNMAP_AFTER_INIT RefPtr<VMWareGraphicsAdapter> VMWareGraphicsAdapter::try_initialize(PCI::DeviceIdentifier const& pci_device_identifier)
UNMAP_AFTER_INIT LockRefPtr<VMWareGraphicsAdapter> VMWareGraphicsAdapter::try_initialize(PCI::DeviceIdentifier const& pci_device_identifier)
{
PCI::HardwareID id = pci_device_identifier.hardware_id();
VERIFY(id.vendor_id == PCI::VendorID::VMWare);
// Note: We only support VMWare SVGA II adapter
if (id.device_id != 0x0405)
return {};
auto adapter = MUST(adopt_nonnull_ref_or_enomem(new (nothrow) VMWareGraphicsAdapter(pci_device_identifier)));
auto adapter = MUST(adopt_nonnull_lock_ref_or_enomem(new (nothrow) VMWareGraphicsAdapter(pci_device_identifier)));
MUST(adapter->initialize_adapter());
return adapter;
}

4
Kernel/Graphics/VMWare/GraphicsAdapter.h
View file

@ -26,7 +26,7 @@ class VMWareGraphicsAdapter final
friend class GraphicsManagement;
public:
static RefPtr<VMWareGraphicsAdapter> try_initialize(PCI::DeviceIdentifier const&);
static LockRefPtr<VMWareGraphicsAdapter> try_initialize(PCI::DeviceIdentifier const&);
virtual ~VMWareGraphicsAdapter() = default;
ErrorOr<void> modeset_primary_screen_resolution(Badge<VMWareDisplayConnector>, size_t width, size_t height);
@ -49,7 +49,7 @@ private:
explicit VMWareGraphicsAdapter(PCI::DeviceIdentifier const&);
Memory::TypedMapping<volatile VMWareDisplayFIFORegisters> m_fifo_registers;
RefPtr<VMWareDisplayConnector> m_display_connector;
LockRefPtr<VMWareDisplayConnector> m_display_connector;
const IOAddress m_io_registers_base;
mutable Spinlock m_io_access_lock { LockRank::None };
mutable RecursiveSpinlock m_operation_lock { LockRank::None };

6
Kernel/Graphics/VirtIOGPU/Console.cpp
View file

@ -11,10 +11,10 @@ namespace Kernel::Graphics::VirtIOGPU {
constexpr static AK::Time refresh_interval = AK::Time::from_milliseconds(16);
NonnullRefPtr<Console> Console::initialize(VirtIODisplayConnector& parent_display_connector)
NonnullLockRefPtr<Console> Console::initialize(VirtIODisplayConnector& parent_display_connector)
{
auto current_resolution = parent_display_connector.current_mode_setting();
return adopt_ref(*new Console(parent_display_connector, current_resolution));
return adopt_lock_ref(*new Console(parent_display_connector, current_resolution));
}
Console::Console(VirtIODisplayConnector const& parent_display_connector, DisplayConnector::ModeSetting current_resolution)
@ -36,7 +36,7 @@ void Console::flush(size_t, size_t, size_t, size_t)
void Console::enqueue_refresh_timer()
{
NonnullRefPtr<Timer> refresh_timer = adopt_ref(*new Timer());
NonnullLockRefPtr<Timer> refresh_timer = adopt_lock_ref(*new Timer());
refresh_timer->setup(CLOCK_MONOTONIC, refresh_interval, [this]() {
if (m_enabled.load() && m_dirty) {
MUST(g_io_work->try_queue([this]() {

4
Kernel/Graphics/VirtIOGPU/Console.h
View file

@ -14,7 +14,7 @@ namespace Kernel::Graphics::VirtIOGPU {
class Console final : public GenericFramebufferConsole {
public:
static NonnullRefPtr<Console> initialize(VirtIODisplayConnector& parent_display_connector);
static NonnullLockRefPtr<Console> initialize(VirtIODisplayConnector& parent_display_connector);
virtual void set_resolution(size_t width, size_t height, size_t pitch) override;
virtual void flush(size_t x, size_t y, size_t width, size_t height) override;
@ -25,7 +25,7 @@ private:
virtual u8* framebuffer_data() override;
Console(VirtIODisplayConnector const& parent_display_connector, DisplayConnector::ModeSetting current_resolution);
NonnullRefPtr<VirtIODisplayConnector> m_parent_display_connector;
NonnullLockRefPtr<VirtIODisplayConnector> m_parent_display_connector;
bool m_dirty { false };
};

2
Kernel/Graphics/VirtIOGPU/DisplayConnector.cpp
View file

@ -15,7 +15,7 @@
namespace Kernel {
NonnullRefPtr<VirtIODisplayConnector> VirtIODisplayConnector::must_create(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id)
NonnullLockRefPtr<VirtIODisplayConnector> VirtIODisplayConnector::must_create(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id)
{
auto device_or_error = DeviceManagement::try_create_device<VirtIODisplayConnector>(graphics_adapter, scanout_id);
VERIFY(!device_or_error.is_error());

6
Kernel/Graphics/VirtIOGPU/DisplayConnector.h
View file

@ -30,7 +30,7 @@ class VirtIODisplayConnector final : public DisplayConnector {
friend class DeviceManagement;
public:
static NonnullRefPtr<VirtIODisplayConnector> must_create(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id);
static NonnullLockRefPtr<VirtIODisplayConnector> must_create(VirtIOGraphicsAdapter& graphics_adapter, Graphics::VirtIOGPU::ScanoutID scanout_id);
void set_edid_bytes(Badge<VirtIOGraphicsAdapter>, Array<u8, 128> const& edid_bytes);
void set_safe_mode_setting_after_initialization(Badge<VirtIOGraphicsAdapter>);
@ -81,8 +81,8 @@ private:
// Context used for kernel operations (e.g. flushing resources to scanout)
Graphics::VirtIOGPU::ContextID m_kernel_context_id;
NonnullRefPtr<VirtIOGraphicsAdapter> m_graphics_adapter;
RefPtr<Graphics::Console> m_console;
NonnullLockRefPtr<VirtIOGraphicsAdapter> m_graphics_adapter;
LockRefPtr<Graphics::Console> m_console;
Graphics::VirtIOGPU::Protocol::DisplayInfoResponse::Display m_display_info {};
Graphics::VirtIOGPU::ScanoutID m_scanout_id;

6
Kernel/Graphics/VirtIOGPU/GPU3DDevice.cpp
View file

@ -21,7 +21,7 @@ VirtIOGPU3DDevice::PerContextState::PerContextState(Graphics::VirtIOGPU::Context
{
}
NonnullRefPtr<VirtIOGPU3DDevice> VirtIOGPU3DDevice::must_create(VirtIOGraphicsAdapter const& adapter)
NonnullLockRefPtr<VirtIOGPU3DDevice> VirtIOGPU3DDevice::must_create(VirtIOGraphicsAdapter const& adapter)
{
// Setup memory transfer region
auto region_result = MM.allocate_kernel_region(
@ -48,7 +48,7 @@ void VirtIOGPU3DDevice::detach(OpenFileDescription& description)
CharacterDevice::detach(description);
}
ErrorOr<RefPtr<VirtIOGPU3DDevice::PerContextState>> VirtIOGPU3DDevice::get_context_for_description(OpenFileDescription& description)
ErrorOr<LockRefPtr<VirtIOGPU3DDevice::PerContextState>> VirtIOGPU3DDevice::get_context_for_description(OpenFileDescription& description)
{
auto res = m_context_state_lookup.get(&description);
if (!res.has_value())
@ -66,7 +66,7 @@ ErrorOr<void> VirtIOGPU3DDevice::ioctl(OpenFileDescription& description, unsigne
SpinlockLocker locker(m_graphics_adapter->operation_lock());
// TODO: Delete the context if it fails to be set in m_context_state_lookup
auto context_id = m_graphics_adapter->create_context();
RefPtr<PerContextState> per_context_state = TRY(PerContextState::try_create(context_id));
LockRefPtr<PerContextState> per_context_state = TRY(PerContextState::try_create(context_id));
TRY(m_context_state_lookup.try_set(&description, per_context_state));
return {};
}

12
Kernel/Graphics/VirtIOGPU/GPU3DDevice.h
View file

@ -95,21 +95,21 @@ class VirtIOGPU3DDevice : public CharacterDevice {
friend class DeviceManagement;
public:
static NonnullRefPtr<VirtIOGPU3DDevice> must_create(VirtIOGraphicsAdapter const&);
static NonnullLockRefPtr<VirtIOGPU3DDevice> must_create(VirtIOGraphicsAdapter const&);
private:
VirtIOGPU3DDevice(VirtIOGraphicsAdapter const& graphics_adapter, NonnullOwnPtr<Memory::Region> transfer_buffer_region);
class PerContextState final : public AtomicRefCounted<PerContextState> {
public:
static ErrorOr<RefPtr<PerContextState>> try_create(Graphics::VirtIOGPU::ContextID context_id)
static ErrorOr<LockRefPtr<PerContextState>> try_create(Graphics::VirtIOGPU::ContextID context_id)
{
auto region_result = TRY(MM.allocate_kernel_region(
NUM_TRANSFER_REGION_PAGES * PAGE_SIZE,
"VIRGL3D userspace upload buffer"sv,
Memory::Region::Access::ReadWrite,
AllocationStrategy::AllocateNow));
return TRY(adopt_nonnull_ref_or_enomem(new (nothrow) PerContextState(context_id, move(region_result))));
return TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) PerContextState(context_id, move(region_result))));
}
Graphics::VirtIOGPU::ContextID context_id() { return m_context_id; }
Memory::Region& transfer_buffer_region() { return *m_transfer_buffer_region; }
@ -131,12 +131,12 @@ private:
virtual void detach(OpenFileDescription&) override;
private:
ErrorOr<RefPtr<PerContextState>> get_context_for_description(OpenFileDescription&);
ErrorOr<LockRefPtr<PerContextState>> get_context_for_description(OpenFileDescription&);
NonnullRefPtr<VirtIOGraphicsAdapter> m_graphics_adapter;
NonnullLockRefPtr<VirtIOGraphicsAdapter> m_graphics_adapter;
// Context used for kernel operations (e.g. flushing resources to scanout)
Graphics::VirtIOGPU::ContextID m_kernel_context_id;
HashMap<OpenFileDescription*, RefPtr<PerContextState>> m_context_state_lookup;
HashMap<OpenFileDescription*, LockRefPtr<PerContextState>> m_context_state_lookup;
// Memory management for backing buffers
NonnullOwnPtr<Memory::Region> m_transfer_buffer_region;
constexpr static size_t NUM_TRANSFER_REGION_PAGES = 256;

4
Kernel/Graphics/VirtIOGPU/GraphicsAdapter.cpp
View file

@ -21,7 +21,7 @@ namespace Kernel {
#define DEVICE_EVENTS_CLEAR 0x4
#define DEVICE_NUM_SCANOUTS 0x8
NonnullRefPtr<VirtIOGraphicsAdapter> VirtIOGraphicsAdapter::initialize(PCI::DeviceIdentifier const& device_identifier)
NonnullLockRefPtr<VirtIOGraphicsAdapter> VirtIOGraphicsAdapter::initialize(PCI::DeviceIdentifier const& device_identifier)
{
VERIFY(device_identifier.hardware_id().vendor_id == PCI::VendorID::VirtIO);
// Setup memory transfer region
@ -30,7 +30,7 @@ NonnullRefPtr<VirtIOGraphicsAdapter> VirtIOGraphicsAdapter::initialize(PCI::Devi
"VirtGPU Scratch Space"sv,
Memory::Region::Access::ReadWrite));
auto adapter = adopt_ref(*new (nothrow) VirtIOGraphicsAdapter(device_identifier, move(scratch_space_region)));
auto adapter = adopt_lock_ref(*new (nothrow) VirtIOGraphicsAdapter(device_identifier, move(scratch_space_region)));
adapter->initialize();
MUST(adapter->initialize_adapter());
return adapter;

6
Kernel/Graphics/VirtIOGPU/GraphicsAdapter.h
View file

@ -37,7 +37,7 @@ class VirtIOGraphicsAdapter final
friend class VirtIOGPU3DDevice;
public:
static NonnullRefPtr<VirtIOGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
static NonnullLockRefPtr<VirtIOGraphicsAdapter> initialize(PCI::DeviceIdentifier const&);
virtual void initialize() override;
void initialize_3d_device();
@ -63,7 +63,7 @@ private:
Graphics::VirtIOGPU::ResourceID resource_id { 0 };
};
RefPtr<VirtIODisplayConnector> display_connector;
LockRefPtr<VirtIODisplayConnector> display_connector;
PhysicalBuffer main_buffer;
PhysicalBuffer back_buffer;
};
@ -119,7 +119,7 @@ private:
// Note: Resource ID 0 is invalid, and we must not allocate 0 as the first resource ID.
Atomic<u32> m_resource_id_counter { 1 };
Atomic<u32> m_context_id_counter { 1 };
RefPtr<VirtIOGPU3DDevice> m_3d_device;
LockRefPtr<VirtIOGPU3DDevice> m_3d_device;
bool m_has_virgl_support { false };
// Synchronous commands