Enhance filesystem formatting support and tests

- Added support for `mimxrt` to the `--format` option in `mpflash flash`.
- Updated `CHANGELOG.md` to reflect the new filesystem support.
- Improved the `erase_bdev.py` and `format_bdev.py` scripts for better runtime detection of filesystem types.
- Added unit tests for filesystem class detection and block device polling.

Signed-off-by: Jos Verlinde <Jos_Verlinde@hotmail.com>

Author: Josverl

CHANGELOG.md

@@ -8,8 +8,9 @@ All notable changes to mpflash are documented in this file.
 
 - **`--format` option for `mpflash flash`** — reformats the board's filesystem after
   flashing, recreating an empty filesystem of the same type (`VfsLfs2` or `VfsFat`) via
-  the MicroPython block device. Supported on `rp2`, `esp32`, `esp8266`, `samd`, `stm32`
-  and `nrf`.
+  the MicroPython block device. Supported on `rp2`, `esp32`, `esp8266`, `samd`, `stm32`,
+  `nrf` and `mimxrt`. The mount point and filesystem type are detected at runtime using
+  the same `vfs.mount()` enumeration as `mpremote df`.
 - **`mpflash format` command** — reformats the filesystem of connected boards without
   flashing new firmware. Asks for confirmation before erasing (skip with `--yes`) and
   supports the same ports as `flash --format`.

mpflash/flash/format_fs.py

@@ -15,7 +15,7 @@
 FORMAT_SCRIPT = HERE / "format_bdev.py"
 
 # Ports for which the internal-flash block device is known.
-SUPPORTED_FORMAT_PORTS = frozenset({"rp2", "esp32", "esp8266", "samd", "stm32", "nrf"})
+SUPPORTED_FORMAT_PORTS = frozenset({"rp2", "esp32", "esp8266", "samd", "stm32", "nrf", "mimxrt"})
 
 _OK_MARKER = "FORMAT: done"
 

mpflash/mpremoteboard/erase_bdev.py

@@ -1,11 +1,12 @@
 # pragma: no cover
 """Erase the filesystem block device, then reset the board.
 
-Run on the board via ``mpremote run``. It locates the port's filesystem
-``bdev`` (the same one ``_boot.py`` mounts), unmounts it, erases every block
-using the extended block-device protocol and finally calls ``machine.reset()``.
-The board reboots into MicroPython and ``_boot.py`` recreates a fresh, empty
-filesystem.
+Run on the board via ``mpremote run``. It locates the port's block device
+(polling the factory each MicroPython port exposes), unmounts every writable
+filesystem found via ``vfs.mount()`` (the same enumeration as ``mpremote df``),
+erases every block using the extended block-device protocol and finally calls
+``machine.reset()``. The board reboots into MicroPython and ``_boot.py``
+recreates a fresh, empty filesystem.
 
 Only the filesystem storage region is erased - the firmware itself lives in a
 separate flash region and is left untouched. Entering the UF2 bootloader is a
@@ -17,44 +18,68 @@
 _IOCTL_BLOCK_ERASE = 6
 
 
-def _get_bdev():
-    """Return (bdev, mount_point) for the running port, or (None, None)."""
+def _vfs():
+    """Return the module providing ``mount``/``umount`` (``vfs`` or legacy ``os``)."""
     try:
-        import rp2
+        import vfs
 
-        return rp2.Flash(), "/"
-    except Exception:
-        pass
-    try:
-        import samd
+        return vfs
+    except ImportError:
+        import os
 
-        return samd.Flash(), "/"
-    except Exception:
-        pass
+        return os
+
+
+# (module, attribute, kwargs): the block-device factory each MicroPython port
+# exposes. Instantiated as ``module.attribute(**kwargs)``. Adding a new port is
+# a new entry here, not a port-name check elsewhere.
+_BDEV_FACTORIES = (
+    ("rp2", "Flash", {}),
+    ("samd", "Flash", {}),
+    ("nrf", "Flash", {}),
+    ("mimxrt", "Flash", {}),
+    ("alif", "Flash", {}),
+    ("pyb", "Flash", {"start": 0}),  # stm32
+    ("psoc_edge", "QSPI_Flash", {}),
+)
+
+
+def _get_bdev():
+    """Return the internal-flash block device for the running port, or None.
+
+    Polls the known block-device factories in turn; the first that imports and
+    instantiates wins. esp32 / esp8266 instead expose a ready-made ``bdev``.
+    """
+    for mod_name, attr, kwargs in _BDEV_FACTORIES:
+        try:
+            return getattr(__import__(mod_name), attr)(**kwargs)
+        except Exception:
+            pass
     try:
-        import nrf
+        from flashbdev import bdev  # esp32 / esp8266
 
-        return nrf.Flash(), "/flash"
+        return bdev
     except Exception:
         pass
-    return None, None
+    return None
 
 
-def _umount(mount_point):
-    """Unmount the filesystem so erasing does not fight cached writes."""
+def _list_mounts(vfs):
+    """Return [(fs, mount_point), ...] via ``vfs.mount()`` (like ``mpremote df``)."""
     try:
-        import vfs
+        return list(vfs.mount())
+    except (AttributeError, TypeError):
+        return []
 
-        umount = vfs.umount
-    except Exception:
-        import os
 
-        umount = os.umount
-    for point in (mount_point, "/", "/flash"):
+def _umount(vfs):
+    """Unmount writable filesystems so erasing does not fight cached writes."""
+    points = [point for fs, point in _list_mounts(vfs) if "Rom" not in str(fs)]
+    for point in points + ["/", "/flash"]:
         if not point:
             continue
         try:
-            umount(point)
+            vfs.umount(point)
         except Exception:
             pass
 
@@ -70,11 +95,11 @@ def _erase(bdev):
 
 
 def main():
-    bdev, mount_point = _get_bdev()
+    bdev = _get_bdev()
     if bdev is None:
         print("ERASE: no filesystem block device found")
         return
-    _umount(mount_point)
+    _umount(_vfs())
     try:
         count = _erase(bdev)
     except Exception as exc:

mpflash/mpremoteboard/format_bdev.py

@@ -1,10 +1,11 @@
 # pragma: no cover
 """Reformat the filesystem block device, keeping the board on MicroPython.
 
