From 6e7b0ad879fb06973476104204e6efe2085678e5 Mon Sep 17 00:00:00 2001
From: Patryk Kubiak <patryk.kubiak90@gmail.com>
Date: Wed, 30 Sep 2026 13:13:47 +0200
Subject: [PATCH 1/2] Add the automount service; FAT and exFAT are mounted by
 dmfatfs

dmblkid now reports vfat and exfat with module "dmfatfs" and as
mountable, now that dmfatfs mounts them straight from a node.

services/automount: one instance per block node dmdevfs reports
([class=block] start=automount@%name). It probes the node with dmblkid
and mounts a mountable file system at /mnt/<volume label>, or at
/mnt/<node name> when the volume has no label or that path is taken.
Characters that do not belong in a path or a shell word become '_'. A
partition table, unknown contents or dmffs leave it with nothing to do
(exit 0); a mounted instance waits for its stop (node removed, or
"service stop") and unmounts. Picking the path and mounting happen under
a lock shared by all instances; only /mnt itself is created, as dmvfs
needs no directory under a mount point.

The mount logic (automount.c) is tested on the host with a fake tree and
images probed by the real dmblkid (test_automount).

CI: clone dmod for dmod_loader into a fresh directory - the dmod:1.0.4
image already has a /tmp/dmod, which made the step fail on main - and run
test_automount.

Tested on STM32F746G-DISCO: the card's partition was mounted at boot, the
whole-medium instance exited, "service stop" unmounted it (the node could
be mounted by hand again), "service start" mounted it again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                   |  17 +-
 CMakeLists.txt                             |   3 +
 README.md                                  |  18 +-
 docs/api-reference.md                      |  12 +-
 include/dmblkid.h                          |   4 +-
 manifest.dmm                               |   4 +
 services/automount/CMakeLists.txt          |  26 ++
 services/automount/README.md               |  92 +++++++
 services/automount/automount.dmr           |  25 ++
 services/automount/configs/automount.rules |  11 +
 services/automount/configs/automount@.ini  |  20 ++
 services/automount/src/automount.c         | 226 ++++++++++++++++++
 services/automount/src/automount.h         |  85 +++++++
 services/automount/src/main.c              | 140 +++++++++++
 services/blkid/README.md                   |   2 +-
 services/blkid/src/main.c                  |   2 +-
 src/dmblkid_exfat.c                        |   2 +-
 src/dmblkid_fat.c                          |   2 +-
 tests/CMakeLists.txt                       |  43 +++-
 tests/automount_test.c                     | 265 +++++++++++++++++++++
 tests/dmblkid_test.c                       |  14 +-
 21 files changed, 978 insertions(+), 35 deletions(-)
 create mode 100644 services/automount/CMakeLists.txt
 create mode 100644 services/automount/README.md
 create mode 100644 services/automount/automount.dmr
 create mode 100644 services/automount/configs/automount.rules
 create mode 100644 services/automount/configs/automount@.ini
 create mode 100644 services/automount/src/automount.c
 create mode 100644 services/automount/src/automount.h
 create mode 100644 services/automount/src/main.c
 create mode 100644 tests/automount_test.c

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 45a92df..16ec90b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,19 +36,23 @@ jobs:
           test -f build/dmf/blkid.dmf
           test -f build/dmf/dmpart.dmf
           test -f build/dmf/test_dmpart.dmf
+          test -f build/dmf/automount.dmf
+          test -f build/dmf/test_automount.dmf
           echo "Module files present"
 
       # dmblkid uses the 64-bit file API (Dmod_FileSeek/_FileTell/_FileSize
       # 2.0, dmod#312). The dmod_loader in the 1.0.4 image predates it, so
       # the tests run in one built from the same dmod develop the module
-      # is built against.
+      # is built against. Cloned into a fresh directory: the image already
+      # has a /tmp/dmod of its own.
       - name: Build dmod_loader from dmod develop
         run: |
-          git clone --depth 1 -b develop https://github.com/choco-technologies/dmod.git /tmp/dmod
-          cmake -S /tmp/dmod -B /tmp/dmod/build -DDMOD_MODE=DMOD_SYSTEM \
+          DMOD_SRC=$(mktemp -d)
+          git clone --depth 1 -b develop https://github.com/choco-technologies/dmod.git "$DMOD_SRC"
+          cmake -S "$DMOD_SRC" -B "$DMOD_SRC/build" -DDMOD_MODE=DMOD_SYSTEM \
             -DDMOD_BUILD_EXAMPLES=ON -DDMOD_BUILD_TESTS=OFF
-          cmake --build /tmp/dmod/build --target dmod_loader
-          echo "DMOD_LOADER=/tmp/dmod/build/examples/system/dmod_loader/dmod_loader" >> $GITHUB_ENV
+          cmake --build "$DMOD_SRC/build" --target dmod_loader
+          echo "DMOD_LOADER=$DMOD_SRC/build/examples/system/dmod_loader/dmod_loader" >> $GITHUB_ENV
 
       - name: Run tests with dmod_loader
         run: |
@@ -57,6 +61,8 @@ jobs:
           ${DMOD_LOADER} build/dmf/test_dmpart.dmf
           dmf-get install -d ${DMOD_DMF_DIR}/test_dmblkid-local.dmd -y
           ${DMOD_LOADER} build/dmf/test_dmblkid.dmf
+          dmf-get install -d ${DMOD_DMF_DIR}/test_automount-local.dmd -y
+          ${DMOD_LOADER} build/dmf/test_automount.dmf
 
   build-targets:
     name: Build for ${{ matrix.arch }}
@@ -87,3 +93,4 @@ jobs:
           test -f dmf/dmblkid.dmf
           test -f dmf/blkid.dmf
           test -f dmf/dmpart.dmf
+          test -f dmf/automount.dmf
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 855475b..fb2c958 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -91,5 +91,8 @@ add_subdirectory(libs/dmpart)
 # blkid - command line front end
 add_subdirectory(services/blkid)
 
+# automount - mounts block nodes as dmdevfs reports them
+add_subdirectory(services/automount)
+
 enable_testing()
 add_subdirectory(tests)
diff --git a/README.md b/README.md
index 4380a81..042f9d7 100644
--- a/README.md
+++ b/README.md
@@ -24,9 +24,10 @@ prints it.
 | blank, damaged or unsupported | `unknown` | - | size |
 
 Every type is mapped to the DMOD filesystem module that handles it and
