RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 17:27:35 +00:00
Code Issues Activity Actions

Kernel/PCI: Break early of controller iteration over devices in OOM case

Browse source 
This is mainly useful when adding an HostController but due to OOM
condition, we abort temporary Vector insertion of a DeviceIdentifier
and then exit the iteration loop to report back the error if occured.
This commit is contained in:
Liav A 2022-02-04 22:11:50 +02:00 • committed by Andreas Kling
parent 3fb289e27d
commit 428d4ae337
5 changed files with 18 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Kernel/Bus/PCI/Access.cpp
View file

@ -133,11 +133,14 @@ ErrorOr<void> Access::add_host_controller_and_enumerate_attached_devices(Nonnull
// definitely before enumerating devices behing that. // definitely before enumerating devices behing that.
m_host_controllers.set(domain_number, move(controller)); m_host_controllers.set(domain_number, move(controller));
ErrorOr<void> expansion_result; ErrorOr<void> expansion_result;
m_host_controllers.get(domain_number).value()->enumerate_attached_devices([&](DeviceIdentifier const& device_identifier) -> void { m_host_controllers.get(domain_number).value()->enumerate_attached_devices([&](DeviceIdentifier const& device_identifier) -> IterationDecision {
m_device_identifiers.append(device_identifier); m_device_identifiers.append(device_identifier);
auto result = device_identifiers_behind_host_controller.try_append(device_identifier); auto result = device_identifiers_behind_host_controller.try_append(device_identifier);
if (result.is_error()) if (result.is_error()) {
expansion_result = result; expansion_result = result;
return IterationDecision::Break;
}
return IterationDecision::Continue;
}); });
if (expansion_result.is_error()) if (expansion_result.is_error())
return expansion_result; return expansion_result;
@ -166,8 +169,9 @@ UNMAP_AFTER_INIT void Access::rescan_hardware()
SpinlockLocker scan_locker(m_scan_lock); SpinlockLocker scan_locker(m_scan_lock);
VERIFY(m_device_identifiers.is_empty()); VERIFY(m_device_identifiers.is_empty());
for (auto it = m_host_controllers.begin(); it != m_host_controllers.end(); ++it) { for (auto it = m_host_controllers.begin(); it != m_host_controllers.end(); ++it) {
(*it).value->enumerate_attached_devices([this](DeviceIdentifier device_identifier) -> void { (*it).value->enumerate_attached_devices([this](DeviceIdentifier device_identifier) -> IterationDecision {
m_device_identifiers.append(device_identifier); m_device_identifiers.append(device_identifier);
return IterationDecision::Continue;
}); });
} }
} }

8
Kernel/Bus/PCI/Controller/HostBridge.cpp
View file

