From 5ce2f3d3295ac3ab973e0f79d0cdf41a67101ea6 Mon Sep 17 00:00:00 2001
From: Roman Kubiak <56821808+rkubiak01@users.noreply.github.com>
Date: Tue, 17 Nov 2020 12:27:25 +0100
Subject: [PATCH] Revert "[EGD-4344] vfs-utils refactor (#1010)" (#1027)

This reverts commit e6ca468d2c0a3d3f9a045c123ee901690e2b28a9.
---
 CMakeLists.txt                                |   1 +
 .../application-desktop/windows/Update.cpp    |   8 +-
 .../windows/QuotesMainWindow.cpp              |   2 +-
 .../application-settings/windows/Info.cpp     |   4 +-
 module-bluetooth/Bluetooth/BtKeysStorage.cpp  |   6 +-
 .../service-desktop/ServiceDesktop.cpp        |   2 +-
 .../endpoints/update/UpdateMuditaOS.cpp       |  22 +-
 module-utils/CMakeLists.txt                   |   2 +-
 module-utils/Utils.cpp                        | 182 ------------
 module-utils/Utils.hpp                        |  19 --
 module-utils/common_data/EventStore.cpp       | 103 -------
 module-utils/common_data/EventStore.hpp       |  58 ----
 module-vfs/CMakeLists.txt                     |   1 +
 .../cross/free_rtos_custom/portable/vfs.cpp   |  18 +-
 .../linux/free_rtos_custom/portable/vfs.cpp   |  15 +-
 module-vfs/include/user/deprecated/vfs.hpp    |  55 +++-
 module-vfs/src/deprecated/vfs-utils.cpp       | 277 ++++++++++++++++++
 module-vfs/src/deprecated/vfs.cpp             |   7 +-
 module-vfs/tests/unittest_vfs.cpp             |  19 +-
 19 files changed, 381 insertions(+), 420 deletions(-)
 delete mode 100644 module-utils/Utils.cpp
 create mode 100644 module-vfs/src/deprecated/vfs-utils.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index efa3643cc..b49407233 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -192,6 +192,7 @@ target_link_libraries(${PROJECT_NAME}
         module-os
         module-utils
         module-vfs
+        module-utils
         module-sys
         module-cellular
         module-db
diff --git a/module-apps/application-desktop/windows/Update.cpp b/module-apps/application-desktop/windows/Update.cpp
index 45745f353..0509c7533 100644
--- a/module-apps/application-desktop/windows/Update.cpp
+++ b/module-apps/application-desktop/windows/Update.cpp
@@ -176,11 +176,11 @@ namespace gui
                 updateVersion << utils::localize.get("app_desktop_update_to");
                 updateVersion << ": ";
                 updateVersion << msg.updateStats
-                                     .versioInformation[BootConfigJson::os_version][BootConfigJson::version_string]
+                                     .versioInformation[purefs::json::os_version][purefs::json::version_string]
                                      .string_value();
                 updateVersion << " (";
                 updateVersion << msg.updateStats
-                                     .versioInformation[BootConfigJson::git_info][BootConfigJson::os_git_revision]
+                                     .versioInformation[purefs::json::git_info][purefs::json::os_git_revision]
                                      .string_value();
                 updateVersion << ")";
 
@@ -188,8 +188,8 @@ namespace gui
                 updateFileDetails << ": ";
                 updateFileDetails << std::to_string(msg.updateStats.totalBytes / 1024);
                 updateFileDetails << "Kb (";
-                updateFileDetails << msg.updateStats.versioInformation[BootConfigJson::misc][BootConfigJson::builddate]
-                                         .string_value();
+                updateFileDetails
+                    << msg.updateStats.versioInformation[purefs::json::misc][purefs::json::builddate].string_value();
                 updateFileDetails << ")";
 
                 currentVersionInfo->setText(currentVersion.str());
diff --git a/module-apps/application-settings-new/windows/QuotesMainWindow.cpp b/module-apps/application-settings-new/windows/QuotesMainWindow.cpp
index 6d1f24ac5..febf23843 100644
--- a/module-apps/application-settings-new/windows/QuotesMainWindow.cpp
+++ b/module-apps/application-settings-new/windows/QuotesMainWindow.cpp
@@ -47,7 +47,7 @@ namespace gui
     {
         std::string err;
 
-        std::string fileContents = utils::filesystem::loadFileAsString(fn);
+        std::string fileContents = vfs.loadFileAsString(fn);
 
         auto obj = json11::Json::parse(fileContents, err).array_items();
 
diff --git a/module-apps/application-settings/windows/Info.cpp b/module-apps/application-settings/windows/Info.cpp
index ea7dd763f..d51300e32 100644
--- a/module-apps/application-settings/windows/Info.cpp
+++ b/module-apps/application-settings/windows/Info.cpp
@@ -50,9 +50,9 @@ namespace gui
         addAlignedLabelWithValue(box, "Version:", std::string(VERSION));
         addAlignedLabelWithValue(box,
                                  "Bootloader:",
-                                 (Store::BootConfig::get()->getBootloaderVersion().empty()
+                                 (vfs.getBootConfig().bootloader_verion.empty()
                                       ? utils::localize.get("not available")
-                                      : Store::BootConfig::get()->getBootloaderVersion()));
+                                      : vfs.getBootConfig().bootloader_verion));
 
         std::string firmwareVersion;
         CellularServiceAPI::GetFirmwareVersion(getApplication(), firmwareVersion);
diff --git a/module-bluetooth/Bluetooth/BtKeysStorage.cpp b/module-bluetooth/Bluetooth/BtKeysStorage.cpp
index 84911f402..fc5d1c2b5 100644
--- a/module-bluetooth/Bluetooth/BtKeysStorage.cpp
+++ b/module-bluetooth/Bluetooth/BtKeysStorage.cpp
@@ -2,8 +2,6 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include <algorithm>
-
-#include "Utils.hpp"
 #include "BtKeysStorage.hpp"
 
 json11::Json Bt::KeyStorage::fileJson = json11::Json();
@@ -41,7 +39,7 @@ namespace Bt
     {
         LOG_INFO("opening storage from API");
         fileContent.clear();
-        fileContent = utils::filesystem::loadFileAsString(strings::keysFilename);
+        fileContent = vfs.loadFileAsString(strings::keysFilename);
         if (fileContent.empty()) {
             LOG_WARN("opening empty key file!");
             return;
@@ -133,7 +131,7 @@ namespace Bt
     {
         json11::Json finalJson = json11::Json::object{{strings::keys, keys}};
         fileContent            = finalJson.dump();
-        utils::filesystem::replaceWithString(strings::keysFilename, fileContent);
+        vfs.replaceWithString(strings::keysFilename, fileContent);
     }
 
 } // namespace Bt
diff --git a/module-services/service-desktop/ServiceDesktop.cpp b/module-services/service-desktop/ServiceDesktop.cpp
index 07669c9e3..cba132996 100644
--- a/module-services/service-desktop/ServiceDesktop.cpp
+++ b/module-services/service-desktop/ServiceDesktop.cpp
@@ -104,7 +104,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
         return std::make_shared<sys::ResponseMessage>();
     });
 
-    Store::BootConfig::get()->updateTimestamp();
+    vfs.updateTimestamp();
     return (sys::ReturnCodes::Success);
 }
 
