solo5: Remove references to PCI, fix issues with device registration

Author: fwsGonzo

api/kernel/solo5_manager.hpp

@@ -18,109 +18,19 @@
 #ifndef KERNEL_SOLO5_MANAGER_HPP
 #define KERNEL_SOLO5_MANAGER_HPP
 
-#include <vector>
-#include <cstdio>
-#include <unordered_map>
+#include <memory>
 #include <delegate>
-
-#include <hw/pci_device.hpp>
 #include <hw/devices.hpp>
 
 class Solo5_manager {
-private:
-  using Device_registry = std::unordered_map<PCI::classcode, std::vector<hw::PCI_Device>>;
-
 public:
-  template <PCI::classcode CLASS>
-  static hw::PCI_Device& device(const int n) noexcept {
-    return devices_[CLASS][n];
-  };
-
-  template <PCI::classcode CLASS>
-  static size_t num_of_devices() noexcept {
-    return devices_[CLASS].size();
-  }
-
-  /** Whats being stored and returned is a unique_ptr of the given device */
-  template <typename Device_type>
-  using Dev_ptr = std::unique_ptr<Device_type>;
-
-  /** The function (factory) thats create the Dev_ptr from PCI_Device, supplied by the driver */
-  template <typename Device_type>
-  using Driver_factory = delegate< Dev_ptr<Device_type>(hw::PCI_Device&) >;
-
-  /**
-   * @brief Register a specific type of driver factory
-   * @details Register a specific type of driver factory
-   * (function that creates a pointer to the given Device, with its full driver implementation)
-   * Indexed as a combination of vendor + product
-   *
-   * @param vendor Driver vendor id
-   * @param product Driver product id
-   * @param driver_factory Function for creating a driver
-   * @tparam Device_type The specific type of Device the driver is for
-   */
-  template <typename Device_type>
-  static void register_driver(uint16_t vendor, uint16_t product,
-    Driver_factory<Device_type> driver_factory)
-  {
-    drivers<Device_type>().emplace(get_driver_id(vendor, product), driver_factory);
-  }
-
-  /** Currently a combination of Model + Product (we don't care about the revision etc. atm.)*/
-  using driver_id_t = uint32_t;
-
-  /** Combine vendor and product id to represent a driver id */
-  static driver_id_t get_driver_id(uint16_t vendor, uint16_t product)
-  { return (uint32_t)(vendor) << 16 | product; }
+  using Nic_ptr = std::unique_ptr<hw::Nic>;
+  using Blk_ptr = std::unique_ptr<hw::Block_device>;
 
-  static driver_id_t get_driver_id(hw::PCI_Device& dev)
-  { return get_driver_id(dev.vendor_id(), dev.product_id()); }
+  static void register_net(delegate<Nic_ptr()>);
+  static void register_blk(delegate<Blk_ptr()>);
 
-private:
-  static Device_registry devices_;
-
-  /** A register for a specific type of drivers: map[driver_id, driver_factory]*/
-  template <typename Device_type>
-  using Driver_registry = std::unordered_map<driver_id_t, Driver_factory<Device_type> >;
-
-  /**
-   * @brief Retrieve drivers (factories) of a given type of device
-   *
-   * @return A collection of driver factories indexed by driver_id
-   */
-  template <typename Device_type>
-  static Driver_registry<Device_type>& drivers() {
-    static Driver_registry<Device_type> drivers_;
-    return drivers_;
-  }
-
-  template <typename Device_type>
-  inline static bool register_device(hw::PCI_Device& dev);
-
-  /**
-   *  Keep track of certain devices
-   *
-   *  The PCI manager can probe and keep track of devices which can (possibly)
-   *  be specialized by the Dev-class later.
-   */
   static void init();
-
-  friend class OS;
 }; //< class Solo5_manager
 
-template <typename Device_type>
-inline bool Solo5_manager::register_device(hw::PCI_Device& dev) {
-  try {
-    auto driver_factory = drivers<Device_type>().at(get_driver_id(dev));
-    INFO2("|  +--+ Driver: Found");
-
-    hw::Devices::register_device(driver_factory(dev));
-    return true;
-  } catch(std::out_of_range) {
-    INFO2("|  +--+ Driver: Not found");
-  }
-  return false;
-}
-
 #endif //< KERNEL_SOLO5_MANAGER_HPP

src/drivers/solo5blk.cpp

@@ -13,7 +13,7 @@ extern "C" {
 #include <solo5.h>
 }
 
