Merge pull request #1414 from alfred-bratterud/master

Merge dev

Author: alfreb

.gitignore

@@ -47,3 +47,5 @@ build_x86_64/
 CMakeFiles*
 CMakeCache*
 cmake_install.cmake
+
+dummy.disk

CMakeLists.txt

@@ -17,6 +17,8 @@ set(CMAKE_C_COMPILER_TARGET ${TRIPLE})
 
 message(STATUS "Target triple ${TRIPLE}")
 
+option(WITH_SOLO5 "Install with solo5 support" ON)
+
 set(CMAKE_TOOLCHAIN_FILE ${INCLUDEOS_ROOT}/cmake/${ARCH}-elf-toolchain.cmake)
 
 project (includeos C CXX)
@@ -48,7 +50,7 @@ endif(cpu_feat_vanilla)
 option(single_threaded "Compile without SMP support" ON)
 
 # create random hex string as stack protector canary
-string(RANDOM LENGTH 8 ALPHABET 0123456789ABCDEF STACK_PROTECTOR_VALUE)
+string(RANDOM LENGTH 16 ALPHABET 0123456789ABCDEF STACK_PROTECTOR_VALUE)
 
 set(CAPABS "${CAPABS} -mno-red-zone -fstack-protector-strong -D_STACK_GUARD_VALUE_=0x${STACK_PROTECTOR_VALUE}")
 