diff --git a/module-services/service-desktop/endpoints/update/UpdateMuditaOS.cpp b/module-services/service-desktop/endpoints/update/UpdateMuditaOS.cpp
index e976757b2..614337cbb 100644
--- a/module-services/service-desktop/endpoints/update/UpdateMuditaOS.cpp
+++ b/module-services/service-desktop/endpoints/update/UpdateMuditaOS.cpp
@@ -202,7 +202,7 @@ updateos::UpdateError UpdateMuditaOS::verifyVersion()
         return updateos::UpdateError::VerifyVersionFailure;
     }
 
-    std::string versionJsonString = utils::filesystem::loadFileAsString(getUpdateTmpChild(updateos::file::version));
+    std::string versionJsonString = vfs.loadFileAsString(getUpdateTmpChild(updateos::file::version));
     std::string parserError;
     json11::Json updateVersionInformation = json11::Json::parse(versionJsonString, parserError);
     if (parserError != "") {
@@ -313,24 +313,24 @@ updateos::UpdateError UpdateMuditaOS::updateBootJSON()
     fs::path bootJSONAbsoulte         = purefs::createPath(purefs::dir::getRootDiskPath(), purefs::file::boot_json);
     informDebug("updateBootJSON %s", bootJSONAbsoulte.c_str());
 
-    FILE *fp = fopen(bootJSONAbsoulte.c_str(), "r");
+    vfs::FILE *fp = vfs.fopen(bootJSONAbsoulte.c_str(), "r");
 
     if (fp != nullptr) {
-        utils::filesystem::computeCRC32(fp, &bootJSONAbsoulteCRC);
+        vfs.computeCRC32(fp, &bootJSONAbsoulteCRC);
         bootJSONAbsoulte += purefs::extension::crc32;
 
-        FILE *fpCRC = fopen(bootJSONAbsoulte.c_str(), "w");
+        vfs::FILE *fpCRC = vfs.fopen(bootJSONAbsoulte.c_str(), "w");
         if (fpCRC != nullptr) {
             std::array<char, purefs::buffer::crc_char_size> crcBuf;
             snprintf(crcBuf.data(), crcBuf.size(), "%lX", bootJSONAbsoulteCRC);
-            fwrite(crcBuf.data(), 1, purefs::buffer::crc_char_size, fpCRC);
-            fclose(fpCRC);
+            vfs.fwrite(crcBuf.data(), 1, purefs::buffer::crc_char_size, fpCRC);
+            vfs.fclose(fpCRC);
         }
         else {
             return updateos::UpdateError::CantUpdateCRC32JSON;
         }
 
-        fclose(fp);
+        vfs.fclose(fp);
     }
     else {
         return updateos::UpdateError::CantUpdateCRC32JSON;
@@ -422,7 +422,7 @@ updateos::UpdateError UpdateMuditaOS::prepareTempDirForUpdate()
 {
     status = updateos::UpdateState::CreatingDirectories;
 
-    updateTempDirectory = purefs::dir::getTemporaryPath() / utils::filesystem::generateRandomId(updateos::prefix_len);
+    updateTempDirectory = purefs::dir::getTemporaryPath() / vfs::generateRandomId(updateos::prefix_len);
 
     informDebug("Temp dir for update %s", updateTempDirectory.c_str());
 
@@ -592,10 +592,10 @@ const fs::path UpdateMuditaOS::checkForUpdate()
         if (versionInfo.is_null())
             continue;
 
-        if (versionInfo[BootConfigJson::os_version][BootConfigJson::version_string].is_string()) {
+        if (versionInfo[purefs::json::os_version][purefs::json::version_string].is_string()) {
             if (UpdateMuditaOS::isUpgradeToCurrent(
-                    versionInfo[BootConfigJson::os_version][BootConfigJson::version_string].string_value())) {
-                return purefs::dir::getUpdatesOSPath() / file.fileName;
+                    versionInfo[purefs::json::os_version][purefs::json::version_string].string_value())) {
+                return updatesOSPath / file.fileName;
             }
         }
     }
diff --git a/module-utils/CMakeLists.txt b/module-utils/CMakeLists.txt
index 515512ede..d5a648b65 100644
--- a/module-utils/CMakeLists.txt
+++ b/module-utils/CMakeLists.txt
@@ -33,7 +33,7 @@ set (SOURCES
         ${CMAKE_CURRENT_SOURCE_DIR}/NumberHolderMatcher.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/country.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/state/ServiceState.hpp
-        Utils.cpp)
+)
 
 add_library(${PROJECT_NAME} STATIC ${SOURCES} ${BOARD_SOURCES})
 
diff --git a/module-utils/Utils.cpp b/module-utils/Utils.cpp
deleted file mode 100644
index 694557234..000000000
--- a/module-utils/Utils.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#include <time/time_conversion.hpp>
-#include <random>
-#include <ticks.hpp>
-#include "Utils.hpp"
-
-namespace utils
-{
-    namespace filesystem
-    {
-        bool replaceWithString(const fs::path &fileToModify, const std::string &stringToWrite)
-        {
-            auto lamb = [](FILE *stream) { fclose(stream); };
-            std::unique_ptr<FILE, decltype(lamb)> fp(fopen(fileToModify.c_str(), "w"), lamb);
-
-            if (fp.get() != nullptr) {
-                size_t dataWritten = fprintf(fp.get(), stringToWrite.c_str());
-                return dataWritten == stringToWrite.length();
-            }
-            else {
-                return false;
-            }
-        }
-
-        bool updateFileCRC32(const fs::path &file)
-        {
-            unsigned long fileCRC32 = 0;
-            auto lamb               = [](FILE *stream) { fclose(stream); };
-
-            std::unique_ptr<FILE, decltype(lamb)> fp(fopen(file.c_str(), "r"), lamb);
-
-            if (fp.get() != nullptr) {
-                auto crc32Buf = std::make_unique<char[]>(purefs::buffer::crc_char_size);
-                int written   = 0;
-                computeCRC32(fp.get(), &fileCRC32);
-                LOG_INFO("updateFileCRC32 writing new crc32 %08" PRIX32 " for %s",
-                         static_cast<std::uint32_t>(fileCRC32),
-                         file.c_str());
-                if (fileCRC32 != 0) {
-                    if ((written = sprintf(crc32Buf.get(), "%08" PRIX32, fileCRC32)) !=
-                        (purefs::buffer::crc_char_size - 1)) {
-                        LOG_INFO("updateFileCRC32 can't prepare string for crc32, sprintf returned %d instead of %d",
-                                 written,
-                                 purefs::buffer::crc_char_size - 1);
-                        return false;
-                    }
-                    fs::path fileCRC32Path = file;
-                    fileCRC32Path += purefs::extension::crc32;
-
-                    std::unique_ptr<FILE, decltype(lamb)> fpCRC32(fopen(fileCRC32Path.c_str(), "w"), lamb);
-
-                    if (fpCRC32.get() != nullptr) {
-                        if (fwrite(crc32Buf.get(), 1, purefs::buffer::crc_char_size, fpCRC32.get()) ==
-                            purefs::buffer::crc_char_size) {
-                            LOG_INFO("updateFileCRC32 wrote \"%s\" in %s", crc32Buf.get(), fileCRC32Path.c_str());
-                            return true;
-                        }
-                        else {
-                            LOG_WARN("updateFileCRC32 can't write new crc32");
-                            return false;
-                        }
-                    }
-                    else {
-                        LOG_WARN("updateFileCRC32 can't open crc32 file for write");
-                        return false;
-                    }
-                }
-            }
-            else {
-                LOG_WARN("updateFileCRC32 can't open file %s for write", file.c_str());
-                return false;
-            }
-
-            return false;
-        }
-
-        void computeCRC32(FILE *file, unsigned long *outCrc32)
-        {
-            if (outCrc32 == nullptr)
-                return;
-
-            std::unique_ptr<unsigned char[]> buf(new unsigned char[purefs::buffer::crc_buf]);
-            size_t bufLen;
-
-            *outCrc32 = 0;
-
-            while (!feof(file)) {
-                bufLen = fread(buf.get(), 1, purefs::buffer::crc_buf, file);
-                if (bufLen <= 0)
-                    break;
-
-                *outCrc32 = Crc32_ComputeBuf(*outCrc32, buf.get(), bufLen);
-            }
-        }
-
-        bool verifyCRC32Value(const std::string &filePath, const unsigned long crc32)
-        {
-            unsigned long crc32Read;
-            auto lamb = [](FILE *stream) { fclose(stream); };
-
-            std::unique_ptr<FILE, decltype(lamb)> fp(fopen(filePath.c_str(), "r"), lamb);
-
-            if (fp.get() != nullptr) {
-                utils::filesystem::computeCRC32(fp.get(), &crc32Read);
-                LOG_INFO("verifyCRC computed crc32 for %s is %08" PRIX32,
-                         filePath.c_str(),
-                         static_cast<std::uint32_t>(crc32Read));
-                return (crc32Read == crc32);
-            }
-            LOG_ERROR("verifyCRC can't open %s", filePath.c_str());
-            return false;
-        }
-
-        bool verifyCRC(const fs::path filePath)
-        {
-            auto lamb = [](FILE *stream) { fclose(stream); };
-            std::unique_ptr<char[]> crcBuf(new char[purefs::buffer::crc_char_size]);
-            size_t readSize;
-            fs::path crcFilePath(filePath);
-            crcFilePath += purefs::extension::crc32;
-
-            std::unique_ptr<FILE, decltype(lamb)> fp(fopen(crcFilePath.c_str(), "r"), lamb);
-
-            if (fp.get() != nullptr) {
-                if ((readSize = fread(crcBuf.get(), 1, purefs::buffer::crc_char_size, fp.get())) !=
-                    (purefs::buffer::crc_char_size)) {
-                    LOG_ERROR("verifyCRC fread on %s returned different size then %d [%zu]",
-                              crcFilePath.c_str(),
-                              purefs::buffer::crc_char_size,
-                              readSize);
-                    return false;
-                }
-
-                const unsigned long crc32Read = strtoull(crcBuf.get(), nullptr, purefs::buffer::crc_radix);
-
-                LOG_INFO("verifyCRC read %s string:\"%s\" hex:%08lX", crcFilePath.c_str(), crcBuf.get(), crc32Read);
-                return verifyCRC32Value(filePath, crc32Read);
-            }
-            LOG_ERROR("verifyCRC can't open %s", crcFilePath.c_str());
-            return false;
-        }
-
-        std::string generateRandomId(uint32_t length)
-        {
-            const std::string CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-            std::random_device random_device;
-            std::mt19937 generator(random_device());
-            generator.seed(utils::time::Timestamp().getTime());
-            std::uniform_int_distribution<> distribution(0, CHARACTERS.size() - 1);
-
-            std::string random_string;
-
-            for (std::size_t i = 0; i < length; ++i) {
-                random_string += CHARACTERS[distribution(generator)];
-            }
-
-            return random_string;
-        }
-
-        std::string loadFileAsString(const fs::path &fileToLoad)
-        {
-            LOG_DEBUG("loadFileAsString %s", fileToLoad.c_str());
-            auto lamb = [](FILE *stream) { fclose(stream); };
-            std::unique_ptr<char[]> readBuf(new char[purefs::buffer::tar_buf]);
-            std::unique_ptr<FILE, decltype(lamb)> fp(fopen(fileToLoad.c_str(), "r"), lamb);
-            std::string contents;
-            size_t readSize;
-
-            if (fp.get() != nullptr) {
-                while (!feof(fp.get())) {
-                    readSize = fread(readBuf.get(), 1, purefs::buffer::tar_buf, fp.get());
-                    contents.append(static_cast<const char *>(readBuf.get()), readSize);
-                }
-            }
-
-            return contents;
-        }
-    } // namespace filesystem
-} // namespace utils
diff --git a/module-utils/Utils.hpp b/module-utils/Utils.hpp
index 9d801eecb..9550a8aad 100644
--- a/module-utils/Utils.hpp
+++ b/module-utils/Utils.hpp
@@ -2,17 +2,14 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once
-
 #include "i18/i18.hpp"
 #include <algorithm> // std::find_if_not
 #include <log/log.hpp>
 #include <sstream>
 #include <iomanip>
 #include <cmath>
-#include <filesystem>
 
 #define MAGIC_ENUM_RANGE_MAX 256
-
 #include <magic_enum.hpp>
 
 namespace utils
@@ -243,20 +240,4 @@ namespace utils
 #endif
     }
 
