net: init

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/e1000.rs

@@ -23,6 +23,8 @@ use crate::acpi::aml;
 use crate::arch::interrupts::{self, InterruptStack};
 use crate::drivers::pci::*;
 use crate::mem::paging::*;
+use crate::net::{self, ethernet, MacAddr, NetworkDevice};
+use crate::utils::sync::BMutex;
 
 const TX_DESC_NUM: u32 = 32;
 const TX_DESC_SIZE: u32 = TX_DESC_NUM * core::mem::size_of::<TxDescriptor>() as u32;
@@ -212,10 +214,14 @@ impl<'a> Eeprom<'a> {
 
 struct E1000 {
     base: VirtAddr,
+    mac: MacAddr,
+
+    tx_cur: usize,
+    tx_ring: VirtAddr,
 }
 
 impl E1000 {
-    fn new(header: &PciHeader) -> Result<(), Error> {
+    fn new(header: &PciHeader) -> Result<Self, Error> {
         header.enable_bus_mastering();
         header.enable_mmio();
 
@@ -232,8 +238,12 @@ impl E1000 {
             header.capabilities().collect::<alloc::vec::Vec<_>>()
         );
 
-        let this = Self {
+        let mut this = Self {
             base: registers_addr.as_hhdm_virt(),
+            mac: MacAddr([0; 6]),
+
+            tx_cur: 0,
+            tx_ring: VirtAddr::zero(),
         };
 
         this.reset();
@@ -263,6 +273,8 @@ impl E1000 {
             mac[5]
         );
 
+        this.mac = MacAddr(mac);
+
         this.init_tx()?;
         this.init_rx()?;
 
@@ -289,7 +301,27 @@ impl E1000 {
         this.receive();
 
         log::trace!("e1000: successfully initialized");
-        Ok(())
+        Ok(this)
+    }
+
+    fn send(&mut self, packet: ethernet::Packet) {
+        let cur = self.tx_cur;
+        let ring = self.tx_ring();
+        let e: PhysFrame<Size4KiB> = FRAME_ALLOCATOR.allocate_frame().unwrap();
+
+        unsafe {
+            *(e.start_address().as_hhdm_virt().as_ptr::<u8>() as *mut ethernet::Packet) = packet;
+        }
+
+        ring[cur].addr = e.start_address().as_u64();
+        ring[cur].length = core::mem::size_of::<ethernet::Packet>() as u16;
+        ring[cur].cmd = 0b1011;
+        ring[cur].status = TStatus::empty();
+
+        drop(ring);
+        self.tx_cur = (self.tx_cur + 1) % TX_DESC_NUM as usize;
+
+        self.write(Register::TxDescTail, self.tx_cur as u32);
     }
 
     fn receive(&self) {}
@@ -302,7 +334,13 @@ impl E1000 {
         }
     }
 
-    fn init_tx(&self) -> Result<(), Error> {
+    fn tx_ring(&mut self) -> &mut [TxDescriptor] {
+        self.tx_ring
+            .read_mut::<[TxDescriptor; TX_DESC_NUM as usize]>()
+            .unwrap()
+    }
+
+    fn init_tx(&mut self) -> Result<(), Error> {
         assert!(TX_DESC_SIZE < Size4KiB::SIZE as u32);
 
         let frame: PhysFrame<Size4KiB> =
@@ -319,6 +357,8 @@ impl E1000 {
             desc.status = TStatus::DD;
         }
 
+        self.tx_ring = addr;
+
         self.write(Register::TxDesLo, phys.as_u64() as _);
         self.write(Register::TxDesHi, (phys.as_u64() >> 32) as _);
         self.write(Register::TxDescLen, TX_DESC_SIZE);
@@ -433,6 +473,24 @@ impl E1000 {
     }
 }
 
+struct Device(BMutex<E1000>);
+
+impl Device {
+    fn new(e1000: E1000) -> Self {
+        Self(BMutex::new(e1000))
+    }
+}
+
+impl NetworkDevice for Device {
+    fn send(&self, packet: ethernet::Packet) {
+        self.0.lock().send(packet)
+    }
+
+    fn mac(&self) -> net::MacAddr {
+        self.0.lock().mac
+    }
+}
+
 struct Handler;
 
 impl Handler {
@@ -447,12 +505,15 @@ impl PciDeviceHandle for Handler {
     }
 
     fn start(&self, header: &PciHeader, _offset_table: &mut OffsetPageTable) {
-        E1000::new(header).unwrap()
+        let e1000 = E1000::new(header).unwrap();
+        let device = Arc::new(Device::new(e1000));
+
+        net::add_device(device);
     }
 }
 
 fn irq_handler(_stack: &mut InterruptStack) {
-    unreachable!()
+    log::debug!("a!")
 }
 
 fn init() {

src/aero_kernel/src/main.rs

@@ -82,6 +82,7 @@ mod fs;
 mod logger;
 mod mem;
 mod modules;
+mod net;
 mod rendy;
 mod socket;
 mod syscall;
@@ -144,6 +145,9 @@ fn kernel_main_thread() {
     modules::init();
     log::info!("loaded kernel modules");
 
+    net::init();
+    log::info!("initialized networking stack");
+
     #[cfg(target_arch = "x86_64")]
     arch::enable_acpi();
 

src/aero_kernel/src/net/arp.rs

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2021-2023 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// Address Resolution Protocol
+
+use alloc::collections::BTreeMap;
+use spin::{Once, RwLock};
+
+use super::ethernet::MacAddr;
+use super::ip::Ipv4Addr;
+
+struct Entry {
+    mac: MacAddr,
+}
+
+impl Entry {
+    fn new(mac: MacAddr) -> Self {
+        Self { mac }
+    }
+}
+
+struct Cache(BTreeMap<Ipv4Addr, Entry>);
+
+impl Cache {
+    fn new() -> Self {
+        Self(BTreeMap::new())
+    }
+
+    fn insert(&mut self, ip: Ipv4Addr, mac: MacAddr) {
+        if let Some(_entry) = self.0.get_mut(&ip) {
+            todo!()
+        } else {
+            self.0.insert(ip, Entry::new(mac));
+        }
+    }
+
+    fn get(&self, ip: Ipv4Addr) -> Option<MacAddr> {
+        if let Some(entry) = self.0.get(&ip) {
+            return Some(entry.mac);
+        }
+
+        None
+    }
+}
+
+static CACHE: Once<RwLock<Cache>> = Once::new();
+
+pub fn get(ip: Ipv4Addr) -> Option<MacAddr> {
+    CACHE
+        .get()
+        .as_ref()
+        .expect("arp: cache not initialized")
+        .read()
+        .get(ip)
+}
+
+pub fn init() {
+    CACHE.call_once(|| {
+        let mut cache = Cache::new();
+        cache.insert(Ipv4Addr::BROADCAST, MacAddr::BROADCAST);
+
+        RwLock::new(cache)
+    });
+}

src/aero_kernel/src/net/dhcp.rs

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021-2023 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// Dynamic Host Configuration Protocol
+
+use super::{ethernet, ip::Ipv4Addr};
+
+pub fn init() {
+    // Send DHCP discover message (UDP: source port=67; destination port=68).
+    let balls = ethernet::Packet::new(ethernet::Type::Ip);
+
+    super::ethernet::send_packet(balls, Ipv4Addr::BROADCAST);
+}

src/aero_kernel/src/net/ethernet.rs

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021-2023 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use super::arp;
+use super::ip::Ipv4Addr;
+
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+#[repr(C)]
+pub struct MacAddr(pub [u8; 6]);
+
+impl MacAddr {
+    pub const BROADCAST: Self = Self([0xff; 6]);
+}
+
+#[repr(u16)]
+pub enum Type {
+    Ip = 0x800,
+}
+
+#[repr(C, packed)]
+pub struct Packet {
+    pub dest_mac: MacAddr,
+    pub src_mac: MacAddr,
+    pub typ: Type,
+}
+
+impl Packet {
+    /// Creates a new ethernet packet.
+    pub fn new(typ: Type) -> Self {
+        let src_mac = super::default_device().mac();
+        Self {
+            src_mac,
+            dest_mac: MacAddr([0; 6]),
+            typ,
+        }
+    }
+}
+
+pub fn send_packet(mut packet: Packet, ip: Ipv4Addr) {
+    if let Some(addr) = arp::get(ip) {
+        packet.dest_mac = addr;
+        super::default_device().send(packet);
+    }
+}

src/aero_kernel/src/net/ip.rs

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2021-2023 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/// Size of IPv4 adderess in octets.
+///
+/// [RFC 8200 § 2]: https://www.rfc-editor.org/rfc/rfc791#section-3.2
+pub const ADDR_SIZE: usize = 4;
+
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
+pub struct Ipv4Addr(pub [u8; ADDR_SIZE]);
+
+impl Ipv4Addr {
+    pub const BROADCAST: Self = Self([0xff; ADDR_SIZE]);
+}