jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 */
6
7#include <AK/Singleton.h>
8#include <Kernel/Bus/PCI/API.h>
9#include <Kernel/CommandLine.h>
10#include <Kernel/KString.h>
11#include <Kernel/Memory/AnonymousVMObject.h>
12#include <Kernel/Multiboot.h>
13#include <Kernel/Net/Intel/E1000ENetworkAdapter.h>
14#include <Kernel/Net/Intel/E1000NetworkAdapter.h>
15#include <Kernel/Net/LoopbackAdapter.h>
16#include <Kernel/Net/NetworkingManagement.h>
17#include <Kernel/Net/Realtek/RTL8168NetworkAdapter.h>
18#include <Kernel/Sections.h>
19
20namespace Kernel {
21
22static Singleton<NetworkingManagement> s_the;
23
24NetworkingManagement& NetworkingManagement::the()
25{
26 return *s_the;
27}
28
29bool NetworkingManagement::is_initialized()
30{
31 return s_the.is_initialized();
32}
33
34UNMAP_AFTER_INIT NetworkingManagement::NetworkingManagement()
35{
36}
37
38NonnullLockRefPtr<NetworkAdapter> NetworkingManagement::loopback_adapter() const
39{
40 return *m_loopback_adapter;
41}
42
43void NetworkingManagement::for_each(Function<void(NetworkAdapter&)> callback)
44{
45 m_adapters.for_each([&](auto& adapter) {
46 callback(adapter);
47 });
48}
49
50ErrorOr<void> NetworkingManagement::try_for_each(Function<ErrorOr<void>(NetworkAdapter&)> callback)
51{
52 return m_adapters.with([&](auto& adapters) -> ErrorOr<void> {
53 for (auto& adapter : adapters)
54 TRY(callback(adapter));
55 return {};
56 });
57}
58
59LockRefPtr<NetworkAdapter> NetworkingManagement::from_ipv4_address(IPv4Address const& address) const
60{
61 if (address[0] == 0 && address[1] == 0 && address[2] == 0 && address[3] == 0)
62 return m_loopback_adapter;
63 if (address[0] == 127)
64 return m_loopback_adapter;
65 return m_adapters.with([&](auto& adapters) -> LockRefPtr<NetworkAdapter> {
66 for (auto& adapter : adapters) {
67 if (adapter->ipv4_address() == address || adapter->ipv4_broadcast() == address)
68 return adapter;
69 }
70 return nullptr;
71 });
72}
73
74LockRefPtr<NetworkAdapter> NetworkingManagement::lookup_by_name(StringView name) const
75{
76 return m_adapters.with([&](auto& adapters) -> LockRefPtr<NetworkAdapter> {
77 for (auto& adapter : adapters) {
78 if (adapter->name() == name)
79 return adapter;
80 }
81 return nullptr;
82 });
83}
84
85ErrorOr<NonnullOwnPtr<KString>> NetworkingManagement::generate_interface_name_from_pci_address(PCI::DeviceIdentifier const& device_identifier)
86{
87 VERIFY(device_identifier.class_code().value() == 0x2);
88 // Note: This stands for e - "Ethernet", p - "Port" as for PCI bus, "s" for slot as for PCI slot
89 auto name = TRY(KString::formatted("ep{}s{}", device_identifier.address().bus(), device_identifier.address().device()));
90 VERIFY(!NetworkingManagement::the().lookup_by_name(name->view()));
91 return name;
92}
93
94struct PCINetworkDriverInitializer {
95 ErrorOr<bool> (*probe)(PCI::DeviceIdentifier const&) = nullptr;
96 ErrorOr<NonnullLockRefPtr<NetworkAdapter>> (*create)(PCI::DeviceIdentifier const&) = nullptr;
97};
98
99static constexpr PCINetworkDriverInitializer s_initializers[] = {
100 { RTL8168NetworkAdapter::probe, RTL8168NetworkAdapter::create },
101 { E1000NetworkAdapter::probe, E1000NetworkAdapter::create },
102 { E1000ENetworkAdapter::probe, E1000ENetworkAdapter::create },
103};
104
105UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<NetworkAdapter>> NetworkingManagement::determine_network_device(PCI::DeviceIdentifier const& device_identifier) const
106{
107 for (auto& initializer : s_initializers) {
108 auto initializer_probe_found_driver_match_or_error = initializer.probe(device_identifier);
109 if (initializer_probe_found_driver_match_or_error.is_error()) {
110 dmesgln("Networking: Failed to probe device {}, due to {}", device_identifier.address(), initializer_probe_found_driver_match_or_error.error());
111 continue;
112 }
113 auto initializer_probe_found_driver_match = initializer_probe_found_driver_match_or_error.release_value();
114 if (initializer_probe_found_driver_match) {
115 auto adapter = TRY(initializer.create(device_identifier));
116 TRY(adapter->initialize({}));
117 return adapter;
118 }
119 }
120 dmesgln("Networking: Failed to initialize device {}, unsupported network adapter", device_identifier.address());
121 return Error::from_errno(ENODEV);
122}
123
124bool NetworkingManagement::initialize()
125{
126 if (!kernel_command_line().is_physical_networking_disabled() && !PCI::Access::is_disabled()) {
127 MUST(PCI::enumerate([&](PCI::DeviceIdentifier const& device_identifier) {
128 // Note: PCI class 2 is the class of Network devices
129 if (device_identifier.class_code().value() != 0x02)
130 return;
131 auto result = determine_network_device(device_identifier);
132 if (result.is_error()) {
133 dmesgln("Failed to initialize network adapter ({} {}): {}", device_identifier.address(), device_identifier.hardware_id(), result.error());
134 return;
135 }
136 m_adapters.with([&](auto& adapters) { adapters.append(result.release_value()); });
137 }));
138 }
139 auto loopback = LoopbackAdapter::try_create();
140 VERIFY(loopback);
141 m_adapters.with([&](auto& adapters) { adapters.append(*loopback); });
142 m_loopback_adapter = loopback;
143 return true;
144}
145}