-whether that module can mount the node. Today none can: FAT and exFAT have
-no module yet, and dmffs mounts memory-mapped flash rather than a node - so
-they are reported, but marked not mountable.
+whether that module can mount the node: FAT and exFAT are mounted by
+[dmfatfs](https://github.com/choco-technologies/dmfatfs) from the node
+itself; dmffs is reported, but marked not mountable - it mounts
+memory-mapped flash rather than a node.
 
 Detection is strict, so that nothing is mounted by mistake:
 
@@ -72,11 +73,18 @@ The command line front end:
 ```
 > blkid /dev/dmsdio0/0 /dev/dmsdio0/0p1
 /dev/dmsdio0/0: PTTYPE="mbr" PTUUID="1a2b3c4d" PARTITIONS="1" BLOCK_SIZE="512" SIZE="15931539456"
-/dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="SDCARD" UUID="CAFE-BABE" SIZE="15930490880" MOUNTABLE="no"
+/dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="SDCARD" UUID="CAFE-BABE" SIZE="15930490880" MODULE="dmfatfs" MOUNTABLE="yes"
 ```
 
 See [services/blkid/README.md](services/blkid/README.md).
 
+### Automount
+
+The `automount` service mounts every block node dmdevfs reports that holds
+a mountable file system, at `/mnt/<volume label>` (or `/mnt/<node name>`
+when there is no label or it is taken), and unmounts it when the node goes
+away. See [services/automount/README.md](services/automount/README.md).
+
 ## API
 
 | Function | Description |
@@ -174,6 +182,7 @@ dmblkid/
 ├── libs/
 │   └── dmpart/            # dmpart - MBR/GPT parser library (also used by dmdevfs)
 ├── services/
+│   ├── automount/         # automount service (mounts block nodes under /mnt)
 │   └── blkid/             # blkid command line application
 ├── src/
 │   ├── dmblkid.c          # dmblkid_probe(), result accessors
@@ -187,6 +196,7 @@ dmblkid/
 ├── tests/
 │   ├── CMakeLists.txt
 │   ├── dmblkid_test.c
+│   ├── automount_test.c   # automount service logic
 │   └── test_images.c      # Image builders
 ├── CMakeLists.txt
 ├── Makefile
diff --git a/docs/api-reference.md b/docs/api-reference.md
index 6b70f95..55b22f1 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -123,9 +123,9 @@ const char* dmblkid_get_uuid(const dmblkid_t* result);
 const char* dmblkid_get_module(const dmblkid_t* result);
 ```
 
-The DMOD filesystem module that handles the type: `"dmffs"` for dmffs.
-`NULL` for types the ecosystem has no module for yet (FAT, exFAT), for
-partition tables and for unknown contents.
+The DMOD filesystem module that handles the type: `"dmfatfs"` for FAT and
+exFAT, `"dmffs"` for dmffs. `NULL` for partition tables and for unknown
+contents.
 
 ### `dmblkid_is_mountable`
 
@@ -133,9 +133,9 @@ partition tables and for unknown contents.
 bool dmblkid_is_mountable(const dmblkid_t* result);
 ```
 
-`true` only if `dmblkid_get_module()` can mount the node itself. `false` for
-dmffs: its module mounts memory-mapped flash (`flash_addr`/`flash_size`), not
-a node.
+`true` only if `dmblkid_get_module()` can mount the node itself - FAT and
+exFAT (`dmvfs_mount_fs("dmfatfs", <dir>, <node>)`). `false` for dmffs: its
+module mounts memory-mapped flash (`flash_addr`/`flash_size`), not a node.
 
 ### `dmblkid_get_size`
 
diff --git a/include/dmblkid.h b/include/dmblkid.h
index 4a46a23..2de2f94 100644
--- a/include/dmblkid.h
+++ b/include/dmblkid.h
@@ -76,8 +76,8 @@ dmod_dmblkid_api(1.0, const char*, _get_label, ( const dmblkid_t* result ));
 dmod_dmblkid_api(1.0, const char*, _get_uuid, ( const dmblkid_t* result ));
 
 /**
- * @return Name of the DMOD filesystem module that handles this format, or
- *         NULL if the ecosystem has none (FAT, exFAT today).
+ * @return Name of the DMOD filesystem module that handles this format
+ *         ("dmfatfs" for FAT/exFAT, "dmffs"), or NULL if there is none.
  */
 dmod_dmblkid_api(1.0, const char*, _get_module, ( const dmblkid_t* result ));
 
diff --git a/manifest.dmm b/manifest.dmm
index 44e55c6..d6aafda 100644
--- a/manifest.dmm
+++ b/manifest.dmm
@@ -8,6 +8,10 @@ dmblkid https://github.com/choco-technologies/dmblkid/releases/download/v<versio
 # with dmblkid
 blkid https://github.com/choco-technologies/dmblkid/releases/download/v<version>/blkid-v<version>-<arch_name>.zip
 
+# automount - mount service for block nodes (services/automount), built and
+# released together with dmblkid
+automount https://github.com/choco-technologies/dmblkid/releases/download/v<version>/automount-v<version>-<arch_name>.zip
+
 # dmpart - partition table parser library (libs/dmpart), used by dmblkid and
 # dmdevfs; built and released together with dmblkid
 dmpart https://github.com/choco-technologies/dmblkid/releases/download/v<version>/dmpart-v<version>-<arch_name>.zip
diff --git a/services/automount/CMakeLists.txt b/services/automount/CMakeLists.txt
new file mode 100644
index 0000000..ae96233
--- /dev/null
+++ b/services/automount/CMakeLists.txt
@@ -0,0 +1,26 @@
+# =====================================================================
+#               automount - mount service for block nodes
+# =====================================================================
+# Mounts every block node dmdevfs reports that holds a mountable file
+# system, started per node by libsystemd - see README.md.
+set(DMOD_MODULE_NAME        automount)
+set(DMOD_AUTHOR_NAME        "Patryk Kubiak")
+set(DMOD_STACK_SIZE         2048)
+set(DMOD_PRIORITY           0)
+set(DMOD_DMR_PATH           ${CMAKE_CURRENT_SOURCE_DIR}/automount.dmr)
+
+dmod_add_executable(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
+    src/main.c
+    src/automount.c
+)
+
+target_include_directories(${DMOD_MODULE_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
+
+dmod_link_modules(${DMOD_MODULE_NAME}
+    dmosi
+    libsystemd
+)
diff --git a/services/automount/README.md b/services/automount/README.md
new file mode 100644
index 0000000..12a90d5
--- /dev/null
+++ b/services/automount/README.md
@@ -0,0 +1,92 @@
+# automount
+
+Mount service for block nodes: one instance per node dmdevfs reports as a
+block device (a whole medium or one of its partitions). If the node holds a
+file system that a DMOD module can mount from a node - FAT and exFAT through
+[dmfatfs](https://github.com/choco-technologies/dmfatfs) today - it is
+mounted under `/mnt` for as long as the node exists.
+
+```
+> ls /mnt
+bootfs  dmsdio0_0p2
+> ls /mnt/bootfs
+config.txt  cmdline.txt  overlays  ...
+```
+
+## How it runs
+
+1. dmdevfs reports every block node to libsystemd as class `block`, e.g.
+   `("block", "dmsdio0_0p1", "/dev/dmsdio0/0p1")`.
+2. The `[class=block]` rule in [`configs/automount.rules`](configs/automount.rules)
+   starts `automount@dmsdio0_0p1` from [`configs/automount@.ini`](configs/automount@.ini)
+   with the node path and the node name as arguments.
+3. automount probes the node with dmblkid:
+   - **mountable file system** - mounted with the module dmblkid names
+     (`dmblkid_get_module()`) at `/mnt/<label>`, or at `/mnt/<node name>`
+     when the volume has no label or `/mnt/<label>` is already taken (a
+     second card with the same label, a manual mount, a file, ...);
+   - **anything else** - a partition table (its partitions get instances of
+     their own), unknown contents, dmffs (it mounts flash, not nodes) -
+     nothing to do: automount exits with 0.
+4. A mounted instance sleeps until it is stopped - the node went away (card
+   removed; dmdevfs removes the partition nodes before the medium) or
+   `service stop automount@<name>` - then unmounts the volume and exits.
+
+In the label, every character that does not belong in a path or a shell
+word - control characters, space, `/`, `\`, `;`, `|`, `&`, `<`, `>`, quotes,
+`` ` ``, `$`, `*`, `?` - becomes `_` (`My Card` -> `/mnt/My_Card`). A label
+that is only such characters, `.` or `..` counts as no label.
+
+Picking the directory and mounting there happen under a lock shared by all
+instances, so two volumes never end up at the same path. Only `/mnt` itself
+is created: dmvfs needs no directory under a mount point, so an unmounted
+volume leaves nothing behind.
+
+A whole medium and its partition are never both mounted: a medium with a
+partition table is left to its partitions, and dmfatfs refuses a node that
+overlaps one already in use anyway.
+
+## Stopping
+
+automount registers a semaphore with `libsystemd_set_stop_semaphore()`: a
+stop wakes it, it unmounts and returns from `main()`. The unit sets
+`stop_timeout_ms=5000` for the unmount to write back what the file system
+still caches; if the instance has to be killed, a process exit callback
+still unmounts the volume.
+
+Remove a card only after its volumes are unmounted (`service stop
+automount@<name>`): data a file system has not written back yet is lost
+otherwise.
+
+## Exit status and restarts
+
+automount exits with 0 when there is nothing to mount, when the node does
+not exist or cannot be mounted (logged), and after a stop. It only fails
+(`-ENOMEM`) on resource shortage. The unit does not restart it
+(`restart=no`) and is `type=oneshot`, so an exit with nothing to mount is
+logged as information rather than a warning.
+
+## Installing
+
+Copy [`configs/automount.rules`](configs/automount.rules) into libsystemd's
+rules directory and [`configs/automount@.ini`](configs/automount@.ini) into
+its units directory. Both ship in the automount package under `configs/`;
+with dmod-boot, list the module as:
+
+```
+automount service=automount@.ini
+automount rules=automount.rules
+```
+
+The file system modules (e.g. `dmfatfs`) must be available to be loaded.
+
+## Usage
+
+```
+automount <node> <name> [<base dir>]
+```
+
+Not meant to be started by hand: `<node>` is the absolute path of the block
+node (e.g. `/dev/dmsdio0/0p1`), `<name>` the directory used when the label
+cannot be (e.g. `dmsdio0_0p1`), `<base dir>` the directory volumes are
+mounted in (default `/mnt`).
diff --git a/services/automount/automount.dmr b/services/automount/automount.dmr
new file mode 100644
index 0000000..c773c7c
--- /dev/null
+++ b/services/automount/automount.dmr
@@ -0,0 +1,25 @@
+# DMOD Resource File for automount
+# This file specifies where resources should be installed
+
+# === Core Module ===
+dmf=./${module}.dmf => ${destination}/${module}.dmf [origin=${dmf_dir}/${module}.dmf]
+dmfc=./${module}.dmfc => ${destination}/${module}.dmfc [origin=${build_dir}/dmfc/${module}.dmfc]
+dmd=./${module}.dmd => ${destination}/${module}.dmd [origin=${dmf_dir}/${module}.dmd]
+version=./${module}_version.txt => ${destination}/${module}_version.txt [origin=${dmf_dir}/${module}_version.txt]
+
+# === Documentation ===
+# NOTE: ${repo_dir} is the top-level repo root (automount is built through
+# add_subdirectory() from dmblkid's CMakeLists.txt), so paths are relative to
+# the repo root, not to services/automount.
+readme=./README.md => ${destination}/${module}/README.md [origin=${repo_dir}/services/automount/README.md]
+
+# === Configuration Files ===
+# automount@.ini unit template + automount.rules device rule, ready to drop into
+# libsystemd's units/rules directories - see README.md
+configs=./configs => ${destination}/${module}/configs [origin=${repo_dir}/services/automount/configs]
+
+# === License ===
+license=./LICENSE => ${destination}/${module}/LICENSE [origin=${repo_dir}/LICENSE]
+
+# Adding itself
+dmr=./${module}.dmr => ${destination}/${module}/${module}.dmr [origin=${repo_dir}/services/automount/${module}.dmr]
diff --git a/services/automount/configs/automount.rules b/services/automount/configs/automount.rules
new file mode 100644
index 0000000..e047c85
--- /dev/null
+++ b/services/automount/configs/automount.rules
@@ -0,0 +1,11 @@
+; automount.rules - libsystemd device rule.
+;
+; dmdevfs reports every block node - whole media and their partitions -
+; under class "block", named after the node path ("/dmsdio0/0p1" ->
+; "dmsdio0_0p1"), with the node's absolute path as the user value. Start one
+; automount@<name> instance for each, instantiated on demand from
+; automount@.ini; the removal of the node stops it (and unmounts it) again.
+;
+; Load with libsystemd_load_rules() on the directory this file lives in.
+[class=block]
+start=automount@%name
diff --git a/services/automount/configs/automount@.ini b/services/automount/configs/automount@.ini
new file mode 100644
index 0000000..abd76e0
--- /dev/null
+++ b/services/automount/configs/automount@.ini
@@ -0,0 +1,20 @@
+; automount@.ini - libsystemd unit template, instantiated once per block node
+; by the [class=block] rule in automount.rules.
+;
+; %i expands to the node's name (e.g. "dmsdio0_0p1"), %v to its absolute path
+; (e.g. "/dev/dmsdio0/0p1"). A third argument would replace the base
+; directory the volumes are mounted in (default /mnt).
+;
+; automount exits with 0 right away when there is nothing to mount (a
+; partition table, unknown contents) and stays running while the volume is
+; mounted; the removal of the node stops it, which unmounts the volume.
+; type=oneshot only makes libsystemd log such a clean exit as information
+; rather than a warning - stopping a running instance works the same.
+;
+; stop_timeout_ms: the unmount writes back what the file system still caches.
+description=Automount for %i
+exec=automount
+args=%v %i
+type=oneshot
+restart=no
+stop_timeout_ms=5000
diff --git a/services/automount/src/automount.c b/services/automount/src/automount.c
new file mode 100644
index 0000000..4e561c3
--- /dev/null
+++ b/services/automount/src/automount.c
@@ -0,0 +1,226 @@
+/**
+ * @file automount.c
+ * @brief Mount logic of the automount service
+ */
+#include "dmod.h"
+#include "dmblkid.h"
+#include "automount.h"
+#include <errno.h>
+#include <string.h>
+
+#define AUTOMOUNT_MAGIC     0x41554D54u     /* 'AUMT' */
+
+struct automount
+{
+    uint32_t        magic;
+    automount_ops_t ops;
+    char*           dir;        /**< Mount directory, owned */
+};
+
+/* What was found on the node: the module to mount it with and its label. */
+typedef struct
+{
+    char*   module;
+    char*   label;      /**< NULL if the volume has none */
+} volume_t;
+
+static bool is_valid(const automount_t* mount)
+{
+    return mount != NULL && mount->magic == AUTOMOUNT_MAGIC;
+}
+
+static bool is_unsafe(unsigned char c)
+{
+    static const char unsafe[] = " /\\;|&<>\"'`$*?";
+    return c < 0x20u || c == 0x7Fu || strchr(unsafe, c) != NULL;
+}
+
+char* automount_label_to_name(const char* label)
+{
+    if (label == NULL || strcmp(label, ".") == 0 || strcmp(label, "..") == 0)
+    {
+        return NULL;
+    }
+    char* name = Dmod_StrDup(label);
+    bool  kept = false;
+    for (char* c = name; c != NULL && *c != '\0'; c++)
+    {
+        bool unsafe = is_unsafe((unsigned char)*c);
+        *c   = unsafe ? '_' : *c;
+        kept = kept || !unsafe;
+    }
+    if (name != NULL && !kept)
+    {
+        Dmod_Free(name);
+        name = NULL;
+    }
+    return name;
+}
+
+const char* automount_get_dir(const automount_t* mount)
+{
+    return is_valid(mount) ? mount->dir : NULL;
+}
+
+static void free_volume(volume_t* volume)
+{
+    if (volume->module != NULL)
+    {
+        Dmod_Free(volume->module);
+    }
+    if (volume->label != NULL)
+    {
+        Dmod_Free(volume->label);
+    }
+}
+
+/* 1: mountable volume found, 0: nothing to mount, negative errno: failure. */
+static int probe_volume(const char* node, volume_t* volume)
+{
+    dmblkid_t* result = NULL;
+    int ret = dmblkid_probe(node, &result);
+    if (ret != 0)
+    {
+        return ret;
+    }
+    ret = 0;
+    if (dmblkid_is_mountable(result))
+    {
+        const char* label = dmblkid_get_label(result);
+        volume->module = Dmod_StrDup(dmblkid_get_module(result));
+        volume->label  = (label != NULL) ? automount_label_to_name(label) : NULL;
+        ret = (volume->module != NULL && (label == NULL || volume->label != NULL)) ? 1 : -ENOMEM;
+    }
+    else
+    {
+        DMOD_LOG_INFO("automount: nothing to mount on %s (%s)\n", node,
+                      (dmblkid_get_type(result) != NULL) ? dmblkid_get_type(result) : "unknown contents");
+    }
+    dmblkid_destroy(result);
+    return ret;
+}
+
+/* "<base_dir>/<name>" on the heap */
+static char* join_path(const char* base_dir, const char* name)
+{
+    size_t base_length = strlen(base_dir);
+    char*  path        = Dmod_Malloc(base_length + strlen(name) + 2);
+    if (path != NULL)
+    {
+        memcpy(path, base_dir, base_length);
+        path[base_length] = '/';
+        strcpy(&path[base_length + 1], name);
+    }
+    return path;
+}
+
+/* Mount at <base_dir>/<name> - or -EBUSY if it is taken. Under the lock. */
+static int mount_at(const automount_ops_t* ops, const volume_t* volume, const char* node,
+                    const char* base_dir, const char* name, char** dir)
+{
+    *dir = join_path(base_dir, name);
+    if (*dir == NULL)
+    {
+        return -ENOMEM;
+    }
+    int ret = ops->exists(*dir) ? -EBUSY : ops->mount(volume->module, *dir, node);
+    if (ret != 0)
+    {
+        Dmod_Free(*dir);
+        *dir = NULL;
+    }
+    return ret;
+}
+
+/* The label directory first, then the node name if the label is missing or taken. */
+static int mount_volume(const automount_ops_t* ops, const volume_t* volume, const char* node,
+                        const char* name, const char* base_dir, char** dir)
+{
+    ops->lock();
+    int ret = ops->exists(base_dir) ? 0 : ops->make_dir(base_dir);
+    if (ret == 0)
+    {
+        ret = (volume->label != NULL) ? mount_at(ops, volume, node, base_dir, volume->label, dir) : -EBUSY;
+        if (ret == -EBUSY)
+        {
+            ret = mount_at(ops, volume, node, base_dir, name, dir);
+        }
+    }
+    ops->unlock();
+    return ret;
+}
+
+static bool valid_arguments(const automount_ops_t* ops, const char* node, const char* name, const char* base_dir)
+{
+    return ops != NULL && ops->mount != NULL && ops->unmount != NULL && ops->exists != NULL &&
+           ops->make_dir != NULL && ops->lock != NULL && ops->unlock != NULL &&
+           node != NULL && name != NULL && base_dir != NULL && name[0] != '\0' && strchr(name, '/') == NULL;
+}
+
+static automount_t* create_mount(const automount_ops_t* ops, char* dir)
+{
+    automount_t* mount = Dmod_Malloc(sizeof(automount_t));
+    if (mount == NULL)
+    {
+        return NULL;
+    }
+    mount->magic = AUTOMOUNT_MAGIC;
+    mount->ops   = *ops;
+    mount->dir   = dir;
+    return mount;
+}
+
+static void release_dir(const automount_ops_t* ops, char* dir)
+{
+    ops->lock();
+    int ret = ops->unmount(dir);
+    ops->unlock();
+    if (ret != 0)
+    {
+        DMOD_LOG_ERROR("automount: cannot unmount %s (%d)\n", dir, ret);
+    }
+    Dmod_Free(dir);
+}
+
+automount_t* automount_create(const automount_ops_t* ops, const char* node, const char* name,
+                              const char* base_dir, int* error)
+{
+    int      unused;
+    int*     status = (error != NULL) ? error : &unused;
+    volume_t volume = { 0 };
+    char*    dir    = NULL;
+    if (!valid_arguments(ops, node, name, base_dir))
+    {
+        *status = -EINVAL;
+        return NULL;
+    }
+    *status = probe_volume(node, &volume);
+    if (*status == 1)
+    {
+        *status = mount_volume(ops, &volume, node, name, base_dir, &dir);
+        if (*status == 0)
+        {
+            DMOD_LOG_INFO("automount: %s mounted at %s (%s)\n", node, dir, volume.module);
+        }
+    }
+    free_volume(&volume);
+    automount_t* mount = (dir != NULL) ? create_mount(ops, dir) : NULL;
+    if (dir != NULL && mount == NULL)
+    {
+        release_dir(ops, dir);
+        *status = -ENOMEM;
+    }
+    return mount;
+}
+
+void automount_destroy(automount_t* mount)
+{
+    if (!is_valid(mount))
+    {
+        return;
+    }
+    mount->magic = 0;
+    DMOD_LOG_INFO("automount: unmounting %s\n", mount->dir);
+    release_dir(&mount->ops, mount->dir);
+    Dmod_Free(mount);
+}
diff --git a/services/automount/src/automount.h b/services/automount/src/automount.h
new file mode 100644
index 0000000..95539cb
--- /dev/null
+++ b/services/automount/src/automount.h
@@ -0,0 +1,85 @@
+#ifndef AUTOMOUNT_H
+#define AUTOMOUNT_H
+
+#include <stdbool.h>
+
+/**
+ * @file automount.h
+ * @brief Mount logic of the automount service (see automount.c)
+ *
+ * Private to the service: main.c runs it with dmvfs and the file API, the
+ * tests with recording fakes. Everything that touches the file system tree
+ * goes through automount_ops_t, only the probe (dmblkid) is called
+ * directly.
+ */
+
+/** How automount reaches the file system tree. All members are required. */
+typedef struct
+{
+    /** Mount @p node with file system module @p module at @p dir: 0 or a negative errno. */
+    int  (*mount)(const char* module, const char* dir, const char* node);
+    /** Unmount @p dir: 0 or a negative errno. */
+    int  (*unmount)(const char* dir);
+    /** Whether anything (a file, a directory, a mount) exists at @p path. */
+    bool (*exists)(const char* path);
+    /** Create directory @p path: 0 or a negative errno. */
+    int  (*make_dir)(const char* path);
+    /**
+     * Lock shared by every automount instance: picking a free directory
+     * and mounting there happen under it, so two instances never take
+     * the same one.
+     */
+    void (*lock)(void);
+    void (*unlock)(void);
+} automount_ops_t;
+
+typedef struct automount automount_t;
+
+/**
+ * @brief Mount @p node if it holds a file system a module can mount
+ *
+ * Probes the node with dmblkid. For a mountable file system the mount
+ * directory is <base_dir>/<volume label>, or <base_dir>/<name> when the
+ * volume has no label or <base_dir>/<label> is already taken (by another
+ * volume with the same label, or anything else). Characters that do not
+ * belong in a path or a shell word are replaced with '_' in the label.
+ * Only <base_dir> is created if missing: dmvfs needs no directory under a
+ * mount point, so nothing is left behind once it is unmounted.
+ *
+ * @param ops       Tree access; copied.
+ * @param node      Device node, e.g. "/dev/dmsdio0/0p1"
+ * @param name      Fallback directory name, e.g. "dmsdio0_0p1"
+ * @param base_dir  Directory the volumes are mounted in, e.g. "/mnt"
+ * @param error     Receives 0 when there is nothing to mount (partition
+ *                  table, unknown contents, file system without a module
+ *                  that mounts nodes), otherwise a negative errno value:
+ *                  the probe error (e.g. -ENOENT), -EBUSY (no free
+ *                  directory), the mount error, or -ENOMEM.
+ * @return The mount, or NULL when nothing was mounted.
+ */
+automount_t* automount_create(const automount_ops_t* ops, const char* node, const char* name,
+                              const char* base_dir, int* error);
+
+/**
+ * @brief Unmount and release the mount
+ *
+ * Safe with NULL. Also safe from a process exit callback after the thread
+ * of the service was killed.
+ */
+void automount_destroy(automount_t* mount);
+
+/** @return The mount directory, e.g. "/mnt/BOOT"; NULL for an invalid mount. */
+const char* automount_get_dir(const automount_t* mount);
+
+/**
+ * @brief Directory name for a volume label
+ *
+ * @return The label with every character that does not belong in a path or
+ *         a shell word (control characters, space, '/', '\\', ';', '|', '&',
+ *         '<', '>', quotes, '`', '$', '*', '?') replaced with '_', on the
+ *         heap; NULL for no label, a label that is only such characters,
+ *         "." or "..", or on allocation failure.
+ */
+char* automount_label_to_name(const char* label);
+
+#endif // AUTOMOUNT_H
diff --git a/services/automount/src/main.c b/services/automount/src/main.c
new file mode 100644
index 0000000..9009c56
--- /dev/null
+++ b/services/automount/src/main.c
@@ -0,0 +1,140 @@
+#include "dmod.h"
+#include "dmosi.h"
+#include "libsystemd.h"
+#include "automount.h"
+#include <errno.h>
+
+/*
+ * automount <node> <name> [<base dir>] - mount service for one block node.
+ *
+ * dmdevfs reports every block node (whole media and partitions) to
+ * libsystemd as class "block"; the [class=block] rule in
+ * configs/automount.rules starts automount@<name> from
+ * configs/automount@.ini with the node path and the node name. The service
+ * mounts the node if it holds a mountable file system, waits until it is
+ * stopped (the node went away, or "service stop"), then unmounts it. The
+ * mount logic is in automount.c.
+ */
+
+#define DEFAULT_BASE_DIR    "/mnt"
+#define DIR_MODE            0755
+
+/*
+ * dmvfs is built into the firmware (it is not a module), its API is
+ * resolved from the system like the rest of the built-in API.
+ */
+DMOD_BUILTIN_API( dmvfs, 1.0, bool, _mount_fs, (const char* fs_name, const char* mount_point, const char* config) );
+DMOD_BUILTIN_API( dmvfs, 1.0, bool, _unmount_fs, (const char* mount_point) );
+
+/* Shared by every running instance - they all run this one loaded module. */
+static void* g_lock;
+
+int dmod_init(const Dmod_Config_t* Config)
+{
+    (void)Config;
+    g_lock = Dmod_Mutex_New(false);
+    return (g_lock != NULL) ? 0 : -ENOMEM;
+}
+
+int dmod_deinit(void)
+{
+    if (g_lock != NULL)
+    {
+        Dmod_Mutex_Delete(g_lock);
+        g_lock = NULL;
+    }
+    return 0;
+}
+
+static int  op_mount(const char* module, const char* dir, const char* node) { return dmvfs_mount_fs(module, dir, node) ? 0 : -EIO; }
+static int  op_unmount(const char* dir)     { return dmvfs_unmount_fs(dir) ? 0 : -EIO; }
+static bool op_exists(const char* path)     { return Dmod_Access(path, 0) == 0; }
+static int  op_make_dir(const char* path)   { return (Dmod_MakeDir(path, DIR_MODE) == 0) ? 0 : -EIO; }
+static void op_lock(void)                   { Dmod_Mutex_Lock(g_lock); }
+static void op_unlock(void)                 { Dmod_Mutex_Unlock(g_lock); }
+
+/* Only reached when the unit had to be killed: main() never returned. */
+static void on_killed(dmosi_process_t process, int exit_status, void* arg)
+{
+    (void)process;
+    (void)exit_status;
+    automount_destroy((automount_t*)arg);
+}
+
+static void print_usage(const char* prog)
+{
+    Dmod_Printf("Usage: %s <node> <name> [<base dir>]\n", prog);
+    Dmod_Printf("\n");
+    Dmod_Printf("Mount service for one block node (e.g. /dev/dmsdio0/0p1): mounts the file\n");
+    Dmod_Printf("system on it at <base dir>/<label> (<base dir>/<name> if the volume has no\n");
+    Dmod_Printf("label or it is taken; <base dir> defaults to " DEFAULT_BASE_DIR ") until stopped.\n");
+    Dmod_Printf("Normally started by libsystemd from automount@.ini for every node dmdevfs\n");
+    Dmod_Printf("reports as \"block\".\n");
+}
+
+/* Sleep until libsystemd asks the service to stop. */
+static int wait_for_stop(void)
+{
+    dmosi_semaphore_t wakeup = dmosi_semaphore_create(0, 1);
+    if (wakeup == NULL)
+    {
+        return -ENOMEM;
+    }
+    int ret = libsystemd_set_stop_semaphore(wakeup);
+    if (ret == 0)
+    {
+        while (!libsystemd_stop_requested())
+        {
+            dmosi_semaphore_wait(wakeup, 1, -1);
+        }
+        libsystemd_set_stop_semaphore(NULL);
+    }
+    else
+    {
+        DMOD_LOG_ERROR("automount: cannot register for stop requests (%d)\n", ret);
+    }
+    dmosi_semaphore_destroy(wakeup);
+    return ret;
+}
+
+static int run(automount_t* mount)
+{
+    dmosi_process_t self = dmosi_process_current();
+    dmosi_process_exit_callback_handle_t killed =
+        (self != NULL) ? dmosi_process_register_exit_callback(self, on_killed, mount) : NULL;
+    if (killed == NULL)
+    {
+        DMOD_LOG_ERROR("automount: cannot register exit callback\n");
+        return -ENOMEM;
+    }
+    int ret = wait_for_stop();
+    dmosi_process_unregister_exit_callback(self, killed);
+    return ret;
+}
+
+int main(int argc, char* argv[])
+{
+    if (argc < 3 || argv[1][0] == '\0' || argv[2][0] == '\0')
+    {
+        print_usage(argv[0]);
+        return -EINVAL;
+    }
+    /* Filled at run time: a constant initializer could become a pointer table in data, which the loader does not relocate. */
+    automount_ops_t ops;
+    ops.mount      = op_mount;
+    ops.unmount    = op_unmount;
+    ops.exists     = op_exists;
+    ops.make_dir   = op_make_dir;
+    ops.lock       = op_lock;
+    ops.unlock     = op_unlock;
+    int error = 0;
+    automount_t* mount = automount_create(&ops, argv[1], argv[2], (argc > 3) ? argv[3] : DEFAULT_BASE_DIR, &error);
+    if (mount == NULL)
+    {
+        /* Nothing to mount, or it cannot be mounted: a restart would not change that. */
+        return (error == -ENOMEM) ? error : 0;
+    }
+    int ret = run(mount);
+    automount_destroy(mount);
+    return ret;
+}
diff --git a/services/blkid/README.md b/services/blkid/README.md
index 1163fb3..7157074 100644
--- a/services/blkid/README.md
+++ b/services/blkid/README.md
@@ -12,7 +12,7 @@ One line per node:
 ```
 > blkid /dev/dmsdio0/0 /dev/dmsdio0/0p1 /dev/dmsdio0/0p2
 /dev/dmsdio0/0: PTTYPE="mbr" PTUUID="1a2b3c4d" PARTITIONS="2" BLOCK_SIZE="512" SIZE="15931539456"
-/dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="BOOT" UUID="CAFE-BABE" SIZE="268435456" MOUNTABLE="no"
+/dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="BOOT" UUID="CAFE-BABE" SIZE="268435456" MODULE="dmfatfs" MOUNTABLE="yes"
 /dev/dmsdio0/0p2: SIZE="15662055424"
 ```
 
diff --git a/services/blkid/src/main.c b/services/blkid/src/main.c
index 8beb36a..5eb6d0e 100644
--- a/services/blkid/src/main.c
+++ b/services/blkid/src/main.c
@@ -6,7 +6,7 @@
  * blkid <node>... - print what dmblkid finds on each node, one line per node:
  *
  *   /dev/dmsdio0/0: PTTYPE="mbr" PTUUID="1a2b3c4d" PARTITIONS="2" SIZE="15931539456"
- *   /dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="BOOT" UUID="1234-ABCD" SIZE="268435456" MOUNTABLE="no"
+ *   /dev/dmsdio0/0p1: TYPE="vfat" VERSION="FAT32" LABEL="BOOT" UUID="1234-ABCD" SIZE="268435456" MODULE="dmfatfs" MOUNTABLE="yes"
  *   /dev/dmsdio0/0p2: SIZE="15662055424"
  *
  * Nodes are never listed automatically: reading a character device (a UART)
diff --git a/src/dmblkid_exfat.c b/src/dmblkid_exfat.c
index b31a593..4903e6d 100644
--- a/src/dmblkid_exfat.c
+++ b/src/dmblkid_exfat.c
@@ -171,7 +171,7 @@ static int exfat_set_version(dmblkid_t* result, const exfat_boot_t* b)
 static int exfat_describe(const dmblkid_source_t* source, const exfat_boot_t* b, dmblkid_t* result)
 {
     /* No DMOD filesystem module mounts exFAT yet. */
-    dmblkid_set_filesystem(result, "exfat", NULL, false);
+    dmblkid_set_filesystem(result, "exfat", "dmfatfs", true);
     int ret = exfat_set_version(result, b);
     ret = (ret < 0) ? ret : dmblkid_set_serial(&result->uuid, b->serial);
     ret = (ret < 0) ? ret : exfat_find_label(source, b, &result->label);
diff --git a/src/dmblkid_fat.c b/src/dmblkid_fat.c
index b8fe6cb..f81a2c2 100644
--- a/src/dmblkid_fat.c
+++ b/src/dmblkid_fat.c
@@ -166,7 +166,7 @@ static int fat_describe(const dmblkid_source_t* source, const uint8_t* s, const
                         dmblkid_t* result)
 {
     /* No DMOD filesystem module mounts FAT yet. */
-    dmblkid_set_filesystem(result, "vfat", NULL, false);
+    dmblkid_set_filesystem(result, "vfat", "dmfatfs", true);
     const char* version = (g->bits == 12u) ? "FAT12" : (g->bits == 16u) ? "FAT16" : "FAT32";
     int ret = dmblkid_set_string(&result->version, version);
     int found = (ret < 0) ? ret : fat_find_root_label(source, g, &result->label);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 398f7cc..be3f30a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -15,19 +15,40 @@ target_include_directories(${DMOD_MODULE_NAME} PRIVATE
 
 target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
 
-# Register the test module with ctest - this replays the same two steps CI
-# runs (see .github/templates/ci.yml.template): install the test module's
+# Register a test module with ctest - this replays the same two steps CI
+# runs (see .github/workflows/ci.yml): install the test module's
 # dependencies with dmf-get, then execute it through dmod_loader. The test's
 # exit code equals its number of failed steps (see dmod_add_test).
 find_program(DMF_GET_EXECUTABLE dmf-get HINTS ${DMOD_TOOLS_BIN_DIR} PATHS ENV PATH)
 find_program(DMOD_LOADER_EXECUTABLE dmod_loader HINTS ${DMOD_TOOLS_BIN_DIR} PATHS ENV PATH)
 
-if(DMF_GET_EXECUTABLE AND DMOD_LOADER_EXECUTABLE)
-    add_test(
-        NAME ${DMOD_MODULE_NAME}
-        COMMAND ${CMAKE_COMMAND} -E env DMOD_DMF_DIR=${DMOD_DMF_DIR}
-            bash -c "${DMF_GET_EXECUTABLE} install -d ${DMOD_DMF_DIR}/${DMOD_MODULE_NAME}-local.dmd -y && ${DMOD_LOADER_EXECUTABLE} ${DMOD_DMF_DIR}/${DMOD_MODULE_NAME}.dmf"
-    )
-else()
-    message(WARNING "dmf-get/dmod_loader not found - 'ctest' will not run ${DMOD_MODULE_NAME}. Build the tools first with -DDMOD_BUILD_TOOLS=ON")
-endif()
+function(dmblkid_register_test name)
+    if(DMF_GET_EXECUTABLE AND DMOD_LOADER_EXECUTABLE)
+        add_test(
+            NAME ${name}
+            COMMAND ${CMAKE_COMMAND} -E env DMOD_DMF_DIR=${DMOD_DMF_DIR}
+                bash -c "${DMF_GET_EXECUTABLE} install -d ${DMOD_DMF_DIR}/${name}-local.dmd -y && ${DMOD_LOADER_EXECUTABLE} ${DMOD_DMF_DIR}/${name}.dmf"
+        )
+    else()
+        message(WARNING "dmf-get/dmod_loader not found - 'ctest' will not run ${name}. Build the tools first with -DDMOD_BUILD_TOOLS=ON")
+    endif()
+endfunction()
+
+dmblkid_register_test(test_dmblkid)
+
+# test_automount - the automount service logic. Compiles the logic's source
+# (the unit under test) into the test; the service's main.c, which only adds
+# dmvfs, the file API and libsystemd around it, cannot run on the host loader
+# (no dmvfs there).
+set(DMOD_MODULE_NAME        test_automount)
+dmod_add_test(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
+    automount_test.c
+    test_images.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/../services/automount/src/automount.c
+)
+target_include_directories(${DMOD_MODULE_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../include
+    ${CMAKE_CURRENT_SOURCE_DIR}/../services/automount/src
+)
+target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
+dmblkid_register_test(${DMOD_MODULE_NAME})
diff --git a/tests/automount_test.c b/tests/automount_test.c
new file mode 100644
index 0000000..7c707cf
--- /dev/null
+++ b/tests/automount_test.c
@@ -0,0 +1,265 @@
+#define DMOD_ENABLE_REGISTRATION ON
+#include "dmod_test.h"
+#include "dmblkid.h"
+#include "automount.h"
+#include "test_images.h"
+#include <errno.h>
+#include <string.h>
+
+/*
+ * The automount service logic (services/automount/src/automount.c) on image
+ * files probed by the real dmblkid, with a fake file system tree: every
+ * directory created and every mount point is recorded (a mount point exists
+ * while mounted, like in dmvfs), so the steps can check where a volume ended
+ * up and that nothing is left behind.
+ */
+
+#define IMAGE_PATH      "automount_test.img"
+#define BASE_DIR        "/mnt"
+#define NODE_NAME       "dmsdio0_0p1"
+#define MAX_PATHS       8
+#define MAX_PATH_LENGTH 64
+
+typedef struct
+{
+    char    dirs[MAX_PATHS][MAX_PATH_LENGTH];     /* existing directories, "" = free slot */
+    char    mounted_dir[MAX_PATH_LENGTH];
+    char    mounted_module[MAX_PATH_LENGTH];
+    char    mounted_node[MAX_PATH_LENGTH];
+    int     mount_calls;
+    int     unmount_calls;
+    int     mount_result;
+    int     locked;
+} fake_tree_t;
+
+static fake_tree_t g_tree;
+
+static int find_dir(const char* path)
+{
+    for (int i = 0; i < MAX_PATHS; i++)
+    {
+        if (strcmp(g_tree.dirs[i], path) == 0)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static void add_dir(const char* path)
+{
+    int slot = find_dir("");
+    if (slot >= 0)
+    {
+        strncpy(g_tree.dirs[slot], path, MAX_PATH_LENGTH - 1);
+    }
+}
+
+static void copy_text(char* target, const char* text)
+{
+    strncpy(target, text, MAX_PATH_LENGTH - 1);
+    target[MAX_PATH_LENGTH - 1] = '\0';
+}
+
+static int fake_mount(const char* module, const char* dir, const char* node)
+{
+    g_tree.mount_calls++;
+    if (g_tree.mount_result == 0)
+    {
+        add_dir(dir);
+        copy_text(g_tree.mounted_dir, dir);
+        copy_text(g_tree.mounted_module, module);
+        copy_text(g_tree.mounted_node, node);
+    }
+    return g_tree.mount_result;
+}
+
+static int fake_unmount(const char* dir)
+{
+    g_tree.unmount_calls++;
+    if (strcmp(g_tree.mounted_dir, dir) != 0)
+    {
+        return -EINVAL;
+    }
+    g_tree.dirs[find_dir(dir)][0] = '\0';
+    g_tree.mounted_dir[0] = '\0';
+    return 0;
+}
+
+static bool fake_exists(const char* path)       { return find_dir(path) >= 0; }
+static int  fake_make_dir(const char* path)     { add_dir(path); return 0; }
+static void fake_lock(void)                     { g_tree.locked++; }
+static void fake_unlock(void)                   { g_tree.locked--; }
+
+static automount_ops_t make_ops(void)
+{
+    automount_ops_t ops;
+    ops.mount      = fake_mount;
+    ops.unmount    = fake_unmount;
+    ops.exists     = fake_exists;
+    ops.make_dir   = fake_make_dir;
+    ops.lock       = fake_lock;
+    ops.unlock     = fake_unlock;
+    return ops;
+}
+
+static automount_t* create(int* error)
+{
+    automount_ops_t ops = make_ops();
+    return automount_create(&ops, IMAGE_PATH, NODE_NAME, BASE_DIR, error);
+}
+
+void dmod_test_setup(void)
+{
+    memset(&g_tree, 0, sizeof(g_tree));
+}
+
+void dmod_test_teardown(void)
+{
+    Dmod_FileRemove(IMAGE_PATH);
+}
+
+static bool name_is(const char* label, const char* expected)
+{
+    char* name = automount_label_to_name(label);
+    bool  ok   = (expected == NULL) ? name == NULL : (name != NULL && strcmp(name, expected) == 0);
+    if (name != NULL)
+    {
+        Dmod_Free(name);
+    }
+    return ok;
+}
+
+DMOD_TEST_STEP(label_to_name)
+{
+    DMOD_TEST_EXPECT_TRUE(name_is("BOOT", "BOOT"));
+    DMOD_TEST_EXPECT_TRUE(name_is("My Card", "My_Card"));
+    DMOD_TEST_EXPECT_TRUE(name_is("a/b\\c;d", "a_b_c_d"));
+    DMOD_TEST_EXPECT_TRUE(name_is("Karta \xC5\x82", "Karta_\xC5\x82"));
+    DMOD_TEST_EXPECT_TRUE(name_is("NO.NAME", "NO.NAME"));
+    DMOD_TEST_EXPECT_TRUE(name_is(NULL, NULL));
+    DMOD_TEST_EXPECT_TRUE(name_is("   ", NULL));
+    DMOD_TEST_EXPECT_TRUE(name_is(".", NULL));
+    DMOD_TEST_EXPECT_TRUE(name_is("..", NULL));
+}
+
+DMOD_TEST_STEP(mounts_at_label)
+{
+    int error = 1;
+    DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
+    automount_t* mount = create(&error);
+    DMOD_TEST_EXPECT_NOT_NULL(mount);
+    DMOD_TEST_EXPECT_EQ(error, 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(automount_get_dir(mount), BASE_DIR "/BOOT"), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/BOOT"), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_module, "dmfatfs"), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_node, IMAGE_PATH), 0);
+    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR));
+    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR "/BOOT"));
+    automount_destroy(mount);
+    DMOD_TEST_EXPECT_EQ(g_tree.unmount_calls, 1);
+    DMOD_TEST_EXPECT_EQ(g_tree.mounted_dir[0], '\0');
+    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/BOOT"));
+    DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
+}
+
+DMOD_TEST_STEP(utf8_label)
+{
+    DMOD_TEST_EXPECT_TRUE(test_build_exfat(IMAGE_PATH, true));
+    automount_t* mount = create(NULL);
+    DMOD_TEST_EXPECT_NOT_NULL(mount);
+    DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/Karta_\xC5\x82"), 0);
+    automount_destroy(mount);
+}
+
+DMOD_TEST_STEP(taken_label_falls_back_to_node_name)
+{
+    DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
+    add_dir(BASE_DIR);
+    add_dir(BASE_DIR "/BOOT");
+    automount_t* mount = create(NULL);
+    DMOD_TEST_EXPECT_NOT_NULL(mount);
+    DMOD_TEST_EXPECT_EQ(strcmp(automount_get_dir(mount), BASE_DIR "/" NODE_NAME), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/" NODE_NAME), 0);
+    automount_destroy(mount);
+    /* Only its own directory is removed */
+    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR "/BOOT"));
+    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/" NODE_NAME));
+}
+
+DMOD_TEST_STEP(everything_taken)
+{
+    int error = 0;
+    DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
+    add_dir(BASE_DIR "/BOOT");
+    add_dir(BASE_DIR "/" NODE_NAME);
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_EQ(error, -EBUSY);
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+    DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
+}
+
+DMOD_TEST_STEP(partition_table_is_left_to_the_partitions)
+{
+    int error = 1;
+    DMOD_TEST_EXPECT_TRUE(test_build_mbr(IMAGE_PATH));
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_EQ(error, 0);
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR));
+}
+
+DMOD_TEST_STEP(unknown_contents_are_not_mounted)
+{
+    int error = 1;
+    DMOD_TEST_EXPECT_TRUE(test_image_create(IMAGE_PATH, TEST_MIB));
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_EQ(error, 0);
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+}
+
+DMOD_TEST_STEP(dmffs_is_not_mounted)
+{
+    int error = 1;
+    DMOD_TEST_EXPECT_TRUE(test_build_dmffs(IMAGE_PATH));
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_EQ(error, 0);
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+}
+
+DMOD_TEST_STEP(missing_node)
+{
+    int error = 0;
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_TRUE(error < 0);
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+}
+
+DMOD_TEST_STEP(mount_failure_cleans_up)
+{
+    int error = 0;
+    DMOD_TEST_EXPECT_TRUE(test_build_fat16(IMAGE_PATH));
+    g_tree.mount_result = -EIO;
+    DMOD_TEST_EXPECT_NULL(create(&error));
+    DMOD_TEST_EXPECT_EQ(error, -EIO);
+    /* Not a naming problem - the node name is not tried as well */
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 1);
+    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/DATA16"));
+    DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
+}
+
+DMOD_TEST_STEP(invalid_arguments)
+{
+    int             error = 0;
+    automount_ops_t ops   = make_ops();
+    DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
+    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, "a/b", BASE_DIR, &error));
+    DMOD_TEST_EXPECT_EQ(error, -EINVAL);
+    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, "", BASE_DIR, &error));
+    DMOD_TEST_EXPECT_NULL(automount_create(NULL, IMAGE_PATH, NODE_NAME, BASE_DIR, &error));
+    ops.lock = NULL;
+    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, NODE_NAME, BASE_DIR, &error));
+    DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
+    automount_destroy(NULL);
+    DMOD_TEST_EXPECT_NULL(automount_get_dir(NULL));
+}
diff --git a/tests/dmblkid_test.c b/tests/dmblkid_test.c
index 53e2ea5..72b5ff6 100644
--- a/tests/dmblkid_test.c
+++ b/tests/dmblkid_test.c
@@ -57,6 +57,13 @@ static void expect_unknown(void)
     DMOD_TEST_EXPECT_FALSE(dmblkid_is_mountable(g_result));
 }
 