-    namespace filesystem
-    {
-        bool replaceWithString(const fs::path &fileToModify, const std::string &stringToWrite);
-
-        bool updateFileCRC32(const fs::path &file);
-
-        void computeCRC32(FILE *file, unsigned long *outCrc32);
-
-        bool verifyCRC32Value(const std::string &filePath, const unsigned long crc32);
-
-        bool verifyCRC(const fs::path filePath);
-
-        std::string generateRandomId(uint32_t length = 0);
-
-        std::string loadFileAsString(const fs::path &fileToLoad);
-    } // namespace filesystem
 } // namespace utils
diff --git a/module-utils/common_data/EventStore.cpp b/module-utils/common_data/EventStore.cpp
index 34fcc7574..53e32b643 100644
--- a/module-utils/common_data/EventStore.cpp
+++ b/module-utils/common_data/EventStore.cpp
@@ -5,11 +5,6 @@
 #include <log/log.hpp>
 #include <memory>
 #include <mutex.hpp>
-#include <vfs.hpp>
-#include <module-vfs/include/user/purefs/filesystem_paths.hpp>
-#include <Utils.hpp>
-#include <source/version.hpp>
-#include <module-utils/time/time_conversion.hpp>
 
 namespace Store
 {
@@ -70,102 +65,4 @@ namespace Store
     {
         return (sim == SIM::SIM1 || sim == SIM::SIM2);
     }
-
-    /**
-     * BootConfig holds all information in .boot.json
-     * @return
-     */
-
-    cpp_freertos::MutexStandard BootConfig::bootConfigMutex;
-    BootConfig *BootConfig::get()
-    {
-        static auto ptr = new BootConfig();
-        return ptr;
-    }
-
-    void BootConfig::setRootPath(const std::filesystem::path &newRootPath)
-    {
-        cpp_freertos::LockGuard lock(bootConfigMutex);
-        os_root_path = newRootPath;
-    }
-
-    const std::filesystem::path BootConfig::getOSRootPath()
-    {
-        cpp_freertos::LockGuard lock(bootConfigMutex);
-        return (os_root_path);
-    }
-
-    const std::string BootConfig::getOSType()
-    {
-        cpp_freertos::LockGuard lock(bootConfigMutex);
-        return (os_type);
-    }
-
-    const std::string BootConfig::getBootloaderVersion()
-    {
-        cpp_freertos::LockGuard lock(bootConfigMutex);
-        return (bootloader_verion);
-    }
-
-    bool BootConfig::loadBootConfig(const std::filesystem::path &bootJsonPath)
-    {
-        std::string parseErrors  = "";
-        std::string jsonContents = utils::filesystem::loadFileAsString(fs::path("/sys") / bootJsonPath);
-
-        LOG_INFO("loadBootConfig parsing %s", (fs::path("/sys") / bootJsonPath).c_str());
-        LOG_INFO("loadBootConfig \"%s\"", jsonContents.c_str());
-
-        boot_json_parsed = json11::Json::parse(jsonContents, parseErrors);
-
-        cpp_freertos::LockGuard lock(bootConfigMutex);
-        if (parseErrors == "") {
-            os_type           = boot_json_parsed[BootConfigJson::main][BootConfigJson::os_type].string_value();
-            os_image          = boot_json_parsed[BootConfigJson::main][BootConfigJson::os_image].string_value();
-            os_root_path      = purefs::dir::getRootDiskPath() / os_type;
-            boot_json         = bootJsonPath;
-            bootloader_verion = boot_json_parsed[BootConfigJson::bootloader][BootConfigJson::os_version].string_value();
-            timestamp         = utils::time::Timestamp().str("%c");
-            os_version        = std::string(VERSION);
-
-            LOG_INFO("boot_config: %s", to_json().dump().c_str());
-            return true;
-        }
-        else {
-            os_type      = PATH_CURRENT;
-            os_image     = purefs::file::boot_bin;
-            os_root_path = purefs::dir::getRootDiskPath() / os_type;
-            boot_json    = bootJsonPath;
-            timestamp    = utils::time::Timestamp().str("%c");
-            os_version   = std::string(VERSION);
-
-            LOG_WARN("loadBootConfig failed to parse %s: \"%s\"", bootJsonPath.c_str(), parseErrors.c_str());
-            return false;
-        }
-    }
-
-    void BootConfig::updateTimestamp()
-    {
-        timestamp = utils::time::Timestamp().str("%c");
-        LOG_INFO("vfs::updateTimestamp \"%s\"", to_json().dump().c_str());
-
-        if (utils::filesystem::replaceWithString(boot_json, to_json().dump())) {
-            utils::filesystem::updateFileCRC32(boot_json);
-        }
-    }
-
-    json11::Json BootConfig::to_json() const
-    {
-        return json11::Json::object{
-            {BootConfigJson::main,
-             json11::Json::object{{BootConfigJson::os_image, os_image},
-                                  {BootConfigJson::os_type, os_type},
-                                  {BootConfigJson::os_version, os_version},
-                                  {BootConfigJson::timestamp, timestamp}}},
-
-            {BootConfigJson::git_info,
-             json11::Json::object{{BootConfigJson::os_git_tag, std::string(GIT_TAG)},
-                                  {BootConfigJson::os_git_revision, std::string(GIT_REV)},
-                                  {BootConfigJson::os_git_branch, std::string(GIT_BRANCH)}}},
-            {BootConfigJson::bootloader, json11::Json::object{{BootConfigJson::os_version, bootloader_verion}}}};
-    }
 }; // namespace Store