@@ -141,6 +143,7 @@ if(vmbuild)
   # Install vmbuilder as an external project
   ExternalProject_Add(vmbuild
     PREFIX vmbuild # Build where
+    BUILD_ALWAYS 1
     SOURCE_DIR ${INCLUDEOS_ROOT}/vmbuild # Where is project located
     BINARY_DIR ${INCLUDEOS_ROOT}/vmbuild/build
     INSTALL_DIR ${BIN} # Where to install
@@ -151,6 +154,7 @@ endif(vmbuild)
 option(diskbuilder "Build and install memdisk helper tool" ON)
 if(diskbuilder)
   ExternalProject_Add(diskbuilder
+    BUILD_ALWAYS 1
     SOURCE_DIR ${INCLUDEOS_ROOT}/diskimagebuild
     BINARY_DIR ${INCLUDEOS_ROOT}/diskimagebuild/build
     INSTALL_DIR ${BIN}
@@ -213,6 +217,7 @@ install(PROGRAMS
   ${CMAKE_CURRENT_SOURCE_DIR}/etc/scripts/grubify.sh
   ${CMAKE_CURRENT_SOURCE_DIR}/etc/scripts/qemu-ifup
   ${CMAKE_CURRENT_SOURCE_DIR}/etc/scripts/qemu_cmd.sh
+  ${CMAKE_CURRENT_SOURCE_DIR}/etc/scripts/ukvm-ifup.sh
   ${CMAKE_CURRENT_SOURCE_DIR}/etc/scripts/run.sh
   DESTINATION includeos/scripts)
 

api/crash

@@ -0,0 +1,8 @@
+// -*-C++-*-
+#pragma once
+#ifndef API_CRASH_HEADER
+#define API_CRASH_HEADER
+
+#include <kernel/syscalls.hpp>
+
+#endif

api/fs/dirent.hpp

@@ -38,6 +38,7 @@ namespace fs {
         size_{sz}, attrib_ {attr},
         modif {modt}
     {}
+    Dirent(const Dirent&) noexcept;
 
     Enttype type() const noexcept
     { return ftype; }

api/fs/disk.hpp

@@ -23,6 +23,7 @@
 #include <fs/filesystem.hpp>
 #include <fs/dirent.hpp>
 #include <hw/block_device.hpp>
+#include <common>
 
 #include <deque>
 #include <vector>
@@ -129,7 +130,13 @@ namespace fs {
     // Returns a reference to a mounted filesystem
     // If no filesystem is mounted, the results are undefined
     File_system& fs() noexcept
-    { return *filesys; }
+    {
+      if(UNLIKELY(not fs_ready()))
+      {
+        throw Err_not_mounted{"Filesystem not ready - make sure to init_fs before accessing"};
+      }
+      return *filesys;
+    }
 
   private:
     void internal_init(partition_t part, on_init_func func);

api/hw/devices.hpp

@@ -49,6 +49,7 @@ namespace hw {
     /** List all devices (decorated, as seen in boot output) */
     inline static void print_devices();
 
+    inline static void flush_all();
 
     inline static void deactivate_all();
 
@@ -161,6 +162,11 @@ namespace hw {
     deactivate_type(devices<hw::Block_device>());
     deactivate_type(devices<hw::Nic>());
   }
+  inline void Devices::flush_all()
+  {
+    for (auto& dev : devices<hw::Nic>())
+        dev->flush();
+  }
 
 } //< namespace hw
 

api/hw/mac_addr.hpp

@@ -64,6 +64,29 @@ union Addr {
     : part{a,b,c,d,e,f}
   {}
 
+  static uint8_t dehex(char c)
+  {
+    if (c >= '0' && c <= '9')
+        return (c - '0');
+    else if (c >= 'a' && c <= 'f')
+        return 10 + (c - 'a');
+    else if (c >= 'A' && c <= 'F')
+        return 10 + (c - 'A');
+    else
+        return 0;
+  }
+
+  Addr(const char *smac) noexcept
+  {
+    uint8_t macaddr[PARTS_LEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+    for (size_t i = 0; i < PARTS_LEN; i++) {
+        macaddr[i] = dehex(*smac++) << 4;
+        macaddr[i] |= dehex(*smac++);
+        smac++;
+    }
+    memcpy(part, macaddr, PARTS_LEN);
+  }
+
   /**
    * Assignment operator
    *

api/hw/nic.hpp

@@ -96,7 +96,14 @@ namespace hw {
     /** Move this nic to current CPU **/
     virtual void move_to_this_cpu() = 0;
 
+    /** Flush remaining packets if possible. **/
+    virtual void flush() = 0;
+
     virtual ~Nic() {}
+
+    /** Trigger a read from buffers, pusing any packets up the stack */
+    virtual void poll() = 0;
+
   protected:
     /**
      *  Constructor

api/hw/pci_device.hpp

@@ -21,6 +21,7 @@
 #include <cstdint>
 #include <common>
 #include <vector>
+#include <unordered_map>
 
 #define  PCI_CAP_ID_AF        0x13	/* PCI Advanced Features */
 #define  PCI_CAP_ID_MAX       PCI_CAP_ID_AF
@@ -43,6 +44,9 @@ namespace PCI {
 
   static const uint32_t  WTF                   {~0x0U};
 
+  static const uint32_t  SOLO5_NET_DUMMY_ADDR  {0xFFFE};
+  static const uint32_t  SOLO5_BLK_DUMMY_ADDR  {0xFFFF};
+
   /**
    *  @brief PCI device message format
    *
@@ -71,7 +75,7 @@ namespace PCI {
   }; //< union msg
 
   /** Relevant class codes (many more) */
-  enum classcode_t {
+  enum classcode : uint8_t {
     OLD = 0,
     STORAGE,
     NIC,
@@ -91,17 +95,23 @@ namespace PCI {
     ENCRYPTION,
     SIGPRO,
     OTHER=255
+
+
   }; //< enum classcode_t
 
-  enum {
+  enum vendor_t : uint16_t {
     VENDOR_AMD     = 0x1022,
     VENDOR_INTEL   = 0x8086,
     VENDOR_CIRRUS  = 0x1013,
     VENDOR_VIRTIO  = 0x1AF4,
     VENDOR_REALTEK = 0x10EC,
     VENDOR_VMWARE  = 0x15AD,
+    VENDOR_SOLO5   = 0x5050,
   };
 
+  static inline const char* classcode_str(uint8_t code);
+  static inline const char* vendor_str(uint16_t code);
+
   struct Resource {
     int       type;
     uint32_t  start;
@@ -117,6 +127,8 @@ namespace PCI {
 } //< namespace PCI
 
 namespace hw {
+
+
 struct msix_t;
   /**
    *  @brief Communication class for all PCI devices
@@ -247,6 +259,8 @@ struct msix_t;
       };
     };
 
+    inline std::string to_string() const;
+
   private:
     // @brief The 3-part PCI address
     uint16_t pci_addr_;
@@ -275,14 +289,60 @@ struct msix_t;
 
 } //< namespace hw
 
-namespace std {
-template<>
-struct hash<PCI::classcode_t> {
-public:
-  std::size_t operator()(PCI::classcode_t const& key) const noexcept {
-    return key;
-  }
-};
+static const char* PCI::classcode_str(uint8_t code){
+  const std::unordered_map<uint8_t, const char*> classcodes {
+      {classcode::OLD, "Old"},
+      {classcode::STORAGE, "Storage controller"},
+      {classcode::NIC, "Network controller"},
+      {classcode::DISPLAY, "Display controller"},
+      {classcode::MULTIMEDIA, "Multimedia device"},
+      {classcode::MEMORY, "Memory controller"},
+      {classcode::BRIDGE, "Bridge device"},
+      {classcode::COMMUNICATION, "Simple comm. controller "},
+      {classcode::BASE_SYSTEM_PER,"Base system periph."},
+      {classcode::INPUT_DEVICE, "Input device"},
+      {classcode::DOCKING_STATION, "Docking station"},
+      {classcode::PROCESSOR, "Processor"},
+      {classcode::SERIAL_BUS, "Serial bus controller"},
+      {classcode::WIRELESS, "Wireless"},
+      {classcode::IO_CTL, "Intelligent IO controller"},
+      {classcode::SATELLITE, "Satellite comm. controller"},
+      {classcode::ENCRYPTION, "Encryption / decryption controller"},
+      {classcode::SIGPRO,"Sigpro"},
+      {classcode::OTHER, "Other"}
+    };
+
+  auto it = classcodes.find(code);
+  if (it != classcodes.end())
+    return it->second;
+
+  return "Unknown classcode";
+}
+
+static const char* PCI::vendor_str(uint16_t code){
+  const std::unordered_map<uint16_t, const char*> classcodes {
+    {VENDOR_AMD,     "AMD"},
+    {VENDOR_INTEL,   "Intel"},
+    {VENDOR_CIRRUS,  "Cirrus"},
+    {VENDOR_VIRTIO,  "VirtIO"} ,
+    {VENDOR_REALTEK, "REALTEK"},
+    {VENDOR_VMWARE,  "VMWare"}
+  };
+
+  auto it = classcodes.find(code);
+  return it == classcodes.end() ? "Unknown vendor" : it->second;
 }
 
+
+#include <sstream>
+std::string hw::PCI_Device::to_string() const {
+  std::stringstream str;
+  str << PCI::classcode_str(classcode()) << ", "
+      << PCI::vendor_str((PCI::vendor_t)vendor_id())
+      << std::hex << " ("<< vendor_id() << " / " << product_id() << ")";
+  return str.str();
+};
+
+
+
 #endif //< HW_PCI_DEVICE_HPP

api/kernel/cpuid.hpp

@@ -19,8 +19,12 @@
 #ifndef KERNEL_CPUID_HPP
 #define KERNEL_CPUID_HPP
 
+#include <unordered_map>
+#include <vector>
+
 namespace CPUID
 {
+
   enum class Feature
   {
     // ------------------------------------------------------------------------
@@ -46,7 +50,7 @@ namespace CPUID
     SSE4_1,            // Streaming SIMD Extensions 4.1
     SSE4_2,            // Streaming SIMD Extensions 4.2
     X2APIC,            // Extended xAPIC Support
-    MOVBE,             // MOVBE Instruction
+    MOVBE,             // MOVBE Instruction (move after swapping bytes)
     POPCNT,            // POPCNT Instruction
     TSC_DEADLINE,      // Local APIC supports TSC Deadline
     AES,               // AESNI Instruction
@@ -98,15 +102,32 @@ namespace CPUID
     SVM,               // Secture Virtual Machines (AMD-V)
                        // aka. AMD-V (AMD's virtualization extension)
     SSE4A,             // SSE4a
+
+    // ------------------------------------------------------------------------
+    // 4th gen. Core features
+    // ------------------------------------------------------------------------
+    AVX2,              // AVX2
+    BMI1,              // Bit manipulation 1
+    BMI2,              // Bit manipulation 2
+    LZCNT,             // Count leading zero bits
   };
 
+  using Feature_map =  const std::unordered_map<Feature, const char*>;
+  using Feature_list = std::vector<Feature>;
+  using Feature_names = std::vector<const char*>;
+
+  Feature_names  detect_features_str();
+  Feature_list detect_features();
+
   bool is_amd_cpu()   noexcept;
   bool is_intel_cpu() noexcept;
   bool has_feature(Feature f);
 
   bool kvm_feature(unsigned id) noexcept;
 } //< CPUID
 
+
+
 #define KVM_FEATURE_CLOCKSOURCE   0
 #define KVM_FEATURE_NOP_IO_DELAY  1
 #define KVM_FEATURE_MMU_OP        2   /* deprecated */