memory_monitor.cpp

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
 */
 
#include "memory_monitor.hpp"
#include "callbacks.hpp"
#include "error_handler.hpp"
#include <zephyr/dfu/mcuboot.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/sys/printk.h>
 
namespace satnogs::comms
{
 
static K_WORK_DELAYABLE_DEFINE(scan_work, memory_monitor::flash_monitor_hdlr);
 
/* ─────────────────── Flash device & constants ───────────────────────── */
static const struct device *const flash = DEVICE_DT_GET(DT_NODELABEL(flash));
 
static constexpr size_t chunk_bytes = 32;   /* one flash_read()    */
static constexpr size_t burst_bytes = 1024; /* pause every 1 KB   */
uint8_t                 buf[chunk_bytes];

void
memory_monitor::start(int32_t delay)
{
  /* if already running -> do nothing */
  if (atomic_cas(&m_running, settings::FALSE_MAGIC, settings::TRUE_MAGIC)) {
    m_burst_delay_ms = delay * 1000; /* convert to milliseconds */
    m_scan_off       = 0;
    k_work_schedule(&scan_work, K_NO_WAIT); /* first sweep now */
  }
}

void
memory_monitor::stop()
{
  /* if already stopped -> do nothing */
  if (atomic_cas(&m_running, settings::TRUE_MAGIC, settings::FALSE_MAGIC)) {
    k_work_cancel_delayable(&scan_work);
  }
}
 
memory_monitor::memory_monitor()
    : m_running(settings::FALSE_MAGIC),
      m_burst_delay_ms(CONFIG_FLASH_MONITOR_BURST_DELAY_SECS * 1000),
      m_scan_off(0)
{
#ifdef CONFIG_BOOTLOADER_MCUBOOT
  const struct flash_area *fa;
  if (flash_area_open(boot_fetch_active_slot(), &fa) != 0) {
    throw flash_init_exception(__FILE__, __LINE__);
  }
  m_flash_size   = fa->fa_size;
  m_flash_offset = fa->fa_off;
#else
  m_flash_size   = DT_REG_SIZE(DT_NODELABEL(slot0_partition));
  m_flash_offset = DT_REG_ADDR(DT_NODELABEL(slot0_partition));
#endif
}

void
memory_monitor::flash_monitor_hdlr(struct k_work *work)
{
  try {
    auto &mem_mon = memory_monitor::get_instance();
    if (atomic_get(&mem_mon.m_running) ==
        static_cast<atomic_val_t>(settings::TRUE_MAGIC)) {
 
      /* ---- scan at most one 1 KiB burst per invocation ---- */
      const off_t off_start = mem_mon.m_scan_off;
      const off_t off_end   = MIN(off_start + static_cast<off_t>(burst_bytes),
                                  static_cast<off_t>(mem_mon.m_flash_size));
 
      for (off_t off = off_start; off < off_end; off += chunk_bytes) {
        const size_t len  = MIN(chunk_bytes, mem_mon.m_flash_size - off);
        const off_t  addr = mem_mon.m_flash_offset + off;
 
        int err = flash_read(flash, addr, buf, len);
        if (err == -EIO) {
          throw flash_read_exception(__FILE__, __LINE__);
        }
      }
      mem_mon.m_scan_off = off_end;
      if (mem_mon.m_scan_off >= static_cast<off_t>(mem_mon.m_flash_size)) {
        mem_mon.m_scan_off = 0;
      }
      k_work_reschedule(&scan_work, K_MSEC(mem_mon.m_burst_delay_ms));
    }
  } catch (const lib::exception &e) {
    auto &err = error_handler::get_instance();
    err.handle(e);
  } catch (const std::exception &e) {
    auto &err = error_handler::get_instance();
    err.handle(e);
  }
}
 
} // namespace satnogs::comms