Merge pull request #1211 from fwsGonzo/dev

Various tweaks to use routing between different CPUs

Author: fwsGonzo

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(); }
-
   };
 
-
-} //< namespace fs
+} //< fs
 
 #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/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/smp

@@ -120,6 +120,8 @@ public:
   // call this to signal that tasks are queued up
   static void signal();
 
+  // trigger interrupt on specified CPU
+  static void unicast(int cpu, uint8_t intr);
   // broadcast-trigger interrupt on all waiting APs
   static void broadcast(uint8_t intr);
 

examples/acorn/service.cpp

@@ -72,8 +72,9 @@ void Service::start(const std::string&) {
   disk = fs::new_shared_memdisk();
 
   // mount the main partition in the Master Boot Record
-  disk->init_fs([](fs::error_t err) {
-
+  disk->init_fs(
+  [](fs::error_t err, auto& fs)
+  {
       if (err)  panic("Could not mount filesystem, retreating...\n");
 
       /** IP STACK SETUP **/
@@ -152,11 +153,12 @@ void Service::start(const std::string&) {
       router.use("/api/dashboard", dashboard_->router());
 
       // Fallback route for angular application - serve index.html if route is not found
-      router.on_get("/app/.*", [](auto, auto res) {
+      router.on_get("/app/.*", 
+      [&fs](auto, auto res) {
         #ifdef VERBOSE_WEBSERVER
         printf("[@GET:/app/*] Fallback route - try to serve index.html\n");
         #endif
-        disk->fs().cstat("/public/app/index.html", [res](auto err, const auto& entry) {
+        fs.cstat("/public/app/index.html", [res](auto err, const auto& entry) {
           if(err) {
             res->send_code(http::Not_Found);
           } else {

src/arch/x86/smp.cpp

@@ -165,9 +165,12 @@ void ::SMP::broadcast(uint8_t irq)
 {
   x86::APIC::get().bcast_ipi(IRQ_BASE + irq);
 }
+void ::SMP::unicast(int cpu, uint8_t irq)
+{
+  x86::APIC::get().send_ipi(cpu, IRQ_BASE + irq);
+}
 
 static spinlock_t __global_lock = 0;
-static spinlock_t __memory_lock = 0;
 
 void ::SMP::global_lock() noexcept
 {
@@ -180,6 +183,8 @@ void ::SMP::global_unlock() noexcept
 
 /// SMP variants of malloc and free ///
 #ifndef INCLUDEOS_SINGLE_THREADED
+static spinlock_t __memory_lock = 0;
+
 #include <malloc.h>
 void* malloc(size_t size)
 {

src/drivers/virtionet.cpp

@@ -44,13 +44,11 @@ void VirtioNet::get_config() {
 VirtioNet::VirtioNet(hw::PCI_Device& d)
   : Virtio(d),
     Link(Link_protocol{{this, &VirtioNet::transmit}, mac()},
-        std::max(2048u, queue_size(0) * 2), 2048 /* half-page buffers */),
+        std::max(256u, queue_size(0) * 2), 2048 /* half-page buffers */),
     packets_rx_{Statman::get().create(Stat::UINT64, device_name() + ".packets_rx").get_uint64()},
     packets_tx_{Statman::get().create(Stat::UINT64, device_name() + ".packets_tx").get_uint64()}
 {
   INFO("VirtioNet", "Driver initializing");
-  static_assert(VIRTIO_HDR_OFFSET >= sizeof(virtio_net_hdr),
-                "Must be at least larger than the driver header itself");
 
   uint32_t needed_features = 0
     | (1 << VIRTIO_NET_F_MAC)
@@ -188,20 +186,17 @@ void VirtioNet::msix_conf_handler()
 }
 void VirtioNet::msix_recv_handler()
 {
-  bool dequeued_rx = false;
+  int dequeued_rx = 0;
   rx_q.disable_interrupts();
   // handle incoming packets as long as bufstore has available buffers
   while (rx_q.new_incoming())
   {
     auto res = rx_q.dequeue();
-    auto pckt_ptr = recv_packet(res.data(), res.size());
-    Link::receive(std::move(pckt_ptr));
+    Link::receive( recv_packet(res.data(), res.size()) );
 
+    dequeued_rx++;
     // Requeue a new buffer
-    if (bufstore().available() > 0)
-        add_receive_buffer(bufstore().get_buffer());
-
-    dequeued_rx = true;
+    add_receive_buffer(bufstore().get_buffer());
 
     // Stat increase packets received
     packets_rx_++;
@@ -248,7 +243,7 @@ void VirtioNet::add_receive_buffer(uint8_t* pkt)
   auto* vnet = pkt + sizeof(Packet);
 
   Token token1 {{vnet, sizeof(virtio_net_hdr)}, Token::IN };
-  Token token2 {{vnet + VIRTIO_HDR_OFFSET, packet_len()}, Token::IN };
+  Token token2 {{vnet + sizeof(virtio_net_hdr), packet_len()}, Token::IN };
 
   std::array<Token, 2> tokens {{ token1, token2 }};
   rx_q.enqueue(tokens);
@@ -263,19 +258,25 @@ VirtioNet::recv_packet(uint8_t* data, uint16_t size)
   assert(bufstore().is_buffer((uint8_t*) ptr));
 #endif
 
-  new (ptr) net::Packet(frame_offset_device(), size - frame_offset_device(), frame_offset_device() + packet_len(), &bufstore());
+  new (ptr) net::Packet(
+      sizeof(virtio_net_hdr), 
+      size - sizeof(virtio_net_hdr), 
+      sizeof(virtio_net_hdr) + packet_len(), 
+      &bufstore());
 
   return net::Packet_ptr(ptr);
 }
 
 net::Packet_ptr
 VirtioNet::create_packet(int link_offset)
 {
- debug("<Virtionet> Creating packet, device offset %i (virtionet header size %i) link offset %i \n",
-         frame_offset_device(), sizeof(virtio_net_hdr), link_offset);
   auto* ptr = (net::Packet*) bufstore().get_buffer();
 
-  new (ptr) net::Packet(frame_offset_device() + link_offset, 0, frame_offset_device() + packet_len(), &bufstore());
+  new (ptr) net::Packet(
+        sizeof(virtio_net_hdr) + link_offset, 
+        0, 
+        sizeof(virtio_net_hdr) + packet_len(), 
+        &bufstore());
 
   return net::Packet_ptr(ptr);
 }
@@ -314,7 +315,8 @@ void VirtioNet::transmit(net::Packet_ptr pckt) {
   net::Packet_ptr tail = std::move(pckt);
 
   // Transmit all we can directly
-  while (tx_q.num_free() and tail) {
+  while (tx_q.num_free() and tail != nullptr)
+  {
     debug("%i tokens left in TX queue \n", tx_q.num_free());
     // next in line
     auto next = tail->detach_tail();
@@ -325,20 +327,22 @@ void VirtioNet::transmit(net::Packet_ptr pckt) {
     transmitted++;
     // Stat increase packets transmitted
     packets_tx_++;
-
-    if (!tail) break;
   }
 
-  // Notify virtio about new packets
   if (LIKELY(transmitted)) {
+#ifdef NO_DEFERRED_KICK
+    tx_q.enable_interrupts();
+    tx_q.kick();
+#else
     begin_deferred_kick();
+#endif
   }
 
   // Buffer the rest
   if (UNLIKELY(tail)) {
     debug("Buffering remaining packets..\n");
     add_to_tx_buffer(std::move(tail));
-    }
+  }
 }
 
 void VirtioNet::enqueue(net::Packet* pckt)
@@ -357,10 +361,7 @@ void VirtioNet::enqueue(net::Packet* pckt)
 
 void VirtioNet::begin_deferred_kick()
 {
-#ifdef NO_DEFERRED_KICK
-  tx_q.enable_interrupts();
-  tx_q.kick();
-#else
+#ifndef NO_DEFERRED_KICK
   if (!deferred_kick) {
     deferred_kick = true;
     PER_CPU(deferred_devs).devs.push_back(this);
@@ -371,9 +372,11 @@ void VirtioNet::begin_deferred_kick()
 void VirtioNet::handle_deferred_devices()
 {
 #ifndef NO_DEFERRED_KICK
-  for (auto* dev : PER_CPU(deferred_devs).devs) {
-    // kick transmitq
+  for (auto* dev : PER_CPU(deferred_devs).devs)
+  if (dev->deferred_kick)
+  {
     dev->deferred_kick = false;
+    // kick transmitq
     dev->tx_q.enable_interrupts();
     dev->tx_q.kick();
   }