diff --git a/module-utils/common_data/EventStore.hpp b/module-utils/common_data/EventStore.hpp
index 496796934..4b1a4e619 100644
--- a/module-utils/common_data/EventStore.hpp
+++ b/module-utils/common_data/EventStore.hpp
@@ -10,8 +10,6 @@
 // it's not meant to serve as polling interface - rather to serve data
 
 #include <cstddef>
-#include <filesystem>
-#include <module-utils/json/json11.hpp>
 
 namespace cpp_freertos
 {
@@ -19,26 +17,6 @@ namespace cpp_freertos
     class MutexStandard;
 } // namespace cpp_freertos
 
-namespace BootConfigJson
-{
-    inline constexpr auto main            = "main";
-    inline constexpr auto os_type         = "ostype";
-    inline constexpr auto os_image        = "imagename";
-    inline constexpr auto os_version      = "version";
-    inline constexpr auto version_major   = "major";
-    inline constexpr auto version_inor    = "minor";
-    inline constexpr auto version_patch   = "patch";
-    inline constexpr auto version_string  = "string";
-    inline constexpr auto timestamp       = "timestamp";
-    inline constexpr auto misc            = "misc";
-    inline constexpr auto builddate       = "builddate";
-    inline constexpr auto git_info        = "git";
-    inline constexpr auto os_git_tag      = "git_tag";
-    inline constexpr auto os_git_revision = "git_commit";
-    inline constexpr auto os_git_branch   = "git_branch";
-    inline constexpr auto bootloader      = "bootloader";
-}; // namespace BootConfigJson
-
 namespace Store
 {
     struct Battery
@@ -51,7 +29,6 @@ namespace Store
         unsigned int level = 0;
 
         static const Battery &get();
-
         static Battery &modify();
     };
 
@@ -102,7 +79,6 @@ namespace Store
     {
       private:
         GSM() = default;
-
         SignalStrength signalStrength;
         Network network;
 
@@ -110,7 +86,6 @@ namespace Store
 
       public:
         GSM(const GSM &) = delete;
-
         GSM &operator=(const GSM &) = delete;
 
         enum class Tray
@@ -142,44 +117,11 @@ namespace Store
         } modem = Modem::OFF;
 
         void setSignalStrength(const SignalStrength &signalStrength);
