storage.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2025, Libre Space Foundation <http://libre.space>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
 
#pragma once
 
#include <etl/string.h>
#include <satnogs-comms-lib/board.hpp>
#include <satnogs-comms-lib/exception.hpp>
#include <zephyr/fs/fs.h>
#include <zephyr/kernel.h>
 
namespace satnogs::comms
{
 
class storage
{
public:
  static constexpr size_t SECTOR_SIZE = CONFIG_EMMC_SECTOR_SIZE;
 
  class file
  {
  public:
    friend storage;
    file(const etl::istring &path) : m_file{}
    {
      if (path.size() >= CONFIG_STORAGE_MAX_PATH_LEN) {
        throw max_path_exception(__FILE__, __LINE__);
      }
 
      struct fs_dirent entry;
 
      int rc = fs_stat(path.c_str(), &entry);
      if (rc < 0 || entry.type != FS_DIR_ENTRY_FILE) {
        throw read_exception(__FILE__, __LINE__);
      }
 
      fs_file_t_init(&m_file);
 
      rc = fs_open(&m_file, path.c_str(), FS_O_READ);
      if (rc < 0) {
        throw fs_exception(__FILE__, __LINE__);
      }
    }
 
    ~file() { fs_close(&m_file); }
 
  private:
    struct fs_file_t m_file;
  };
 
  class directory
  {
  public:
    friend storage;
    directory(const etl::istring &path)
    {
      fs_dir_t_init(&m_dir);
 
      if (path.size() >= CONFIG_STORAGE_MAX_PATH_LEN) {
        throw max_path_exception(__FILE__, __LINE__);
      }
 
      int rc = fs_opendir(&m_dir, path.c_str());
      if (rc) {
        throw open_dir_exception(__FILE__, __LINE__);
      }
    }
 
    ~directory() { fs_closedir(&m_dir); }
 
  private:
    struct fs_dir_t m_dir;
  };
 
  static storage &
  get_instance()
  {
    static storage instance;
    return instance;
  }
 
  storage(storage const &) = delete;
 
  void
  operator=(storage const &) = delete;
 
  void
  enable(bool en);
 
  bool
  enabled() const;
 
  bool
  mounted() const;
 
  void
  set_dir(lib::emmc::dir d);
 
  lib::emmc::dir
  get_dir() const;
 
  bool
  ready() const;
 
  void
  truncate(const etl::istring &path, size_t len);
 
  void
  mkdir(const etl::istring &path);
 
  void
  rm(const etl::istring &path);
 
  void
  rmdir(const etl::istring &path);
 
  size_t
  write(const etl::istring &path, const uint8_t *b, size_t len);
 
  size_t
  write(const etl::istring &path, const uint8_t *b, size_t len, size_t offset);
 
  void
  ls(const etl::istring &path, etl::istring &res);
 
  bool
  ls(directory &dir, fs_dirent &entry);
 
  bool
  is_file(const etl::istring &path);
 
  bool
  is_dir(const etl::istring &path);
 
  uint64_t
  du(const etl::istring &path);
 
  size_t
  read(const etl::istring &path, uint8_t *b, size_t len, size_t offset);
 
  size_t
  read(file &f, uint8_t *b, size_t len, size_t offset);
 
  size_t
  read(file &f, uint8_t *b, size_t len);
 
  size_t
  write_raw(const uint8_t *b, size_t start_sector, size_t len);
 
  size_t
  read_raw(uint8_t *b, size_t start_sector, size_t sectors);
 
  void
  erase_sectors(size_t start_sector, size_t sectors);
 
  size_t
  sectors_num() const;
 
  float
  utilization();
 
  class open_dir_exception : public lib::exception
  {
  public:
    open_dir_exception(const char *file_name, int line)
        : exception(
              exception::severity::MINOR, file_name, line,
              error_msg{"Failed to open directory", "strgopend", ESTORAGE})
    {
    }
  };
 
  class delete_dir_exception : public lib::exception
  {
  public:
    delete_dir_exception(const char *file_name, int line)
        : exception(exception::severity::MINOR, file_name, line,
                    error_msg{"Directory deletion did not complete", "strgdeld",
                              ESTORAGE})
    {
    }
  };
 
  class delete_file_exception : public lib::exception
  {
  public:
    delete_file_exception(const char *file_name, int line)
        : exception(
              exception::severity::MINOR, file_name, line,
              error_msg{"File deletion did not complete", "strgdelf", ESTORAGE})
    {
    }
  };
 
  class max_path_exception : public lib::exception
  {
  public:
    max_path_exception(const char *file_name, int line)
        : exception(exception::severity::MINOR, file_name, line,
                    error_msg{"File path is too big", "strgpath", ESTORAGE})
    {
    }
  };
 
  class mount_exception : public lib::exception
  {
  public:
    mount_exception(const char *file_name, int line, int err)
        : exception(
              exception::severity::MAJOR, file_name, line,
              error_msg{"Failed to (un)mount storage device", "strgmnt", err})
    {
    }
  };
 
  class not_ready_exception : public lib::exception
  {
  public:
    not_ready_exception(const char *file_name, int line)
        : exception(
              exception::severity::MINOR, file_name, line,
              error_msg{"Storage device is not ready", "strgnotrdy", ESTORAGE})
    {
    }
  };
 
  class read_exception : public lib::exception
  {
  public:
    read_exception(const char *file_name, int line)
        : exception(exception::severity::MINOR, file_name, line,
                    error_msg{"Read exception", "strgrd", ESTORAGE})
    {
    }
  };
 
  class fs_exception : public lib::exception
  {
  public:
    fs_exception(const char *file_name, int line)
        : exception(
              exception::severity::MINOR, file_name, line,
              error_msg{"Filesystem operation failed", "strgfs", ESTORAGE})
    {
    }
  };
 
private:
  bool                                     m_enabled;
  bool                                     m_mounted;
  etl::string<CONFIG_STORAGE_MAX_PATH_LEN> m_pname;
  mutable struct k_mutex                   m_mtx;
 
  storage();
 
  void
  set_dir_priv(lib::emmc::dir d, bool mnt = false);
 
  int
  rm_priv(const etl::istring &path);
 
  bool
  ready_raw() const;
};
} // namespace satnogs::comms