+/* FAT and exFAT are mounted by dmfatfs, straight from the node. */
+static void expect_dmfatfs(void)
+{
+    DMOD_TEST_EXPECT_TRUE(str_is(dmblkid_get_module(g_result), "dmfatfs"));
+    DMOD_TEST_EXPECT_TRUE(dmblkid_is_mountable(g_result));
+}
+
 /* ---- filesystems ---- */
 
 DMOD_TEST_STEP(fat12_floppy_with_mbr_like_boot_code)
@@ -65,8 +72,7 @@ DMOD_TEST_STEP(fat12_floppy_with_mbr_like_boot_code)
     DMOD_TEST_EXPECT_TRUE(probe());
     expect_filesystem("vfat", "FAT12", "FLOPPY", "1234-ABCD");
     DMOD_TEST_EXPECT_EQ(dmblkid_get_size(g_result), 2880ull * 512u);
-    DMOD_TEST_EXPECT_NULL(dmblkid_get_module(g_result));
-    DMOD_TEST_EXPECT_FALSE(dmblkid_is_mountable(g_result));
+    expect_dmfatfs();
 }
 
 DMOD_TEST_STEP(fat16_label_from_bpb)
@@ -74,6 +80,7 @@ DMOD_TEST_STEP(fat16_label_from_bpb)
     DMOD_TEST_EXPECT_TRUE(test_build_fat16(IMAGE_PATH));
     DMOD_TEST_EXPECT_TRUE(probe());
     expect_filesystem("vfat", "FAT16", "DATA16", "0BAD-F00D");