-Run on the board via ``mpremote run``. It locates the port's filesystem
-``bdev`` (the same one ``_boot.py`` mounts), detects the current filesystem
-type (``VfsLfs2`` or ``VfsFat``) and recreates an empty filesystem of that
-type, then remounts it.
+Run on the board via ``mpremote run``. It discovers the mounted filesystem
+using the same ``vfs.mount()`` enumeration as ``mpremote df`` (so the mount
+point and filesystem type are detected at runtime, not hardcoded per port),
+locates the port's block device, then recreates an empty filesystem of the
+same type and remounts it at the same mount point.
 
 Only the filesystem storage region is reformatted - the firmware itself lives
 in a separate flash region and is left untouched.
@@ -23,50 +24,79 @@ def _vfs():
         return os
 
 
-def _get_bdev():
-    """Return (bdev, mount_point) for the running port, or (None, None)."""
-    try:
-        import rp2
+# (module, attribute, kwargs): the block-device factory each MicroPython port
+# exposes. Instantiated as ``module.attribute(**kwargs)``. Adding a new port is
+# a new entry here, not a port-name check elsewhere.
+_BDEV_FACTORIES = (
+    ("rp2", "Flash", {}),
+    ("samd", "Flash", {}),
+    ("nrf", "Flash", {}),
+    ("mimxrt", "Flash", {}),
+    ("alif", "Flash", {}),
+    ("pyb", "Flash", {"start": 0}),  # stm32
+    ("psoc_edge", "QSPI_Flash", {}),
+)
 
-        return rp2.Flash(), "/"
-    except Exception:
-        pass
-    try:
-        import samd
 
-        return samd.Flash(), "/"
-    except Exception:
-        pass
-    try:
-        import nrf
+def _get_bdev():
+    """Return the internal-flash block device for the running port, or None.
 
-        return nrf.Flash(), "/flash"
-    except Exception:
-        pass
+    Polls the known block-device factories in turn; the first that imports and
+    instantiates wins. esp32 / esp8266 instead expose a ready-made ``bdev``.
+    """
+    for mod_name, attr, kwargs in _BDEV_FACTORIES:
+        try:
+            return getattr(__import__(mod_name), attr)(**kwargs)
+        except Exception:
+            pass
     try:
         from flashbdev import bdev  # esp32 / esp8266
 
-        return bdev, "/"
+        return bdev
     except Exception:
         pass
+    return None
+
+
+def _list_mounts(vfs):
+    """Return [(fs, mount_point), ...] via ``vfs.mount()`` (like ``mpremote df``)."""
     try:
-        import pyb  # stm32
+        return list(vfs.mount())
+    except (AttributeError, TypeError):
+        return []
 
-        return pyb.Flash(start=0), "/"
-    except Exception:
-        pass
-    return None, None
+
+def _target_mount(vfs):
+    """Return (fs, mount_point) for the writable internal filesystem.
+
+    Uses the runtime mount table, skipping the read-only ROM filesystem and
+    removable SD cards. Falls back to probing the usual internal-flash mount
+    points when the mount table cannot be enumerated (older firmware).
+    """
+    for fs, point in _list_mounts(vfs):
+        if "Rom" in str(fs) or point.startswith("/sd"):
+            continue
+        return fs, point
+    import os
+
+    for point in ("/", "/flash"):
+        try:
+            os.statvfs(point)
+            return None, point
+        except OSError:
+            pass
+    return None, "/"
 
 
 def _detect_fs(vfs, bdev):
