Merge branch 'dev' of github.com:hioa-cs/IncludeOS into dev

Author: AndreasAakesson

api/fs/common.hpp

@@ -28,9 +28,8 @@
 
 namespace fs {
 
-  // Generic structure for directory entries
   struct Dirent;
-
+  struct File_system;
 
   /**
    * @brief Type used as a building block to represent buffers
@@ -185,24 +184,23 @@ namespace fs {
   /** @var no_error: Always returns boolean false when used in expressions */
   extern error_t no_error;
 
-    /** Async function types **/
-  using on_init_func  = delegate<void(error_t)>;
+  /** Async function types **/
+  using on_init_func  = delegate<void(error_t, File_system&)>;
   using on_ls_func    = delegate<void(error_t, dirvec_t)>;
   using on_read_func  = delegate<void(error_t, buffer_t, uint64_t)>;
   using on_stat_func  = delegate<void(error_t, const Dirent&)>;
 
 
-  struct List {
+  struct List
+  {
     error_t  error;
     dirvec_t entries;
     auto begin() { return entries->begin(); }
     auto end() { return entries->end(); }
     auto cbegin() { return entries->cbegin(); }
     auto cend() { return entries->cend(); }
-
   };
 
+} //< fs
 
-} //< namespace fs
-
-#endif //< FS_ERROR_HPP
+#endif //< FS_COMMON_HPP

api/fs/disk.hpp

