feat(driver): add e1000e driver

.clang-format

@@ -16,7 +16,7 @@ Standard: Cpp11
 IncludeCategories:
   - Regex: '^<types/'
     Priority: '4'
-  - Regex: '^<(kernel|fs)/'
+  - Regex: '^<(kernel|fs|net|driver)/'
     Priority: '5'
   - Regex: '^<.*\.h>'
     Priority: '3'

.gdbinit

@@ -6,6 +6,6 @@ set output-radix 16
 symbol-file build/kernel.out
 target remote:1234
 
-# layout src
-b tmpfs::mkdir
+layout src
+b do_socket
 c

CMakeLists.txt

@@ -38,6 +38,7 @@ set(KERNEL_MAIN_SOURCES src/dev/builtin-chardev.cc
                         src/fs/fat.cpp
                         src/fs/tmpfs.cc
                         src/fs/procfs.cc
+                        src/driver/e1000e.cc
                         src/kinit.cpp
                         src/kernel/async/waitlist.cc
                         src/kernel/async/lock.cc
@@ -56,6 +57,7 @@ set(KERNEL_MAIN_SOURCES src/dev/builtin-chardev.cc
                         src/kernel/module.cc
                         src/kernel/vfs.cpp
                         src/kernel/vga.cpp
+                        src/kernel/hw/acpi.cc
                         src/kernel/hw/ahci.cc
                         src/kernel/hw/pci.cc
                         src/kernel/hw/serial.cc
@@ -68,8 +70,13 @@ set(KERNEL_MAIN_SOURCES src/dev/builtin-chardev.cc
                         src/kernel/vfs/inode.cc
                         src/kernel/vfs/vfs.cc
                         src/kernel/signal.cpp
+                        src/net/ethernet.cc
+                        src/net/netdev.cc
+                        src/types/crc.cc
                         src/types/elf.cpp
                         src/types/libstdcpp.cpp
+                        include/defs.hpp
+                        include/driver/e1000e.hpp
                         include/fs/fat.hpp
                         include/kernel/async/waitlist.hpp
                         include/kernel/async/lock.hpp
@@ -96,12 +103,16 @@ set(KERNEL_MAIN_SOURCES src/dev/builtin-chardev.cc
                         include/kernel/task/forward.hpp
                         include/kernel/task/thread.hpp
                         include/kernel/task/readyqueue.hpp
+                        include/kernel/hw/acpi.hpp
                         include/kernel/hw/pci.hpp
                         include/kernel/hw/port.hpp
                         include/kernel/hw/serial.hpp
                         include/kernel/hw/timer.hpp
                         include/kernel/input/keycodes.h
                         include/kernel/user/thread_local.hpp
+                        include/net/arp.hpp
+                        include/net/ethernet.hpp
+                        include/net/netdev.hpp
                         include/types/bitmap.hpp
                         include/types/buffer.hpp
                         include/types/elf.hpp

gblibc/include/errno.h

@@ -17,6 +17,7 @@ extern int* __errno_location(void);
 #define EIO 5
 #define EBADF 9
 #define ECHILD 10
+#define EAGAIN 11
 #define ENOMEM 12
 #define EACCES 13
 #define EFAULT 14

include/defs.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <types/types.h>
+
+using u8 = uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+using u64 = uint64_t;
+using usize = size_t;
+
+using i8 = int8_t;
+using i16 = int16_t;
+using i32 = int32_t;
+using i64 = int64_t;
+using isize = ssize_t;
+
+template <typename T>
+constexpr bool test(T x, T y) {
+    return (x & y) == y;
+}

include/driver/e1000e.hpp

@@ -0,0 +1,229 @@
+#include <defs.hpp>
+
+namespace hw::e1000e {
+
+// Register names
+// Control register
+constexpr u32 REG_CTRL = 0x00000;
+// Status register
+constexpr u32 REG_STATUS = 0x00008;
+// Interrupt cause register
+constexpr u32 REG_ICR = 0x000C0;
+// Interrupt mask set/clear register
+constexpr u32 REG_IMS = 0x000D0;
+// Interrupt mask clear register
+constexpr u32 REG_IMC = 0x000D8;
+
+// Receive control
+constexpr u32 REG_RCTL = 0x00100;
+
+// These registers are per-queue
+
+// Receive descriptor base address low
+constexpr u32 REG_RDBAL = 0x02800;
+// Receive descriptor base address high
+constexpr u32 REG_RDBAH = 0x02804;
+// Receive descriptor length
+constexpr u32 REG_RDLEN = 0x02808;
+// Receive descriptor head
+constexpr u32 REG_RDH = 0x02810;
+// Receive descriptor tail
+constexpr u32 REG_RDT = 0x02818;
+// Receive descriptor control
+constexpr u32 REG_RXDCTL = 0x02828;
+
+// Transmit control
+constexpr u32 REG_TCTL = 0x00400;
+
+// These registers are per-queue
+
+// Transmit descriptor base address low
+constexpr u32 REG_TDBAL = 0x03800;
+// Transmit descriptor base address high
+constexpr u32 REG_TDBAH = 0x03804;
+// Transmit descriptor length
+constexpr u32 REG_TDLEN = 0x03808;
+// Transmit descriptor head
+constexpr u32 REG_TDH = 0x03810;
+// Transmit descriptor tail
+constexpr u32 REG_TDT = 0x03818;
+// Transmit descriptor control
+constexpr u32 REG_TXDCTL = 0x03828;
+
+// Collision counter
+constexpr u32 REG_COLC = 0x04028;
+// Good packets received counter
+constexpr u32 REG_GPRC = 0x04074;
+// Multicast packets received counter
+constexpr u32 REG_MPRC = 0x0407C;
+// Good packets transmitted counter
+constexpr u32 REG_GPTC = 0x04080;
+// Good octets received counter low
+constexpr u32 REG_GORCL = 0x04088;
+// Good octets received counter high
+constexpr u32 REG_GORCH = 0x0408C;
+// Good octets transmitted counter low
+constexpr u32 REG_GOTCL = 0x04090;
+// Good octets transmitted counter high
+constexpr u32 REG_GOTCH = 0x04094;
+
+// Full-duplex
+constexpr u32 CTRL_FD = 0x00000001;
+// GIO master disable
+constexpr u32 CTRL_GIOD = 0x00000004;
+// Set link up
+constexpr u32 CTRL_SLU = 0x00000040;
+// Software reset
+constexpr u32 CTRL_RST = 0x04000000;
+// Receive flow control enable
+constexpr u32 CTRL_RFCE = 0x08000000;
+// Transmit flow control enable
+constexpr u32 CTRL_TFCE = 0x10000000;
+
+// Full-duplex
+constexpr u32 STATUS_FD = 0x00000001;
+// Link up
+constexpr u32 STATUS_LU = 0x00000002;
+// Transmit paused
+constexpr u32 STATUS_TXOFF = 0x00000010;
+// Link speed settings
+constexpr u32 STATUS_SPEED_MASK = 0x000000C0;
+constexpr u32 STATUS_SPEED_10M = 0x00000000;
+constexpr u32 STATUS_SPEED_100M = 0x00000040;
+constexpr u32 STATUS_SPEED_1000M = 0x00000080;
+// GIO master enable
+constexpr u32 STATUS_GIOE = 0x00080000;
+
+// Receive control enable
+constexpr u32 RCTL_EN = 0x00000002;
+// Store bad packets
+constexpr u32 RCTL_SBP = 0x00000004;
+// Unicast promiscuous mode
+constexpr u32 RCTL_UPE = 0x00000008;
+// Multicast promiscuous mode
+constexpr u32 RCTL_MPE = 0x00000010;
+// Long packet enable
+constexpr u32 RCTL_LPE = 0x00000020;
+// Loopback mode
+constexpr u32 RCTL_LBM_MASK = 0x000000C0;
+constexpr u32 RCTL_LBM_NO = 0x00000000;
+constexpr u32 RCTL_LBM_MAC = 0x00000040;
+// Receive descriptor minimum threshold size
+constexpr u32 RCTL_RDMTS_MASK = 0x00000300;
+constexpr u32 RCTL_RDMTS_HALF = 0x00000000;
+constexpr u32 RCTL_RDMTS_QUARTER = 0x00000100;
+constexpr u32 RCTL_RDMTS_EIGHTH = 0x00000200;
+// Receive descriptor type
+constexpr u32 RCTL_DTYP_MASK = 0x00000C00;
+constexpr u32 RCTL_DTYP_LEGACY = 0x00000000;
+constexpr u32 RCTL_DTYP_SPLIT = 0x00000400;
+// Multicast offset
+constexpr u32 RCTL_MO_MASK = 0x00003000;
+// Broadcast accept mode
+constexpr u32 RCTL_BAM = 0x00008000;
+// Receive buffer size
+constexpr u32 RCTL_BSIZE_MASK = 0x00030000;
+constexpr u32 RCTL_BSIZE_2048 = 0x00000000;
+constexpr u32 RCTL_BSIZE_1024 = 0x00010000;
+constexpr u32 RCTL_BSIZE_512 = 0x00020000;
+constexpr u32 RCTL_BSIZE_256 = 0x00030000;
+// VLAN filter enable
+constexpr u32 RCTL_VFE = 0x00040000;
+// Canonical form indicator enable
+constexpr u32 RCTL_CFIEN = 0x00080000;
+// Canonical form indicator bit value
+constexpr u32 RCTL_CFI = 0x00100000;
+// Discard pause frames
+constexpr u32 RCTL_DPF = 0x00400000;
+// Pass MAC control frames
+constexpr u32 RCTL_PMCF = 0x00800000;
+// Buffer size extension
+constexpr u32 RCTL_BSEX = 0x02000000;
+// Strip Ethernet CRC
+constexpr u32 RCTL_SECRC = 0x04000000;
+// Flexible buffer size
+constexpr u32 RCTL_FLXBUF_MASK = 0x78000000;
+constexpr u32 RCTL_BSIZE_16384 = (RCTL_BSIZE_1024 | RCTL_BSEX);
+constexpr u32 RCTL_BSIZE_8192 = (RCTL_BSIZE_512 | RCTL_BSEX);
+constexpr u32 RCTL_BSIZE_4096 = (RCTL_BSIZE_256 | RCTL_BSEX);
+
+// Transmit control enable
+constexpr u32 TCTL_EN = 0x00000002;
+// Pad short packets
+constexpr u32 TCTL_PSP = 0x00000008;
+// Collision threshold
+constexpr u32 TCTL_CT_MASK = 0x00000ff0;
+constexpr u32 TCTL_CT_SHIFT = 4;
+// Collision distance
+constexpr u32 TCTL_COLD_MASK = 0x003ff000;
+constexpr u32 TCTL_COLD_SHIFT = 12;
+// Software XOFF transmission
+constexpr u32 TCTL_SWXOFF = 0x00400000;
+// Packet burst enable
+constexpr u32 TCTL_PBE = 0x00800000;
+// Re-transmit on late collision
+constexpr u32 TCTL_RTLC = 0x01000000;
+
+// Transmit descriptor written back
+constexpr u32 ICR_TXDW = 0x00000001;
+// Link status change
+constexpr u32 ICR_LSC = 0x00000004;
+// Receive sequence error
+constexpr u32 ICR_RXSEQ = 0x00000008;
+// Receive descriptor minimum threshold
+constexpr u32 ICR_RXDMT0 = 0x00000010;
+// Receive overrun
+constexpr u32 ICR_RXO = 0x00000040;
+// Receive timer expired
+constexpr u32 ICR_RXT0 = 0x00000080;
+// MDIO access complete
+constexpr u32 ICR_MDAC = 0x00000200;
+// Transmit descriptor low minimum threshold
+constexpr u32 ICR_TXD_LOW = 0x00008000;
+// Small packet received
+constexpr u32 ICR_SRPD = 0x00010000;
+// ACK frame received
+constexpr u32 ICR_ACK = 0x0020000;
+// Management frame received
+constexpr u32 ICR_MNG = 0x0040000;
+// Other interrupt
+constexpr u32 ICR_OTHER = 0x01000000;
+// Interrupt asserted
+constexpr u32 ICR_INT = 0x80000000;
+
+constexpr u32 ICR_NORMAL =
+    (ICR_LSC | ICR_RXO | ICR_MDAC | ICR_SRPD | ICR_ACK | ICR_MNG);
+constexpr u32 ICR_UP = (ICR_TXDW | ICR_RXSEQ | ICR_RXDMT0 | ICR_RXT0);
+
+struct RxDescriptor {
+    u64 bufferAddress;
+    u16 length;
+    u16 volatile csum; // Checksum
+    u8 volatile status;
+    u8 volatile errors;
+    u16 vlan;
+};
+
+// Descriptor done
+constexpr u8 RXD_STAT_DD = 0x01;
+
+struct TxDescriptor {
+    u64 bufferAddress;
+    u16 length;
+    u8 cso; // Checksum offset
+    u8 cmd;
+    u8 volatile status;
+    u8 css; // Checksum start
+    u16 vlan;
+};
+
+// Descriptor done
+constexpr u8 TXD_STAT_DD = 0x01;
+// End of packet
+constexpr u8 TXD_CMD_EOP = 0x01;
+// Insert FCS
+constexpr u8 TXD_CMD_IFCS = 0x02;
+// Report status
+constexpr u8 TXD_CMD_RS = 0x08;
+
+} // namespace hw::e1000e

include/kernel/hw/acpi.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <types/path.hpp>
+#include <types/types.h>
+
+namespace kernel::hw::acpi {
+
+struct PACKED ACPI_table_header {
+    char signature[4];
+    uint32_t length;
+    uint8_t revision;
+    uint8_t checksum;
+    uint8_t oemid[6];
+    uint8_t oem_table_id[8];
+    uint32_t oem_revision;
+    uint32_t creator_id;
+    uint32_t creator_revision;
+};
+
+struct PACKED MCFG {
+    ACPI_table_header header;
+    uint64_t : 64;
+    struct MCFG_entry {
+        uint64_t base_address;
+        uint16_t segment_group;
+        uint8_t start_bus;
+        uint8_t end_bus;
+        uint32_t : 32;
+    } entries[];
+};
+
+int parse_acpi_tables();
+void* get_table(types::string_view name);
+
+} // namespace kernel::hw::acpi

include/kernel/hw/pci.hpp

@@ -1,9 +1,14 @@
 #pragma once
 
 #include <functional>
+#include <memory>
 
 #include <stdint.h>
 
+#include <types/types.h>
+
+#include <kernel/mem/phys.hpp>
+
 namespace kernel::kinit {
 
 void init_pci();
@@ -12,43 +17,11 @@ void init_pci();
 
 namespace kernel::hw::pci {
 
-struct bar_mmio {
-    uint32_t always_zero : 1;
-    uint32_t type : 2;
-    uint32_t prefetchable : 1;
-    uint32_t base_address : 28;
-};
-
-struct bar_io {
-    uint32_t always_one : 1;
-    uint32_t reserved : 1;
-    uint32_t base_address : 30;
-};
-
-union bar {
-    bar_mmio mmio;
-    bar_io io;
-};
-
-struct config_reg {
-    uint32_t addr_base;
-
-    explicit constexpr config_reg(uint32_t bus, uint32_t dev, uint32_t func)
-        : addr_base(0x80000000U | (bus << 16) | (dev << 11) | (func << 8)) {}
-
-    // offset is in range from 0x00 to 0xff
-    uint32_t read32(uint32_t offset) const;
-    uint16_t read16(uint16_t offset) const;
-
-    // read n-th 32-bit register
-    uint32_t operator[](uint32_t n) const;
-};
-
-struct device_header_base {
+struct PACKED device_header_base {
     uint16_t vendor;
     uint16_t device;
-    uint16_t command;
-    uint16_t status;
+    uint16_t volatile command;
+    uint16_t volatile status;
     uint8_t revision_id;
     uint8_t prog_if;
     uint8_t subclass;
@@ -56,41 +29,59 @@ struct device_header_base {
     uint8_t cache_line_size;
     uint8_t latency_timer;
     uint8_t header_type;
-    uint8_t bist;
+    uint8_t volatile bist;
 };
 
-struct device_header_type0 {
-    bar bars[6];
+struct PACKED device_header_type0 {
+    device_header_base base;
+
+    uint32_t bars[6];
     uint32_t cardbus_cis_pointer;
     uint16_t subsystem_vendor_id;
     uint16_t subsystem_id;
     uint32_t expansion_rom_base_address;
     uint8_t capabilities_pointer;
-    uint8_t reserved[7];
-    uint8_t interrupt_line;
-    uint8_t interrupt_pin;
+    uint8_t __reserved[7];
+    uint8_t volatile interrupt_line;
+    uint8_t volatile interrupt_pin;
     uint8_t min_grant;
     uint8_t max_latency;
 };
 
+struct SegmentGroup {
+    mem::physaddr<void, false> base;
+    int number;
+};
+
 class pci_device {
+   private:
+    std::shared_ptr<SegmentGroup> segment_group;
+    int bus;
+    int device;
+    int function;
+    void* config_space;
+
+    explicit pci_device(std::shared_ptr<SegmentGroup> segment_group, int bus,
+                        int device, int function, void* config_space);
+
    public:
-    config_reg reg;
+    static pci_device* probe(std::shared_ptr<SegmentGroup> segment_group,
+                             int bus, int device, int function);
 
-    uint16_t vendor;
-    uint16_t device;
+    device_header_base& header() const;
+    device_header_type0& header_type0() const;
 
-    uint8_t revision_id;
-    uint8_t subclass;
-    uint8_t class_code;
-    uint8_t header_type;
+    void enableBusMastering();
 
-    explicit pci_device(config_reg reg);
+    template <typename T>
+    inline T& at(size_t offset) const {
+        return *reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(config_space) +
+                                     offset);
+    }
 };
 
-using driver_t = std::function<int(pci_device*)>;
+using driver_t = std::function<int(pci_device&)>;
 
-pci_device* probe_device(uint8_t bus, uint8_t device, uint8_t function);
 int register_driver(uint16_t vendor, uint16_t device, driver_t drv);
 
 } // namespace kernel::hw::pci

include/kernel/mem/phys.hpp

@@ -29,9 +29,7 @@ class physaddr {
     }
 
     constexpr operator T*() const noexcept { return cast_to<T*>(); }
-
     constexpr T* operator->() const noexcept { return *this; }
-
     constexpr uintptr_t phys() const noexcept { return m_ptr; }
 };
 

include/kernel/syscall.hpp

@@ -62,6 +62,7 @@ namespace syscall {
     int do_unlink(const char __user* pathname);
     int do_truncate(const char __user* pathname, long length);
     int do_mkdir(const char __user* pathname, mode_t mode);
+    int do_socket(int domain, int type, int protocol);
 
     // in procops.cc
     int do_chdir(const char __user* path);

include/net/arp.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <defs.hpp>
+
+#include <net/ethernet.hpp>
+
+namespace net {
+
+struct PACKED ARPFrame {
+    u16 l2Type;
+    u16 protoType;
+    u8 l2AddrLen;
+    u8 protoAddrLen;
+    u16 op;
+
+    MACAddress srcMAC;
+    u32 srcIP;
+    MACAddress dstMAC;
+    u32 dstIP;
+};
+
+} // namespace net

include/net/ethernet.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <defs.hpp>
+
+namespace net {
+
+u16 htons(u16 val);
+u32 htonl(u32 val);
+u64 htonll(u64 val);
+
+struct PACKED MACAddress {
+    u8 addr[6];
+};
+
+struct PACKED EthernetHeader {
+    MACAddress dst;
+    MACAddress src;
+    u16 type;
+    u8 payload[];
+};
+
+} // namespace net

include/net/netdev.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <defs.hpp>
+#include <functional>
+
+#include <stdint.h>
+
+#include <kernel/hw/pci.hpp>
+#include <net/ethernet.hpp>
+
+namespace net {
+
+constexpr unsigned long NETDEV_UP = 0x001;
+constexpr unsigned long NETDEV_DOWN = 0x002;
+
+constexpr unsigned long NETDEV_SPEED_MASK = 0x03c;
+constexpr unsigned long NETDEV_SPEED_UNKNOWN = 0x004;
+constexpr unsigned long NETDEV_SPEED_10M = 0x008;
+constexpr unsigned long NETDEV_SPEED_100M = 0x010;
+constexpr unsigned long NETDEV_SPEED_1000M = 0x020;
+
+class Netdev {
+   protected:
+    unsigned long status;
+    MACAddress mac;
+
+    Netdev(kernel::hw::pci::pci_device& device);
+
+   public:
+    kernel::hw::pci::pci_device& device;
+
+    virtual ~Netdev() = default;
+
+    int setLinkSpeed(unsigned long speedFlag);
+
+    virtual int up() = 0;
+    virtual isize send(const u8* data, usize len) = 0;
+};
+
+int registerNetdev(std::unique_ptr<Netdev> dev);
+
+} // namespace net

include/types/path.hpp

@@ -52,6 +52,16 @@ class string_view {
             return false;
         return operator==(str.c_str());
     }
+
+    constexpr bool operator<(const string_view& val) const {
+        for (std::size_t i = 0; i < m_len && i < val.m_len; ++i) {
+            if (m_str[i] < val.m_str[i])
+                return true;
+            if (m_str[i] > val.m_str[i])
+                return false;
+        }
+        return m_len < val.m_len;
+    }
 };
 
 class path_iterator {

pretty-print.py

@@ -111,7 +111,7 @@ class rbtreePrinter:
                 break
 
 class stringPrinter:
-    def __init__(self, val):
+    def __init__(self, val: gdb.Value):
         self.val = val
 
     def to_string(self):
@@ -125,6 +125,18 @@ class stringPrinter:
     def display_hint(self):
         return 'string'
 
+class stringViewPrinter:
+    def __init__(self, val: gdb.Value):
+        self.val = val
+        self.string = val['m_str']
+        self.length = val['m_len']
+
+    def to_string(self):
+        return self.string.string(length=self.length)
+
+    def display_hint(self):
+        return 'string'
+
 class listPrinter:
     def __init__(self, val):
         self.val: gdb.Value = val
@@ -335,6 +347,9 @@ def build_pretty_printer(val: gdb.Value):
     if re.compile(r"^std::basic_string<.*>$").match(typename):
         return stringPrinter(val)
 
+    if re.compile(r"^types::string_view$").match(typename):
+        return stringViewPrinter(val)
+
     if re.compile(r"^std::shared_ptr<.*>$").match(typename):
         return sharedPointerPrinter(val)
 

src/driver/e1000e.cc

@@ -0,0 +1,389 @@
+#include <defs.hpp>
+
+#include <assert.h>
+#include <errno.h>
+
+#include <driver/e1000e.hpp>
+#include <kernel/hw/pci.hpp>
+#include <kernel/irq.hpp>
+#include <kernel/log.hpp>
+#include <kernel/mem/paging.hpp>
+#include <kernel/mem/phys.hpp>
+#include <kernel/module.hpp>
+#include <net/arp.hpp>
+#include <net/ethernet.hpp>
+#include <net/netdev.hpp>
+
+using namespace kernel::kmod;
+using namespace kernel::hw::pci;
+using namespace kernel::mem;
+using namespace net;
+
+using namespace hw::e1000e;
+
+constexpr int E1000E_RX_DESC_COUNT = 32;
+constexpr int E1000E_TX_DESC_COUNT = 32;
+
+class e1000eDevice : public virtual Netdev {
+    u8* base;
+
+    // rx at 0x0000, tx at 0x0200
+    paging::page* rtDescriptorPage;
+
+    int rxHead;
+    int rxTail;
+
+    int txHead;
+    int txTail;
+
+    void* at(long offset) const;
+    void write(long offset, u32 value) const;
+    u32 read(long offset) const;
+
+    physaddr<RxDescriptor> rxDescriptors() const;
+    physaddr<TxDescriptor> txDescriptors() const;
+
+    virtual int up() override;
+    virtual isize send(const u8* buffer, usize length) override;
+
+    int reset();
+    int getMacAddress();
+    int clearStats();
+    int clearRxTxDescriptorTable();
+
+    int setupRx();
+    int setupTx();
+
+   public:
+    static int probe(pci_device& dev);
+
+    e1000eDevice(pci_device& dev, u8* base);
+    virtual ~e1000eDevice();
+};
+
+e1000eDevice::e1000eDevice(pci_device& dev, u8* base)
+    : Netdev(dev)
+    , base(base)
+    , rtDescriptorPage(paging::alloc_page())
+    , rxHead(-1)
+    , rxTail(-1)
+    , txHead(-1)
+    , txTail(-1) {
+    auto pPage = physaddr<u8>{paging::page_to_pfn(rtDescriptorPage)};
+    memset(pPage, 0, 0x1000);
+
+    auto pRxDescriptors = this->rxDescriptors();
+    for (int i = 0; i < E1000E_RX_DESC_COUNT; i++) {
+        auto& desc = pRxDescriptors[i];
+
+        auto bufPage = paging::alloc_pages(2);
+        desc.bufferAddress = paging::page_to_pfn(bufPage);
+    }
+
+    clearRxTxDescriptorTable();
+
+    getMacAddress();
+}
+
+// TODO: make sure all transactions are complete before freeing resources
+e1000eDevice::~e1000eDevice() {
+    auto pRxDescriptors = this->rxDescriptors();
+    for (int i = 0; i < E1000E_RX_DESC_COUNT; i++) {
+        auto& desc = pRxDescriptors[i];
+
+        auto* bufPage = paging::pfn_to_page(desc.bufferAddress);
+        paging::free_pages(bufPage, 2);
+
+        desc.bufferAddress = 0;
+    }
+
+    paging::free_page(rtDescriptorPage);
+}
+
+void* e1000eDevice::at(long offset) const {
+    return base + offset;
+}
+
+void e1000eDevice::write(long offset, u32 value) const {
+    *reinterpret_cast<u32 volatile*>(at(offset)) = value;
+}
+
+u32 e1000eDevice::read(long offset) const {
+    return *reinterpret_cast<u32 volatile*>(at(offset));
+}
+
+physaddr<RxDescriptor> e1000eDevice::rxDescriptors() const {
+    auto pfn = paging::page_to_pfn(rtDescriptorPage);
+    return physaddr<RxDescriptor>(pfn);
+}
+
+physaddr<TxDescriptor> e1000eDevice::txDescriptors() const {
+    auto pfn = paging::page_to_pfn(rtDescriptorPage);
+    return physaddr<TxDescriptor>(pfn + 0x200);
+}
+
+int e1000eDevice::reset() {
+    // disable interrupts
+    write(REG_IMC, 0xffffffff);
+
+    // pcie master disable
+    u32 ctrl = read(REG_CTRL);
+    ctrl |= CTRL_GIOD;
+    write(REG_CTRL, ctrl);
+
+    while (test(read(REG_STATUS), STATUS_GIOE))
+        ;
+
+    ctrl = read(REG_CTRL);
+    ctrl |= CTRL_RST;
+    write(REG_CTRL, ctrl);
+
+    while (test(read(REG_CTRL), CTRL_RST))
+        ;
+
+    // disable interrupts again
+    write(REG_IMC, 0xffffffff);
+
+    return 0;
+}
+
+int e1000eDevice::getMacAddress() {
+    memcpy(&mac, at(0x5400), 6);
+    return 0;
+}
+
+int e1000eDevice::setupRx() {
+    auto pRxDescriptors = this->rxDescriptors();
+
+    write(REG_RDBAL, pRxDescriptors.phys() & 0xffffffff);
+    write(REG_RDBAH, pRxDescriptors.phys() >> 32);
+
+    write(REG_RDLEN, E1000E_RX_DESC_COUNT * sizeof(RxDescriptor));
+
+    write(REG_RDH, 0);
+    rxHead = 0;
+
+    write(REG_RDT, E1000E_RX_DESC_COUNT - 1);
+    rxTail = E1000E_RX_DESC_COUNT - 1;
+
+    write(REG_RCTL, RCTL_EN | RCTL_UPE | RCTL_MPE | RCTL_LPE | RCTL_LBM_NO |
+                        RCTL_DTYP_LEGACY | RCTL_BAM | RCTL_BSIZE_8192 |
+                        RCTL_SECRC);
+
+    return 0;
+}
+
+int e1000eDevice::setupTx() {
+    auto pTxDescriptors = this->txDescriptors();
+
+    write(REG_TDBAL, pTxDescriptors.phys() & 0xffffffff);
+    write(REG_TDBAH, pTxDescriptors.phys() >> 32);
+
+    write(REG_TDLEN, E1000E_TX_DESC_COUNT * sizeof(TxDescriptor));
+
+    write(REG_TDH, 0);
+    txHead = 0;
+
+    write(REG_TDT, 0);
+    txTail = 0;
+
+    write(REG_TCTL, TCTL_EN | TCTL_PSP | (15 << TCTL_CT_SHIFT) |
+                        (64 << TCTL_COLD_SHIFT) | TCTL_RTLC);
+
+    return 0;
+}
+
+int e1000eDevice::up() {
+    // set link up
+    u32 ctrl = read(REG_CTRL);
+    u32 stat = read(REG_STATUS);
+
+    if (!test(ctrl, CTRL_SLU) || !test(stat, STATUS_LU))
+        return -EIO;
+
+    // auto negotiation speed
+    switch (stat & STATUS_SPEED_MASK) {
+        case STATUS_SPEED_10M:
+            setLinkSpeed(NETDEV_SPEED_10M);
+            break;
+        case STATUS_SPEED_100M:
+            setLinkSpeed(NETDEV_SPEED_100M);
+            break;
+        case STATUS_SPEED_1000M:
+            setLinkSpeed(NETDEV_SPEED_1000M);
+            break;
+        default:
+            return -EINVAL;
+    }
+
+    // clear multicast table
+    for (int i = 0; i < 128; i += 4)
+        write(0x5200 + i, 0);
+
+    clearStats();
+
+    // enable interrupts
+    write(REG_IMS, ICR_NORMAL | ICR_UP);
+
+    // read to clear any pending interrupts
+    read(REG_ICR);
+
+    kernel::irq::register_handler(
+        device.header_type0().interrupt_line, [this]() {
+            auto cause = read(REG_ICR);
+
+            if (!test(cause, ICR_INT))
+                return;
+
+            rxHead = read(REG_RDH);
+
+            auto nextTail = (rxTail + 1) % E1000E_RX_DESC_COUNT;
+            while (nextTail != rxHead) {
+                auto pRxDescriptors = rxDescriptors();
+                auto& desc = pRxDescriptors[nextTail];
+
+                assert(desc.status & RXD_STAT_DD);
+
+                auto pBuf = physaddr<u8>{desc.bufferAddress};
+                kmsg("==== e1000e: received packet ====");
+
+                char buf[256];
+                for (int i = 0; i < desc.length; i++) {
+                    if (i && i % 16 == 0)
+                        kmsg("");
+
+                    snprintf(buf, sizeof(buf), "%x ", pBuf[i]);
+                    kernel::tty::console->print(buf);
+                }
+
+                kmsg("\n==== e1000e: end of packet ====");
+
+                desc.status = 0;
+                rxTail = nextTail;
+                nextTail = (nextTail + 1) % E1000E_RX_DESC_COUNT;
+            }
+
+            write(REG_RDT, rxTail);
+        });
+
+    int ret = setupRx();
+    if (ret != 0)
+        return ret;
+
+    ret = setupTx();
+    if (ret != 0)
+        return ret;
+
+    status &= ~NETDEV_DOWN;
+    status |= NETDEV_UP;
+
+    return 0;
+}
+
+isize e1000eDevice::send(const u8* buffer, usize length) {
+    auto txTailNext = (txTail + 1) % E1000E_TX_DESC_COUNT;
+    if (txTailNext == txHead)
+        return -EAGAIN;
+
+    auto pTxDescriptors = this->txDescriptors();
+    auto& desc = pTxDescriptors[txTail];
+
+    if (!(desc.status & TXD_STAT_DD))
+        return -EIO;
+
+    auto bufPage = paging::alloc_page();
+    auto pPage = physaddr<u8>{paging::page_to_pfn(bufPage)};
+    memcpy(pPage, buffer, length);
+
+    desc.bufferAddress = pPage.phys();
+    desc.length = length;
+    desc.cmd = TXD_CMD_EOP | TXD_CMD_IFCS | TXD_CMD_RS;
+    desc.status = 0;
+
+    txTail = txTailNext;
+    write(REG_TDT, txTailNext);
+
+    while (!test(desc.status, TXD_STAT_DD))
+        ;
+
+    return 0;
+}
+
+int e1000eDevice::clearStats() {
+    write(REG_COLC, 0);
+    write(REG_GPRC, 0);
+    write(REG_MPRC, 0);
+    write(REG_GPTC, 0);
+    write(REG_GORCL, 0);
+    write(REG_GORCH, 0);
+    write(REG_GOTCL, 0);
+    write(REG_GOTCH, 0);
+
+    return 0;
+}
+
+int e1000eDevice::clearRxTxDescriptorTable() {
+    auto pRxDescriptors = this->rxDescriptors();
+    for (int i = 0; i < E1000E_RX_DESC_COUNT; i++) {
+        auto& desc = pRxDescriptors[i];
+        desc.status = 0;
+    }
+
+    auto pTxDescriptors = this->txDescriptors();
+    for (int i = 0; i < E1000E_TX_DESC_COUNT; i++) {
+        auto& desc = pTxDescriptors[i];
+        desc.status = TXD_STAT_DD;
+    }
+
+    return 0;
+}
+
+int e1000eDevice::probe(pci_device& dev) {
+    auto bar0 = dev.header_type0().bars[0];
+    if ((bar0 & 0xf) != 0)
+        return -EINVAL;
+
+    dev.enableBusMastering();
+
+    auto baseAddress = physaddr<uint8_t, false>{bar0 & ~0xf};
+    auto e1000ePointer = std::make_unique<e1000eDevice>(dev, baseAddress);
+
+    int ret = e1000ePointer->reset();
+    if (ret != 0)
+        return ret;
+
+    ret = e1000ePointer->up();
+    if (ret != 0)
+        return ret;
+
+    return registerNetdev(std::move(e1000ePointer));
+}
+
+class e1000e_module : public virtual kmod {
+   public:
+    e1000e_module() : kmod("e1000e") {}
+
+    virtual int init() override {
+        const int device_id[] = {
+            0x100e,
+            0x10d3,
+            0x10ea,
+            0x153a,
+        };
+
+        for (auto id : device_id) {
+            auto ret = kernel::hw::pci::register_driver(0x8086, id,
+                                                        e1000eDevice::probe);
+
+            // TODO: in case any of the devices fail to register,
+            // we should return an error code and cleanup these
+            // device drivers
+            if (ret != 0)
+                return ret;
+        }
+
+        return 0;
+    }
+};
+
+INTERNAL_MODULE(e1000e, e1000e_module);

src/kernel/hw/acpi.cc

@@ -0,0 +1,99 @@
+#include <map>
+
+#include <assert.h>
+#include <errno.h>
+
+#include <types/path.hpp>
+#include <types/types.h>
+
+#include <kernel/hw/acpi.hpp>
+#include <kernel/mem/phys.hpp>
+
+using namespace kernel::mem;
+
+namespace kernel::hw::acpi {
+
+static std::map<types::string_view, ACPI_table_header*> acpi_tables;
+
+struct PACKED RSDP {
+    uint64_t signature;
+    uint8_t checksum;
+    uint8_t oemid[6];
+    uint8_t revision;
+    uint32_t rsdt_addr;
+};
+
+struct PACKED RSDT {
+    ACPI_table_header header;
+    uint32_t entries[];
+};
+
+static bool checksum(const void* data, size_t len) {
+    uint8_t sum = 0;
+    for (size_t i = 0; i < len; ++i)
+        sum += reinterpret_cast<const uint8_t*>(data)[i];
+    return sum == 0;
+}
+
+static const RSDP* _find_rsdp() {
+    for (uintptr_t addr = 0xe0000; addr < 0x100000; addr += 0x10) {
+        physaddr<RSDP> rsdp{addr};
+
+        // "RSD PTR "
+        if (rsdp->signature == 0x2052545020445352) {
+            if (checksum(rsdp, sizeof(RSDP)))
+                return rsdp;
+        }
+    }
+
+    return nullptr;
+}
+
+static const RSDT* _rsdt() {
+    static const RSDT* rsdt;
+    if (rsdt)
+        return rsdt;
+
+    auto* rsdp = _find_rsdp();
+    if (!rsdp || rsdp->revision != 0)
+        return nullptr;
+
+    const RSDT* cur_rsdt = physaddr<const RSDT>{rsdp->rsdt_addr};
+
+    constexpr auto rsdt_signature = types::string_view{"RSDT", 4};
+    auto signature = types::string_view{cur_rsdt->header.signature, 4};
+    if (signature != rsdt_signature)
+        return nullptr;
+    if (!checksum(cur_rsdt, cur_rsdt->header.length))
+        return nullptr;
+
+    return rsdt = cur_rsdt;
+}
+
+int parse_acpi_tables() {
+    auto rsdt = _rsdt();
+    if (!rsdt)
+        return -ENOENT;
+
+    auto entries =
+        (rsdt->header.length - sizeof(ACPI_table_header)) / sizeof(uint32_t);
+    for (uint32_t i = 0; i < entries; ++i) {
+        physaddr<ACPI_table_header> header{rsdt->entries[i]};
+        if (!checksum(header, header->length))
+            continue;
+
+        types::string_view table_name{header->signature, 4};
+        acpi_tables[table_name] = header;
+    }
+
+    return 0;
+}
+
+void* get_table(types::string_view name) {
+    auto iter = acpi_tables.find(name);
+    if (iter == acpi_tables.end())
+        return nullptr;
+    return iter->second;
+}
+
+} // namespace kernel::hw::acpi

src/kernel/hw/ahci.cc

@@ -2,6 +2,7 @@
 #include <cstddef>
 #include <vector>
 
+#include <assert.h>
 #include <errno.h>
 #include <stdint.h>
 
@@ -488,10 +489,13 @@ class ahci_module : public virtual kmod {
         ports.resize(32);
 
         auto ret = kernel::hw::pci::register_driver(
-            VENDOR_INTEL, DEVICE_AHCI, [this](pci_device* dev) -> int {
-                this->dev = dev;
+            VENDOR_INTEL, DEVICE_AHCI, [this](pci_device& dev) -> int {
+                this->dev = &dev;
 
-                physaddr<hba_ghc, false> pp_base{dev->reg[PCI_REG_ABAR]};
+                auto pointerBase = dev.header_type0().bars[5];
+                assert((pointerBase & 0xf) == 0);
+
+                physaddr<hba_ghc, false> pp_base{pointerBase & ~0xf};
                 this->ghc = pp_base;
 
                 this->ghc->global_host_control =

src/kernel/hw/pci.cc

@@ -6,13 +6,9 @@
 
 #include <types/types.h>
 
+#include <kernel/hw/acpi.hpp>
 #include <kernel/hw/pci.hpp>
-#include <kernel/hw/port.hpp>
-
-using kernel::hw::p32;
-
-constexpr p32 paddr(0xCF8);
-constexpr p32 pdata(0xCFC);
+#include <kernel/mem/phys.hpp>
 
 using device_no = uint32_t;
 constexpr device_no make_device(uint32_t vendor, uint32_t device) {
@@ -22,93 +18,59 @@ constexpr device_no make_device(uint32_t vendor, uint32_t device) {
 namespace kernel::hw::pci {
 
 // lower 16 bits are vendor id, higher 16 bits are device id
-std::map<device_no, pci_device>* pci_devices_p;
-std::map<device_no, driver_t>* pci_drivers_p;
-
-// getter of the global variable
-std::map<device_no, pci_device>& pci_devices() {
-    if (!pci_devices_p) [[unlikely]]
-        pci_devices_p = new std::map<device_no, pci_device>();
-    return *pci_devices_p;
-}
-
-// getter of the global variable
-std::map<device_no, driver_t>& pci_drivers() {
-    if (!pci_drivers_p) [[unlikely]]
-        pci_drivers_p = new std::map<device_no, driver_t>();
-    return *pci_drivers_p;
-}
-
-// class config_reg
+std::map<device_no, pci_device*> s_pci_devices;
+std::map<device_no, driver_t> s_pci_drivers;
+
+pci_device::pci_device(std::shared_ptr<SegmentGroup> segment_group, int bus,
+                       int dev, int func, void* config_space)
+    : segment_group(segment_group)
+    , bus(bus)
+    , device(dev)
+    , function(func)
+    , config_space(config_space) {}
+
+pci_device* pci_device::probe(std::shared_ptr<SegmentGroup> segmentGroup,
+                              int bus, int device, int function) {
+    auto configSpaceAddress = segmentGroup->base.phys() + (bus << 20) +
+                              (device << 15) + (function << 12);
+
+    auto pConfigSpace =
+        mem::physaddr<device_header_base, false>{configSpaceAddress};
+
+    if (pConfigSpace->vendor == 0xffff)
+        return nullptr;
 
-uint32_t config_reg::read32(uint32_t offset) const {
-    paddr = (addr_base | (offset & 0xFC));
-    return *pdata;
+    return new pci_device(segmentGroup, bus, device, function, pConfigSpace);
 }
 
-uint16_t config_reg::read16(uint16_t offset) const {
-    return (read32(offset) >> ((offset & 2) << 3)) & 0xFFFF;
+void pci_device::enableBusMastering() {
+    auto& header = this->header();
+    header.command |= 0x4;
 }
 
-uint32_t config_reg::operator[](uint32_t n) const {
-    return read32(n << 2);
+device_header_base& pci_device::header() const {
+    return at<device_header_base>(0);
 }
 
-// end class config_reg
-
-// class pci_device
-
-pci_device::pci_device(config_reg reg) : reg(reg) {
-    uint32_t tmp = reg[0];
-
-    vendor = tmp & 0xFFFF;
-    device = tmp >> 16;
-
-    tmp = reg[2];
-    revision_id = tmp & 0xFF;
-    subclass = (tmp >> 16) & 0xFF;
-    class_code = tmp >> 24;
-
-    tmp = reg[3];
-    header_type = (tmp >> 16) & 0xFF;
-}
-
-// end class pci_device
-
-pci_device* probe_device(uint8_t bus, uint8_t dev, uint8_t func) {
-    config_reg reg(bus, dev, func);
-
-    uint32_t tmp = reg[0];
-    uint16_t vendor = tmp & 0xFFFF;
-    uint16_t device = tmp >> 16;
-
-    if (vendor == 0xFFFF)
-        return nullptr;
-
-    auto [iter, inserted] =
-        hw::pci::pci_devices().emplace(make_device(vendor, device), reg);
-    assert(inserted);
-
-    return &iter->second;
+device_header_type0& pci_device::header_type0() const {
+    return at<device_header_type0>(0);
 }
 
 int register_driver(uint16_t vendor, uint16_t device, driver_t drv) {
-    auto& drivers = pci_drivers();
     device_no dev = make_device(vendor, device);
 
-    auto iter = drivers.find(dev);
-    if (iter != drivers.end())
+    auto iter = s_pci_drivers.find(dev);
+    if (iter != s_pci_drivers.end())
         return -EEXIST;
 
-    auto [_, inserted] = drivers.emplace(dev, drv);
+    auto [_, inserted] = s_pci_drivers.emplace(dev, drv);
     assert(inserted);
 
-    auto& devices = pci_devices();
-    auto deviter = devices.find(dev);
+    auto deviter = s_pci_devices.find(dev);
 
     // TODO: check status or print log
-    if (deviter != devices.end())
-        drv(&deviter->second);
+    if (deviter != s_pci_devices.end())
+        drv(*deviter->second);
 
     return 0;
 }
@@ -119,13 +81,34 @@ namespace kernel::kinit {
 
 SECTION(".text.kinit")
 void init_pci() {
-    for (int bus = 0; bus < 256; ++bus) {
-        for (int dev = 0; dev < 32; ++dev) {
-            for (int func = 0; func < 8; ++func) {
-                auto* pcidev = hw::pci::probe_device(bus, dev, func);
-                if (!pcidev)
-                    break;
-                // TODO: call driver if exists
+    using namespace hw::acpi;
+    using namespace hw::pci;
+
+    auto* mcfg = (MCFG*)get_table("MCFG");
+    assert(mcfg);
+
+    int n_entries =
+        (mcfg->header.length - sizeof(MCFG)) / sizeof(MCFG::MCFG_entry);
+    for (int i = 0; i < n_entries; ++i) {
+        auto& entry = *&mcfg->entries[i];
+        auto segment_group = std::make_shared<SegmentGroup>(
+            mem::physaddr<void, false>{entry.base_address},
+            entry.segment_group);
+
+        for (int bus = entry.start_bus; bus <= entry.end_bus; ++bus) {
+            for (int dev = 0; dev < 32; ++dev) {
+                for (int func = 0; func < 8; ++func) {
+                    auto* pdev =
+                        pci_device::probe(segment_group, bus, dev, func);
+                    if (!pdev)
+                        break;
+
+                    auto& header = pdev->header();
+
+                    auto [iter, inserted] = s_pci_devices.emplace(
+                        make_device(header.vendor, header.device), pdev);
+                    assert(inserted);
+                }
             }
         }
     }

src/kernel/syscall.cpp

@@ -144,6 +144,7 @@ DEFINE_SYSCALL32(access, const char __user*, pathname, int, mode)
 DEFINE_SYSCALL32(unlink, const char __user*, pathname)
 DEFINE_SYSCALL32(truncate, const char __user*, pathname, long, length)
 DEFINE_SYSCALL32(mkdir, const char __user*, pathname, mode_t, mode)
+DEFINE_SYSCALL32(socket, int, domain, int, type, int, protocol)
 DEFINE_SYSCALL32_TO(fcntl64, fcntl, int, fd, int, cmd, unsigned long, arg)
 
 DEFINE_SYSCALL32_TO(sendfile64, sendfile, int, out_fd, int, in_fd,
@@ -437,6 +438,7 @@ void kernel::init_syscall_table() {
     REGISTER_SYSCALL_HANDLER(0xf3, set_thread_area);
     REGISTER_SYSCALL_HANDLER(0xfc, exit_group);
     REGISTER_SYSCALL_HANDLER(0x102, set_tid_address);
+    REGISTER_SYSCALL_HANDLER(0x167, socket);
     REGISTER_SYSCALL_HANDLER(0x17f, statx);
     REGISTER_SYSCALL_HANDLER(0x180, arch_prctl);
     REGISTER_SYSCALL_HANDLER(0x193, clock_gettime64);

src/kernel/syscall/fileops.cc

@@ -476,6 +476,10 @@ int kernel::syscall::do_poll(pollfd __user* fds, nfds_t nfds, int timeout) {
     // return 0;
 }
 
+int kernel::syscall::do_socket(int domain, int type, int protocol) {
+    return -EINVAL;
+}
+
 /* TODO: implement vfs_stat(stat*)
 int do_stat(const char __user* pathname, stat __user* buf)
 {

src/kinit.cpp

@@ -5,6 +5,7 @@
 #include <types/allocator.hpp>
 #include <types/types.h>
 
+#include <kernel/hw/acpi.hpp>
 #include <kernel/hw/pci.hpp>
 #include <kernel/hw/timer.hpp>
 #include <kernel/interrupt.hpp>
@@ -73,6 +74,8 @@ void NORETURN real_kernel_init(mem::paging::pfn_t kernel_stack_pfn) {
     init_interrupt();
     hw::timer::init_pit();
 
+    hw::acpi::parse_acpi_tables();
+
     init_pci();
 
     init_syscall_table();

src/net/ethernet.cc

@@ -0,0 +1,13 @@
+#include <net/ethernet.hpp>
+
+u16 net::htons(u16 x) {
+    return __builtin_bswap16(x);
+}
+
+u32 net::htonl(u32 x) {
+    return __builtin_bswap32(x);
+}
+
+u64 net::htonll(u64 x) {
+    return __builtin_bswap64(x);
+}

src/net/netdev.cc

@@ -0,0 +1,26 @@
+#include <map>
+
+#include <errno.h>
+
+#include <net/netdev.hpp>
+
+using namespace net;
+
+static int s_nextNetdevId = 0;
+static std::map<int, std::unique_ptr<Netdev>> s_netdevs;
+
+Netdev::Netdev(kernel::hw::pci::pci_device& device)
+    : status{NETDEV_DOWN | NETDEV_SPEED_UNKNOWN}, mac{}, device{device} {}
+
+int Netdev::setLinkSpeed(unsigned long speedFlag) {
+    status = (status & ~NETDEV_SPEED_MASK) | speedFlag;
+    return 0;
+}
+
+int net::registerNetdev(std::unique_ptr<Netdev> dev) {
+    auto [it, inserted] = s_netdevs.try_emplace(s_nextNetdevId, std::move(dev));
+    if (!inserted)
+        return -EFAULT;
+
+    return s_nextNetdevId++;
+}

src/types/crc.cc

@@ -0,0 +1,55 @@
+#include <defs.hpp>
+
+static constexpr u32 poly8_lookup[256] = {
+    0,          0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
+    0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+    0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
+    0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
+    0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
+    0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
+    0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
+    0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+    0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
+    0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
+    0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
+    0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+    0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
+    0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
+    0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D};
+
+u32 crc32(const u8* buffer, size_t length) {
+    u32 crc = 0xffffffff;
+
+    for (size_t i = 0; i < length; i++)
+        crc = poly8_lookup[(crc ^ buffer[i]) & 0xff] ^ (crc >> 8);
+
+    return ~crc;
+}