-    """Detect the current filesystem class, defaulting to the first available.
+    """Probe the block device to detect its filesystem class.
 
     Only Vfs* classes present in this firmware build are considered; some ports
     (for example nrf) are built without ``VfsFat``, so look them up defensively
     to avoid an ``AttributeError``.
     """
     candidates = []
-    for name in ("VfsLfs2", "VfsFat"):
+    for name in ("VfsLfs2", "VfsLfs1", "VfsFat"):
         cls = getattr(vfs, name, None)
         if cls is not None:
             candidates.append(cls)
@@ -79,13 +109,31 @@ def _detect_fs(vfs, bdev):
     return candidates[0] if candidates else None
 
 
+def _fs_class(vfs, fs, bdev):
+    """Return the Vfs* class to recreate.
+
+    Prefers the type of the currently mounted filesystem (from its repr, e.g.
+    ``<VfsLfs2>``), which is the most reliable signal; if there is no mounted
+    filesystem to learn from, probe the block device instead.
+    """
+    if fs is not None:
+        text = str(fs)
+        for name in ("VfsLfs2", "VfsLfs1", "VfsFat"):
+            if name in text:
+                cls = getattr(vfs, name, None)
+                if cls is not None:
+                    return cls
+    return _detect_fs(vfs, bdev)
+
+
 def main():
     vfs = _vfs()
-    bdev, mount_point = _get_bdev()
+    bdev = _get_bdev()
     if bdev is None:
         print("FORMAT: no filesystem block device found")
         return
-    fs_cls = _detect_fs(vfs, bdev)
+    fs, mount_point = _target_mount(vfs)
+    fs_cls = _fs_class(vfs, fs, bdev)
     if fs_cls is None:
         print("FORMAT: no supported filesystem type available")
         return
@@ -97,11 +145,11 @@ def main():
     try:
         if fs_cls is getattr(vfs, "VfsLfs2", None):
             fs_cls.mkfs(bdev, progsize=256)
-            fs = fs_cls(bdev, progsize=256)
+            new_fs = fs_cls(bdev, progsize=256)
         else:
             fs_cls.mkfs(bdev)
-            fs = fs_cls(bdev)
-        vfs.mount(fs, mount_point or "/")
+            new_fs = fs_cls(bdev)
+        vfs.mount(new_fs, mount_point or "/")
     except Exception as exc:
         print("FORMAT: failed:", exc)
         return

tests/flash/test_format_fs.py

@@ -71,6 +71,68 @@ class _VfsBoth:
     assert detect(_VfsBoth(), object()) is _FakeFat
 
 
+def test_fs_class_prefers_mounted_fs_type():
+    """The mounted filesystem's own type wins over probing the block device."""
+
+    class _VfsBoth:
+        VfsLfs2 = _FakeLfs2  # would succeed if probed
+        VfsFat = _FakeFat
+
+    class _MountedFat:
+        def __repr__(self):
+            return "<VfsFat>"
+
+    fs_class = _load_format_bdev_namespace()["_fs_class"]
+    assert fs_class(_VfsBoth(), _MountedFat(), object()) is _FakeFat
+
+
+def test_target_mount_skips_rom_and_sd():
+    """_target_mount returns the writable internal fs, skipping ROM and SD."""
+
+    class _Fs:
+        def __init__(self, name):
+            self._name = name
+
+        def __repr__(self):
+            return self._name
+
+    rom, sd, flash = _Fs("<VfsRom>"), _Fs("<VfsFat>"), _Fs("<VfsLfs2>")
+
+    class _Vfs:
+        @staticmethod
+        def mount():
+            return [(rom, "/rom"), (sd, "/sd"), (flash, "/flash")]
+
+    fs, point = _load_format_bdev_namespace()["_target_mount"](_Vfs())
+    assert (fs, point) == (flash, "/flash")
+
+
+def test_get_bdev_polls_port_factory(monkeypatch):
+    """_get_bdev instantiates the first available port block-device factory."""
+    import sys
+    import types
+
+    sentinel = object()
+    fake = types.ModuleType("mimxrt")
+    fake.Flash = lambda: sentinel
+    monkeypatch.setitem(sys.modules, "mimxrt", fake)
+
+    assert _load_format_bdev_namespace()["_get_bdev"]() is sentinel
+
+
+def test_get_bdev_falls_back_to_flashbdev(monkeypatch):
+    """esp32 / esp8266 expose a ready-made bdev via flashbdev."""
+    import sys
+    import types
+
+    sentinel = object()
+    fake = types.ModuleType("flashbdev")
+    fake.bdev = sentinel
+    monkeypatch.setitem(sys.modules, "flashbdev", fake)
+
+    assert _load_format_bdev_namespace()["_get_bdev"]() is sentinel
+
+
 def _fakeboard(port="rp2", serialport="COM42"):
     board = MPRemoteBoard(serialport)
     board.connected = True