@@ -42,7 +42,7 @@ namespace fs {
 
     struct Partition;
     using on_parts_func = delegate<void(fs::error_t, std::vector<Partition>&)>;
-    using on_init_func = delegate<void(fs::error_t)>;
+    using on_init_func  = delegate<void(fs::error_t, File_system&)>;
     using lba_t = uint32_t;
 
     enum partition_t {

api/fs/filesystem.hpp

@@ -27,10 +27,6 @@ namespace fs {
   struct Dirent;
 
   struct File_system {
-
-    /** Initialize this filesystem with LBA at @base_sector */
-    virtual void init(uint64_t lba, uint64_t size, on_init_func on_init) = 0;
-
     /** Get unique (per device type) device id for underlying device.*/
     virtual Device_id device_id() = 0;
 
@@ -76,6 +72,9 @@ namespace fs {
     /** Returns the name of this filesystem */
     virtual std::string name() const = 0;
 
+    /** Initialize this filesystem with LBA at @base_sector */
+    virtual void init(uint64_t lba, uint64_t size, on_init_func on_init) = 0;
+
     /** Default destructor */
     virtual ~File_system() noexcept = default;
   }; //< class File_system

api/net/buffer_store.hpp

@@ -82,9 +82,10 @@ namespace net
     std::vector<buffer_t> available_;
     int                  cpu;
     static bool          smp_enabled_;
+#ifndef INCLUDEOS_SINGLE_THREADED
     // has strict alignment reqs, so put at end
     spinlock_t           plock;
-
+#endif
     BufferStore(BufferStore&)  = delete;
     BufferStore(BufferStore&&) = delete;
     BufferStore& operator=(BufferStore&)  = delete;

api/net/http/connection.hpp

@@ -67,7 +67,7 @@ namespace http {
     inline TCP_conn release();
 
     /**
-     * @brief      Wether the underlying TCP connection has been released or not
+     * @brief      Whether the underlying TCP connection has been released or not
      *
      * @return     true if the underlying TCP connection is released
      */

api/net/http/message.hpp

@@ -99,7 +99,7 @@ class Message {
    *
    * @param[in]  len   The length of the content
    *
-   * @return     Outcome of wether the field got updated or not
+   * @return     Outcome of whether the field got updated or not
    */
   inline bool set_content_length(size_t len);
 

api/net/inet.hpp

@@ -100,6 +100,7 @@ namespace net {
     virtual void force_start_send_queues() = 0;
 
     virtual void move_to_this_cpu() = 0;
+    virtual int  get_cpu_id() const noexcept = 0;
 
   }; //< class Inet<LINKLAYER, IPV>
 } //< namespace net

api/net/inet4.hpp

@@ -194,6 +194,10 @@ namespace net {
 
     void move_to_this_cpu() override;
 
+    int  get_cpu_id() const noexcept override {
+      return this->cpu_id;
+    }
+
     /** Return the stack on the given Nic */
     template <int N = 0>
     static auto&& stack()
@@ -248,6 +252,7 @@ namespace net {
 
     std::shared_ptr<net::DHClient> dhcp_{};
 
+    int   cpu_id;
     const uint16_t MTU_;
 
     friend class Super_stack;

api/net/router.hpp

@@ -31,27 +31,41 @@ namespace net {
     using Addr = typename IPV::addr;
     using Netmask = typename IPV::addr;
 
-    Addr dest_net()
-    { return dest_net_; }
+    Addr net() const noexcept
+    { return net_; }
 
-    Netmask netmask()
+    Netmask netmask() const noexcept
     { return netmask_; }
 
-    Addr gateway()
+    Addr gateway() const noexcept
     { return gateway_; }
 
-    int cost()
+    int cost() const noexcept
     { return cost_; }
 
-    Stack_ptr interface()
+    Stack_ptr interface() const noexcept
     { return iface_; };
 
-    Route(Addr dest_net, Netmask mask, Addr gateway, Stack& iface, int cost)
-      : dest_net_{dest_net}, netmask_{mask}, gateway_{gateway}, iface_{&iface}, cost_{cost}
+    Stack_ptr match(typename IPV::addr dest) const noexcept
+    { return (dest & netmask_) == net_ ? iface_ : nullptr; }
+
+    bool operator<(const Route& b) const
+    { return cost() < b.cost(); }
+
+    bool operator==(const Route& b) const
+    {
+      return net_ == b.net() and
+        netmask_ == b.netmask() and
+        cost_ == b.cost() and
+        iface_ == b.interface();
+    }
+
+    Route(Addr net, Netmask mask, Addr gateway, Stack& iface, int cost)
+      : net_{net}, netmask_{mask}, gateway_{gateway}, iface_{&iface}, cost_{cost}
     {}
 
   private:
-    Addr dest_net_;
+    Addr net_;
     Netmask netmask_;
     Addr gateway_;
     Stack_ptr iface_;
@@ -82,33 +96,62 @@ namespace net {
     { return Forward_delg(*this, forward); }
 
 
-    /** Get the interface route for a certain IP **/
-    virtual Stack_ptr get_interface(typename IPV::addr dest) {
+    /** Get any interface route for a certain IP **/
+    Route<IPV>* get_first_route(typename IPV::addr dest) {
 
       for (auto&& route : routing_table_) {
-        if ((dest & route.netmask()) == route.dest_net())
-          return route.interface();
+        Stack_ptr match = route.match(dest);
+        if (match) return &route;
       }
 
       return nullptr;
+    };
 
+    /** Get any interface route for a certain IP **/
+    Stack_ptr get_first_interface(typename IPV::addr dest) {
+      auto route = get_first_route(dest);
+      if (route) return route->interface();
+      return nullptr;
     };
 
+    /** Check if there exists a route for a given IP **/
     bool route_check(typename IPV::addr dest){
-      return get_interface(dest);
+      return get_first_interface(dest) != nullptr;
     }
 
 
+    /**
+     * Get all routes for a certain IP
+     * @todo : Optimize!
+     **/
+    Routing_table get_all_routes(typename IPV::addr dest) {
+
+      Routing_table t;
+      std::copy_if(routing_table_.begin(),
+                   routing_table_.end(),
+                   std::back_inserter(t), [dest](const Route<IPV>& route) {
+                     return route.match(dest);
+                   });
+      return t;
+    }
+
+    /**
+     * Get cheapest route for a certain IP
+     * @todo : Optimize!
+     **/
+    Route<IPV>* get_cheapest_route(typename IPV::addr dest) {
+      Routing_table all = get_all_routes(dest);
+      std::sort(all.begin(), all.end());
+      if (not all.empty()) return &all.front();
+      return nullptr;
+    };
+
 
     /** Construct a router over a set of interfaces **/
-    Router(Interfaces& ifaces, Routing_table&& tbl = {})
+    Router(Interfaces& ifaces, Routing_table tbl = {})
       : networks_{ifaces}, routing_table_{tbl}
     {  }
 
-    void set_routing_table(Routing_table&& tbl) {
-      routing_table_ = std::forward(tbl);
-    };
-
     void set_routing_table(Routing_table tbl) {
       routing_table_ = tbl;
     };

api/net/tcp/connection.hpp

@@ -786,7 +786,7 @@ class Connection : public std::enable_shared_from_this<Connection> {
   void writeq_reset();
 
   /*
-    Mark wether the Connection is in TCP write queue or not.
+    Mark whether the Connection is in TCP write queue or not.
   */
   void set_queued(bool queued)
   { queued_ = queued; }
@@ -1046,7 +1046,7 @@ class Connection : public std::enable_shared_from_this<Connection> {
   void timewait_timeout()
   { signal_close(); }
 
-  /** Wether to use Delayed ACK or not */
+  /** Whether to use Delayed ACK or not */
   bool use_dack() const noexcept;
 
   /**