Kernel: Add dmesgln_pci logging for Kernel::PCI

A virtual method named device_name() was added to
Kernel::PCI to support logging the PCI::Device name
and address using dmesgln_pci. Previously, PCI::Device
did not store the device name.

All devices inheriting from PCI::Device now use dmesgln_pci where
they previously used dmesgln.

8 files changed, 47 insertions, 42 deletions

diff --git a/Kernel/Net/Intel/E1000NetworkAdapter.cpp b/Kernel/Net/Intel/E1000NetworkAdapter.cpp
index baaf77ffbc..7b5f4a11da 100644
--- a/Kernel/Net/Intel/E1000NetworkAdapter.cpp
+++ b/Kernel/Net/Intel/E1000NetworkAdapter.cpp
@@ -192,16 +192,17 @@ UNMAP_AFTER_INIT void E1000NetworkAdapter::setup_interrupts()
 
 UNMAP_AFTER_INIT bool E1000NetworkAdapter::initialize()
 {
-    dmesgln("E1000: Found @ {}", pci_address());
+    dmesgln_pci(*this, "Found @ {}", pci_address());
+
     enable_bus_mastering(pci_address());
 
-    dmesgln("E1000: IO base: {}", m_registers_io_window);
-    dmesgln("E1000: Interrupt line: {}", interrupt_number());
+    dmesgln_pci(*this, "IO base: {}", m_registers_io_window);
+    dmesgln_pci(*this, "Interrupt line: {}", interrupt_number());
     detect_eeprom();
-    dmesgln("E1000: Has EEPROM? {}", m_has_eeprom);
+    dmesgln_pci(*this, "Has EEPROM? {}", m_has_eeprom);
     read_mac_address();
     auto const& mac = mac_address();
-    dmesgln("E1000: MAC address: {}", mac.to_string());
+    dmesgln_pci(*this, "MAC address: {}", mac.to_string());
 
     initialize_rx_descriptors();
     initialize_tx_descriptors();
diff --git a/Kernel/Net/Intel/E1000NetworkAdapter.h b/Kernel/Net/Intel/E1000NetworkAdapter.h
index d14920dda5..4869c40c84 100644
--- a/Kernel/Net/Intel/E1000NetworkAdapter.h
+++ b/Kernel/Net/Intel/E1000NetworkAdapter.h
@@ -32,6 +32,7 @@ public:
     virtual bool link_full_duplex() override;
 
     virtual StringView purpose() const override { return class_name(); }
+    virtual StringView device_name() const override { return "E1000"sv; }
 
 protected:
     void setup_interrupts();
diff --git a/Kernel/Net/NE2000/NetworkAdapter.cpp b/Kernel/Net/NE2000/NetworkAdapter.cpp
index 65fba19d1f..3df63f0be9 100644
--- a/Kernel/Net/NE2000/NetworkAdapter.cpp
+++ b/Kernel/Net/NE2000/NetworkAdapter.cpp
@@ -169,17 +169,17 @@ UNMAP_AFTER_INIT NE2000NetworkAdapter::NE2000NetworkAdapter(PCI::Address address
     , IRQHandler(irq)
     , m_registers_io_window(move(registers_io_window))
 {
-    dmesgln("NE2000: Found @ {}", pci_address());
+    dmesgln_pci(*this, "Found @ {}", pci_address());
 
-    dmesgln("NE2000: Port base: {}", m_registers_io_window);
-    dmesgln("NE2000: Interrupt line: {}", interrupt_number());
+    dmesgln_pci(*this, "Port base: {}", m_registers_io_window);
+    dmesgln_pci(*this, "Interrupt line: {}", interrupt_number());
 
     int ram_errors = ram_test();
-    dmesgln("NE2000: RAM test {}, got {} byte errors", (ram_errors == 0 ? "OK" : "KO"), ram_errors);
+    dmesgln_pci(*this, "RAM test {}, got {} byte errors", (ram_errors == 0 ? "OK" : "KO"), ram_errors);
 
     reset();
     set_mac_address(m_mac_address);
-    dmesgln("NE2000: MAC address: {}", m_mac_address.to_string());
+    dmesgln_pci(*this, "MAC address: {}", m_mac_address.to_string());
     enable_irq();
 }
 
@@ -206,22 +206,22 @@ bool NE2000NetworkAdapter::handle_irq(RegisterState const&)
         u8 fae = in8(REG_RD_FAE_TALLY);
         u8 crc = in8(REG_RD_CRC_TALLY);
         u8 miss = in8(REG_RD_MISS_PKT_TALLY);
-        dmesgln("NE2000NetworkAdapter: Packet reception error framing={} crc={} missed={}", fae, crc, miss);
+        dmesgln_pci(*this, "Packet reception error framing={} crc={} missed={}", fae, crc, miss);
         // TODO: handle counters
     }
     if (status & BIT_INTERRUPTMASK_TXE) {
-        dmesgln("NE2000NetworkAdapter: Packet transmission error");
+        dmesgln_pci(*this, "Packet transmission error");
     }
     if (status & BIT_INTERRUPTMASK_OVW) {
-        dmesgln("NE2000NetworkAdapter: Ring buffer reception overflow error");
+        dmesgln_pci(*this, "Ring buffer reception overflow error");
         // TODO: handle counters
     }
     if (status & BIT_INTERRUPTMASK_CNT) {
-        dmesgln("NE2000NetworkAdapter: Counter overflow error");
+        dmesgln_pci(*this, "Counter overflow error");
         // TODO: handle counters
     }
     if (status & BIT_INTERRUPTMASK_RST) {
-        dmesgln("NE2000NetworkAdapter: NIC requires reset due to packet reception overflow");
+        dmesgln_pci(*this, "NIC requires reset due to packet reception overflow");
         // TODO: proper reset procedure
         reset();
     }
@@ -371,12 +371,12 @@ void NE2000NetworkAdapter::send_raw(ReadonlyBytes payload)
     dbgln_if(NE2000_DEBUG, "NE2000NetworkAdapter: Sending packet length={}", payload.size());
 
     if (payload.size() > NE2K_RAM_SEND_SIZE) {
-        dmesgln("NE2000NetworkAdapter: Packet to send was too big; discarding");
+        dmesgln_pci(*this, "Packet to send was too big; discarding");
         return;
     }
 
     while (in8(REG_RW_COMMAND) & BIT_COMMAND_TXP)
-        m_wait_queue.wait_forever("NE2000NetworkAdapter"sv);
+        m_wait_queue.wait_forever(device_name());
 
     disable_irq();
     size_t packet_size = payload.size();
diff --git a/Kernel/Net/NE2000/NetworkAdapter.h b/Kernel/Net/NE2000/NetworkAdapter.h
index ee37fdd6a2..33328fa0a2 100644
--- a/Kernel/Net/NE2000/NetworkAdapter.h
+++ b/Kernel/Net/NE2000/NetworkAdapter.h
@@ -39,6 +39,7 @@ public:
     virtual bool link_full_duplex() override { return true; }
 
     virtual StringView purpose() const override { return class_name(); }
+    virtual StringView device_name() const override { return class_name(); }
 
 private:
     NE2000NetworkAdapter(PCI::Address, u8, NonnullOwnPtr<IOWindow> registers_io_window, NonnullOwnPtr<KString>);
diff --git a/Kernel/Net/Realtek/RTL8139NetworkAdapter.cpp b/Kernel/Net/Realtek/RTL8139NetworkAdapter.cpp
index 3d2fecdb89..b856814511 100644
--- a/Kernel/Net/Realtek/RTL8139NetworkAdapter.cpp
+++ b/Kernel/Net/Realtek/RTL8139NetworkAdapter.cpp
@@ -133,12 +133,12 @@ UNMAP_AFTER_INIT RTL8139NetworkAdapter::RTL8139NetworkAdapter(PCI::Address addre
 {
     m_tx_buffers.ensure_capacity(RTL8139_TX_BUFFER_COUNT);
 
-    dmesgln("RTL8139: Found @ {}", pci_address());
+    dmesgln_pci(*this, "Found @ {}", pci_address());
 
     enable_bus_mastering(pci_address());
 
-    dmesgln("RTL8139: I/O port base: {}", m_registers_io_window);
-    dmesgln("RTL8139: Interrupt line: {}", interrupt_number());
+    dmesgln_pci(*this, "I/O port base: {}", m_registers_io_window);
+    dmesgln_pci(*this, "Interrupt line: {}", interrupt_number());
 
     // we add space to account for overhang from the last packet - the rtl8139
     // can optionally guarantee that packets will be contiguous by
@@ -154,7 +154,7 @@ UNMAP_AFTER_INIT RTL8139NetworkAdapter::RTL8139NetworkAdapter(PCI::Address addre
 
     read_mac_address();
     auto const& mac = mac_address();
-    dmesgln("RTL8139: MAC address: {}", mac.to_string());
+    dmesgln_pci(*this, "MAC address: {}", mac.to_string());
 
     enable_irq();
 }
@@ -181,31 +181,31 @@ bool RTL8139NetworkAdapter::handle_irq(RegisterState const&)
             receive();
         }
         if (status & INT_RXERR) {
-            dmesgln("RTL8139: RX error - resetting device");
+            dmesgln_pci(*this, "RX error - resetting device");
             reset();
         }
         if (status & INT_TXOK) {
             dbgln_if(RTL8139_DEBUG, "RTL8139: TX complete");
         }
         if (status & INT_TXERR) {
-            dmesgln("RTL8139: TX error - resetting device");
+            dmesgln_pci(*this, "TX error - resetting device");
             reset();
         }
         if (status & INT_RX_BUFFER_OVERFLOW) {
-            dmesgln("RTL8139: RX buffer overflow");
+            dmesgln_pci(*this, "RX buffer overflow");
         }
         if (status & INT_LINK_CHANGE) {
             m_link_up = (in8(REG_MSR) & MSR_LINKB) == 0;
-            dmesgln("RTL8139: Link status changed up={}", m_link_up);
+            dmesgln_pci(*this, "Link status changed up={}", m_link_up);
         }
         if (status & INT_RX_FIFO_OVERFLOW) {
-            dmesgln("RTL8139: RX FIFO overflow");
+            dmesgln_pci(*this, "RX FIFO overflow");
         }
         if (status & INT_LENGTH_CHANGE) {
-            dmesgln("RTL8139: Cable length change");
+            dmesgln_pci(*this, "Cable length change");
         }
         if (status & INT_SYSTEM_ERROR) {
-            dmesgln("RTL8139: System error - resetting device");
+            dmesgln_pci(*this, "System error - resetting device");
             reset();
         }
     }
@@ -278,7 +278,7 @@ void RTL8139NetworkAdapter::send_raw(ReadonlyBytes payload)
     dbgln_if(RTL8139_DEBUG, "RTL8139: send_raw length={}", payload.size());
 
     if (payload.size() > PACKET_SIZE_MAX) {
-        dmesgln("RTL8139: Packet was too big; discarding");
+        dmesgln_pci(*this, "Packet was too big; discarding");
         return;
     }
 
@@ -294,7 +294,7 @@ void RTL8139NetworkAdapter::send_raw(ReadonlyBytes payload)
     }
 
     if (hw_buffer == -1) {
-        dmesgln("RTL8139: Hardware buffers full; discarding packet");
+        dmesgln_pci(*this, "Hardware buffers full; discarding packet");
         return;
     }
 