-Solo5Blk::Solo5Blk(hw::PCI_Device& d)
+Solo5Blk::Solo5Blk()
   : hw::Block_device()
 {
   INFO("Solo5Blk", "Block device with %llu sectors", solo5_blk_sectors());
@@ -48,7 +48,6 @@ void Solo5Blk::deactivate()
 
 struct Autoreg_solo5blk {
   Autoreg_solo5blk() {
-    Solo5_manager::register_driver<hw::Block_device>(PCI::VENDOR_SOLO5, 0x1001,
-                                                     &Solo5Blk::new_instance);
+    Solo5_manager::register_blk(&Solo5Blk::new_instance);
   }
 } autoreg_solo5blk;

src/drivers/solo5blk.hpp

@@ -29,9 +29,9 @@ class Solo5Blk : public hw::Block_device
 {
 public:
 
-  static std::unique_ptr<Block_device> new_instance(hw::PCI_Device& d)
+  static std::unique_ptr<Block_device> new_instance()
   {
-    return std::make_unique<Solo5Blk>(d);
+    return std::make_unique<Solo5Blk>();
   }
 
   static constexpr size_t SECTOR_SIZE = 512;
@@ -68,7 +68,7 @@ class Solo5Blk : public hw::Block_device
   void deactivate() override; // stays
 
   /** Constructor. @param pcidev an initialized PCI device. */
-  Solo5Blk(hw::PCI_Device& pcidev);
+  Solo5Blk();
 
 private:
   // stat counters

src/drivers/solo5net.cpp

@@ -21,38 +21,31 @@
 
 #include "solo5net.hpp"
 #include <net/packet.hpp>
-#include <kernel/irq_manager.hpp>
-#include <kernel/syscalls.hpp>
 #include <hw/pci.hpp>
-#include <stdio.h>
-#include <malloc.h>
-#include <string.h>
+#include <cstdio>
+#include <cstring>
 
 extern "C" {
 #include <solo5.h>
 }
 
 using namespace net;
 
-constexpr size_t MTU_ = 1520;
-constexpr size_t BUFFER_CNT = 1000;
-
-// XXX: do we really need a bufstore?
-BufferStore solo5_bufstore{ BUFFER_CNT,  MTU_ };
-
 const char* Solo5Net::driver_name() const { return "Solo5Net"; }
 
-Solo5Net::Solo5Net(hw::PCI_Device& d)
+Solo5Net::Solo5Net()
   : Link(Link_protocol{{this, &Solo5Net::transmit}, mac()},
          2048u, sizeof(net::Packet) + MTU()),
     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("Solo5Net", "Driver initializing");
+  mac_addr = MAC::Addr(solo5_net_mac_str());
 }
 
 #include <cstdlib>
-void Solo5Net::transmit(net::Packet_ptr pckt) {
+void Solo5Net::transmit(net::Packet_ptr pckt)
+{
   net::Packet_ptr tail = std::move(pckt);
 
   // Transmit all we can directly
@@ -64,7 +57,6 @@ void Solo5Net::transmit(net::Packet_ptr pckt) {
     net::Packet* pckt = tail.release();
     uint8_t *buf = pckt->buf();
 
-    printf("Solo5 writing packet %i bytes \n", pckt->size());
     solo5_net_write_sync(buf, pckt->size());
 
     tail = std::move(next);
@@ -81,33 +73,29 @@ void Solo5Net::transmit(net::Packet_ptr pckt) {
 std::unique_ptr<Packet>
 Solo5Net::create_packet(int link_offset)
 {
-  auto buffer = solo5_bufstore.get_buffer();
+  auto buffer = bufstore().get_buffer();
   auto* pckt = (net::Packet*) buffer.addr;
 
-  new (pckt) net::Packet(link_offset, 0, MTU_, &solo5_bufstore);
+  new (pckt) net::Packet(link_offset, 0, packet_len(), buffer.bufstore);
   return net::Packet_ptr(pckt);
 }
 
 std::unique_ptr<Packet>
 Solo5Net::recv_packet()
 {
-  auto buffer = solo5_bufstore.get_buffer();
+  auto buffer = bufstore().get_buffer();
   auto* pckt = (net::Packet*) buffer.addr;
-  int size = MTU_;
-  new (pckt) net::Packet(0, size, MTU_, &solo5_bufstore);
+  new (pckt) net::Packet(0, MTU(), packet_len(), &bufstore());
   uint8_t *buf = pckt->buf();
-  memset(buf, 0, size);
   // Populate the packet buffer with new packet, if any
+  int size = MTU();
   if (solo5_net_read_sync(buf, &size) == 0) {
     // Adjust packet size to match received data
-    //printf("Solo5 data size: %i \n", size);
     if (size) {
       pckt->set_data_end(size);
-      //printf("Solo5 Packet size: %i \n", pckt->size());
       return net::Packet_ptr(pckt);
     }
   }
-  printf("Solo5 didn't get data. Size: %i \n", size);
   return nullptr;
 }
 
@@ -127,7 +115,6 @@ void Solo5Net::deactivate()
 
 struct Autoreg_solo5net {
   Autoreg_solo5net() {
-    Solo5_manager::register_driver<hw::Nic>(PCI::VENDOR_SOLO5, 0x1000,
-                                            &Solo5Net::new_instance);
+    Solo5_manager::register_net(&Solo5Net::new_instance);
   }
 } autoreg_solo5net;

src/drivers/solo5net.hpp

@@ -36,31 +36,34 @@ class Solo5Net : public net::Link_layer<net::Ethernet> {
   using Link          = net::Link_layer<net::Ethernet>;
   using Link_protocol = Link::Protocol;
 
-  static std::unique_ptr<Nic> new_instance(hw::PCI_Device& d)
+  static std::unique_ptr<Nic> new_instance()
   {
-    return std::make_unique<Solo5Net>(d);
+    return std::make_unique<Solo5Net>();
   }
 
   /** Human readable name. */
   const char* driver_name() const override;
 
   /** Mac address. */
-  const MAC::Addr& mac() const noexcept override
-  {
-    return MAC::Addr(solo5_net_mac_str());
+  const MAC::Addr& mac() const noexcept override {
+    return mac_addr;
   }
 
   uint16_t MTU() const noexcept override
   { return 1500; }
 
+  uint16_t packet_len() const noexcept {
+    return sizeof(net::ethernet::Header) + MTU();
+  }
+
   net::downstream create_physical_downstream()
   { return {this, &Solo5Net::transmit}; }
 
   /** Linklayer input. Hooks into IP-stack bottom, w.DOWNSTREAM data.*/
   void transmit(net::Packet_ptr pckt);
 
   /** Constructor. @param pcidev an initialized PCI device. */
-  Solo5Net(hw::PCI_Device& pcidev);
+  Solo5Net();
 
   /** Space available in the transmit queue, in packets */
   size_t transmit_queue_available() override {
@@ -83,7 +86,7 @@ class Solo5Net : public net::Link_layer<net::Ethernet> {
   void poll() override;
 
 private:
-
+  MAC::Addr mac_addr;
   std::unique_ptr<net::Packet> recv_packet();
   /** Stats */
   uint64_t& packets_rx_;

src/kernel/solo5_manager.cpp

@@ -20,25 +20,31 @@
 #include <delegate>
 
 #include <kernel/solo5_manager.hpp>
-#include <hw/devices.hpp>
-#include <hw/pci_device.hpp>
 #include <stdexcept>
 #include <util/fixedvec.hpp>
 
-static const int ELEMENTS = 16;
+static const int ELEMENTS = 4;
+using namespace hw;
+using Nic_ptr = std::unique_ptr<hw::Nic>;
+using Blk_ptr = std::unique_ptr<hw::Block_device>;
 
-// PCI devices
-fixedvector<hw::PCI_Device, ELEMENTS> devices(Fixedvector_Init::UNINIT);
+fixedvector<delegate<Nic_ptr()>, ELEMENTS> nics(Fixedvector_Init::UNINIT);
+fixedvector<delegate<Blk_ptr()>, ELEMENTS> blks(Fixedvector_Init::UNINIT);
+
+void Solo5_manager::register_net(delegate<Nic_ptr()> func)
+{
+  nics.add(func);
+}
+void Solo5_manager::register_blk(delegate<Blk_ptr()> func)
+{
+  blks.add(func);
+}
 
 void Solo5_manager::init() {
   INFO("Solo5", "Looking for solo5 devices");
 
-  uint32_t id_net = 0x1000 << 16 | PCI::VENDOR_SOLO5;
-  uint32_t id_blk = 0x1001 << 16 | PCI::VENDOR_SOLO5;
-
-  auto& stored_blk = devices.emplace(PCI::SOLO5_BLK_DUMMY_ADDR, id_blk, 0);
-  auto& stored_net = devices.emplace(PCI::SOLO5_NET_DUMMY_ADDR, id_net, 0);
-
-  register_device<hw::Block_device>(stored_blk);
-  register_device<hw::Nic>(stored_net);
+  for (auto nic : nics)
+    hw::Devices::register_device<hw::Nic> (nic());
+  for (auto blk : blks)
+    hw::Devices::register_device<hw::Block_device> (blk());
 }

test_ukvm.sh

@@ -2,7 +2,6 @@
 . ./etc/set_traps.sh
 
 pushd examples/demo_service
-rm -rf build
 mkdir -p build
 pushd build
 PLATFORM=x86_solo5 cmake ..