+    expect_dmfatfs();
 }
 
 DMOD_TEST_STEP(fat32_label_from_root_directory)
@@ -81,6 +88,7 @@ DMOD_TEST_STEP(fat32_label_from_root_directory)
     DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
     DMOD_TEST_EXPECT_TRUE(probe());
     expect_filesystem("vfat", "FAT32", "BOOT", "CAFE-BABE");
+    expect_dmfatfs();
 }
 
 DMOD_TEST_STEP(exfat_above_4gib)
@@ -90,7 +98,7 @@ DMOD_TEST_STEP(exfat_above_4gib)
     /* The label lives in the cluster heap at 4.5 GiB. */
     expect_filesystem("exfat", "1.0", "Karta \xC5\x82", "5EED-0001");
     DMOD_TEST_EXPECT_EQ(dmblkid_get_size(g_result), 5ull * TEST_GIB);
-    DMOD_TEST_EXPECT_FALSE(dmblkid_is_mountable(g_result));
+    expect_dmfatfs();
 }
 
 DMOD_TEST_STEP(exfat_bad_boot_checksum)

From b20675112bd447d25403c46df83df2e7a7cbb485 Mon Sep 17 00:00:00 2001
From: Patryk Kubiak <patryk.kubiak90@gmail.com>
Date: Wed, 30 Sep 2026 13:37:47 +0200
Subject: [PATCH 2/2] Move the automount logic into libautomount

Applications run once per instance, libraries are loaded once: with the
mount logic inside the automount application, every mounted volume carried
its own ~6 KB copy of it. libs/libautomount now holds all of it -
probe, label, path choice, mount/unmount, the lock shared by the
instances and the libsystemd stop handling (libautomount_run()) - and the
automount service is only a main() calling libautomount_run(): 484 B
instead of 6032 B (cortex-m7 .dmf).

The logic no longer takes a table of function pointers: the dmvfs access
is in libautomount_os.c, which the host tests replace with fakes at link
time (test_automount -> test_libautomount).