@ -50,7 +50,7 @@ UNMAP_AFTER_INIT Vector<Capability> HostBridge::get_capabilities_for_function(Bu
return capabilities; return capabilities;
} }
UNMAP_AFTER_INIT void HostBridge::enumerate_functions(Function<void(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, FunctionNumber function, bool recursive_search_into_bridges) UNMAP_AFTER_INIT void HostBridge::enumerate_functions(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, FunctionNumber function, bool recursive_search_into_bridges)
{ {
dbgln_if(PCI_DEBUG, "PCI: Enumerating function, bus={}, device={}, function={}", bus, device, function); dbgln_if(PCI_DEBUG, "PCI: Enumerating function, bus={}, device={}, function={}", bus, device, function);
Address address(domain_number(), bus.value(), device.value(), function.value()); Address address(domain_number(), bus.value(), device.value(), function.value());
@ -79,7 +79,7 @@ UNMAP_AFTER_INIT void HostBridge::enumerate_functions(Function<void(DeviceIdenti
} }
} }
UNMAP_AFTER_INIT void HostBridge::enumerate_device(Function<void(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, bool recursive_search_into_bridges) UNMAP_AFTER_INIT void HostBridge::enumerate_device(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, bool recursive_search_into_bridges)
{ {
dbgln_if(PCI_DEBUG, "PCI: Enumerating device in bus={}, device={}", bus, device); dbgln_if(PCI_DEBUG, "PCI: Enumerating device in bus={}, device={}", bus, device);
if (read16_field(bus, device, 0, PCI::RegisterOffset::VENDOR_ID) == PCI::none_value) if (read16_field(bus, device, 0, PCI::RegisterOffset::VENDOR_ID) == PCI::none_value)
@ -93,14 +93,14 @@ UNMAP_AFTER_INIT void HostBridge::enumerate_device(Function<void(DeviceIdentifie
} }
} }
UNMAP_AFTER_INIT void HostBridge::enumerate_bus(Function<void(DeviceIdentifier)> const& callback, BusNumber bus, bool recursive_search_into_bridges) UNMAP_AFTER_INIT void HostBridge::enumerate_bus(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber bus, bool recursive_search_into_bridges)
{ {
dbgln_if(PCI_DEBUG, "PCI: Enumerating bus {}", bus); dbgln_if(PCI_DEBUG, "PCI: Enumerating bus {}", bus);
for (u8 device = 0; device < 32; ++device) for (u8 device = 0; device < 32; ++device)
enumerate_device(callback, bus, device, recursive_search_into_bridges); enumerate_device(callback, bus, device, recursive_search_into_bridges);
} }
UNMAP_AFTER_INIT void HostBridge::enumerate_attached_devices(Function<void(DeviceIdentifier)> callback) UNMAP_AFTER_INIT void HostBridge::enumerate_attached_devices(Function<IterationDecision(DeviceIdentifier)> callback)
{ {
VERIFY(Access::the().access_lock().is_locked()); VERIFY(Access::the().access_lock().is_locked());
VERIFY(Access::the().scan_lock().is_locked()); VERIFY(Access::the().scan_lock().is_locked());

8
Kernel/Bus/PCI/Controller/HostBridge.h
View file

@ -31,7 +31,7 @@ protected:
explicit HostBridge(PCI::Domain const&); explicit HostBridge(PCI::Domain const&);
private: private:
virtual void enumerate_attached_devices(Function<void(DeviceIdentifier)> callback) override; virtual void enumerate_attached_devices(Function<IterationDecision(DeviceIdentifier)> callback) override;
Bitmap m_enumerated_buses; Bitmap m_enumerated_buses;
@ -41,9 +41,9 @@ private:
Optional<u8> get_capabilities_pointer_for_function(BusNumber, DeviceNumber, FunctionNumber); Optional<u8> get_capabilities_pointer_for_function(BusNumber, DeviceNumber, FunctionNumber);
Vector<Capability> get_capabilities_for_function(BusNumber, DeviceNumber, FunctionNumber); Vector<Capability> get_capabilities_for_function(BusNumber, DeviceNumber, FunctionNumber);
void enumerate_bus(Function<void(DeviceIdentifier)> const& callback, BusNumber, bool recursive); void enumerate_bus(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber, bool recursive);
void enumerate_functions(Function<void(DeviceIdentifier)> const& callback, BusNumber, DeviceNumber, FunctionNumber, bool recursive); void enumerate_functions(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber, DeviceNumber, FunctionNumber, bool recursive);
void enumerate_device(Function<void(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, bool recursive); void enumerate_device(Function<IterationDecision(DeviceIdentifier)> const& callback, BusNumber bus, DeviceNumber device, bool recursive);
}; };
} }

2
Kernel/Bus/PCI/Controller/HostController.h
View file

@ -31,7 +31,7 @@ public:
u32 domain_number() const { return m_domain.domain_number(); } u32 domain_number() const { return m_domain.domain_number(); }
virtual void enumerate_attached_devices(Function<void(DeviceIdentifier)> callback) = 0; virtual void enumerate_attached_devices(Function<IterationDecision(DeviceIdentifier)> callback) = 0;
protected: protected:
explicit HostController(PCI::Domain const& domain) explicit HostController(PCI::Domain const& domain)

3
Kernel/Storage/StorageManagement.cpp
View file

@ -5,6 +5,7 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <AK/IterationDecision.h>
#include <AK/Singleton.h> #include <AK/Singleton.h>
#include <AK/StringView.h> #include <AK/StringView.h>
#include <AK/UUID.h> #include <AK/UUID.h>
@ -53,7 +54,7 @@ UNMAP_AFTER_INIT void StorageManagement::enumerate_pci_controllers(bool force_pi
using SubclassID = PCI::MassStorage::SubclassID; using SubclassID = PCI::MassStorage::SubclassID;
if (!kernel_command_line().disable_physical_storage()) { if (!kernel_command_line().disable_physical_storage()) {
MUST(PCI::enumerate([&](PCI::DeviceIdentifier const& device_identifier) { MUST(PCI::enumerate([&](PCI::DeviceIdentifier const& device_identifier) -> void {
if (device_identifier.class_code().value() != to_underlying(PCI::ClassID::MassStorage)) { if (device_identifier.class_code().value() != to_underlying(PCI::ClassID::MassStorage)) {
return; return;
} }