Merge pull request #1199 from alfred-bratterud/dev

IP-stack horror: proper isolation between layers

Author: alfreb

CMakeLists.txt

@@ -57,7 +57,7 @@ init_submodule(mod/uzlib)
 set(OPTIMIZE "-O2")
 
 if(debug OR debug-info OR debug-all)
-	set(CAPABS "${CAPABS} -O0")
+	set(OTPIMIZE "-O0")
 endif(debug OR debug-info OR debug-all)
 
 if(minimal)

api/hw/mac_addr.hpp

@@ -25,69 +25,90 @@
 #include <string>
 #include <cstring>    // strncmp
 
-namespace hw {
-// MAC address
-union MAC_addr {
-  // no. parts in a MAC address
-  static constexpr size_t PARTS_LEN = 6;
-  // The parts of the MAC address
-  uint8_t part[PARTS_LEN];
-
-  struct {
-    uint16_t minor;
-    uint32_t major;
-  } __attribute__((packed));
-
-  MAC_addr() noexcept : part{} {}
-
-  MAC_addr(const uint8_t a, const uint8_t b, const uint8_t c,
-       const uint8_t d, const uint8_t e, const uint8_t f) noexcept
-    : part{a,b,c,d,e,f}
-  {}
-
-  MAC_addr& operator=(const MAC_addr cpy) noexcept {
-    minor = cpy.minor;
-    major = cpy.major;
-    return *this;
-  }
-
-  /**
-   * @brief Hex representation of a MAC address
-   *
-   * @return hex string representation
-   */
-  std::string hex_str() const {
-    char hex_addr[18];
-    snprintf(hex_addr, sizeof(hex_addr), "%02x:%02x:%02x:%02x:%02x:%02x",
-            part[0], part[1], part[2],
-            part[3], part[4], part[5]);
-    return hex_addr;
-  }
-
-  /**
-   * @brief String representation of a MAC address
-   * @note default is hex
-   * @return string representation of the MAC address
-   */
-  std::string str() const
-  { return hex_str(); }
-
-  std::string to_string() const
-  { return str(); }
-
-  operator std::string () const
-  { return str(); }
-
-  /** Check for equality */
-  bool operator==(const MAC_addr mac) const noexcept
-  {
-    return strncmp(
-                   reinterpret_cast<const char*>(part),
-                   reinterpret_cast<const char*>(mac.part),
-                   PARTS_LEN) == 0;
-  }
-
-}  __attribute__((packed)); //< union addr
+namespace MAC {
+
+  // MAC address
+  union Addr {
+    // no. parts in a MAC address
+    static constexpr size_t PARTS_LEN = 6;
+    // The parts of the MAC address
+    uint8_t part[PARTS_LEN];
+
+    struct {
+      uint16_t minor;
+      uint32_t major;
+    } __attribute__((packed));
+
+    Addr() noexcept : part{} {}
+
+    Addr(const uint8_t a, const uint8_t b, const uint8_t c,
+             const uint8_t d, const uint8_t e, const uint8_t f) noexcept
+      : part{a,b,c,d,e,f}
+    {}
+
+    Addr& operator=(const Addr cpy) noexcept {
+      minor = cpy.minor;
+      major = cpy.major;
+      return *this;
+    }
+
+
+    /**
+     * @brief Hex representation of a MAC address
+     *
+     * @return hex string representation
+     */
+    std::string hex_str() const {
+      char hex_addr[18];
+      snprintf(hex_addr, sizeof(hex_addr), "%02x:%02x:%02x:%02x:%02x:%02x",
+               part[0], part[1], part[2],
+               part[3], part[4], part[5]);
+      return hex_addr;
+    }
+
+    /**
+     * @brief String representation of a MAC address
+     * @note default is hex
+     * @return string representation of the MAC address
+     */
+    std::string str() const
+    { return hex_str(); }
+
+    std::string to_string() const
+    { return str(); }
+
+    operator std::string () const
+    { return str(); }
+
+    /** Check for equality */
+    bool operator==(const Addr mac) const noexcept
+    {
+      return strncmp(
+                     reinterpret_cast<const char*>(part),
+                     reinterpret_cast<const char*>(mac.part),
+                     PARTS_LEN) == 0;
+    }
+
+    bool operator!=(const Addr mac) const noexcept
+    { return not(*this == mac); }
+
+  }  __attribute__((packed)); //< union addr
+
+  const Addr EMPTY {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+
+  // uint16_t(0xFFFF), uint32_t(0xFFFFFFFF)
+  const Addr BROADCAST {0xff,0xff,0xff,0xff,0xff,0xff};
+
+  // uint16_t(0x0000), uint32_t(0x01000000)
+  const Addr MULTICAST {0,0,0x01,0,0,0};
+
+  // uint16_t(0x3333), uint32_t(0x01000000)
+  const Addr IPv6mcast_01 {0x33,0x33,0x01,0,0,0};
+
+  // uint16_t(0x3333), uint32_t(0x02000000)
+  const Addr IPv6mcast_02 {0x33,0x33,0x02,0,0,0};
+
+
 }
 
 #endif

api/hw/nic.hpp

@@ -20,7 +20,6 @@
 
 #include "../net/buffer_store.hpp"
 #include "mac_addr.hpp"
-#include <net/frame.hpp>
 #include <net/inet_common.hpp>
 
 namespace hw {
@@ -31,7 +30,7 @@ namespace hw {
   class Nic {
   public:
     using upstream    = delegate<void(net::Packet_ptr)>;
-    using downstream  = upstream;
+    using downstream  = net::downstream_link;
 
     enum class Proto {ETH, IEEE802111};
 
@@ -49,7 +48,7 @@ namespace hw {
     { return "NIC"; }
 
     /** The mac address. */
-    virtual const MAC_addr& mac() const noexcept = 0;
+    virtual const MAC::Addr& mac() const noexcept = 0;
 
     virtual uint16_t MTU() const noexcept = 0;
 
@@ -65,7 +64,17 @@ namespace hw {
     size_t buffers_available()
     { return bufstore_.available(); }
 
-    virtual net::Packet_ptr create_packet(uint16_t) = 0;
+    /** Number of bytes in a frame needed by the device itself **/
+    virtual size_t frame_offset_device() = 0;
+
+    /** Number of bytes in a frame needed by the link layer **/
+    virtual size_t frame_offset_link() = 0;
+
+    /**
+     * Create a packet with appropriate size for the underlying link
+     * @param layer_begin : offset in octets from the link-layer header
+     */
+    virtual net::Packet_ptr create_packet(int layer_begin) = 0;
 
     /** Subscribe to event for when there is more room in the tx queue */
     void on_transmit_queue_available(net::transmit_avail_delg del)
@@ -75,6 +84,12 @@ namespace hw {
 
     virtual void deactivate() = 0;
 
+    /** Stats getters **/
+    virtual uint64_t get_packets_rx() = 0;
+    virtual uint64_t get_packets_tx() = 0;
+    virtual uint64_t get_packets_dropped() = 0;
+
+    /** Move this nic to current CPU **/
     virtual void move_to_this_cpu() = 0;
 
     virtual ~Nic() {}

api/kernel/irq_manager.hpp

@@ -126,10 +126,16 @@ class alignas(SMP_ALIGN) IRQ_manager {
   /** process all pending interrupts */
   void process_interrupts();
 
+  std::array<uint64_t*,IRQ_LINES>& get_count_handled()
+  { return count_handled; }
+
+  std::array<uint64_t,IRQ_LINES>& get_count_received()
+  { return count_received; }
+
   /** Initialize for a local APIC */
   static void init(int cpuid);
-
   IRQ_manager() = default;
+
 private:
   IRQ_manager(IRQ_manager&) = delete;
   IRQ_manager(IRQ_manager&&) = delete;
@@ -138,7 +144,8 @@ class alignas(SMP_ALIGN) IRQ_manager {
 
   IDTDescr     idt[INTR_LINES];
   irq_delegate irq_delegates_[IRQ_LINES];
-  uint64_t*    counters[IRQ_LINES];
+  std::array<uint64_t*,IRQ_LINES> count_handled;
+  std::array<uint64_t, IRQ_LINES> count_received;
 
   MemBitmap  irq_subs;
   MemBitmap  irq_pend;

api/net/ethernet/ethernet.hpp

@@ -20,9 +20,8 @@
 #define NET_ETHERNET_HPP
 
 #include <string>
-
-#include "frame.hpp"
 #include "header.hpp"
+#include "ethertype.hpp"
 #include <hw/mac_addr.hpp> // ethernet address
 #include <hw/nic.hpp> // protocol
 #include <net/inet_common.hpp>
@@ -34,41 +33,8 @@ namespace net {
   public:
     static constexpr size_t MINIMUM_PAYLOAD = 46;
 
-    /**
-     *  Some big-endian ethernet types
-     *
-     *  From http://en.wikipedia.org/wiki/EtherType
-     */
-    enum ethertype_le {
-      _ETH_IP4   = 0x0800,
-      _ETH_ARP   = 0x0806,
-      _ETH_WOL   = 0x0842,
-      _ETH_IP6   = 0x86DD,
-      _ETH_FLOW  = 0x8808,
-      _ETH_JUMBO = 0x8870
-    };
-
-    /** Little-endian ethertypes. */
-    enum ethertype {
-      ETH_IP4   = 0x8,
-      ETH_ARP   = 0x608,
-      ETH_WOL   = 0x4208,
-      ETH_IP6   = 0xdd86,
-      ETH_FLOW  = 0x888,
-      ETH_JUMBO = 0x7088,
-      ETH_VLAN  = 0x81
-    };
-
-    using Frame = ethernet::Frame;
-
     // MAC address
-    using addr = hw::MAC_addr;
-
-    static const addr MULTICAST_FRAME;
-    static const addr BROADCAST_FRAME;
-
-    static const addr IPv6mcast_01;
-    static const addr IPv6mcast_02;
+    using addr = MAC::Addr;
 
     /** Constructor */
     explicit Ethernet(downstream physical_downstream, const addr& mac) noexcept;
@@ -106,13 +72,23 @@ namespace net {
     { return physical_downstream_; }
 
     static constexpr uint16_t header_size() noexcept
-    { return sizeof(ethernet::Header) + sizeof(ethernet::trailer_t); }
+    { return sizeof(ethernet::Header); }
 
     static constexpr hw::Nic::Proto proto() noexcept
     { return hw::Nic::Proto::ETH; }
 
     /** Transmit data, with preallocated space for eth.header */
-    void transmit(Packet_ptr);
+    void transmit(Packet_ptr, addr dest, Ethertype);
+
+    /** Stats getters **/
+    uint64_t get_packets_rx()
+    { return packets_rx_; }
+
+    uint64_t get_packets_tx()
+    { return packets_tx_; }
+
+    uint64_t get_packets_dropped()
+    { return packets_dropped_; }
 
   private:
     const addr& mac_;
@@ -123,9 +99,9 @@ namespace net {
     uint32_t& packets_dropped_;
 
     /** Upstream OUTPUT connections */
-    upstream ip4_upstream_ = [](net::Packet_ptr){};
-    upstream ip6_upstream_ = [](net::Packet_ptr){};
-    upstream arp_upstream_ = [](net::Packet_ptr){};
+    upstream ip4_upstream_ = nullptr;
+    upstream ip6_upstream_ = nullptr;
+    upstream arp_upstream_ = nullptr;
 
     /** Downstream OUTPUT connection */
     downstream physical_downstream_ = [](Packet_ptr){};

api/net/ethernet/ethertype.hpp

@@ -0,0 +1,39 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#ifndef NET_ETHERTYPE_HPP
+#define NET_ETHERTYPE_HPP
+
+
+namespace net {
+
+  /** Little-endian ethertypes. More entries here:
+      http://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml */
+  enum class Ethertype : uint16_t {
+    IP4   = 0x8,
+    ARP   = 0x608,
+    WOL   = 0x4208,
+    IP6   = 0xdd86,
+    FLOW  = 0x888,
+    JUMBO = 0x7088,
+    VLAN  = 0x81
+  };
+
+}
+
+#endif