virtionet: Using minimal amount of buffers

Author: fwsGonzo

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();
   }

src/drivers/virtionet.hpp

@@ -187,9 +187,6 @@ class VirtioNet : Virtio, public net::Link_layer<net::Ethernet> {
     uint16_t num_buffers;
   }__attribute__((packed));
 
-  // make packets cache-aligned on the IP-layer
-  static const int VIRTIO_HDR_OFFSET = sizeof(virtio_net_hdr);
-
   Virtio::Queue rx_q;
   Virtio::Queue tx_q;
   Virtio::Queue ctrl_q;