@@ -327,7 +327,7 @@ void RTL8139NetworkAdapter::receive()
     dbgln_if(RTL8139_DEBUG, "RTL8139: receive, status={:#04x}, length={}, offset={}", status, length, m_rx_buffer_offset);
 
     if (!(status & RX_OK) || (status & (RX_INVALID_SYMBOL_ERROR | RX_CRC_ERROR | RX_FRAME_ALIGNMENT_ERROR)) || (length >= PACKET_SIZE_MAX) || (length < PACKET_SIZE_MIN)) {
-        dmesgln("RTL8139: receive got bad packet, status={:#04x}, length={}", status, length);
+        dmesgln_pci(*this, "receive got bad packet, status={:#04x}, length={}", status, length);
         reset();
         return;
     }
diff --git a/Kernel/Net/Realtek/RTL8139NetworkAdapter.h b/Kernel/Net/Realtek/RTL8139NetworkAdapter.h
index 6d95c85785..b1062b8f4b 100644
--- a/Kernel/Net/Realtek/RTL8139NetworkAdapter.h
+++ b/Kernel/Net/Realtek/RTL8139NetworkAdapter.h
@@ -32,6 +32,7 @@ public:
     virtual bool link_full_duplex() override;
 
     virtual StringView purpose() const override { return class_name(); }
