tools/mpremote: Add deploy-mapfs.

Signed-off-by: Damien George <damien@micropython.org>

tools/mpremote/mpremote/commands.py

@@ -6,6 +6,7 @@ import serial.tools.list_ports
 
 from .transport import TransportError
 from .transport_serial import SerialTransport, stdout_write_bytes
+from .mapfs import make_mapfs
 
 
 class CommandError(Exception):
@@ -259,3 +260,46 @@ def do_rtc(state, args):
         _do_execbuffer(state, "import machine; machine.RTC().datetime({})".format(timetuple), True)
     else:
         _do_execbuffer(state, "import machine; print(machine.RTC().datetime())", True)
+
+
+def do_deploy_mapfs(state, args):
+    state.ensure_raw_repl()
+    state.did_action()
+
+    # Detect the mapfs and get its associated device.
+    state.transport.exec("import vfs; mapfs = vfs.mount('/mapfs')")
+    if state.transport.eval("mapfs") == b"None":
+        print("/mapfs does not exist on device")
+        sys.exit(1)
+    if state.transport.eval("mapfs.device()") == b"None":
+        print("/mapfs does not have an associated device")
+        sys.exit(1)
+    state.transport.exec("dev=mapfs.device()")
+    block_count = int(str(state.transport.eval("dev.ioctl(4,0)"), "ascii"))
+    block_size = int(str(state.transport.eval("dev.ioctl(5,0)"), "ascii"))
+    print(
+        f"/mapfs is a block device of size {block_count}*{block_size}={block_count * block_size} bytes"
+    )
+
+    # Create the mapfs filesystem.
+    mapfs = make_mapfs(args.path[0], "/")
+    print(f"Image size is {len(mapfs)} bytes")
+
+    if len(mapfs) > block_count * block_size:
+        print("/mapfs is too small for image")
+        sys.exit(1)
+
+    # Deploy the mapfs filesystem to the device.
+    state.transport.exec(f"buf=bytearray({block_size})")
+    for block in range(0, (len(mapfs) + block_size - 1) // block_size):
+        mapfs_block = mapfs[block * block_size : (block + 1) * block_size]
+        off = 0
+        while off < len(mapfs_block):
+            l = min(len(mapfs_block) - off, 256)
+            state.transport.exec(f"buf[{off}:{off+l}]=" + repr(mapfs_block[off : off + l]))
+            off += l
+        print(f"\rWriting block {block}", end="")
+        state.transport.exec(f"dev.writeblocks({block},buf)")
+
+    print()
+    print("Image deployed")

tools/mpremote/mpremote/main.py

@@ -36,6 +36,7 @@ from .commands import (
     do_resume,
     do_rtc,
     do_soft_reset,
+    do_deploy_mapfs,
 )
 from .mip import do_mip
 from .repl import do_repl
@@ -219,6 +220,12 @@ def argparse_mip():
     return cmd_parser
 
 
+def argparse_deploy_mapfs():
+    cmd_parser = argparse.ArgumentParser(description="deploy a directory to /mapfs on the device")
+    cmd_parser.add_argument("path", nargs=1, help="path to directory to deploy")
+    return cmd_parser
+
+
 def argparse_none(description):
     return lambda: argparse.ArgumentParser(description=description)
 
@@ -293,6 +300,10 @@ _COMMANDS = {
         do_version,
         argparse_none("print version and exit"),
     ),
+    "deploy-mapfs": (
+        do_deploy_mapfs,
+        argparse_deploy_mapfs,
+    ),
 }
 
 # Additional commands aliases.

tools/mpremote/mpremote/mapfs.py

@@ -0,0 +1,110 @@
+# MIT license; Copyright (c) 2022 Damien P. George
+
+import struct, sys, os
+
+
+class VfsMapWriter:
+    MAGIC = b"MF"
+
+    def __init__(self):
+        self.filename = None
+        self.data = bytearray()
+        self.data += VfsMapWriter.MAGIC
+
+    def finalise(self):
+        self.data += b"\x00\x00"
+
+    def open(self, filename, attr):
+        assert self.filename is None
+        assert attr == "wb"
+        self.filename = filename
+        self.filedata = b""
+        return self
+
+    def mkdir(self, dir):
+        assert self.filename is None
+        self.data += struct.pack("<H", 0x8000 | len(dir))
+        self.data += bytes(dir, "ascii")
+
+    def close(self):
+        assert self.filename
+        self.data += struct.pack("<HI", len(self.filename), len(self.filedata))
+        self.data += bytes(self.filename, "ascii")
+        self.data += self.filedata
+        self.filename = None
+
+    def write(self, data):
+        assert self.filename
+        self.filedata += data
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, a, b, c):
+        self.close()
+
+
+def copy_recursively(vfs, src_dir, dest_dir):
+    if dest_dir == "/":
+        dest_dir = ""
+    assert src_dir.endswith("/")
+    assert len(dest_dir) == 0 or dest_dir.endswith("/")
+    DIR = 1 << 14
+    for name in os.listdir(src_dir):
+        if name in (".", ".."):
+            continue
+        src_name = src_dir + name
+        dest_name = dest_dir + name
+        st = os.stat(src_name)
+        if st[0] & DIR:
+            print(" -", dest_name + "/")
+            vfs.mkdir(dest_name)
+            copy_recursively(vfs, src_name + "/", dest_name + "/")
+        else:
+            print(" -", dest_name)
+            with open(src_name, "rb") as src, vfs.open(dest_name, "wb") as dest:
+                dest.write(src.read())
+
+
+def make_mapfs(src_dir, dest_dir):
+    if not src_dir.endswith("/"):
+        src_dir += "/"
+
+    vfs = VfsMapWriter()
+
+    # Build the filesystem recursively.
+    print("Building mapfs filesystem, source directory: {}".format(src_dir))
+    try:
+        copy_recursively(vfs, src_dir, dest_dir)
+    except OSError as er:
+        if er.args[0] == 28:  # ENOSPC
+            print("Error: not enough space on filesystem", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print("Error: OSError {}".format(er.args[0]), file=sys.stderr)
+            sys.exit(1)
+
+    vfs.finalise()
+
+    return vfs.data
+
+
+def main():
+    if len(sys.argv) != 2:
+        print("usage: {} <dir>".format(sys.argv[0]), file=sys.stderr)
+        sys.exit(1)
+
+    # Parse arguments.
+    dir = sys.argv[1]
+
+    mapfs = make_mapfs(dir, "/")
+
+    # Save the block device data.
+    output = dir.rstrip("/") + ".mapfs"
+    print("Writing filesystem image to {}".format(output))
+    with open(output, "wb") as f:
+        f.write(mapfs)
+
+
+if __name__ == "__main__":
+    main()