-
         SignalStrength getSignalStrength() const;
 
         void setNetwork(const Network &signalStrength);
-
         Network getNetwork() const;
 
         static GSM *get();
     };
-
-    class BootConfig
-    {
-      public:
-        BootConfig(const BootConfig &) = delete;
-        BootConfig &operator=(const BootConfig &) = delete;
-        static BootConfig *get();
-
-        void setRootPath(const std::filesystem::path &newRootPath);
-        const std::filesystem::path getOSRootPath();
-        const std::string getOSType();
-        const std::string getBootloaderVersion();
-
-        bool loadBootConfig(const std::filesystem::path &bootJsonPath);
-        void updateTimestamp();
-        [[nodiscard]] json11::Json to_json() const;
-        static int version_compare(const std::string &v1, const std::string &v2);
-
-      private:
-        BootConfig() = default;
-        std::string os_image;
-        std::string os_type;
-        std::string os_version;
-        std::string bootloader_verion;
-        std::string timestamp;
-        json11::Json boot_json_parsed;
-        std::filesystem::path os_root_path;
-        std::filesystem::path boot_json;
-        static cpp_freertos::MutexStandard bootConfigMutex;
-    };
-
 }; // namespace Store
diff --git a/module-vfs/CMakeLists.txt b/module-vfs/CMakeLists.txt
index 26dd8de68..c322d1f3f 100644
--- a/module-vfs/CMakeLists.txt
+++ b/module-vfs/CMakeLists.txt
@@ -45,6 +45,7 @@ set(SOURCES ""
         ${FREERTOS_FAT_SOURCES}
         ${FREERTOS_FAT_EXTSOURCES}
         src/purefs/filesystem_paths.cpp
+        src/deprecated/vfs-utils.cpp
         src/deprecated/vfs.cpp
         src/deprecated/vfsNotifier.cpp
 )
diff --git a/module-vfs/board/cross/free_rtos_custom/portable/vfs.cpp b/module-vfs/board/cross/free_rtos_custom/portable/vfs.cpp
index a07f1c084..9f1ac70f0 100644
--- a/module-vfs/board/cross/free_rtos_custom/portable/vfs.cpp
+++ b/module-vfs/board/cross/free_rtos_custom/portable/vfs.cpp
@@ -4,7 +4,6 @@
 #include "vfs.hpp"
 #include <purefs/filesystem_paths.hpp>
 #include "ff_eMMC_user_disk.hpp"
-#include <module-utils/common_data/EventStore.hpp>
 
 vfs::vfs() : emmc()
 {}
@@ -24,21 +23,20 @@ void vfs::Init()
     /* Print out information on the disk. */
     FF_eMMC_user_DiskShowPartition(emmcFFDisk);
 
-    bootConfig = Store::BootConfig::get();
-    bootConfig->setRootPath(purefs::dir::getRootDiskPath());
+    bootConfig.os_root_path = purefs::dir::getRootDiskPath();
 
