Merge pull request #871 from AndreasAakesson/dev

Changed Packet to be sent as unique_ptr instead of shared_ptr

Author: fwsGonzo

api/kernel/cpuid.hpp

@@ -31,7 +31,7 @@ namespace CPUID
     DTES64,            // 64-Bit Debug Store Area
     MONITOR,           // MONITOR/MWAIT
     DS_CPL,            // CPL Qualified Debug Store
-    VMX,               // Virtual Machine Extensions
+    VMX,               // Virtual Machine Extensions (VT-x)
     SMX,               // Safer Mode Extensions
     EST,               // Enhanced SpeedStep Technology
     TM2,               // Thermal Monitor 2
@@ -94,6 +94,10 @@ namespace CPUID
     PDPE1GB,           // 1 GB Pages
     RDTSCP,            // RDTSCP and IA32_TSC_AUX
     LM,                // Long mode (64-bit Architecture)
+
+    SVM,               // Secture Virtual Machines (AMD-V)
+                       // aka. AMD-V (AMD's virtualization extension)
+    SSE4A,             // SSE4a
   };
 
   bool is_amd_cpu();

api/net/buffer_store.hpp

@@ -21,11 +21,9 @@
 
 #include <stdexcept>
 #include <vector>
-#include <net/inet_common.hpp>
-#include <util/membitmap.hpp>
-
-namespace net{
 
+namespace net
+{
   /**
    * Network buffer storage for uniformly sized buffers.
    *
@@ -62,13 +60,6 @@ namespace net{
 
     inline size_t available() const noexcept
     { return available_.size(); }
-    
-    void lock(void* addr) {
-      auto* buffer = (buffer_t) addr;
-      assert(is_from_pool(buffer));
-      locked.set( buffer_id(buffer) );
-    }
-    void unlock_and_release(buffer_t addr);
 
   private:
     buffer_t pool_begin() const noexcept {
@@ -80,12 +71,11 @@ namespace net{
     size_t buffer_id(buffer_t addr) const {
       return (addr - pool_) / bufsize_;
     }
-    
+
     size_t               poolsize_;
-    const size_t         bufsize_;
+    size_t         bufsize_;
     buffer_t             pool_;
     std::vector<buffer_t> available_;
-    MemBitmap  locked;
 
     BufferStore(BufferStore&)  = delete;
     BufferStore(BufferStore&&) = delete;

api/net/inet4.hpp

@@ -77,10 +77,9 @@ namespace net {
       // get buffer (as packet + data)
       auto* ptr = (Packet*) bufstore_.get_buffer();
       // place packet at front of buffer
-      new (ptr) Packet(nic_.bufsize(), size,
-          delegate<void(void*)>::from<BufferStore, &BufferStore::release> (&bufstore_));
+      new (ptr) Packet(nic_.bufsize(), size, &bufstore_);
       // regular shared_ptr that calls delete on Packet
-      return std::shared_ptr<Packet>(ptr);
+      return Packet_ptr(ptr);
     }
 
     /** MTU retreived from Nic on construction */

api/net/inet_common.hpp

@@ -21,6 +21,7 @@
 #define NET_INET_COMMON_HPP
 
 #include <delegate>
+#include <net/packet.hpp>
 
 namespace net {
   // Packet must be forward declared to avoid circular dependency
@@ -30,7 +31,7 @@ namespace net {
 
   using LinkLayer = Ethernet;
 
-  using Packet_ptr = std::shared_ptr<Packet>;
+  using Packet_ptr = std::unique_ptr<Packet>;
 
   // Downstream / upstream delegates
   using downstream = delegate<void(Packet_ptr)>;
@@ -48,6 +49,14 @@ namespace net {
     return std::static_pointer_cast<T>(packet);
   }
 
+
+  template<typename Derived, typename Base>
+  auto static_unique_ptr_cast( std::unique_ptr<Base>&& p )
+  {
+      auto* d = static_cast<Derived *>(p.release());
+      return std::unique_ptr<Derived>(d);
+  }
+
 } //< namespace net
 
 #endif //< NET_INET_COMMON_HPP

api/net/ip4/packet_arp.hpp

@@ -6,9 +6,9 @@
 // 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.
@@ -24,62 +24,61 @@
 
 namespace net
 {
-  class PacketArp : public Packet,
-                    public std::enable_shared_from_this<PacketArp>
+  class PacketArp : public Packet
   {
   public:
     Arp::header& header() const
     {
       return *(Arp::header*) buffer();
     }
-    
+
     static const size_t headers_size = sizeof(Arp::header);
-    
+
     /** initializes to a default, empty Arp packet, given
         a valid MTU-sized buffer */
     void init(Ethernet::addr local_mac, IP4::addr local_ip)
-    {            
+    {
       auto& hdr = header();
       hdr.ethhdr.type = Ethernet::ETH_ARP;
       hdr.htype = Arp::H_htype_eth;
       hdr.ptype = Arp::H_ptype_ip4;
       hdr.hlen_plen = Arp::H_hlen_plen;
-      
+
       hdr.dipaddr = next_hop();
       hdr.sipaddr = local_ip;
       hdr.shwaddr = local_mac;
     }
-    
+
     void set_dest_mac(Ethernet::addr mac) {
       header().dhwaddr = mac;
-      header().ethhdr.dest = mac; 
-    } 
-    
+      header().ethhdr.dest = mac;
+    }
+
     void set_opcode(Arp::Opcode op) {
       header().opcode = op;
     }
-    
+
     void set_dest_ip(IP4::addr ip) {
       header().dipaddr = ip;
     }
-    
+
     IP4::addr source_ip() const {
       return header().sipaddr;
     }
-    
+
     IP4::addr dest_ip() const {
       return header().dipaddr;
     }
-    
+
     Ethernet::addr source_mac() const {
       return header().ethhdr.src;
     };
-    
+
     Ethernet::addr dest_mac() const {
       return header().ethhdr.dest;
     };
-    
-    
+
+
   };
 }
 

api/net/ip4/packet_ip4.hpp

@@ -26,8 +26,7 @@
 
 namespace net {
 
-  class PacketIP4 : public Packet, // might work as upcast:
-                    public std::enable_shared_from_this<PacketIP4>
+  class PacketIP4 : public Packet
   {
   public:
     static constexpr size_t DEFAULT_TTL {64};

api/net/ip4/packet_udp.hpp

@@ -23,8 +23,7 @@
 
 namespace net
 {
-  class PacketUDP : public PacketIP4, // might work as upcast:
-                    public std::enable_shared_from_this<PacketUDP>
+  class PacketUDP : public PacketIP4
   {
   public:
 

api/net/ip4/udp.hpp

@@ -23,6 +23,7 @@
 #include "../inet.hpp"
 #include "ip4.hpp"
 #include <cstring>
+#include <net/packet.hpp>
 
 namespace net {
 
@@ -35,7 +36,7 @@ namespace net {
     using addr_t = IP4::addr;
     using port_t = uint16_t;
 
-    using Packet_ptr = std::shared_ptr<PacketUDP>;
+    using Packet_ptr = std::unique_ptr<PacketUDP, std::default_delete<net::Packet>>;
     using Stack  = Inet<LinkLayer, IP4>;
 
     typedef delegate<void()> sendto_handler;

api/net/packet.hpp

@@ -20,16 +20,17 @@
 
 #include "buffer_store.hpp"
 #include "ip4/addr.hpp"
+#include <delegate>
 #include <cassert>
 
-namespace net {
-  void default_packet_deleter(void* p);
+namespace net
+{
+  class Packet;
+  using Packet_ptr = std::unique_ptr<Packet>;
 
-  class Packet : public std::enable_shared_from_this<Packet>
+  class Packet
   {
   public:
-    using deleter_t = delegate<void(void*)>;
-
     /**
      *  Construct, using existing buffer.
      *
@@ -41,25 +42,30 @@ namespace net {
     Packet(
         uint16_t cap,
         uint16_t len,
-        deleter_t del = default_packet_deleter) noexcept
+        BufferStore* bs) noexcept
     : capacity_ (cap),
       size_     (len),
-      deleter_  {del}
+      bufstore  (bs)
     {}
-    ~Packet() {
-      deleter_(this);
+
+    virtual ~Packet()
+    {
+      if (bufstore)
+          bufstore->release(this);
+      else
+          delete[] (uint8_t*) this;
     }
 
     /** Get the buffer */
     BufferStore::buffer_t buffer() const noexcept
     { return (BufferStore::buffer_t) buf_; }
 
     /** Get the network packet length - i.e. the number of populated bytes  */
-    inline uint16_t size() const noexcept
+    uint16_t size() const noexcept
     { return size_; }
 
     /** Get the size of the buffer. This is >= len(), usually MTU-size */
-    inline uint16_t capacity() const noexcept
+    uint16_t capacity() const noexcept
     { return capacity_; }
 
     void set_size(uint16_t new_size) noexcept {
@@ -77,27 +83,28 @@ namespace net {
     /* Add a packet to this packet chain.  */
     void chain(Packet_ptr p) noexcept {
       if (!chain_) {
-        chain_ = p;
-        last_ = p;
+        chain_ = std::move(p);
+        last_ = chain_.get();
       } else {
-        last_->chain(p);
-        last_ = p->last_in_chain() ? p->last_in_chain() : p;
+        auto* ptr = p.get();
+        last_->chain(std::move(p));
+        last_ = ptr->last_in_chain() ? ptr->last_in_chain() : ptr;
         assert(last_);
       }
     }
 
     /* Get the last packet in the chain */
-    Packet_ptr last_in_chain() noexcept
+    Packet* last_in_chain() noexcept
     { return last_; }
 
     /* Get the tail, i.e. chain minus the first element */
-    Packet_ptr tail() noexcept
-    { return chain_; }
+    Packet* tail() noexcept
+    { return chain_.get(); }
 
     /* Get the tail, and detach it from the head (for FIFO) */
-    Packet_ptr detach_tail() noexcept
+    auto detach_tail() noexcept
     {
-      auto tail = chain_;
+      auto tail = std::move(chain_);
       chain_ = 0;
       return tail;
     }
@@ -107,11 +114,11 @@ namespace net {
      *  For a UDPv6 packet, the payload location is the start of
      *  the UDPv6 header, and so on
      */
-    inline void set_payload(BufferStore::buffer_t location) noexcept
+    void set_payload(BufferStore::buffer_t location) noexcept
     { payload_ = location; }
 
     /** Get the payload of the packet */
-    inline BufferStore::buffer_t payload() const noexcept
+    BufferStore::buffer_t payload() const noexcept
     { return payload_; }
 
     /**
@@ -120,21 +127,15 @@ namespace net {
      *  Unfortunately, we can't upcast with std::static_pointer_cast
      *  however, all classes derived from Packet should be good to use
      */
-    static Packet_ptr packet(Packet_ptr pckt) noexcept
-    { return *static_cast<Packet_ptr*>(&pckt); }
-
-    // custom deleter for Packet used by network stack
-    void set_deleter(deleter_t cb) {
-      this->deleter_ = cb;
-    }
+    //static Packet_ptr packet(Packet_ptr pckt) noexcept
+    //{ return *static_cast<Packet_ptr*>(&pckt); }
 
     // override delete to do nothing
     static void operator delete (void*) {}
 
   private:
-    /** Let's chain packets */
-    Packet_ptr chain_ {0};
-    Packet_ptr last_ {0};
+    Packet_ptr chain_ {nullptr};
+    Packet*    last_  {nullptr};
 
     /** Default constructor Deleted. See Packet(Packet&). */
     Packet() = delete;
@@ -158,16 +159,12 @@ namespace net {
 
     uint16_t              capacity_;
     uint16_t              size_;
+    BufferStore*          bufstore;
     ip4::Addr             next_hop4_;
-    deleter_t             deleter_;
     BufferStore::buffer_t payload_ {nullptr};
     BufferStore::buffer_t buf_[0];
   }; //< class Packet
 
-  inline void default_packet_deleter(void* p) {
-    delete (Packet*) p;
-  }
-
 } //< namespace net
 
 #endif