11 files changed, 61 insertions(+), 425 deletions(-)

M board/rt1051/newlib/io_syscalls.cpp
M module-bsp/board/rt1051/bsp/battery-charger/battery_charger.cpp
M module-bsp/board/rt1051/bsp/usb
M module-services/service-desktop/endpoints/factoryReset/FactoryReset.cpp
M module-utils/bootconfig/src/bootconfig.cpp
A module-vfs/board/rt1051/purefs/src/vfs_subsystem_internal.cpp
M module-vfs/drivers/src/purefs/fs/filesystem_vfat.cpp
M module-vfs/include/internal/newlib/vfs_io_syscalls.hpp
M module-vfs/src/newlib/vfs_internal_dirent.cpp
M module-vfs/src/newlib/vfs_io_syscalls.cpp
M module-vfs/targets/Target_RT1051.cmake

@@ 7,6 7,7 @@
 #include <sys/types.h>
 #include <dirent.h>
 #include <newlib/vfs_io_syscalls.hpp>
+#include <sys/statvfs.h>
 extern "C"
 {
     using namespace vfsn::internal;


@@ 109,5 110,9 @@ extern "C"
     int fsync( int fd ) {
         return syscalls::fsync(_REENT->_errno, fd);
     }
+    int statvfs(const char *path, struct statvfs *buf)
+    {
+        return syscalls::statvfs(path,buf);
+    }
 }
 

@@ 16,7 16,6 @@ extern "C"
 }
 
 #include "bsp/battery-charger/battery_charger.hpp"
-#include "vfs.hpp"
 
 #include "bsp/BoardDefinitions.hpp"
 #include "common_data/EventStore.hpp"


@@ 24,7 23,7 @@ extern "C"
 #include "drivers/i2c/DriverI2C.hpp"
 #include <cstdio>
 #include <purefs/filesystem_paths.hpp>
-
+#include "fsl_common.h"
 #define BSP_BATTERY_CHARGER_I2C_ADDR (0xD2 >> 1)
 #define BSP_FUEL_GAUGE_I2C_ADDR      (0x6C >> 1)
 #define BSP_TOP_CONTROLLER_I2C_ADDR  (0xCC >> 1)


@@ 337,6 336,8 @@ static int battery_chargerTopControllerWrite(bsp::batteryChargerRegisters regist
 }
 
 static int battery_chargerTopControllerRead(bsp::batteryChargerRegisters registerAddress, uint8_t *value)
