// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#include <purefs/fs/filesystem.hpp>
#include <purefs/fs/drivers/filesystem_vfat.hpp>
#include <purefs/fs/drivers/filesystem_littlefs.hpp>
#include <purefs/blkdev/disk_manager.hpp>
#include <purefs/vfs_subsystem.hpp>
#include <purefs/vfs_subsystem_internal.hpp>
#include <purefs/fs/thread_local_cwd.hpp>
#include <log/log.hpp>
#include <purefs/filesystem_paths.hpp>
#include <module-utils/json/json11.hpp>
#include <sys/stat.h>
#include <fcntl.h>
namespace purefs::subsystem
{
namespace
{
constexpr auto default_blkdev_name = "emmc0";
constexpr auto fat_part_code = 0x0b;
constexpr auto lfs_part_code = 0x9e;
constexpr auto old_layout_part_count = 2;
constexpr auto new_layout_part_count = 3;
constexpr auto boot_size_limit = 16384L;
constexpr auto block_size_max_shift = 21;
namespace json
{
constexpr auto os_type = "ostype";
constexpr auto main = "main";
} // namespace json
std::weak_ptr<blkdev::disk_manager> g_disk_mgr;
std::weak_ptr<fs::filesystem> g_fs_core;
} // namespace
namespace
{
int read_file_to_cpp_string(std::shared_ptr<fs::filesystem> vfs, std::string_view file, std::string &str)
{
int fd = vfs->open(file, O_RDONLY, 0664);
if (fd < 0) {
return fd;
}
size_t rd_pos = 0;
size_t to_read = str.size();
do {
int err = vfs->read(fd, &str[rd_pos], to_read);
if (err < 0) {
vfs->close(fd);
return err;
}
else {
to_read -= err;
rd_pos += err;
}
} while (to_read > 0);
return vfs->close(fd);
}
std::string parse_boot_json_directory(std::string_view file)
{
using namespace std::literals;
auto vfsn = g_fs_core.lock();
if (!vfsn) {
LOG_ERROR("Unable to lock vfs. Fallback to current dir");
return "current"s;
}
struct stat stbuf;
int err = vfsn->stat(file, stbuf);
if (err) {
LOG_ERROR("Unable to lock vfs fallback to current dir");
return "current"s;
}
if (stbuf.st_size > boot_size_limit) {
LOG_ERROR("Boot file to long fallback to current dir");
return "current"s;
}
std::string json_str(stbuf.st_size, ' ');
std::string error;
err = read_file_to_cpp_string(vfsn, file, json_str);
if (err) {
LOG_ERROR("Unable to read boot file fallback to current dir err %i", err);
return "current"s;
}
auto json = json11::Json::parse(json_str, error);
if (!error.empty()) {
LOG_ERROR("Unable to parse json boot file fallback to current dir error %s", error.c_str());
return "current"s;
}
return json[json::main][json::os_type].string_value();
}
} // namespace
auto initialize() -> std::tuple<std::shared_ptr<blkdev::disk_manager>, std::shared_ptr<fs::filesystem>>
{
auto disk_mgr = std::make_shared<blkdev::disk_manager>();
const auto bdev = internal::create_default_block_device();
auto err = disk_mgr->register_device(bdev, default_blkdev_name);
if (err) {
LOG_FATAL("Unable to register block device with error %i", err);
return {};
}
auto fs_core = std::make_shared<fs::filesystem>(disk_mgr);
err = fs_core->register_filesystem("vfat", std::make_shared<fs::drivers::filesystem_vfat>());
if (err) {
LOG_FATAL("Unable to register vfat filesystem with error %i", err);
return {};
}
err = fs_core->register_filesystem("littlefs", std::make_shared<fs::drivers::filesystem_littlefs>());
if (err) {
LOG_FATAL("Unable to register vfat filesystem with error %i", err);
return {};
}
g_disk_mgr = disk_mgr;
g_fs_core = fs_core;
return {disk_mgr, fs_core};
}
auto disk_mgr() -> std::shared_ptr<blkdev::disk_manager>
{
return g_disk_mgr.lock();
}
auto vfs_core() -> std::shared_ptr<fs::filesystem>
{
return g_fs_core.lock();
}
auto mount_defaults() -> int
{
auto disk = g_disk_mgr.lock();
if (!disk) {
LOG_FATAL("Unable to lock disk");
return -EIO;
}
auto parts = disk->partitions(default_blkdev_name);
if (parts.size() != old_layout_part_count && parts.size() != new_layout_part_count) {
LOG_FATAL("Unknown partitions layout part size is %u", unsigned(parts.size()));
return -EIO;
}
auto boot_it = std::end(parts);
auto lfs_it = std::end(parts);
for (auto it = std::begin(parts); it != std::end(parts); ++it) {
if (it->bootable && boot_it == std::end(parts)) {
boot_it = it;
}
else if (it->type == lfs_part_code && lfs_it == std::end(parts)) {
lfs_it = it;
}
}
if (lfs_it == std::end(parts) && parts.size() == old_layout_part_count) {
LOG_ERROR("!!!! Caution !!!! eMMC is formated with vFAT old layout scheme. Filesystem may be currupted on "
"power loss.");
LOG_WARN("Please upgrade to new partition scheme based on the LittleFS filesystem.");
}
if (boot_it == std::end(parts)) {
LOG_FATAL("Unable to find boot partition");
return -ENOENT;
}
auto vfs = g_fs_core.lock();
if (!vfs) {
LOG_FATAL("Unable to lock vfs core");
return -EIO;
}
auto err = vfs->mount(boot_it->name, purefs::dir::getRootDiskPath().string(), "vfat");
if (err) {
return err;
}
if (lfs_it != std::end(parts)) {
if (lfs_it->boot_unit > block_size_max_shift) {
LOG_FATAL("Boot sector size is out of range");
return -ERANGE;
}
else {
const uint32_t lfs_block_size = 1U << lfs_it->boot_unit;
const auto lfs_block_size_ptr = (lfs_it->boot_unit) ? (&lfs_block_size) : nullptr;
err = vfs->mount(
lfs_it->name, purefs::dir::getUserDiskPath().string(), "littlefs", 0, lfs_block_size_ptr);
}
}
const std::string json_file = (dir::getRootDiskPath() / file::boot_json).string();
const auto boot_dir_name = parse_boot_json_directory(json_file);
const auto user_dir = (dir::getRootDiskPath() / boot_dir_name).string();
fs::internal::set_default_thread_cwd(user_dir);
return err;
}
auto unmount_all() -> int
{
auto vfs = g_fs_core.lock();
if (!vfs) {
LOG_ERROR("Unable to lock vfs");
return -EIO;
}
std::list<std::string> mount_points;
int err = vfs->read_mountpoints(mount_points);
if (err) {
return err;
}
for (const auto &mpoint : mount_points) {
err = vfs->umount(mpoint);
if (err)
break;
}
return err;
}
} // namespace purefs::subsystem