+    virtual StringView device_name() const override { return "RTL8139"sv; }
 
 private:
     RTL8139NetworkAdapter(PCI::Address, u8 irq, NonnullOwnPtr<IOWindow> registers_io_window, NonnullOwnPtr<KString>);
diff --git a/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp b/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp
index d61d0f629d..5d5f7d8a25 100644
--- a/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp
+++ b/Kernel/Net/Realtek/RTL8168NetworkAdapter.cpp
@@ -247,14 +247,14 @@ UNMAP_AFTER_INIT RTL8168NetworkAdapter::RTL8168NetworkAdapter(PCI::Address addre
     , m_rx_descriptors_region(MM.allocate_contiguous_kernel_region(Memory::page_round_up(sizeof(TXDescriptor) * (number_of_rx_descriptors + 1)).release_value_but_fixme_should_propagate_errors(), "RTL8168 RX"sv, Memory::Region::Access::ReadWrite).release_value())
     , m_tx_descriptors_region(MM.allocate_contiguous_kernel_region(Memory::page_round_up(sizeof(RXDescriptor) * (number_of_tx_descriptors + 1)).release_value_but_fixme_should_propagate_errors(), "RTL8168 TX"sv, Memory::Region::Access::ReadWrite).release_value())
 {
-    dmesgln("RTL8168: Found @ {}", pci_address());
-    dmesgln("RTL8168: I/O port base: {}", m_registers_io_window);
+    dmesgln_pci(*this, "Found @ {}", pci_address());
+    dmesgln_pci(*this, "I/O port base: {}", m_registers_io_window);
 
     identify_chip_version();
-    dmesgln("RTL8168: Version detected - {} ({}{})", possible_device_name(), (u8)m_version, m_version_uncertain ? "?" : "");
+    dmesgln_pci(*this, "Version detected - {} ({}{})", possible_device_name(), (u8)m_version, m_version_uncertain ? "?" : "");
 
     if (!determine_supported_version()) {
-        dmesgln("RTL8168: Aborting initialization! Support for your chip version ({}) is not implemented yet, please open a GH issue and include this message.", (u8)m_version);
+        dmesgln_pci(*this, "Aborting initialization! Support for your chip version ({}) is not implemented yet, please open a GH issue and include this message.", (u8)m_version);
         return; // Each ChipVersion requires a specific implementation of configure_phy and hardware_quirks
     }
 
@@ -332,7 +332,7 @@ void RTL8168NetworkAdapter::initialize()
     enable_bus_mastering(pci_address());
 
     read_mac_address();
-    dmesgln("RTL8168: MAC address: {}", mac_address().to_string());
+    dmesgln_pci(*this, "MAC address: {}", mac_address().to_string());
 
     // notify about driver start
     if (m_version >= ChipVersion::Version11 && m_version <= ChipVersion::Version13) {
@@ -1155,19 +1155,19 @@ bool RTL8168NetworkAdapter::handle_irq(RegisterState const&)
             dbgln_if(RTL8168_DEBUG, "RTL8168: TX error - invalid packet");
         }
         if (status & INT_RX_OVERFLOW) {
-            dmesgln("RTL8168: RX descriptor unavailable (packet lost)");
+            dmesgln_pci(*this, "RX descriptor unavailable (packet lost)");
             receive();
         }
         if (status & INT_LINK_CHANGE) {
             m_link_up = (in8(REG_PHYSTATUS) & PHY_LINK_STATUS) != 0;
-            dmesgln("RTL8168: Link status changed up={}", m_link_up);
+            dmesgln_pci(*this, "Link status changed up={}", m_link_up);
         }
         if (status & INT_RX_FIFO_OVERFLOW) {
-            dmesgln("RTL8168: RX FIFO overflow");
+            dmesgln_pci(*this, "RX FIFO overflow");
             receive();
         }
         if (status & INT_SYS_ERR) {
-            dmesgln("RTL8168: Fatal system error");
+            dmesgln_pci(*this, "Fatal system error");
         }
     }
     return was_handled;
@@ -1193,7 +1193,7 @@ void RTL8168NetworkAdapter::send_raw(ReadonlyBytes payload)
     dbgln_if(RTL8168_DEBUG, "RTL8168: send_raw length={}", payload.size());
 
     if (payload.size() > TX_BUFFER_SIZE) {
-        dmesgln("RTL8168: Packet was too big; discarding");
+        dmesgln_pci(*this, "Packet was too big; discarding");
         return;
     }
 
@@ -1237,7 +1237,7 @@ void RTL8168NetworkAdapter::receive()
         dbgln_if(RTL8168_DEBUG, "RTL8168: receive, flags={:#04x}, length={}, descriptor={}", flags, length, descriptor_index);
 
         if (length > RX_BUFFER_SIZE || (flags & RXDescriptor::ErrorSummary) != 0) {
-            dmesgln("RTL8168: receive got bad packet, flags={:#04x}, length={}", flags, length);
+            dmesgln_pci(*this, "receive got bad packet, flags={:#04x}, length={}", flags, length);
         } else if ((flags & RXDescriptor::FirstSegment) != 0 && (flags & RXDescriptor::LastSegment) == 0) {
             VERIFY_NOT_REACHED();
             // Our maximum received packet size is smaller than the descriptor buffer size, so packets should never be segmented
diff --git a/Kernel/Net/Realtek/RTL8168NetworkAdapter.h b/Kernel/Net/Realtek/RTL8168NetworkAdapter.h
index b075c25aee..3a552306f9 100644
--- a/Kernel/Net/Realtek/RTL8168NetworkAdapter.h
+++ b/Kernel/Net/Realtek/RTL8168NetworkAdapter.h
@@ -32,6 +32,7 @@ public:
     virtual i32 link_speed() override;
 
     virtual StringView purpose() const override { return class_name(); }
+    virtual StringView device_name() const override { return class_name(); }
 
 private:
     // FIXME: should this be increased? (maximum allowed here is 1024) - memory usage vs packet loss chance tradeoff