+    __attribute__((used));
+static int battery_chargerTopControllerRead(bsp::batteryChargerRegisters registerAddress, uint8_t *value)
 {
     if (value == NULL) {
         return -1;


@@ 389,7 390,7 @@ static bsp::batteryRetval battery_loadConfiguration(void)
 static bsp::batteryRetval battery_storeConfiguration(void)
 {
     // TODO:M.P procedure below seems to crash system, it should be fixed.
-    if (ff_rename(configs::battery_cfgFile.c_str(), configs::battery_cfgFilePrev.c_str(), false) != 0) {
+    if (rename(configs::battery_cfgFile.c_str(), configs::battery_cfgFilePrev.c_str()) != 0) {
         LOG_ERROR("Could not move configuration file");
         return bsp::batteryRetval::battery_ChargerError;
     }

@@ 1,1 1,1 @@
-Subproject commit bd86bc1e7f464b81746bee08997f8f7adefb99d7
+Subproject commit 43e882e21180a7fceb724a43aa0f72850bbb4a22

@@ 2,9 2,6 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "FactoryReset.hpp"
-#ifndef TARGET_Linux
-#include <FreeRTOSFATConfig.h>
-#endif
 #include <SystemManager/SystemManager.hpp>
 #include <log/log.hpp>
 #include <purefs/filesystem_paths.hpp>


@@ 17,6 14,7 @@
 #include <vector>
 #include <purefs/filesystem_paths.hpp>
 #include <purefs/fs/filesystem.hpp>
+#include <limits.h>
 
 namespace sys
 {


@@ 36,11 34,7 @@ namespace FactoryReset
     static const int max_recurse_depth  = 120; /* 120 is just an arbitrary value of max number of recursive calls.
                                                 * If more then error is assumed, not the real depth of directories."
                                                 */
-#ifdef TARGET_Linux
-    static const int max_filepath_length = 4096;
-#else
-    static const int max_filepath_length = ffconfigMAX_FILENAME;
-#endif
+    static const int max_filepath_length = PATH_MAX;
 
     bool Run(sys::Service *ownerService)
     {

@@ 3,6 3,7 @@
 #include <boot/bootconfig.hpp>
 #include <boot/bootconstants.hpp>
 
+#include <limits.h>
 #include <purefs/filesystem_paths.hpp>
 #include <source/version.hpp>
 #include <time/time_conversion.hpp>

@@ 0,0 1,14 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <purefs/vfs_subsystem_internal.hpp>
+#include <purefs/blkdev/disk_manager.hpp>
+
+namespace purefs::subsystem::internal
+{
+    auto create_default_block_device() -> std::shared_ptr<blkdev::disk>
+    {
+        // TODO: implement for rt1051
+        return nullptr;
+    }
+} // namespace purefs::subsystem::internal

@@ 323,7 323,7 @@ namespace purefs::fs::drivers
             return -ENXIO;
         }
         FRESULT fres{FR_OK};
-        if (f_tell(fp) != newpos) {
+        if (f_tell(fp) != static_cast<unsigned long>(newpos)) {
             fres = f_lseek(fp, newpos);
         }
         return (fres == FR_OK) ? (f_tell(fp)) : translate_error(fres);

@@ 8,6 8,7 @@
 #include <dirent.h>
 #include <stdint.h>
 
+struct statvfs;
 namespace vfsn::internal::syscalls
 {
     int open(int &_errno_, const char *file, int flags, int mode);


@@ 34,4 35,6 @@ namespace vfsn::internal::syscalls
     int chmod(int &_errno_, const char *path, mode_t mode);
     int fchmod(int &_errno_, int fd, mode_t mode);
     int fsync(int &_errno_, int fd);
+    int statvfs(const char *path, struct statvfs *buf);
+
 } // namespace vfsn::internal::syscalls

@@ 2,7 2,6 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 #include "vfs_internal_dirent.hpp"
 #include <cstring>
-#include <ff_stdio.h>
 #include <errno.h>
 #include <new>
 #include <dirent.h>


@@ 11,70 10,21 @@ namespace vfsn::internal::dirent
 {
     DIR_ITER *diropen(int &_errno_, const char *path)
     {
-        FF_Stat_t fs;
-        if (ff_stat(path, &fs)) {
-            _errno_ = stdioGET_ERRNO();
-            if (_errno_ == EFAULT)
-                _errno_ = ENOENT;
-            return nullptr;
-        }
-        if (!(fs.st_mode & FF_IFDIR)) {
-            _errno_ = ENOTDIR;
-            return nullptr;
-        }
-        auto ret = new (std::nothrow) DIR_ITER;
-        if (!ret) {
-            _errno_ = ENOMEM;
-            return nullptr;
-        }
-        ret->dir_state = nullptr;
-        std::strncpy(ret->name_state, path, sizeof(ret->name_state));
-        return ret;
+        return nullptr;
     }
 
     int dirreset(int &_errno_, DIR_ITER *state)
     {
-        if (state->dir_state) {
-            delete reinterpret_cast<FF_FindData_t *>(state->dir_state);
-            state->dir_state = nullptr;
-            _errno_          = 0;
-            return 0;
-        }
-        else {
-            _errno_ = EBADF;
-            return -1;
-        }
+        return -1;
     }
     int dirnext(int &_errno_, DIR_ITER *state)
     {
-        int ret;
-        if (!state->dir_state) {
-            auto fdd = new (std::nothrow) FF_FindData_t;
-            if (!fdd) {
-                _errno_ = ENOMEM;
-                return -1;
-            }
-            std::memset(fdd, 0, sizeof(*fdd));
-            ret              = ff_findfirst(state->name_state, fdd);
-            state->dir_state = fdd;
-        }
-        else {
-            auto fdd = static_cast<FF_FindData_t *>(state->dir_state);
-            ret      = ff_findnext(fdd);
-        }
-        _errno_ = stdioGET_ERRNO();
-        if (_errno_ == EFAULT)
-            _errno_ = ENOENT;
-        return ret;
+        return -1;
     }
 
     int dirclose(int &_errno_, DIR_ITER *state)
     {
-        if (state->dir_state) {
-            delete reinterpret_cast<FF_FindData_t *>(state->dir_state);
-        }
-        delete state;
-        _errno_ = 0;
-        return 0;
+        return -1;
     }
+
 } // namespace vfsn::internal::dirent

@@ 1,6 1,5 @@
 // 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 <errno.h>
 #include <dirent.h>
 #include <log/log.hpp>


@@ 10,454 9,122 @@
 #include "vfs_internal_dirent.hpp"
 #include "HandleManager.hpp"
 #include <newlib/vfs_io_syscalls.hpp>
-#include <deprecated/vfs.hpp>
-
-// NOTE: It will be removed in later stage
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-/** NOTE: This is generic wrapper for newlib syscalls
- * using current VFS implementation. This implementation
- * will be removed in next release when disk manager
- * and new VFS filesystem will be ready
- */
-
-namespace vfsn::internal
-{
-    namespace
-    {
-        stdlib::HandleManager<FF_FILE> gFileHandles;
-    }
-
-    namespace
-    {
-        auto open_to_fopen_flags(int flags)
-        {
-            flags &= ~0x00010000; // Ignore binary
-            if ((flags & O_RDONLY) || !flags) {
-                return "r";
-            }
-            else if (flags & (O_WRONLY | O_CREAT | O_TRUNC)) {
-                return "w";
-            }
-            else if (flags & (O_WRONLY | O_CREAT | O_APPEND)) {
-                return "a";
-            }
-            else if (flags & O_RDWR) {
-                return "r+";
-            }
-            else if (flags & (O_RDWR | O_CREAT | O_TRUNC)) {
-                return "w+";
-            }
-            else if (flags & (O_RDWR | O_CREAT | O_APPEND)) {
-                return "a+";
-            }
-            else {
-                LOG_ERROR("Unsupported flag %08x", flags);
-                return "";
-            }
-        }
-
-    } // namespace
-
-} // namespace vfsn::internal
+#include <sys/statvfs.h>
 
 namespace vfsn::internal::syscalls
 {
     int open(int &_errno_, const char *file, int flags, int mode)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto fflags = open_to_fopen_flags(flags);
-        if (*fflags == '\0') {
-            _errno_ = EINVAL;
-            return -1;
-        }
-        auto fil = ff_fopen(vfs.relativeToRoot(file).c_str(), fflags);
-        if (!fil) {
-            _errno_ = stdioGET_ERRNO();
-            return -1;
-        }
-        int hwnd = gFileHandles.setHandle(fil);
-        if (hwnd < 0) {
-            ff_fclose(fil);
-            _errno_ = EMFILE;
-            LOG_ERROR("Unable to find handle %i", hwnd);
-            return -1;
-        }
-        else {
-            _errno_ = 0;
-            return hwnd;
-        }
+        return -1;
     }
 
     long close(int &_errno_, int fd)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto fil = gFileHandles.clearHandle(fd);
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        auto ret = ff_fclose(fil);
-        _errno_  = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
 
     long write(int &_errno_, int fd, const void *buf, size_t cnt)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        if (fd == STDERR_FILENO || fd == STDOUT_FILENO) {
-            log_WriteToDevice((uint8_t *)buf, cnt);
-            return cnt;
-        }
-        auto fil = gFileHandles[fd];
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        auto ret = ff_fwrite(buf, cnt, 1, fil);
-        _errno_  = stdioGET_ERRNO();
-        return ret > 0 ? (ret * cnt) : ret;
+        return -1;
     }
 
     long read(int &_errno_, int fd, void *buf, size_t cnt)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto fil = gFileHandles[fd];
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        const auto remain_bytes = fil->ulFileSize - fil->ulFilePointer;
-        if (remain_bytes > 0) {
-            cnt            = std::min<size_t>(cnt, remain_bytes);
-            const auto ret = ff_fread(buf, cnt, 1, fil);
-            _errno_        = stdioGET_ERRNO();
-            return ret > 0 ? ret * cnt : ret;
-        }
-        else {
-            _errno_ = 0;
-            return 0;
-        }
+        return -1;
     }
 
     off_t lseek(int &_errno_, int fd, off_t pos, int dir)
     {
-        auto fil = gFileHandles[fd];
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        auto ret = ff_fseek(fil, pos, dir);
-        if (ret) {
-            _errno_ = stdioGET_ERRNO();
-            return static_cast<off_t>(-1);
-        }
-        ret = ff_ftell(fil);
-        if (ret < 0) {
-            _errno_ = stdioGET_ERRNO();
-            return static_cast<off_t>(-1);
-        }
-        return ret;
+        return -1;
     }
     int fstat(int &_errno_, int fd, struct stat *pstat)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto fil = gFileHandles[fd];
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        std::memset(pstat, 0, sizeof(*pstat));
-        pstat->st_ino  = fil->ulObjectCluster;
-        pstat->st_size = fil->ulFileSize;
-        pstat->st_dev  = 0;
-        pstat->st_mode = S_IFREG | 0666;
-        _errno_        = 0;
-        return 0;
+        return -1;
     }
     int link(int &_errno_, const char *existing, const char *newLink)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        _errno_ = ENOSYS;
-        LOG_ERROR("Syscall %s not supported", __PRETTY_FUNCTION__);
         return -1;
     }
     int unlink(int &_errno_, const char *name)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        const auto rel_name = vfs.relativeToRoot(name);
-        auto ret            = ff_remove(rel_name.c_str());
-        if (ret && stdioGET_ERRNO() == EISDIR)
-            ret = ff_deltree(rel_name.c_str(), nullptr, nullptr);
-        _errno_ = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
 
     int fcntl(int &_errno_, int fd, int cmd, int arg)
     {
-        _errno_ = ENOSYS;
-        LOG_ERROR("Syscall %s not supported", __PRETTY_FUNCTION__);
         return -1;
     }
     int stat(int &_errno_, const char *file, struct stat *pstat)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        FF_Stat_t stat_ff;
-        auto ret = ff_stat(vfs.relativeToRoot(file).c_str(), &stat_ff);
-        if (!ret) {
-            std::memset(pstat, 0, sizeof(*pstat));
-            pstat->st_ino  = stat_ff.st_ino;
-            pstat->st_size = stat_ff.st_size;
-            pstat->st_dev  = stat_ff.st_dev;
-            // Linux mode compat
-            if (stat_ff.st_mode == FF_IFREG)
-                pstat->st_mode = S_IFREG | 0666;
-            if (stat_ff.st_mode == FF_IFDIR)
-                pstat->st_mode = S_IFDIR | 0777;
-        }
-        _errno_ = stdioGET_ERRNO();
-        // NOTE: ff_stdio uses wrong errno NOADDRESS
-        if (_errno_ == EFAULT)
-            _errno_ = ENOENT;
-        return ret;
+        return -1;
     }
 
     int chdir(int &_errno_, const char *path)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto ret = ff_chdir(vfs.relativeToRoot(path).c_str());
-        _errno_  = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
     char *getcwd(int &_errno_, char *buf, size_t size)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return nullptr;
-        }
-        auto cwd = ff_getcwd(buf, size);
-        _errno_  = stdioGET_ERRNO();
-        return cwd;
+        return nullptr;
     }
     int rename(int &_errno_, const char *oldName, const char *newName)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto ret = ff_rename(vfs.relativeToRoot(oldName).c_str(), vfs.relativeToRoot(newName).c_str(), true);
