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

Author: alfreb

api/hw/msi.hpp

@@ -48,6 +48,7 @@ namespace hw {
     void init(PCI_Device&);
     void mask_entry(size_t);
     void unmask_entry(size_t);
+    void zero_entry(size_t);
     // enable one (cpu, vector) entry for this device
     uint16_t setup_vector(uint8_t cpu, uint8_t vector);
 

api/kernel/irq_manager.hpp

@@ -129,9 +129,9 @@ class IRQ_manager {
     return cycles_hlt_;
   }
 
-  /** Get the total number of cycles spent working **/
-  uint64_t cycles_active(){
-    return cycles_active_;
+  /** Get the total number of cycles since boot **/
+  uint64_t cycles_total(){
+    return cycles_total_;
   }
 
 private:
@@ -151,7 +151,7 @@ class IRQ_manager {
   MemBitmap  irq_todo;
 
   uint64_t& cycles_hlt_;
-  uint64_t& cycles_active_;
+  uint64_t& cycles_total_;
 
   static const char       default_attr {static_cast<char>(0x8e)};
   static const uint16_t   default_sel  {0x8};

api/kernel/service.hpp

@@ -37,15 +37,11 @@ class Service {
   /**
    *  The service entry point
    *
-   *  This is like 'main' - which we don't have, since the signature wouldn't
-   *  make sense (no command line, no args, no where to return to)
+   *  This is like an applications 'main' function
    *  
-   *  @note Whenever this function returns, the OS will call `hlt`, sleeping
+   *  @note Whenever this function returns, the OS will be sleeping
    *        until an external interrupt fires (there are no regular timer
    *        interrupts unless you've enabled them).
-   *
-   *        Your service should hook up event handlers to some of the events
-   *        (like `Nic::on(HttpConnection, your_callback`))
    */
   static void start(const std::string&);
 
@@ -66,8 +62,6 @@ class Service {
    *  If the virtual machine running your service gets a poweroff signal
    *  (i.e. from the hypervisor, like Qemu or VirtualBox) this function should
    *  ensure a safe shutdown.
-   *  
-   *  @todo This is not implemented
    */
   static void stop();
 }; //< Service

api/net/tcp/connection.hpp

@@ -177,6 +177,20 @@ class Connection : public std::enable_shared_from_this<Connection> {
   const Connection::State& prev_state() const
   { return *prev_state_; }
 
+  uint64_t bytes_received() const
+  { return bytes_rx_; }
+
+  uint64_t bytes_transmitted() const
+  { return bytes_tx_; }
+
+  /**
+   * @brief Total number of bytes in read buffer
+   *
+   * @return bytes not yet read
+   */
+  size_t readq_size() const
+  { return read_request.buffer.size(); }
+
   /**
    * @brief Total number of bytes in send queue
    *
@@ -193,32 +207,6 @@ class Connection : public std::enable_shared_from_this<Connection> {
   uint32_t sendq_remaining() const
   { return writeq.bytes_remaining(); }
 
-  /*
-    Calculates and return bytes transmitted.
-    TODO: Not sure if this will suffice.
-  */
-  uint32_t bytes_transmitted() const
-  { return 0; }
-
-  /*
-    Calculates and return bytes received.
-    TODO: Not sure if this will suffice.
-  */
-  uint32_t bytes_received() const
-  { return 0; }
-
-  /*
-    Bytes queued for transmission.
-    TODO: Implement when retransmission is up and running.
-  */
-  //inline size_t send_queue_bytes() const {}
-
-  /*
-    Bytes currently in receive buffer.
-  */
-  size_t read_queue_bytes() const
-  { return read_request.buffer.size(); }
-
   /*
     Return the id (TUPLE) of the connection.
   */
@@ -477,6 +465,10 @@ class Connection : public std::enable_shared_from_this<Connection> {
   RtxTimeoutCallback      on_rtx_timeout_;
   CloseCallback           on_close_;
 
+  /** Recv/Sent */
+  uint64_t bytes_rx_;
+  uint64_t bytes_tx_;
+
   /** State if connection is in TCP write queue or not. */
   bool queued_;
 

api/net/tcp/listener.hpp

@@ -35,6 +35,8 @@ class Listener {
   using ConnectCallback      = Connection::ConnectCallback;
   using CleanupCallback      = Connection::CleanupCallback;
 
+  using SynQueue = std::deque<Connection_ptr>;
+
   friend class net::TCP;
 
 public:
@@ -70,6 +72,9 @@ class Listener {
   auto syn_queue_size() const
   { return syn_queue_.size(); }
 
+  const SynQueue& syn_queue() const
+  { return syn_queue_; }
+
   /** Delete copy and move constructors.*/
   Listener(Listener&) = delete;
   Listener(Listener&&) = delete;
@@ -81,8 +86,7 @@ class Listener {
 private:
   TCP& host_;
   const port_t port_;
-
-  std::deque<Connection_ptr> syn_queue_;
+  SynQueue syn_queue_;
 
   /** */
   AcceptCallback on_accept_;

api/net/tcp/tcp.hpp

@@ -143,6 +143,9 @@ namespace net {
     tcp::Address address()
     { return inet_.ip_addr(); }
 
+    IPStack& stack() const
+    { return inet_; }
+
   private:
 
     /** Stats */

seed/Makefile

@@ -12,6 +12,9 @@ FILES = service.cpp
 # Your disk image
 DISK=
 
+# Additional drivers (virtionet, virtioblk etc)
+DRIVERS=
+
 # Your own include-path
 LOCAL_INCLUDES=
 

src/hw/msi.cpp

@@ -64,6 +64,11 @@ namespace hw
     auto reg = get_entry(vec, ENT_VECTOR_CTL);
     mm_write(reg, mm_read(reg) & ~MSIX_ENTRY_CTL_MASK);
   }
+  void msix_t::zero_entry(size_t vec)
+  {
+    auto reg = get_entry(vec, ENT_MSG_DATA);
+    mm_write(reg, mm_read(reg) & ~0xff);
+  }
 
   void msix_t::reset_pba_bit(size_t vec)
   {
@@ -103,7 +108,11 @@ namespace hw
     assert(cap >= 0x40);
     // read message control bits
     uint16_t func = dev.read16(cap + 2);
-    assert(func < 0x1000 && "Invalid MSI-X func read");
+    
+    /// if MSIX was already enabled, avoid validating func
+    if ((func & MSIX_ENABLE) == 0)
+      assert(func < 0x1000 && "Invalid MSI-X func read");
+    
     // enable msix and mask all vectors
     func |= MSIX_ENABLE | MSIX_FUNC_MASK;
     dev.write16(cap + 2, func);
@@ -121,9 +130,11 @@ namespace hw
       assert(vectors() <= 16 && "Unreasonably many MSI-X vectors");
     }
 
-    // mask out all entries
-    for (size_t i = 0; i < this->vectors(); i++)
+    // reset all entries
+    for (size_t i = 0; i < this->vectors(); i++) {
       mask_entry(i);
+      zero_entry(i);
+    }
 
     // unmask vectors
     func &= ~MSIX_FUNC_MASK;

src/kernel/irq_manager.cpp

@@ -31,9 +31,9 @@ IRQ_manager::IRQ_manager(uint8_t cpuid)
   : cycles_hlt_{Statman::get()
     .create(Stat::UINT64, std::string(std::string("cpu") + std::to_string(cpuid)
                                       + ".cycles_hlt").c_str() ).get_uint64()},
-  cycles_active_{Statman::get()
+  cycles_total_{Statman::get()
       .create(Stat::UINT64,std::string(std::string("cpu") + std::to_string(cpuid)
-                                       + ".cycles_active").c_str()).get_uint64()}
+                                       + ".cycles_total").c_str()).get_uint64()}
 {}
 
 uint8_t IRQ_manager::get_next_msix_irq()
@@ -199,7 +199,7 @@ void IRQ_manager::notify()
 
       (*counters[intr])++;
 
-      cycles_active_ = OS::cycles_since_boot();
+      cycles_total_ = OS::cycles_since_boot();
 
       irq_todo.reset(intr);
       intr = irq_todo.first_set();
@@ -217,5 +217,5 @@ void IRQ_manager::notify()
   "_irq_cb_return_location:" );
 
   // Count sleep cycles
-  cycles_hlt_ += OS::cycles_since_boot() - cycles_active_;
+  cycles_hlt_ += OS::cycles_since_boot() - cycles_total_;
 }

src/net/tcp/connection.cpp

@@ -43,6 +43,7 @@ Connection::Connection(TCP& host, port_t local_port, Socket remote) :
   cb(),
   read_request(),
   writeq(),
+  bytes_rx_(0), bytes_tx_(0),
   queued_(false),
   time_wait_started(0)
 {
@@ -126,6 +127,8 @@ size_t Connection::receive(const uint8_t* data, size_t n, bool PUSH) {
     buf.renew();
   }
 
+  bytes_rx_ += received;
+
   return received;
 }
 
@@ -409,6 +412,8 @@ void Connection::transmit(Packet_ptr packet) {
   //  packet->seq() - cb.ISS, packet->ack() - cb.IRS);
   debug2("<TCP::Connection::transmit> TX %s\n", packet->to_string().c_str());
 
+  bytes_tx_ += packet->tcp_data_length();
+
   host_.transmit(packet);
   if(packet->should_rtx() and !rtx_timer.active) {
     rtx_start();
@@ -673,6 +678,10 @@ void Connection::retransmit() {
 
   //printf("<TCP::Connection::retransmit> rseq=%u \n", packet->seq() - cb.ISS);
   debug("<TCP::Connection::retransmit> RT %s\n", packet->to_string().c_str());
+
+  // count retranmissions to bytes transmitted?
+  bytes_tx_ += packet->tcp_data_length();
+
   host_.transmit(packet);
   /*
     Every time a packet containing data is sent (including a