Checked on STM32F746G-DISCO: the partition is mounted at boot, the
whole-medium instance exits, "service stop"/"service start" unmount and
mount it again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                      |   8 +-
 CMakeLists.txt                                |   5 +-
 README.md                                     |  11 +-
 libs/libautomount/CMakeLists.txt              |  33 +++++
 libs/libautomount/README.md                   |  56 ++++++++
 libs/libautomount/include/libautomount.h      |  56 ++++++++
 libs/libautomount/libautomount.dmr            |  24 ++++
 libs/libautomount/src/libautomount.c          | 111 ++++++++++++++
 .../libautomount/src/libautomount_core.c      |  79 +++++-----
 libs/libautomount/src/libautomount_core.h     |  90 ++++++++++++
 libs/libautomount/src/libautomount_os.c       |  66 +++++++++
 manifest.dmm                                  |   4 +
 services/automount/CMakeLists.txt             |  17 +--
 services/automount/README.md                  |  17 ++-
 services/automount/src/automount.h            |  85 -----------
 services/automount/src/main.c                 | 136 +-----------------
 tests/CMakeLists.txt                          |  16 +--
 .../{automount_test.c => libautomount_test.c} |  86 +++++------
 18 files changed, 558 insertions(+), 342 deletions(-)
 create mode 100644 libs/libautomount/CMakeLists.txt
 create mode 100644 libs/libautomount/README.md
 create mode 100644 libs/libautomount/include/libautomount.h
 create mode 100644 libs/libautomount/libautomount.dmr
 create mode 100644 libs/libautomount/src/libautomount.c
 rename services/automount/src/automount.c => libs/libautomount/src/libautomount_core.c (61%)
 create mode 100644 libs/libautomount/src/libautomount_core.h
 create mode 100644 libs/libautomount/src/libautomount_os.c
 delete mode 100644 services/automount/src/automount.h
 rename tests/{automount_test.c => libautomount_test.c} (70%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 16ec90b..0e1e56d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -37,7 +37,8 @@ jobs:
           test -f build/dmf/dmpart.dmf
           test -f build/dmf/test_dmpart.dmf
           test -f build/dmf/automount.dmf
-          test -f build/dmf/test_automount.dmf
+          test -f build/dmf/libautomount.dmf
+          test -f build/dmf/test_libautomount.dmf
           echo "Module files present"
 
       # dmblkid uses the 64-bit file API (Dmod_FileSeek/_FileTell/_FileSize
@@ -61,8 +62,8 @@ jobs:
           ${DMOD_LOADER} build/dmf/test_dmpart.dmf
           dmf-get install -d ${DMOD_DMF_DIR}/test_dmblkid-local.dmd -y
           ${DMOD_LOADER} build/dmf/test_dmblkid.dmf
-          dmf-get install -d ${DMOD_DMF_DIR}/test_automount-local.dmd -y
-          ${DMOD_LOADER} build/dmf/test_automount.dmf
+          dmf-get install -d ${DMOD_DMF_DIR}/test_libautomount-local.dmd -y
+          ${DMOD_LOADER} build/dmf/test_libautomount.dmf
 
   build-targets:
     name: Build for ${{ matrix.arch }}
@@ -94,3 +95,4 @@ jobs:
           test -f dmf/blkid.dmf
           test -f dmf/dmpart.dmf
           test -f dmf/automount.dmf
+          test -f dmf/libautomount.dmf
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fb2c958..b3f7276 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -91,7 +91,10 @@ add_subdirectory(libs/dmpart)
 # blkid - command line front end
 add_subdirectory(services/blkid)
 
-# automount - mounts block nodes as dmdevfs reports them
+# libautomount - mounting block nodes (everything automount does, loaded once)
+add_subdirectory(libs/libautomount)
+
+# automount - the per-node service around libautomount
 add_subdirectory(services/automount)
 
 enable_testing()
diff --git a/README.md b/README.md
index 042f9d7..8da4175 100644
--- a/README.md
+++ b/README.md
@@ -83,7 +83,9 @@ See [services/blkid/README.md](services/blkid/README.md).
 The `automount` service mounts every block node dmdevfs reports that holds
 a mountable file system, at `/mnt/<volume label>` (or `/mnt/<node name>`
 when there is no label or it is taken), and unmounts it when the node goes
-away. See [services/automount/README.md](services/automount/README.md).
+away. It is a thin `main()` around [libautomount](libs/libautomount/README.md),
+which does the work once for all instances. See
+[services/automount/README.md](services/automount/README.md).
 
 ## API
 
@@ -180,9 +182,10 @@ dmblkid/
 ├── include/
 │   └── dmblkid.h          # Public API
 ├── libs/
-│   └── dmpart/            # dmpart - MBR/GPT parser library (also used by dmdevfs)
+│   ├── dmpart/            # dmpart - MBR/GPT parser library (also used by dmdevfs)
+│   └── libautomount/      # libautomount - the automount logic, loaded once
 ├── services/
-│   ├── automount/         # automount service (mounts block nodes under /mnt)
+│   ├── automount/         # automount service (per node, around libautomount)
 │   └── blkid/             # blkid command line application
 ├── src/
 │   ├── dmblkid.c          # dmblkid_probe(), result accessors
@@ -196,7 +199,7 @@ dmblkid/
 ├── tests/
 │   ├── CMakeLists.txt
 │   ├── dmblkid_test.c
-│   ├── automount_test.c   # automount service logic
+│   ├── libautomount_test.c # libautomount mount logic
 │   └── test_images.c      # Image builders
 ├── CMakeLists.txt
 ├── Makefile
diff --git a/libs/libautomount/CMakeLists.txt b/libs/libautomount/CMakeLists.txt
new file mode 100644
index 0000000..a85395f
--- /dev/null
+++ b/libs/libautomount/CMakeLists.txt
@@ -0,0 +1,33 @@
+# =====================================================================
+#               libautomount - mounting block nodes as they appear
+# =====================================================================
+# Everything the automount service (services/automount) does, as a library:
+# loaded once, while the service runs once per block node - see README.md.
+# Built and released with dmblkid.
+set(DMOD_MODULE_NAME        libautomount)
+set(DMOD_AUTHOR_NAME        "Patryk Kubiak")
+set(DMOD_STACK_SIZE         1024)
+set(DMOD_DMR_PATH           ${CMAKE_CURRENT_SOURCE_DIR}/libautomount.dmr)
+
+dmod_add_library(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
+    src/libautomount.c
+    src/libautomount_core.c
+    src/libautomount_os.c
+)
+
+target_include_directories(${DMOD_MODULE_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+target_include_directories(${DMOD_MODULE_NAME}_if INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+# dmblkid - local sibling (repository root): headers from its _if target
+target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
+
+dmod_link_modules(${DMOD_MODULE_NAME}
+    dmosi
+    libsystemd
+)
diff --git a/libs/libautomount/README.md b/libs/libautomount/README.md
new file mode 100644
index 0000000..a3a7d5c
--- /dev/null
+++ b/libs/libautomount/README.md
@@ -0,0 +1,56 @@
+# libautomount
+
+Mounting block nodes as they appear - everything the
+[automount](../../services/automount/README.md) service does, as a library.
+
+A library module is loaded once, while the service runs once per block node
+(one instance per partition of every card). Keeping the logic here means it
+is in memory once, however many volumes are mounted: the service itself is
+only a `main()` calling `libautomount_run()`.
+
+## API
+
+```c
+#include "libautomount.h"
+
+/* The whole service: mount, wait for a libsystemd stop, unmount. */
+int libautomount_run(const char* node, const char* name, const char* base_dir);
+
+/* The same without waiting. */
+libautomount_t* libautomount_mount(const char* node, const char* name, const char* base_dir, int* error);
+void            libautomount_unmount(libautomount_t* mount);
+const char*     libautomount_get_dir(const libautomount_t* mount);
+```
+
+- `node` - device node, e.g. `/dev/dmsdio0/0p1`
+- `name` - directory used when the volume label cannot be, e.g. `dmsdio0_0p1`
+- `base_dir` - directory volumes are mounted in, `NULL` for `/mnt`
+
+The node is probed with dmblkid. A file system that a module can mount from
+a node (`dmblkid_is_mountable()`; FAT and exFAT through dmfatfs) is mounted
+with that module at `<base_dir>/<label>`, or `<base_dir>/<name>` when the
+volume has no label or that path is taken. In the label, characters that do
+not belong in a path or a shell word become `_`. Anything else - a partition
+table, unknown contents, dmffs - is left alone (`error` 0, nothing mounted).
+
+Picking the path and mounting happen under one library-wide lock, so two
+volumes never end up at the same path. Only `base_dir` is created: dmvfs
+needs no directory under a mount point.
+
+`libautomount_run()` returns 0 also when there is nothing to mount or the
+volume cannot be mounted (logged), so a service restart policy never spins
+on it; only `-ENOMEM` is an error. While mounted it sleeps on a semaphore
+registered with `libsystemd_set_stop_semaphore()`; if the process is killed
+instead of stopped, a process exit callback unmounts.
+
+## Structure
+
+| File | Contents |
+|------|----------|
+| `src/libautomount.c` | API, `libautomount_run()` (libsystemd stop, exit callback) |
+| `src/libautomount_core.c` | Probe, label, path choice, mount/unmount |
+| `src/libautomount_os.c` | dmvfs and file API access, the lock |
+
+The host tests (`tests/libautomount_test.c` in the repository root) compile
+`libautomount_core.c` with fakes of the `libautomount_os_*()` functions -
+there is no dmvfs on the host loader.
diff --git a/libs/libautomount/include/libautomount.h b/libs/libautomount/include/libautomount.h
new file mode 100644
index 0000000..8d003a3
--- /dev/null
+++ b/libs/libautomount/include/libautomount.h
@@ -0,0 +1,56 @@
+#ifndef LIBAUTOMOUNT_H
+#define LIBAUTOMOUNT_H
+
+#include <stdbool.h>
+#include "dmod_types.h"
+#include "libautomount_defs.h"
+
+/**
+ * libautomount - mounting block nodes as they appear.
+ *
+ * Everything the automount service does, as a library: a library module is
+ * loaded once, while the service runs once per block node - so the service
+ * itself is only a main() calling libautomount_run().
+ *
+ * A node holding a file system that a module can mount from a node (FAT and
+ * exFAT through dmfatfs, as dmblkid reports it) is mounted at
+ * <base dir>/<volume label>, or <base dir>/<name> when the volume has no
+ * label or that path is taken. See README.md.
+ */
+
+typedef struct libautomount libautomount_t;
+
+/**
+ * Mount @p node, wait until the calling process is asked to stop through
+ * libsystemd (libsystemd_stop_service(): node removed, "service stop"),
+ * unmount. If the process is killed instead, an exit callback unmounts.
+ *
+ * Meant to be the whole main() of a service started per node.
+ *
+ * @param node      Device node, e.g. "/dev/dmsdio0/0p1"
+ * @param name      Directory name used when the label cannot be, e.g. "dmsdio0_0p1"
+ * @param base_dir  Directory the volumes are mounted in, NULL for "/mnt"
+ * @return 0 - also when there is nothing to mount, or it cannot be mounted
+ *         (logged; a restart would not change that) - or -ENOMEM.
+ */
+dmod_libautomount_api(1.0, int, _run, ( const char* node, const char* name, const char* base_dir ));
+
+/**
+ * Mount @p node if it holds a mountable file system (see above), without
+ * waiting for anything.
+ *
+ * @param base_dir  NULL for "/mnt"
+ * @param error     Receives 0 when there is nothing to mount, otherwise a
+ *                  negative errno value (probe error, -EBUSY: no free
+ *                  directory, mount error, -EINVAL, -ENOMEM). May be NULL.
+ * @return The mount, or NULL when nothing was mounted.
+ */
+dmod_libautomount_api(1.0, libautomount_t*, _mount, ( const char* node, const char* name, const char* base_dir, int* error ));
+
+/** Unmount a mount made by libautomount_mount() and release it. Safe with NULL. */
+dmod_libautomount_api(1.0, void, _unmount, ( libautomount_t* mount ));
+
+/** @return The directory the volume is mounted at, e.g. "/mnt/BOOT"; NULL for an invalid mount. */
+dmod_libautomount_api(1.0, const char*, _get_dir, ( const libautomount_t* mount ));
+
+#endif // LIBAUTOMOUNT_H
diff --git a/libs/libautomount/libautomount.dmr b/libs/libautomount/libautomount.dmr
new file mode 100644
index 0000000..e0ae19d
--- /dev/null
+++ b/libs/libautomount/libautomount.dmr
@@ -0,0 +1,24 @@
+# DMOD Resource File for libautomount
+# This file specifies where resources should be installed
+
+# === Core Module ===
+dmf=./${module}.dmf => ${destination}/${module}.dmf [origin=${dmf_dir}/${module}.dmf]
+dmfc=./${module}.dmfc => ${destination}/${module}.dmfc [origin=${build_dir}/dmfc/${module}.dmfc]
+dmd=./${module}.dmd => ${destination}/${module}.dmd [origin=${dmf_dir}/${module}.dmd]
+version=./${module}_version.txt => ${destination}/${module}_version.txt [origin=${dmf_dir}/${module}_version.txt]
+
+# === Documentation ===
+# NOTE: ${repo_dir} is the top-level repo root (libautomount is built through
+# add_subdirectory() from dmblkid's CMakeLists.txt), so paths are relative to
+# the repo root, not to libs/libautomount.
+readme=./README.md => ${destination}/${module}/README.md [origin=${repo_dir}/libs/libautomount/README.md]
+
+# === Header Files ===
+# Public header + generated <module>_defs.h
+inc=./include => ${destination}/${module}/include [origin=${repo_dir}/libs/libautomount/include] [origin=${build_dir}/libs/libautomount/${module}_defs.h]
+
+# === License ===
+license=./LICENSE => ${destination}/${module}/LICENSE [origin=${repo_dir}/LICENSE]
+
+# Adding itself
+dmr=./${module}.dmr => ${destination}/${module}/${module}.dmr [origin=${repo_dir}/libs/libautomount/${module}.dmr]
diff --git a/libs/libautomount/src/libautomount.c b/libs/libautomount/src/libautomount.c
new file mode 100644
index 0000000..1959b9a
--- /dev/null
+++ b/libs/libautomount/src/libautomount.c
@@ -0,0 +1,111 @@
+/**
+ * @file libautomount.c
+ * @brief libautomount API: the service loop and the mount/unmount wrappers
+ *
+ * The mount logic is in libautomount_core.c, the dmvfs access in
+ * libautomount_os.c. This is the only translation unit that emits the
+ * library's API registrations (libautomount.h).
+ */
+#define DMOD_ENABLE_REGISTRATION    ON
+#include "dmod.h"
+#include "dmosi.h"
+#include "libsystemd.h"
+#include "libautomount.h"
+#include "libautomount_core.h"
+#include <errno.h>
+
+#define DEFAULT_BASE_DIR    "/mnt"
+
+int dmod_init(const Dmod_Config_t* Config)
+{
+    (void)Config;
+    if (!libautomount_os_init())
+    {
+        DMOD_LOG_ERROR("libautomount: cannot create the lock\n");
+        return -ENOMEM;
+    }
+    return 0;
+}
+
+int dmod_deinit(void)
+{
+    libautomount_os_deinit();
+    return 0;
+}
+
+dmod_libautomount_api_declaration(1.0, libautomount_t*, _mount, ( const char* node, const char* name, const char* base_dir, int* error ))
+{
+    return libautomount_core_mount(node, name, (base_dir != NULL) ? base_dir : DEFAULT_BASE_DIR, error);
+}
+
+dmod_libautomount_api_declaration(1.0, void, _unmount, ( libautomount_t* mount ))
+{
+    libautomount_core_unmount(mount);
+}
+
+dmod_libautomount_api_declaration(1.0, const char*, _get_dir, ( const libautomount_t* mount ))
+{
+    return libautomount_core_get_dir(mount);
+}
+
+/* Only reached when the service had to be killed: libautomount_run() never returned. */
+static void on_killed(dmosi_process_t process, int exit_status, void* arg)
+{
+    (void)process;
+    (void)exit_status;
+    libautomount_core_unmount((libautomount_t*)arg);
+}
+
+/* Sleep until libsystemd asks the calling process to stop. */
+static int wait_for_stop(void)
+{
+    dmosi_semaphore_t wakeup = dmosi_semaphore_create(0, 1);
+    if (wakeup == NULL)
+    {
+        return -ENOMEM;
+    }
+    int ret = libsystemd_set_stop_semaphore(wakeup);
+    if (ret == 0)
+    {
+        while (!libsystemd_stop_requested())
+        {
+            dmosi_semaphore_wait(wakeup, 1, -1);
+        }
+        libsystemd_set_stop_semaphore(NULL);
+    }
+    else
+    {
+        DMOD_LOG_ERROR("libautomount: cannot register for stop requests (%d)\n", ret);
+    }
+    dmosi_semaphore_destroy(wakeup);
+    return ret;
+}
+
+static int wait_while_mounted(libautomount_t* mount)
+{
+    dmosi_process_t self = dmosi_process_current();
+    dmosi_process_exit_callback_handle_t killed =
+        (self != NULL) ? dmosi_process_register_exit_callback(self, on_killed, mount) : NULL;
+    if (killed == NULL)
+    {
+        DMOD_LOG_ERROR("libautomount: cannot register exit callback\n");
+        return -ENOMEM;
+    }
+    int ret = wait_for_stop();
+    dmosi_process_unregister_exit_callback(self, killed);
+    return ret;
+}
+
+dmod_libautomount_api_declaration(1.0, int, _run, ( const char* node, const char* name, const char* base_dir ))
+{
+    int error = 0;
+    libautomount_t* mount = libautomount_core_mount(node, name, (base_dir != NULL) ? base_dir : DEFAULT_BASE_DIR, &error);
+    if (mount == NULL)
+    {
+        /* Nothing to mount, or it cannot be mounted: a restart would not change that. */
+        return (error == -ENOMEM) ? error : 0;
+    }
+    int ret = wait_while_mounted(mount);
+    libautomount_core_unmount(mount);
+    return ret;
+}
diff --git a/services/automount/src/automount.c b/libs/libautomount/src/libautomount_core.c
similarity index 61%
rename from services/automount/src/automount.c
rename to libs/libautomount/src/libautomount_core.c
index 4e561c3..b5eda6f 100644
--- a/services/automount/src/automount.c
+++ b/libs/libautomount/src/libautomount_core.c
@@ -1,20 +1,19 @@
 /**
- * @file automount.c
- * @brief Mount logic of the automount service
+ * @file libautomount_core.c
+ * @brief Mount logic of libautomount
  */
 #include "dmod.h"
 #include "dmblkid.h"
-#include "automount.h"
+#include "libautomount_core.h"
 #include <errno.h>
 #include <string.h>
 
-#define AUTOMOUNT_MAGIC     0x41554D54u     /* 'AUMT' */
+#define LIBAUTOMOUNT_MAGIC  0x41554D54u     /* 'AUMT' */
 
-struct automount
+struct libautomount
 {
-    uint32_t        magic;
-    automount_ops_t ops;
-    char*           dir;        /**< Mount directory, owned */
+    uint32_t    magic;
+    char*       dir;        /**< Mount directory, owned */
 };
 
 /* What was found on the node: the module to mount it with and its label. */
@@ -24,9 +23,9 @@ typedef struct
     char*   label;      /**< NULL if the volume has none */
 } volume_t;
 
-static bool is_valid(const automount_t* mount)
+static bool is_valid(const libautomount_t* mount)
 {
-    return mount != NULL && mount->magic == AUTOMOUNT_MAGIC;
+    return mount != NULL && mount->magic == LIBAUTOMOUNT_MAGIC;
 }
 
 static bool is_unsafe(unsigned char c)
@@ -35,7 +34,7 @@ static bool is_unsafe(unsigned char c)
     return c < 0x20u || c == 0x7Fu || strchr(unsafe, c) != NULL;
 }
 
-char* automount_label_to_name(const char* label)
+char* libautomount_core_label_to_name(const char* label)
 {
     if (label == NULL || strcmp(label, ".") == 0 || strcmp(label, "..") == 0)
     {
@@ -57,7 +56,7 @@ char* automount_label_to_name(const char* label)
     return name;
 }
 
-const char* automount_get_dir(const automount_t* mount)
+const char* libautomount_core_get_dir(const libautomount_t* mount)
 {
     return is_valid(mount) ? mount->dir : NULL;
 }
@@ -88,7 +87,7 @@ static int probe_volume(const char* node, volume_t* volume)
     {
         const char* label = dmblkid_get_label(result);
         volume->module = Dmod_StrDup(dmblkid_get_module(result));
-        volume->label  = (label != NULL) ? automount_label_to_name(label) : NULL;
+        volume->label  = (label != NULL) ? libautomount_core_label_to_name(label) : NULL;
         ret = (volume->module != NULL && (label == NULL || volume->label != NULL)) ? 1 : -ENOMEM;
     }
     else
@@ -115,15 +114,14 @@ static char* join_path(const char* base_dir, const char* name)
 }
 
 /* Mount at <base_dir>/<name> - or -EBUSY if it is taken. Under the lock. */
-static int mount_at(const automount_ops_t* ops, const volume_t* volume, const char* node,
-                    const char* base_dir, const char* name, char** dir)
+static int mount_at(const volume_t* volume, const char* node, const char* base_dir, const char* name, char** dir)
 {
     *dir = join_path(base_dir, name);
     if (*dir == NULL)
     {
         return -ENOMEM;
     }
-    int ret = ops->exists(*dir) ? -EBUSY : ops->mount(volume->module, *dir, node);
+    int ret = libautomount_os_exists(*dir) ? -EBUSY : libautomount_os_mount(volume->module, *dir, node);
     if (ret != 0)
     {
         Dmod_Free(*dir);
@@ -133,48 +131,44 @@ static int mount_at(const automount_ops_t* ops, const volume_t* volume, const ch
 }
 
 /* The label directory first, then the node name if the label is missing or taken. */
-static int mount_volume(const automount_ops_t* ops, const volume_t* volume, const char* node,
-                        const char* name, const char* base_dir, char** dir)
+static int mount_volume(const volume_t* volume, const char* node, const char* name, const char* base_dir, char** dir)
 {
-    ops->lock();
-    int ret = ops->exists(base_dir) ? 0 : ops->make_dir(base_dir);
+    libautomount_os_lock();
+    int ret = libautomount_os_exists(base_dir) ? 0 : libautomount_os_make_dir(base_dir);
     if (ret == 0)
     {
-        ret = (volume->label != NULL) ? mount_at(ops, volume, node, base_dir, volume->label, dir) : -EBUSY;
+        ret = (volume->label != NULL) ? mount_at(volume, node, base_dir, volume->label, dir) : -EBUSY;
         if (ret == -EBUSY)
         {
-            ret = mount_at(ops, volume, node, base_dir, name, dir);
+            ret = mount_at(volume, node, base_dir, name, dir);
         }
     }
-    ops->unlock();
+    libautomount_os_unlock();
     return ret;
 }
 
-static bool valid_arguments(const automount_ops_t* ops, const char* node, const char* name, const char* base_dir)
+static bool valid_arguments(const char* node, const char* name, const char* base_dir)
 {
-    return ops != NULL && ops->mount != NULL && ops->unmount != NULL && ops->exists != NULL &&
-           ops->make_dir != NULL && ops->lock != NULL && ops->unlock != NULL &&
-           node != NULL && name != NULL && base_dir != NULL && name[0] != '\0' && strchr(name, '/') == NULL;
+    return node != NULL && name != NULL && base_dir != NULL && name[0] != '\0' && strchr(name, '/') == NULL;
 }
 
-static automount_t* create_mount(const automount_ops_t* ops, char* dir)
+static libautomount_t* create_mount(char* dir)
 {
-    automount_t* mount = Dmod_Malloc(sizeof(automount_t));
+    libautomount_t* mount = Dmod_Malloc(sizeof(libautomount_t));
     if (mount == NULL)
     {
         return NULL;
     }
-    mount->magic = AUTOMOUNT_MAGIC;
-    mount->ops   = *ops;
+    mount->magic = LIBAUTOMOUNT_MAGIC;
     mount->dir   = dir;
     return mount;
 }
 
-static void release_dir(const automount_ops_t* ops, char* dir)
+static void release_dir(char* dir)
 {
-    ops->lock();
-    int ret = ops->unmount(dir);
-    ops->unlock();
+    libautomount_os_lock();
+    int ret = libautomount_os_unmount(dir);
+    libautomount_os_unlock();
     if (ret != 0)
     {
         DMOD_LOG_ERROR("automount: cannot unmount %s (%d)\n", dir, ret);
@@ -182,14 +176,13 @@ static void release_dir(const automount_ops_t* ops, char* dir)
     Dmod_Free(dir);
 }
 
-automount_t* automount_create(const automount_ops_t* ops, const char* node, const char* name,
-                              const char* base_dir, int* error)
+libautomount_t* libautomount_core_mount(const char* node, const char* name, const char* base_dir, int* error)
 {
     int      unused;
     int*     status = (error != NULL) ? error : &unused;
     volume_t volume = { 0 };
     char*    dir    = NULL;
-    if (!valid_arguments(ops, node, name, base_dir))
+    if (!valid_arguments(node, name, base_dir))
     {
         *status = -EINVAL;
         return NULL;
@@ -197,23 +190,23 @@ automount_t* automount_create(const automount_ops_t* ops, const char* node, cons
     *status = probe_volume(node, &volume);
     if (*status == 1)
     {
-        *status = mount_volume(ops, &volume, node, name, base_dir, &dir);
+        *status = mount_volume(&volume, node, name, base_dir, &dir);
         if (*status == 0)
         {
             DMOD_LOG_INFO("automount: %s mounted at %s (%s)\n", node, dir, volume.module);
         }
     }
     free_volume(&volume);
-    automount_t* mount = (dir != NULL) ? create_mount(ops, dir) : NULL;
+    libautomount_t* mount = (dir != NULL) ? create_mount(dir) : NULL;
     if (dir != NULL && mount == NULL)
     {
-        release_dir(ops, dir);
+        release_dir(dir);
         *status = -ENOMEM;
     }
     return mount;
 }
 
-void automount_destroy(automount_t* mount)
+void libautomount_core_unmount(libautomount_t* mount)
 {
     if (!is_valid(mount))
     {
@@ -221,6 +214,6 @@ void automount_destroy(automount_t* mount)
     }
     mount->magic = 0;
     DMOD_LOG_INFO("automount: unmounting %s\n", mount->dir);
-    release_dir(&mount->ops, mount->dir);
+    release_dir(mount->dir);
     Dmod_Free(mount);
 }
diff --git a/libs/libautomount/src/libautomount_core.h b/libs/libautomount/src/libautomount_core.h
new file mode 100644
index 0000000..5d65230
--- /dev/null
+++ b/libs/libautomount/src/libautomount_core.h
@@ -0,0 +1,90 @@
+#ifndef LIBAUTOMOUNT_CORE_H
+#define LIBAUTOMOUNT_CORE_H
+
+#include <stdbool.h>
+
+/**
+ * @file libautomount_core.h
+ * @brief Mount logic of libautomount (see libautomount_core.c)
+ *
+ * Private to the library. Everything that touches the file system tree goes
+ * through the libautomount_os_*() functions: libautomount_os.c implements
+ * them with dmvfs on target, the host tests (no dmvfs there) link their own
+ * fakes instead. Only the probe (dmblkid) is called directly.
+ */
+
+typedef struct libautomount libautomount_t;
+
+/* ---- tree access (libautomount_os.c, or the tests) ---- */
+
+/** Create / destroy the library-wide lock (target only, from dmod_init()/dmod_deinit()). */
+bool libautomount_os_init(void);
+void libautomount_os_deinit(void);
+
+/** Mount @p node with file system module @p module at @p dir: 0 or a negative errno. */
+int  libautomount_os_mount(const char* module, const char* dir, const char* node);
+
+/** Unmount @p dir: 0 or a negative errno. */
+int  libautomount_os_unmount(const char* dir);
+
+/** Whether anything (a file, a directory, a mount) exists at @p path. */
+bool libautomount_os_exists(const char* path);
+
+/** Create directory @p path: 0 or a negative errno. */
+int  libautomount_os_make_dir(const char* path);
+
+/**
+ * Library-wide lock: picking a free directory and mounting there happen
+ * under it, so two services never take the same one.
+ */
+void libautomount_os_lock(void);
+void libautomount_os_unlock(void);
+
+/* ---- mount logic (libautomount_core.c) ---- */
+
+/**
+ * @brief Mount @p node if it holds a file system a module can mount
+ *
+ * Probes the node with dmblkid. For a mountable file system the mount
+ * directory is <base_dir>/<volume label>, or <base_dir>/<name> when the
+ * volume has no label or <base_dir>/<label> is already taken (by another
+ * volume with the same label, or anything else). Characters that do not
+ * belong in a path or a shell word are replaced with '_' in the label.
+ * Only <base_dir> is created if missing: dmvfs needs no directory under a
+ * mount point, so nothing is left behind once it is unmounted.
+ *
+ * @param node      Device node, e.g. "/dev/dmsdio0/0p1"
+ * @param name      Fallback directory name, e.g. "dmsdio0_0p1"
+ * @param base_dir  Directory the volumes are mounted in, e.g. "/mnt"
+ * @param error     Receives 0 when there is nothing to mount (partition
+ *                  table, unknown contents, file system without a module
+ *                  that mounts nodes), otherwise a negative errno value:
+ *                  the probe error (e.g. -ENOENT), -EBUSY (no free
+ *                  directory), the mount error, -EINVAL or -ENOMEM.
+ * @return The mount, or NULL when nothing was mounted.
+ */
+libautomount_t* libautomount_core_mount(const char* node, const char* name, const char* base_dir, int* error);
+
+/**
+ * @brief Unmount and release the mount
+ *
+ * Safe with NULL. Also safe from a process exit callback after the thread
+ * of the service was killed.
+ */
+void libautomount_core_unmount(libautomount_t* mount);
+
+/** @return The mount directory, e.g. "/mnt/BOOT"; NULL for an invalid mount. */
+const char* libautomount_core_get_dir(const libautomount_t* mount);
+
+/**
+ * @brief Directory name for a volume label
+ *
+ * @return The label with every character that does not belong in a path or
+ *         a shell word (control characters, space, '/', '\\', ';', '|', '&',
+ *         '<', '>', quotes, '`', '$', '*', '?') replaced with '_', on the
+ *         heap; NULL for no label, a label that is only such characters,
+ *         "." or "..", or on allocation failure.
+ */
+char* libautomount_core_label_to_name(const char* label);
+
+#endif // LIBAUTOMOUNT_CORE_H
diff --git a/libs/libautomount/src/libautomount_os.c b/libs/libautomount/src/libautomount_os.c
new file mode 100644
index 0000000..3ec1aa0
--- /dev/null
+++ b/libs/libautomount/src/libautomount_os.c
@@ -0,0 +1,66 @@
+/**
+ * @file libautomount_os.c
+ * @brief File system tree access of libautomount on target (dmvfs)
+ *
+ * The host tests replace this file with fakes (there is no dmvfs there).
+ */
+#include "dmod.h"
+#include "libautomount_core.h"
+#include <errno.h>
+
+#define DIR_MODE    0755
+
+/*
+ * dmvfs is built into the firmware (it is not a module), its API is
+ * resolved from the system like the rest of the built-in API.
+ */
+DMOD_BUILTIN_API( dmvfs, 1.0, bool, _mount_fs, (const char* fs_name, const char* mount_point, const char* config) );
+DMOD_BUILTIN_API( dmvfs, 1.0, bool, _unmount_fs, (const char* mount_point) );
+
+/* One per library - shared by every automount service using it. */
+static void* g_lock;
+
+bool libautomount_os_init(void)
+{
+    g_lock = Dmod_Mutex_New(false);
+    return g_lock != NULL;
+}
+
+void libautomount_os_deinit(void)
+{
+    if (g_lock != NULL)
+    {
+        Dmod_Mutex_Delete(g_lock);
+        g_lock = NULL;
+    }
+}
+
+int libautomount_os_mount(const char* module, const char* dir, const char* node)
+{
+    return dmvfs_mount_fs(module, dir, node) ? 0 : -EIO;
+}
+
+int libautomount_os_unmount(const char* dir)
+{
+    return dmvfs_unmount_fs(dir) ? 0 : -EIO;
+}
+
+bool libautomount_os_exists(const char* path)
+{
+    return Dmod_Access(path, 0) == 0;
+}
+
+int libautomount_os_make_dir(const char* path)
+{
+    return (Dmod_MakeDir(path, DIR_MODE) == 0) ? 0 : -EIO;
+}
+
+void libautomount_os_lock(void)
+{
+    Dmod_Mutex_Lock(g_lock);
+}
+
+void libautomount_os_unlock(void)
+{
+    Dmod_Mutex_Unlock(g_lock);
+}
diff --git a/manifest.dmm b/manifest.dmm
index d6aafda..f9856b9 100644
--- a/manifest.dmm
+++ b/manifest.dmm
@@ -12,6 +12,10 @@ blkid https://github.com/choco-technologies/dmblkid/releases/download/v<version>
 # released together with dmblkid
 automount https://github.com/choco-technologies/dmblkid/releases/download/v<version>/automount-v<version>-<arch_name>.zip
 
+# libautomount - the library automount runs on (libs/libautomount), built and
+# released together with dmblkid
+libautomount https://github.com/choco-technologies/dmblkid/releases/download/v<version>/libautomount-v<version>-<arch_name>.zip
+
 # dmpart - partition table parser library (libs/dmpart), used by dmblkid and
 # dmdevfs; built and released together with dmblkid
 dmpart https://github.com/choco-technologies/dmblkid/releases/download/v<version>/dmpart-v<version>-<arch_name>.zip
diff --git a/services/automount/CMakeLists.txt b/services/automount/CMakeLists.txt
index ae96233..668c98f 100644
--- a/services/automount/CMakeLists.txt
+++ b/services/automount/CMakeLists.txt
@@ -1,8 +1,9 @@
 # =====================================================================
 #               automount - mount service for block nodes
 # =====================================================================
-# Mounts every block node dmdevfs reports that holds a mountable file
-# system, started per node by libsystemd - see README.md.
+# One instance per block node dmdevfs reports, started by libsystemd - see
+# README.md. Only a main(): the work is done by libautomount, which is
+# loaded once for all instances.
 set(DMOD_MODULE_NAME        automount)
 set(DMOD_AUTHOR_NAME        "Patryk Kubiak")
 set(DMOD_STACK_SIZE         2048)
@@ -11,16 +12,6 @@ set(DMOD_DMR_PATH           ${CMAKE_CURRENT_SOURCE_DIR}/automount.dmr)
 
 dmod_add_executable(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
     src/main.c
-    src/automount.c
 )
 
-target_include_directories(${DMOD_MODULE_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-)
-
-target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
-
-dmod_link_modules(${DMOD_MODULE_NAME}
-    dmosi
-    libsystemd
-)
+target_link_libraries(${DMOD_MODULE_NAME} libautomount_if)
diff --git a/services/automount/README.md b/services/automount/README.md
index 12a90d5..d1cfd16 100644
--- a/services/automount/README.md
+++ b/services/automount/README.md
@@ -6,6 +6,10 @@ file system that a DMOD module can mount from a node - FAT and exFAT through
 [dmfatfs](https://github.com/choco-technologies/dmfatfs) today - it is
 mounted under `/mnt` for as long as the node exists.
 
+The service is only a `main()`: the work is done by
+[libautomount](../../libs/libautomount/README.md), which is loaded once for
+all instances.
+
 ```
 > ls /mnt
 bootfs  dmsdio0_0p2
@@ -37,10 +41,10 @@ word - control characters, space, `/`, `\`, `;`, `|`, `&`, `<`, `>`, quotes,
 `` ` ``, `$`, `*`, `?` - becomes `_` (`My Card` -> `/mnt/My_Card`). A label
 that is only such characters, `.` or `..` counts as no label.
 
-Picking the directory and mounting there happen under a lock shared by all
-instances, so two volumes never end up at the same path. Only `/mnt` itself
-is created: dmvfs needs no directory under a mount point, so an unmounted
-volume leaves nothing behind.
+Picking the directory and mounting there happen under a lock in
+libautomount, shared by all instances, so two volumes never end up at the
+same path. Only `/mnt` itself is created: dmvfs needs no directory under a
+mount point, so an unmounted volume leaves nothing behind.
 
 A whole medium and its partition are never both mounted: a medium with a
 partition table is left to its partitions, and dmfatfs refuses a node that
@@ -48,7 +52,7 @@ overlaps one already in use anyway.
 
 ## Stopping
 
-automount registers a semaphore with `libsystemd_set_stop_semaphore()`: a
+libautomount registers a semaphore with `libsystemd_set_stop_semaphore()`: a
 stop wakes it, it unmounts and returns from `main()`. The unit sets
 `stop_timeout_ms=5000` for the unmount to write back what the file system
 still caches; if the instance has to be killed, a process exit callback
@@ -78,7 +82,8 @@ automount service=automount@.ini
 automount rules=automount.rules
 ```
 
-The file system modules (e.g. `dmfatfs`) must be available to be loaded.
+libautomount and dmblkid come in as dependencies of the module; the file
+system modules (e.g. `dmfatfs`) must be available to be loaded.
 
 ## Usage
 
diff --git a/services/automount/src/automount.h b/services/automount/src/automount.h
deleted file mode 100644
index 95539cb..0000000
--- a/services/automount/src/automount.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef AUTOMOUNT_H
-#define AUTOMOUNT_H
-
-#include <stdbool.h>
-
-/**
- * @file automount.h
- * @brief Mount logic of the automount service (see automount.c)
- *
- * Private to the service: main.c runs it with dmvfs and the file API, the
- * tests with recording fakes. Everything that touches the file system tree
- * goes through automount_ops_t, only the probe (dmblkid) is called
- * directly.
- */
-
-/** How automount reaches the file system tree. All members are required. */
-typedef struct
-{
-    /** Mount @p node with file system module @p module at @p dir: 0 or a negative errno. */
-    int  (*mount)(const char* module, const char* dir, const char* node);
-    /** Unmount @p dir: 0 or a negative errno. */
-    int  (*unmount)(const char* dir);
-    /** Whether anything (a file, a directory, a mount) exists at @p path. */
-    bool (*exists)(const char* path);
-    /** Create directory @p path: 0 or a negative errno. */
-    int  (*make_dir)(const char* path);
-    /**
-     * Lock shared by every automount instance: picking a free directory
-     * and mounting there happen under it, so two instances never take
-     * the same one.
-     */
-    void (*lock)(void);
-    void (*unlock)(void);
-} automount_ops_t;
-
-typedef struct automount automount_t;
-
-/**
- * @brief Mount @p node if it holds a file system a module can mount
- *
- * Probes the node with dmblkid. For a mountable file system the mount
- * directory is <base_dir>/<volume label>, or <base_dir>/<name> when the
- * volume has no label or <base_dir>/<label> is already taken (by another
- * volume with the same label, or anything else). Characters that do not
- * belong in a path or a shell word are replaced with '_' in the label.
- * Only <base_dir> is created if missing: dmvfs needs no directory under a
- * mount point, so nothing is left behind once it is unmounted.
- *
- * @param ops       Tree access; copied.
- * @param node      Device node, e.g. "/dev/dmsdio0/0p1"
- * @param name      Fallback directory name, e.g. "dmsdio0_0p1"
- * @param base_dir  Directory the volumes are mounted in, e.g. "/mnt"
- * @param error     Receives 0 when there is nothing to mount (partition
- *                  table, unknown contents, file system without a module
- *                  that mounts nodes), otherwise a negative errno value:
- *                  the probe error (e.g. -ENOENT), -EBUSY (no free
- *                  directory), the mount error, or -ENOMEM.
- * @return The mount, or NULL when nothing was mounted.
- */
-automount_t* automount_create(const automount_ops_t* ops, const char* node, const char* name,
-                              const char* base_dir, int* error);
-
-/**
- * @brief Unmount and release the mount
- *
- * Safe with NULL. Also safe from a process exit callback after the thread
- * of the service was killed.
- */
-void automount_destroy(automount_t* mount);
-
-/** @return The mount directory, e.g. "/mnt/BOOT"; NULL for an invalid mount. */
-const char* automount_get_dir(const automount_t* mount);
-
-/**
- * @brief Directory name for a volume label
- *
- * @return The label with every character that does not belong in a path or
- *         a shell word (control characters, space, '/', '\\', ';', '|', '&',
- *         '<', '>', quotes, '`', '$', '*', '?') replaced with '_', on the
- *         heap; NULL for no label, a label that is only such characters,
- *         "." or "..", or on allocation failure.
- */
-char* automount_label_to_name(const char* label);
-
-#endif // AUTOMOUNT_H
diff --git a/services/automount/src/main.c b/services/automount/src/main.c
index 9009c56..82139d6 100644
--- a/services/automount/src/main.c
+++ b/services/automount/src/main.c
@@ -1,140 +1,18 @@
 #include "dmod.h"
-#include "dmosi.h"
-#include "libsystemd.h"
-#include "automount.h"
+#include "libautomount.h"
 #include <errno.h>
 
 /*
- * automount <node> <name> [<base dir>] - mount service for one block node.
- *
- * dmdevfs reports every block node (whole media and partitions) to
- * libsystemd as class "block"; the [class=block] rule in
- * configs/automount.rules starts automount@<name> from
- * configs/automount@.ini with the node path and the node name. The service
- * mounts the node if it holds a mountable file system, waits until it is
- * stopped (the node went away, or "service stop"), then unmounts it. The
- * mount logic is in automount.c.
+ * automount <node> <name> [<base dir>] - mount service for one block node,
+ * started per node by libsystemd (see ../README.md). All the work is done by
+ * libautomount: a library is loaded once, this service runs once per node.
  */
-
-#define DEFAULT_BASE_DIR    "/mnt"
-#define DIR_MODE            0755
-
-/*
- * dmvfs is built into the firmware (it is not a module), its API is
- * resolved from the system like the rest of the built-in API.
- */
-DMOD_BUILTIN_API( dmvfs, 1.0, bool, _mount_fs, (const char* fs_name, const char* mount_point, const char* config) );
-DMOD_BUILTIN_API( dmvfs, 1.0, bool, _unmount_fs, (const char* mount_point) );
-
-/* Shared by every running instance - they all run this one loaded module. */
-static void* g_lock;
-
-int dmod_init(const Dmod_Config_t* Config)
-{
-    (void)Config;
-    g_lock = Dmod_Mutex_New(false);
-    return (g_lock != NULL) ? 0 : -ENOMEM;
-}
-
-int dmod_deinit(void)
-{
-    if (g_lock != NULL)
-    {
-        Dmod_Mutex_Delete(g_lock);
-        g_lock = NULL;
-    }
-    return 0;
-}
-
-static int  op_mount(const char* module, const char* dir, const char* node) { return dmvfs_mount_fs(module, dir, node) ? 0 : -EIO; }
-static int  op_unmount(const char* dir)     { return dmvfs_unmount_fs(dir) ? 0 : -EIO; }
-static bool op_exists(const char* path)     { return Dmod_Access(path, 0) == 0; }
-static int  op_make_dir(const char* path)   { return (Dmod_MakeDir(path, DIR_MODE) == 0) ? 0 : -EIO; }
-static void op_lock(void)                   { Dmod_Mutex_Lock(g_lock); }
-static void op_unlock(void)                 { Dmod_Mutex_Unlock(g_lock); }
-
-/* Only reached when the unit had to be killed: main() never returned. */
-static void on_killed(dmosi_process_t process, int exit_status, void* arg)
-{
-    (void)process;
-    (void)exit_status;
-    automount_destroy((automount_t*)arg);
-}
-
-static void print_usage(const char* prog)
-{
-    Dmod_Printf("Usage: %s <node> <name> [<base dir>]\n", prog);
-    Dmod_Printf("\n");
-    Dmod_Printf("Mount service for one block node (e.g. /dev/dmsdio0/0p1): mounts the file\n");
-    Dmod_Printf("system on it at <base dir>/<label> (<base dir>/<name> if the volume has no\n");
-    Dmod_Printf("label or it is taken; <base dir> defaults to " DEFAULT_BASE_DIR ") until stopped.\n");
-    Dmod_Printf("Normally started by libsystemd from automount@.ini for every node dmdevfs\n");
-    Dmod_Printf("reports as \"block\".\n");
-}
-
-/* Sleep until libsystemd asks the service to stop. */
-static int wait_for_stop(void)
-{
-    dmosi_semaphore_t wakeup = dmosi_semaphore_create(0, 1);
-    if (wakeup == NULL)
-    {
-        return -ENOMEM;
-    }
-    int ret = libsystemd_set_stop_semaphore(wakeup);
-    if (ret == 0)
-    {
-        while (!libsystemd_stop_requested())
-        {
-            dmosi_semaphore_wait(wakeup, 1, -1);
-        }
-        libsystemd_set_stop_semaphore(NULL);
-    }
-    else
-    {
-        DMOD_LOG_ERROR("automount: cannot register for stop requests (%d)\n", ret);
-    }
-    dmosi_semaphore_destroy(wakeup);
-    return ret;
-}
-
-static int run(automount_t* mount)
-{
-    dmosi_process_t self = dmosi_process_current();
-    dmosi_process_exit_callback_handle_t killed =
-        (self != NULL) ? dmosi_process_register_exit_callback(self, on_killed, mount) : NULL;
-    if (killed == NULL)
-    {
-        DMOD_LOG_ERROR("automount: cannot register exit callback\n");
-        return -ENOMEM;
-    }
-    int ret = wait_for_stop();
-    dmosi_process_unregister_exit_callback(self, killed);
-    return ret;
-}
-
 int main(int argc, char* argv[])
 {
-    if (argc < 3 || argv[1][0] == '\0' || argv[2][0] == '\0')
+    if (argc < 3)
     {
-        print_usage(argv[0]);
+        Dmod_Printf("Usage: %s <node> <name> [<base dir>]\n", argv[0]);
         return -EINVAL;
     }
-    /* Filled at run time: a constant initializer could become a pointer table in data, which the loader does not relocate. */
-    automount_ops_t ops;
-    ops.mount      = op_mount;
-    ops.unmount    = op_unmount;
-    ops.exists     = op_exists;
-    ops.make_dir   = op_make_dir;
-    ops.lock       = op_lock;
-    ops.unlock     = op_unlock;
-    int error = 0;
-    automount_t* mount = automount_create(&ops, argv[1], argv[2], (argc > 3) ? argv[3] : DEFAULT_BASE_DIR, &error);
-    if (mount == NULL)
-    {
-        /* Nothing to mount, or it cannot be mounted: a restart would not change that. */
-        return (error == -ENOMEM) ? error : 0;
-    }
-    int ret = run(mount);
-    automount_destroy(mount);
-    return ret;
+    return libautomount_run(argv[1], argv[2], (argc > 3) ? argv[3] : NULL);
 }
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index be3f30a..1bb7315 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -36,19 +36,19 @@ endfunction()
 
 dmblkid_register_test(test_dmblkid)
 
-# test_automount - the automount service logic. Compiles the logic's source
-# (the unit under test) into the test; the service's main.c, which only adds
-# dmvfs, the file API and libsystemd around it, cannot run on the host loader
-# (no dmvfs there).
-set(DMOD_MODULE_NAME        test_automount)
+# test_libautomount - the libautomount mount logic. Compiles the logic's
+# source (the unit under test) into the test and provides fakes of the
+# libautomount_os_*() functions: the library itself cannot be loaded by the
+# host loader (no dmvfs there).
+set(DMOD_MODULE_NAME        test_libautomount)
 dmod_add_test(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
-    automount_test.c
+    libautomount_test.c
     test_images.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../services/automount/src/automount.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/../libs/libautomount/src/libautomount_core.c
 )
 target_include_directories(${DMOD_MODULE_NAME} PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/../include
-    ${CMAKE_CURRENT_SOURCE_DIR}/../services/automount/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/../libs/libautomount/src
 )
 target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
 dmblkid_register_test(${DMOD_MODULE_NAME})
diff --git a/tests/automount_test.c b/tests/libautomount_test.c
similarity index 70%
rename from tests/automount_test.c
rename to tests/libautomount_test.c
index 7c707cf..9011999 100644
--- a/tests/automount_test.c
+++ b/tests/libautomount_test.c
@@ -1,20 +1,21 @@
 #define DMOD_ENABLE_REGISTRATION ON
 #include "dmod_test.h"
 #include "dmblkid.h"
-#include "automount.h"
+#include "libautomount_core.h"
 #include "test_images.h"
 #include <errno.h>
 #include <string.h>
 
 /*
- * The automount service logic (services/automount/src/automount.c) on image
- * files probed by the real dmblkid, with a fake file system tree: every
+ * The libautomount mount logic (libs/libautomount/src/libautomount_core.c)
+ * on image files probed by the real dmblkid, with fakes of the
+ * libautomount_os_*() functions standing for a file system tree: every
  * directory created and every mount point is recorded (a mount point exists
  * while mounted, like in dmvfs), so the steps can check where a volume ended
  * up and that nothing is left behind.
  */
 
-#define IMAGE_PATH      "automount_test.img"
+#define IMAGE_PATH      "libautomount_test.img"
 #define BASE_DIR        "/mnt"
 #define NODE_NAME       "dmsdio0_0p1"
 #define MAX_PATHS       8
@@ -61,7 +62,7 @@ static void copy_text(char* target, const char* text)
     target[MAX_PATH_LENGTH - 1] = '\0';
 }
 
-static int fake_mount(const char* module, const char* dir, const char* node)
+int libautomount_os_mount(const char* module, const char* dir, const char* node)
 {
     g_tree.mount_calls++;
     if (g_tree.mount_result == 0)
@@ -74,7 +75,7 @@ static int fake_mount(const char* module, const char* dir, const char* node)
     return g_tree.mount_result;
 }
 
-static int fake_unmount(const char* dir)
+int libautomount_os_unmount(const char* dir)
 {
     g_tree.unmount_calls++;
     if (strcmp(g_tree.mounted_dir, dir) != 0)
@@ -86,27 +87,14 @@ static int fake_unmount(const char* dir)
     return 0;
 }
 
-static bool fake_exists(const char* path)       { return find_dir(path) >= 0; }
-static int  fake_make_dir(const char* path)     { add_dir(path); return 0; }
-static void fake_lock(void)                     { g_tree.locked++; }
-static void fake_unlock(void)                   { g_tree.locked--; }
+bool libautomount_os_exists(const char* path)   { return find_dir(path) >= 0; }
+int  libautomount_os_make_dir(const char* path) { add_dir(path); return 0; }
+void libautomount_os_lock(void)                 { g_tree.locked++; }
+void libautomount_os_unlock(void)               { g_tree.locked--; }
 
-static automount_ops_t make_ops(void)
+static libautomount_t* create(int* error)
 {
-    automount_ops_t ops;
-    ops.mount      = fake_mount;
-    ops.unmount    = fake_unmount;
-    ops.exists     = fake_exists;
-    ops.make_dir   = fake_make_dir;
-    ops.lock       = fake_lock;
-    ops.unlock     = fake_unlock;
-    return ops;
-}
-
-static automount_t* create(int* error)
-{
-    automount_ops_t ops = make_ops();
-    return automount_create(&ops, IMAGE_PATH, NODE_NAME, BASE_DIR, error);
+    return libautomount_core_mount(IMAGE_PATH, NODE_NAME, BASE_DIR, error);
 }
 
 void dmod_test_setup(void)
@@ -121,7 +109,7 @@ void dmod_test_teardown(void)
 
 static bool name_is(const char* label, const char* expected)
 {
-    char* name = automount_label_to_name(label);
+    char* name = libautomount_core_label_to_name(label);
     bool  ok   = (expected == NULL) ? name == NULL : (name != NULL && strcmp(name, expected) == 0);
     if (name != NULL)
     {
@@ -147,29 +135,29 @@ DMOD_TEST_STEP(mounts_at_label)
 {
     int error = 1;
     DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
-    automount_t* mount = create(&error);
+    libautomount_t* mount = create(&error);
     DMOD_TEST_EXPECT_NOT_NULL(mount);
     DMOD_TEST_EXPECT_EQ(error, 0);
-    DMOD_TEST_EXPECT_EQ(strcmp(automount_get_dir(mount), BASE_DIR "/BOOT"), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(libautomount_core_get_dir(mount), BASE_DIR "/BOOT"), 0);
     DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/BOOT"), 0);
     DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_module, "dmfatfs"), 0);
     DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_node, IMAGE_PATH), 0);
-    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR));
-    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR "/BOOT"));
-    automount_destroy(mount);
+    DMOD_TEST_EXPECT_TRUE(libautomount_os_exists(BASE_DIR));
+    DMOD_TEST_EXPECT_TRUE(libautomount_os_exists(BASE_DIR "/BOOT"));
+    libautomount_core_unmount(mount);
     DMOD_TEST_EXPECT_EQ(g_tree.unmount_calls, 1);
     DMOD_TEST_EXPECT_EQ(g_tree.mounted_dir[0], '\0');
-    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/BOOT"));
+    DMOD_TEST_EXPECT_FALSE(libautomount_os_exists(BASE_DIR "/BOOT"));
     DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
 }
 
 DMOD_TEST_STEP(utf8_label)
 {
     DMOD_TEST_EXPECT_TRUE(test_build_exfat(IMAGE_PATH, true));
-    automount_t* mount = create(NULL);
+    libautomount_t* mount = create(NULL);
     DMOD_TEST_EXPECT_NOT_NULL(mount);
     DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/Karta_\xC5\x82"), 0);
-    automount_destroy(mount);
+    libautomount_core_unmount(mount);
 }
 
 DMOD_TEST_STEP(taken_label_falls_back_to_node_name)
@@ -177,14 +165,14 @@ DMOD_TEST_STEP(taken_label_falls_back_to_node_name)
     DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
     add_dir(BASE_DIR);
     add_dir(BASE_DIR "/BOOT");
-    automount_t* mount = create(NULL);
+    libautomount_t* mount = create(NULL);
     DMOD_TEST_EXPECT_NOT_NULL(mount);
-    DMOD_TEST_EXPECT_EQ(strcmp(automount_get_dir(mount), BASE_DIR "/" NODE_NAME), 0);
+    DMOD_TEST_EXPECT_EQ(strcmp(libautomount_core_get_dir(mount), BASE_DIR "/" NODE_NAME), 0);
     DMOD_TEST_EXPECT_EQ(strcmp(g_tree.mounted_dir, BASE_DIR "/" NODE_NAME), 0);
-    automount_destroy(mount);
+    libautomount_core_unmount(mount);
     /* Only its own directory is removed */
-    DMOD_TEST_EXPECT_TRUE(fake_exists(BASE_DIR "/BOOT"));
-    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/" NODE_NAME));
+    DMOD_TEST_EXPECT_TRUE(libautomount_os_exists(BASE_DIR "/BOOT"));
+    DMOD_TEST_EXPECT_FALSE(libautomount_os_exists(BASE_DIR "/" NODE_NAME));
 }
 
 DMOD_TEST_STEP(everything_taken)
@@ -206,7 +194,7 @@ DMOD_TEST_STEP(partition_table_is_left_to_the_partitions)
     DMOD_TEST_EXPECT_NULL(create(&error));
     DMOD_TEST_EXPECT_EQ(error, 0);
     DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
-    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR));
+    DMOD_TEST_EXPECT_FALSE(libautomount_os_exists(BASE_DIR));
 }
 
 DMOD_TEST_STEP(unknown_contents_are_not_mounted)