-    if (bootConfig->loadBootConfig(purefs::file::boot_json)) {
-        LOG_INFO("vfs::Init osType %s root:%s", bootConfig->getOSType().c_str(), bootConfig->getOSRootPath().c_str());
-        if (ff_chdir(bootConfig->getOSRootPath().c_str()) != 0) {
-            LOG_ERROR("vfs::Init can't chdir to %s", bootConfig->getOSRootPath().c_str());
+    if (loadBootConfig(getCurrentBootJSON())) {
+        LOG_INFO("vfs::Init osType %s root:%s", bootConfig.os_type.c_str(), bootConfig.os_root_path.c_str());
+        if (ff_chdir(bootConfig.os_root_path.c_str()) != 0) {
+            LOG_ERROR("vfs::Init can't chdir to %s", bootConfig.os_root_path.c_str());
         }
     }
     else {
-        LOG_ERROR("vfs::Init unable to determine OS type, fallback to %s", bootConfig->getOSRootPath().c_str());
+        LOG_ERROR("vfs::Init unable to determine OS type, fallback to %s", bootConfig.os_root_path.c_str());
     }
 
-    LOG_INFO("vfs::Init running on ARM osRootPath: %s", bootConfig->getOSRootPath().c_str());
-    LOG_INFO("vfs::Init boot_config: %s", bootConfig->to_json().dump().c_str());
+    LOG_INFO("vfs::Init running on ARM osRootPath: %s", bootConfig.os_root_path.c_str());
+
     // this should already exist and have user data in it
     // if it does not create an exmpty directory so that sqlite3 does not fault
     if (const auto userDiskPath = purefs::dir::getUserDiskPath(); isDir(userDiskPath.c_str()) == false) {
diff --git a/module-vfs/board/linux/free_rtos_custom/portable/vfs.cpp b/module-vfs/board/linux/free_rtos_custom/portable/vfs.cpp
index ae918918e..c310a2dc4 100644
--- a/module-vfs/board/linux/free_rtos_custom/portable/vfs.cpp
+++ b/module-vfs/board/linux/free_rtos_custom/portable/vfs.cpp
@@ -43,19 +43,20 @@ void vfs::Init()
     /* Print out information on the disk. */
     freertos_fat::internals::diskShowPartition(emmcFFDisk);
 
-    bootConfig = Store::BootConfig::get();
-    bootConfig->setRootPath(purefs::dir::getRootDiskPath());
+    bootConfig.os_root_path = purefs::dir::getRootDiskPath();
 
-    if (bootConfig->loadBootConfig(purefs::file::boot_json)) {
-        LOG_INFO("vfs::Init osType %s root:%s", bootConfig->getOSType().c_str(), bootConfig->getOSRootPath().c_str());
-        if (ff_chdir(bootConfig->getOSRootPath().c_str()) != 0) {
-            LOG_ERROR("vfs::Init can't chdir to %s", bootConfig->getOSRootPath().c_str());
+    if (loadBootConfig(getCurrentBootJSON())) {
+        LOG_INFO("vfs::Init osType %s root:%s", bootConfig.os_type.c_str(), bootConfig.os_root_path.c_str());
+        if (ff_chdir(bootConfig.os_root_path.c_str()) != 0) {
+            LOG_ERROR("vfs::Init can't chdir to %s", bootConfig.os_root_path.c_str());
         }
     }
     else {
-        LOG_ERROR("vfs::Init unable to determine OS type, fallback to %s", bootConfig->getOSRootPath().c_str());
+        LOG_ERROR("vfs::Init unable to determine OS type, fallback to %s", bootConfig.os_root_path.c_str());
     }
 
+    LOG_INFO("vfs::Init running on ARM osRootPath: %s", bootConfig.os_root_path.c_str());
+
     // this should already exist and have user data in it
     // if it does not create an exmpty directory so that sqlite3 does not fault
     if (const auto userDiskPath = purefs::dir::getUserDiskPath(); isDir(userDiskPath.c_str()) == false) {
diff --git a/module-vfs/include/user/deprecated/vfs.hpp b/module-vfs/include/user/deprecated/vfs.hpp
index 3183a6858..aa18cbe43 100644
--- a/module-vfs/include/user/deprecated/vfs.hpp
+++ b/module-vfs/include/user/deprecated/vfs.hpp
@@ -10,7 +10,6 @@
 #include <filesystem>
 #include <crc32/crc32.h>
 #include <log/log.hpp>
-#include <module-utils/common_data/EventStore.hpp>
 #include <json/json11.hpp>
 #include "vfsNotifier.hpp"
 #include "vfs_globals.hpp"
@@ -39,8 +38,41 @@ namespace purefs
         inline constexpr auto copy_buf      = 8192 * 4;
     } // namespace buffer
 
-    // namespace json
+    namespace json
+    {
+        inline constexpr auto main            = "main";
+        inline constexpr auto os_type         = "ostype";
+        inline constexpr auto os_image        = "imagename";
+        inline constexpr auto os_version      = "version";
+        inline constexpr auto version_major   = "major";
+        inline constexpr auto version_inor    = "minor";
+        inline constexpr auto version_patch   = "patch";
+        inline constexpr auto version_string  = "string";
+        inline constexpr auto timestamp       = "timestamp";
+        inline constexpr auto misc            = "misc";
+        inline constexpr auto builddate       = "builddate";
+        inline constexpr auto git_info        = "git";
+        inline constexpr auto os_git_tag      = "git_tag";
+        inline constexpr auto os_git_revision = "git_commit";
+        inline constexpr auto os_git_branch   = "git_branch";
+        inline constexpr auto bootloader      = "bootloader";
+    } // namespace json
 
+    struct BootConfig
+    {
+        std::string os_image;
+        std::string os_type;
+        std::string os_version;
+        std::string bootloader_verion;
+        std::string timestamp;
+        json11::Json boot_json_parsed;
+
+        fs::path os_root_path;
+        fs::path boot_json;
+
+        static int version_compare(const std::string &v1, const std::string &v2);
+        [[nodiscard]] json11::Json to_json() const;
+    };
 }; // namespace purefs
 
 /* NOTE: VFS global object class is now deprecated more information
@@ -105,6 +137,13 @@ class vfs
     [[deprecated]] int deltree(const char *path);
     [[deprecated]] int mkdir(const char *dir);
     [[deprecated]] int rename(const char *oldname, const char *newname);
+    [[deprecated]] std::string loadFileAsString(const fs::path &fileToLoad);
+    [[deprecated]] bool replaceWithString(const fs::path &fileToModify, const std::string &stringToWrite);
+    [[deprecated]] void updateTimestamp();
+    [[deprecated]] struct purefs::BootConfig &getBootConfig()
+    {
+        return bootConfig;
+    }
     [[deprecated]] void registerNotificationHandler(vfsn::utility::vfsNotifier::NotifyHandler handler)
     {
         chnNotifier.registerNotificationHandler(handler);
@@ -114,10 +153,20 @@ class vfs
 #ifndef TARGET_Linux
     bsp::eMMC emmc;
 #endif
+
     FF_Disk_t *emmcFFDisk{};
-    Store::BootConfig *bootConfig;
+
+    [[deprecated]] static void computeCRC32(FILE *file, unsigned long *outCrc32);
+    [[deprecated]] static bool verifyCRC(const std::string filePath, const unsigned long crc32);
+    [[deprecated]] static bool verifyCRC(const fs::path filePath);
+    [[deprecated]] static std::string generateRandomId(size_t length);
 
   private:
+    bool updateFileCRC32(const fs::path &file);
+    const fs::path getCurrentBootJSON();
+    bool loadBootConfig(const fs::path &bootJsonPath);
+    bool updateBootConfig(const fs::path &bootJsonPath);
+    struct purefs::BootConfig bootConfig;
     vfsn::utility::vfsNotifier chnNotifier;
 };
 
diff --git a/module-vfs/src/deprecated/vfs-utils.cpp b/module-vfs/src/deprecated/vfs-utils.cpp
new file mode 100644
index 000000000..05fd038df
--- /dev/null
+++ b/module-vfs/src/deprecated/vfs-utils.cpp
@@ -0,0 +1,277 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <vfs.hpp>
+#include <time/time_conversion.hpp>
+#include <random>
+#include <ticks.hpp>
+#include <source/version.hpp>
+
+#include <purefs/filesystem_paths.hpp>
+
+std::string vfs::generateRandomId(size_t length = 0)
+{
+    const std::string CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+    std::random_device random_device;
+    std::mt19937 generator(random_device());
+    generator.seed(utils::time::Timestamp().getTime());
+    std::uniform_int_distribution<> distribution(0, CHARACTERS.size() - 1);
+
+    std::string random_string;
+
+    for (std::size_t i = 0; i < length; ++i) {
+        random_string += CHARACTERS[distribution(generator)];
+    }
+
+    return random_string;
+}
+
+void vfs::computeCRC32(vfs::FILE *file, unsigned long *outCrc32)
+{
+    if (outCrc32 == nullptr)
+        return;
+
+    std::unique_ptr<unsigned char[]> buf(new unsigned char[purefs::buffer::crc_buf]);
+    size_t bufLen;
+
+    *outCrc32 = 0;
+
+    while (!::vfs.eof(file)) {
+        bufLen = ::vfs.fread(buf.get(), 1, purefs::buffer::crc_buf, file);
+        if (bufLen <= 0)
+            break;
+
+        *outCrc32 = Crc32_ComputeBuf(*outCrc32, buf.get(), bufLen);
+    }
+}
+
+bool vfs::verifyCRC(const std::string filePath, const unsigned long crc32)
+{
+    unsigned long crc32Read;
+    auto lamb = [](vfs::FILE *stream) { ::vfs.fclose(stream); };
+
+    std::unique_ptr<vfs::FILE, decltype(lamb)> fp(::vfs.fopen(filePath.c_str(), "r"), lamb);
+
+    if (fp.get() != nullptr) {
+        computeCRC32(fp.get(), &crc32Read);
+        LOG_INFO(
+            "verifyCRC computed crc32 for %s is %08" PRIX32, filePath.c_str(), static_cast<std::uint32_t>(crc32Read));
+        return (crc32Read == crc32);
+    }
+    LOG_ERROR("verifyCRC can't open %s", filePath.c_str());
+    return (false);
+}
+
+bool vfs::verifyCRC(const fs::path filePath)
+{
+    auto lamb = [](vfs::FILE *stream) { ::vfs.fclose(stream); };
+    std::unique_ptr<char[]> crcBuf(new char[purefs::buffer::crc_char_size]);
+    size_t readSize;
+    fs::path crcFilePath(filePath);
+    crcFilePath += purefs::extension::crc32;
+
+    std::unique_ptr<vfs::FILE, decltype(lamb)> fp(::vfs.fopen(crcFilePath.c_str(), "r"), lamb);
+
+    if (fp.get() != nullptr) {
+        if ((readSize = ::vfs.fread(crcBuf.get(), 1, purefs::buffer::crc_char_size, fp.get())) !=
+            (purefs::buffer::crc_char_size)) {
+            LOG_ERROR("verifyCRC fread on %s returned different size then %d [%zu]",
+                      crcFilePath.c_str(),
+                      purefs::buffer::crc_char_size,
+                      readSize);
+            return false;
+        }
+
+        const unsigned long crc32Read = strtoull(crcBuf.get(), nullptr, purefs::buffer::crc_radix);
+
+        LOG_INFO("verifyCRC read %s string:\"%s\" hex:%08lX", crcFilePath.c_str(), crcBuf.get(), crc32Read);
+        return verifyCRC(filePath, crc32Read);
+    }
+    LOG_ERROR("verifyCRC can't open %s", crcFilePath.c_str());
+    return false;
+}
+
+std::string vfs::loadFileAsString(const fs::path &fileToLoad)
+{
+    auto lamb = [](vfs::FILE *stream) { ::vfs.fclose(stream); };
+    std::unique_ptr<char[]> readBuf(new char[purefs::buffer::tar_buf]);
+    std::unique_ptr<vfs::FILE, decltype(lamb)> fp(fopen(fileToLoad.c_str(), "r"), lamb);
+    std::string contents;
+    size_t readSize;
+
+    if (fp.get() != nullptr) {
+        while (!eof(fp.get())) {
+            readSize = fread(readBuf.get(), 1, purefs::buffer::tar_buf, fp.get());
+            contents.append(static_cast<const char *>(readBuf.get()), readSize);
+        }
+    }
+
+    return contents;
+}
+
+bool vfs::replaceWithString(const fs::path &fileToModify, const std::string &stringToWrite)
+{
+    auto lamb = [](vfs::FILE *stream) { ::vfs.fclose(stream); };
+    std::unique_ptr<vfs::FILE, decltype(lamb)> fp(fopen(fileToModify.c_str(), "w"), lamb);
+
+    if (fp.get() != nullptr) {
+        size_t dataWritten = fprintf(fp.get(), stringToWrite.c_str());
+        return dataWritten == stringToWrite.length();
+    }
+    else {
+        return false;
+    }
+}
+
+const fs::path vfs::getCurrentBootJSON()
+{
+    if (verifyCRC(purefs::file::boot_json)) {
+        return relativeToRoot(purefs::file::boot_json);
+    }
+
+    LOG_INFO("vfs::getCurrentBootJSON crc check failed on %s", purefs::file::boot_json);
+    return relativeToRoot(purefs::file::boot_json);
+}
+
+bool vfs::loadBootConfig(const fs::path &bootJsonPath)
+{
+    std::string parseErrors  = "";
+    std::string jsonContents = loadFileAsString(bootJsonPath);
+
+    LOG_INFO("vfs::getOSRootFromJSON parsing %s", bootJsonPath.c_str());
+    LOG_INFO("vfs::getOSRootFromJSON \"%s\"", jsonContents.c_str());
+
+    bootConfig.boot_json_parsed = json11::Json::parse(jsonContents, parseErrors);
+
+    if (parseErrors == "") {
+        bootConfig.os_type  = bootConfig.boot_json_parsed[purefs::json::main][purefs::json::os_type].string_value();
+        bootConfig.os_image = bootConfig.boot_json_parsed[purefs::json::main][purefs::json::os_image].string_value();
+        bootConfig.os_root_path = purefs::createPath(purefs::dir::getRootDiskPath(), bootConfig.os_type);
+        bootConfig.boot_json    = bootJsonPath;
+        bootConfig.bootloader_verion =
+            bootConfig.boot_json_parsed[purefs::json::bootloader][purefs::json::os_version].string_value();
+        bootConfig.timestamp  = utils::time::Timestamp().str("%c");
+        bootConfig.os_version = std::string(VERSION);
+
+        LOG_INFO("boot_config: %s", bootConfig.to_json().dump().c_str());
+        return true;
+    }
+    else {
+        bootConfig.os_type      = PATH_CURRENT;
+        bootConfig.os_image     = purefs::file::boot_bin;
+        bootConfig.os_root_path = purefs::createPath(purefs::dir::getRootDiskPath(), bootConfig.os_type);
+        bootConfig.boot_json    = bootJsonPath;
+        bootConfig.timestamp    = utils::time::Timestamp().str("%c");
+        bootConfig.os_version   = std::string(VERSION);
+
+        LOG_WARN("vfs::getOSRootFromJSON failed to parse %s: \"%s\"", bootJsonPath.c_str(), parseErrors.c_str());
+        return false;
+    }
+}
+
+bool vfs::updateFileCRC32(const fs::path &file)
+{
+    unsigned long fileCRC32 = 0;
+    auto lamb               = [](vfs::FILE *stream) { ::vfs.fclose(stream); };
+
+    std::unique_ptr<vfs::FILE, decltype(lamb)> fp(fopen(file.c_str(), "r"), lamb);
+
+    if (fp.get() != nullptr) {
+        std::unique_ptr<char[]> crc32Buf(new char[purefs::buffer::crc_char_size]);
+        int written = 0;
+        computeCRC32(fp.get(), &fileCRC32);
+        LOG_INFO("updateFileCRC32 writing new crc32 %08" PRIX32 " for %s",
+                 static_cast<std::uint32_t>(fileCRC32),
+                 file.c_str());
+        if (fileCRC32 != 0) {
+            if ((written = sprintf(crc32Buf.get(), "%08" PRIX32, fileCRC32)) != (purefs::buffer::crc_char_size - 1)) {
+                LOG_INFO("updateFileCRC32 can't prepare string for crc32, sprintf returned %d instead of %d",
+                         written,
+                         purefs::buffer::crc_char_size - 1);
+                return false;
+            }
+            fs::path fileCRC32Path = file;
+            fileCRC32Path += purefs::extension::crc32;
+
+            std::unique_ptr<vfs::FILE, decltype(lamb)> fpCRC32(fopen(fileCRC32Path.c_str(), "w"), lamb);
+
+            if (fpCRC32.get() != nullptr) {
+                if (fwrite(crc32Buf.get(), 1, purefs::buffer::crc_char_size, fpCRC32.get()) ==
+                    purefs::buffer::crc_char_size) {
+                    LOG_INFO("updateFileCRC32 wrote \"%s\" in %s", crc32Buf.get(), fileCRC32Path.c_str());
+                    return true;
+                }
+                else {
+                    LOG_WARN("updateFileCRC32 can't write new crc32");
+                    return false;
+                }
+            }
+            else {
+                LOG_WARN("updateFileCRC32 can't open crc32 file for write");
+                return false;
+            }
+        }
+    }
+    else {
+        LOG_WARN("updateFileCRC32 can't open file %s for write", file.c_str());
+        return false;
+    }
+
+    return false;
+}
+
+void vfs::updateTimestamp()
+{
+    bootConfig.timestamp = utils::time::Timestamp().str("%c");
+    LOG_INFO("vfs::updateTimestamp \"%s\"", bootConfig.to_json().dump().c_str());
+
+    if (replaceWithString(bootConfig.boot_json, bootConfig.to_json().dump())) {
+        updateFileCRC32(bootConfig.boot_json);
+    }
+}
+
+json11::Json purefs::BootConfig::to_json() const
+{
+    return json11::Json::object{
+        {purefs::json::main,
+         json11::Json::object{{purefs::json::os_image, os_image},
+                              {purefs::json::os_type, os_type},
+                              {purefs::json::os_version, os_version},
+                              {purefs::json::timestamp, timestamp}}},
+
+        {purefs::json::git_info,
+         json11::Json::object{{purefs::json::os_git_tag, std::string(GIT_TAG)},
+                              {purefs::json::os_git_revision, std::string(GIT_REV)},
+                              {purefs::json::os_git_branch, std::string(GIT_BRANCH)}}},
+        {purefs::json::bootloader, json11::Json::object{{purefs::json::os_version, bootloader_verion}}}};
+}
+
+// Method to compare two version strings
+//   v1 <  v2  -> -1
+//   v1 == v2  ->  0
+int purefs::BootConfig::version_compare(const std::string &v1, const std::string &v2)
+{
+    size_t i = 0, j = 0;
+    while (i < v1.length() || j < v2.length()) {
+        int acc1 = 0, acc2 = 0;
+
+        while (i < v1.length() && v1[i] != '.') {
+            acc1 = acc1 * 10 + (v1[i] - '0');
+            i++;
+        }
+        while (j < v2.length() && v2[j] != '.') {
+            acc2 = acc2 * 10 + (v2[j] - '0');
+            j++;
+        }
+
+        if (acc1 < acc2)
+            return -1;
+        if (acc1 > acc2)
+            return +1;
+
+        ++i;
+        ++j;
+    }
+    return 0;
+}
diff --git a/module-vfs/src/deprecated/vfs.cpp b/module-vfs/src/deprecated/vfs.cpp
index 39843e49a..415b825c9 100644
--- a/module-vfs/src/deprecated/vfs.cpp
+++ b/module-vfs/src/deprecated/vfs.cpp
@@ -226,19 +226,18 @@ vfs::FilesystemStats vfs::getFilesystemStats()
 std::string vfs::relativeToRoot(const std::string path)
 {
     fs::path fsPath(path);
-    fs::path osRootPath(Store::BootConfig::get()->getOSRootPath());
 
     if (fsPath.is_absolute()) {
-        if (osRootPath.root_directory() == fsPath.root_directory())
+        if (bootConfig.os_root_path.root_directory() == fsPath.root_directory())
             return fsPath;
         else
             return purefs::createPath(purefs::dir::getRootDiskPath(), fsPath.relative_path()).c_str();
     }
 
     if (path.empty())
-        return osRootPath;
+        return bootConfig.os_root_path;
     else
-        return osRootPath / fsPath;
+        return bootConfig.os_root_path / fsPath;
 }
 
 bool vfs::isDir(const char *path)
diff --git a/module-vfs/tests/unittest_vfs.cpp b/module-vfs/tests/unittest_vfs.cpp
index 87a9aff69..14deb047a 100644
--- a/module-vfs/tests/unittest_vfs.cpp
+++ b/module-vfs/tests/unittest_vfs.cpp
@@ -18,7 +18,6 @@
 #include <vector>
 
 #include <algorithm>
-#include "Utils.hpp"
 
 class vfs vfs;
 
@@ -86,9 +85,9 @@ TEST_CASE("Random strings")
 {
     const std::string allowedChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     std::string randomIds8, randomIds16, randomIds32;
-    randomIds8  = utils::filesystem::generateRandomId(8);
-    randomIds16 = utils::filesystem::generateRandomId(16);
-    randomIds32 = utils::filesystem::generateRandomId(32);
+    randomIds8  = vfs.generateRandomId(8);
+    randomIds16 = vfs.generateRandomId(16);
+    randomIds32 = vfs.generateRandomId(32);
 
     REQUIRE(randomIds8.size() == 8);
     for (unsigned int i = 0; i < randomIds8.size(); i++)
@@ -107,7 +106,7 @@ TEST_CASE("CRC32 tests")
 {
     unsigned long crc32 = 0;
     char crcBuf[purefs::buffer::crc_char_size];
-    std::string randomData = utils::filesystem::generateRandomId(128);
+    std::string randomData = vfs.generateRandomId(128);
     auto fd                = vfs.fopen("testFile.txt", "w");
     REQUIRE(fd != nullptr);
 
@@ -116,7 +115,7 @@ TEST_CASE("CRC32 tests")
     REQUIRE(vfs.fclose(fd) == 0);
 
     fd = vfs.fopen("testFile.txt", "r");
-    utils::filesystem::computeCRC32((FILE *)fd, &crc32);
+    vfs.computeCRC32(fd, &crc32);
     sprintf(crcBuf, "%lX", crc32);
     auto fdCRC   = vfs.fopen("testFile.txt.crc32", "w");
     bytesWritten = vfs.fwrite(&crcBuf, 1, purefs::buffer::crc_char_size, fdCRC);
@@ -124,7 +123,7 @@ TEST_CASE("CRC32 tests")
     REQUIRE(vfs.fclose(fdCRC) == 0);
     REQUIRE(vfs.fclose(fd) == 0);
 
-    REQUIRE(utils::filesystem::verifyCRC("testFile.txt") == true);
+    REQUIRE(vfs.verifyCRC("testFile.txt") == true);
     REQUIRE(vfs.remove("testFile.txt") == 0);
     REQUIRE(vfs.remove("testFile.txt.crc32") == 0);
 }
@@ -137,11 +136,11 @@ TEST_CASE("File loading and saving")
     const auto slen = std::strlen(test_str);
     REQUIRE(vfs.fwrite(test_str, 1, slen, fd) == slen);
     vfs.fclose(fd);
-    std::string fileContents = utils::filesystem::loadFileAsString("test1.txt");
+    std::string fileContents = vfs.loadFileAsString("test1.txt");
     REQUIRE(strcmp(fileContents.c_str(), test_str) == 0);
     vfs.mkdir("module-vfs/test_dirx");
-    utils::filesystem::replaceWithString("module-vfs/test_dirx/testWrite.txt", "this is a test");
-    fileContents = utils::filesystem::loadFileAsString("module-vfs/test_dirx/testWrite.txt");
+    vfs.replaceWithString("module-vfs/test_dirx/testWrite.txt", "this is a test");
+    fileContents = vfs.loadFileAsString("module-vfs/test_dirx/testWrite.txt");
     REQUIRE(strcmp(fileContents.c_str(), "this is a test") == 0);
     REQUIRE(vfs.remove("module-vfs/test_dirx/testWrite.txt") == 0);
 }