-        _errno_  = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
 
     int mkdir(int &_errno_, const char *path, uint32_t mode)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto ret = ff_mkdir(vfs.relativeToRoot(path).c_str());
-        _errno_  = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
 
     DIR *opendir(int &_errno_, const char *dirname)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return nullptr;
-        }
-        auto dir      = new DIR;
-        dir->dir_data = dirent::diropen(_errno_, vfs.relativeToRoot(dirname).c_str());
-        if (!dir->dir_data) {
-            delete dir;
-            return nullptr;
-        }
-        dir->position            = 0;
-        dir->file_data.d_ino     = -1;
-        dir->file_data.d_name[0] = '\0';
-        return dir;
+        return nullptr;
     }
 
     int closedir(int &_errno_, DIR *dirp)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        if (!dirp) {
-            _errno_ = EBADF;
-            return -1;
-        }
-        auto res = dirent::dirclose(_errno_, dirp->dir_data);
-        delete dirp;
-        return res;
+        return -1;
     }
 
     struct dirent *readdir(int &_errno_, DIR *dirp)
     {
-        if (!dirp) {
-            _errno_ = EBADF;
-            return nullptr;
-        }
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return nullptr;
-        }
-        auto olderrno{_errno_};
-        auto res = dirent::dirnext(_errno_, dirp->dir_data);
-        auto fff = reinterpret_cast<FF_FindData_t *>(dirp->dir_data->dir_state);
-        if (res < 0) {
-            if (_errno_ == pdFREERTOS_ERRNO_ENMFILE) {
-                _errno_ = olderrno;
-            }
-            return nullptr;
-        }
-        dirp->position += 1;
-        if (strnlen(fff->pcFileName, NAME_MAX) >= sizeof(dirp->file_data.d_name)) {
-            _errno_ = EOVERFLOW;
-            return nullptr;
-        }
-        dirp->file_data.d_ino  = fff->xDirectoryEntry.ulObjectCluster;
-        dirp->file_data.d_type = (fff->ucAttributes & FF_FAT_ATTR_DIR) ? DT_DIR : DT_REG;
-        std::strncpy(dirp->file_data.d_name, fff->pcFileName, sizeof(dirp->file_data.d_name));
-        return &dirp->file_data;
+        return nullptr;
     }
 
     int readdir_r(int &_errno_, DIR *dirp, struct dirent *entry, struct dirent **result)
     {
-        if (!dirp) {
-            return EBADF;
-        }
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto olderrno{_errno_};
-        auto res = dirent::dirnext(_errno_, dirp->dir_data);
-        auto fff = reinterpret_cast<FF_FindData_t *>(dirp->dir_data->dir_state);
-        if (res < 0) {
-            res = _errno_;
-            if (_errno_ == pdFREERTOS_ERRNO_ENMFILE) {
-                res = 0;
-            }
-            _errno_ = olderrno;
-            return res;
-        }
-        dirp->position += 1;
-        if (strnlen(fff->pcFileName, NAME_MAX) >= sizeof(entry->d_name)) {
-            return EOVERFLOW;
-        }
-        entry->d_ino  = fff->xDirectoryEntry.ulObjectCluster;
-        entry->d_type = (fff->ucAttributes & FF_FAT_ATTR_DIR) ? DT_DIR : DT_REG;
-        std::strncpy(entry->d_name, fff->pcFileName, sizeof(entry->d_name));
-        *result = entry;
-        return 0;
+        return -1;
     }
 
     void rewinddir(int &_errno_, DIR *dirp)
     {
-        if (!dirp) {
-            return;
-        }
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return;
-        }
-        dirent::dirreset(_errno_, dirp->dir_data);
-        dirp->position = 0;
     }
 
     void seekdir(int &_errno_, DIR *dirp, long int loc)
     {
-        if (!dirp || loc < 0) {
-            return;
-        }
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return;
-        }
-        if (dirp->position > loc) {
-            dirent::dirreset(_errno_, dirp->dir_data);
-            dirp->position = 0;
-        }
-        while ((dirp->position < loc) && (dirent::dirnext(_errno_, dirp->dir_data) >= 0)) {
-            dirp->position += 1;
-        }
     }
     long int telldir(int &_errno_, DIR *dirp)
     {
-        if (!dirp) {
-            return -1;
-        }
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        return dirp->position;
+        return -1;
     }
 
     int chmod(int &_errno_, const char *path, mode_t mode)
     {
-        _errno_ = ENOSYS;
-        LOG_ERROR("Syscall %s not supported", __PRETTY_FUNCTION__);
         return -1;
     }
     int fchmod(int &_errno_, int fd, mode_t mode)
     {
-        _errno_ = ENOSYS;
-        LOG_ERROR("Syscall %s not supported", __PRETTY_FUNCTION__);
         return -1;
     }
     int fsync(int &_errno_, int fd)
     {
-        if (!vfs.isInitialized()) {
-            _errno_ = EIO;
-            return -1;
-        }
-        auto fil = gFileHandles[fd];
-        if (!fil) {
-            LOG_ERROR("Unable to find handle %i", fd);
-            _errno_ = EBADF;
-            return -1;
-        }
-        auto ret = ff_fflush(fil);
-        _errno_  = stdioGET_ERRNO();
-        return ret;
+        return -1;
     }
+    int statvfs(const char *path, struct statvfs *buf)
+    {
+        return -1;
+    }
+
 } // namespace vfsn::internal::syscalls
 
-#pragma GCC diagnostic pop

@@ 3,6 3,7 @@ set(BOARD_SOURCES ${BOARD_SOURCES}
         src/newlib/vfs_internal_dirent.cpp
         src/newlib/HandleManager.cpp
         board/rt1051/purefs/src/fs/thread_local_cwd.cpp
+        board/rt1051/purefs/src/vfs_subsystem_internal.cpp
         CACHE INTERNAL ""
 )