@@ -244,22 +232,20 @@ DMOD_TEST_STEP(mount_failure_cleans_up)
     DMOD_TEST_EXPECT_EQ(error, -EIO);
     /* Not a naming problem - the node name is not tried as well */
     DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 1);
-    DMOD_TEST_EXPECT_FALSE(fake_exists(BASE_DIR "/DATA16"));
+    DMOD_TEST_EXPECT_FALSE(libautomount_os_exists(BASE_DIR "/DATA16"));
     DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
 }
 
 DMOD_TEST_STEP(invalid_arguments)
 {
-    int             error = 0;
-    automount_ops_t ops   = make_ops();
+    int error = 0;
     DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
-    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, "a/b", BASE_DIR, &error));
+    DMOD_TEST_EXPECT_NULL(libautomount_core_mount(IMAGE_PATH, "a/b", BASE_DIR, &error));
     DMOD_TEST_EXPECT_EQ(error, -EINVAL);
-    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, "", BASE_DIR, &error));
-    DMOD_TEST_EXPECT_NULL(automount_create(NULL, IMAGE_PATH, NODE_NAME, BASE_DIR, &error));
-    ops.lock = NULL;
-    DMOD_TEST_EXPECT_NULL(automount_create(&ops, IMAGE_PATH, NODE_NAME, BASE_DIR, &error));
+    DMOD_TEST_EXPECT_NULL(libautomount_core_mount(IMAGE_PATH, "", BASE_DIR, &error));
+    DMOD_TEST_EXPECT_NULL(libautomount_core_mount(NULL, NODE_NAME, BASE_DIR, &error));
+    DMOD_TEST_EXPECT_NULL(libautomount_core_mount(IMAGE_PATH, NODE_NAME, NULL, &error));
     DMOD_TEST_EXPECT_EQ(g_tree.mount_calls, 0);
-    automount_destroy(NULL);
-    DMOD_TEST_EXPECT_NULL(automount_get_dir(NULL));
+    libautomount_core_unmount(NULL);
+    DMOD_TEST_EXPECT_NULL(libautomount_core_get_dir(NULL));
 }