diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 45a92df..0e1e56d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,19 +36,24 @@ 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/libautomount.dmf
+          test -f build/dmf/test_libautomount.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 +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_libautomount-local.dmd -y
+          ${DMOD_LOADER} build/dmf/test_libautomount.dmf
 
   build-targets:
     name: Build for ${{ matrix.arch }}
@@ -87,3 +94,5 @@ jobs:
           test -f dmf/dmblkid.dmf
           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 855475b..b3f7276 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -91,5 +91,11 @@ add_subdirectory(libs/dmpart)
 # blkid - command line front end
 add_subdirectory(services/blkid)
 
+# 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()
 add_subdirectory(tests)
diff --git a/README.md b/README.md
index 4380a81..8da4175 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,20 @@ 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. 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
 
 | Function | Description |
@@ -172,8 +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 (per node, around libautomount)
 │   └── blkid/             # blkid command line application
 ├── src/
 │   ├── dmblkid.c          # dmblkid_probe(), result accessors
@@ -187,6 +199,7 @@ dmblkid/
 ├── tests/
 │   ├── CMakeLists.txt
 │   ├── dmblkid_test.c
+│   ├── libautomount_test.c # libautomount mount 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/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/libs/libautomount/src/libautomount_core.c b/libs/libautomount/src/libautomount_core.c
new file mode 100644
index 0000000..b5eda6f
--- /dev/null
+++ b/libs/libautomount/src/libautomount_core.c
@@ -0,0 +1,219 @@
+/**
+ * @file libautomount_core.c
+ * @brief Mount logic of libautomount
+ */
+#include "dmod.h"
+#include "dmblkid.h"
+#include "libautomount_core.h"
+#include <errno.h>
+#include <string.h>
+
+#define LIBAUTOMOUNT_MAGIC  0x41554D54u     /* 'AUMT' */
+
+struct libautomount
+{
+    uint32_t    magic;
+    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 libautomount_t* mount)
+{
+    return mount != NULL && mount->magic == LIBAUTOMOUNT_MAGIC;
+}
+
+static bool is_unsafe(unsigned char c)
+{
+    static const char unsafe[] = " /\\;|&<>\"'`$*?";
+    return c < 0x20u || c == 0x7Fu || strchr(unsafe, c) != NULL;
+}
+
+char* libautomount_core_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* libautomount_core_get_dir(const libautomount_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) ? libautomount_core_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 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 = libautomount_os_exists(*dir) ? -EBUSY : libautomount_os_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 volume_t* volume, const char* node, const char* name, const char* base_dir, char** 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(volume, node, base_dir, volume->label, dir) : -EBUSY;
+        if (ret == -EBUSY)
+        {
+            ret = mount_at(volume, node, base_dir, name, dir);
+        }
+    }
+    libautomount_os_unlock();
+    return ret;
+}
+
+static bool valid_arguments(const char* node, const char* name, const char* base_dir)
+{
+    return node != NULL && name != NULL && base_dir != NULL && name[0] != '\0' && strchr(name, '/') == NULL;
+}
+
+static libautomount_t* create_mount(char* dir)
+{
+    libautomount_t* mount = Dmod_Malloc(sizeof(libautomount_t));
+    if (mount == NULL)
+    {
+        return NULL;
+    }
+    mount->magic = LIBAUTOMOUNT_MAGIC;
+    mount->dir   = dir;
+    return mount;
+}
+
+static void release_dir(char* dir)
+{
+    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);
+    }
+    Dmod_Free(dir);
+}
+
+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(node, name, base_dir))
+    {
+        *status = -EINVAL;
+        return NULL;
+    }
+    *status = probe_volume(node, &volume);
+    if (*status == 1)
+    {
+        *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);
+    libautomount_t* mount = (dir != NULL) ? create_mount(dir) : NULL;
+    if (dir != NULL && mount == NULL)
+    {
+        release_dir(dir);
+        *status = -ENOMEM;
+    }
+    return mount;
+}
+
+void libautomount_core_unmount(libautomount_t* mount)
+{
+    if (!is_valid(mount))
+    {
+        return;
+    }
+    mount->magic = 0;
+    DMOD_LOG_INFO("automount: unmounting %s\n", 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 44e55c6..f9856b9 100644
--- a/manifest.dmm
+++ b/manifest.dmm
@@ -8,6 +8,14 @@ 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
+
+# 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
new file mode 100644
index 0000000..668c98f
--- /dev/null
+++ b/services/automount/CMakeLists.txt
@@ -0,0 +1,17 @@
+# =====================================================================
+#               automount - mount service for block nodes
+# =====================================================================
+# 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)
+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
+)
+
+target_link_libraries(${DMOD_MODULE_NAME} libautomount_if)
diff --git a/services/automount/README.md b/services/automount/README.md
new file mode 100644
index 0000000..d1cfd16
--- /dev/null
+++ b/services/automount/README.md
@@ -0,0 +1,97 @@
+# 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.
+
+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
+> 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 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
+overlaps one already in use anyway.
+
+## Stopping
+
+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
+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
+```
+
+libautomount and dmblkid come in as dependencies of the module; 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/main.c b/services/automount/src/main.c
new file mode 100644
index 0000000..82139d6
--- /dev/null
+++ b/services/automount/src/main.c
@@ -0,0 +1,18 @@
+#include "dmod.h"
+#include "libautomount.h"
+#include <errno.h>
+
+/*
+ * 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.
+ */
+int main(int argc, char* argv[])
+{
+    if (argc < 3)
+    {
+        Dmod_Printf("Usage: %s <node> <name> [<base dir>]\n", argv[0]);
+        return -EINVAL;
+    }
+    return libautomount_run(argv[1], argv[2], (argc > 3) ? argv[3] : NULL);
+}
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..1bb7315 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_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}
+    libautomount_test.c
+    test_images.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}/../libs/libautomount/src
+)
+target_link_libraries(${DMOD_MODULE_NAME} dmblkid_if)
+dmblkid_register_test(${DMOD_MODULE_NAME})
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)
diff --git a/tests/libautomount_test.c b/tests/libautomount_test.c
new file mode 100644
index 0000000..9011999
--- /dev/null
+++ b/tests/libautomount_test.c
@@ -0,0 +1,251 @@
+#define DMOD_ENABLE_REGISTRATION ON
+#include "dmod_test.h"
+#include "dmblkid.h"
+#include "libautomount_core.h"
+#include "test_images.h"
+#include <errno.h>
+#include <string.h>
+
+/*
+ * 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      "libautomount_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';
+}
+
+int libautomount_os_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;
+}
+
+int libautomount_os_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;
+}
+
+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 libautomount_t* create(int* error)
+{
+    return libautomount_core_mount(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 = libautomount_core_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));
+    libautomount_t* mount = create(&error);
+    DMOD_TEST_EXPECT_NOT_NULL(mount);
+    DMOD_TEST_EXPECT_EQ(error, 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(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(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));
+    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);
+    libautomount_core_unmount(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");
+    libautomount_t* mount = create(NULL);
+    DMOD_TEST_EXPECT_NOT_NULL(mount);
+    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);
+    libautomount_core_unmount(mount);
+    /* Only its own directory is removed */
+    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)
+{
+    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(libautomount_os_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(libautomount_os_exists(BASE_DIR "/DATA16"));
+    DMOD_TEST_EXPECT_EQ(g_tree.locked, 0);
+}
+
+DMOD_TEST_STEP(invalid_arguments)
+{
+    int error = 0;
+    DMOD_TEST_EXPECT_TRUE(test_build_fat32(IMAGE_PATH));
+    DMOD_TEST_EXPECT_NULL(libautomount_core_mount(IMAGE_PATH, "a/b", BASE_DIR, &error));
+    DMOD_TEST_EXPECT_EQ(error, -EINVAL);
+    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);
+    libautomount_core_unmount(NULL);
+    DMOD_TEST_EXPECT_NULL(libautomount_core_get_dir(NULL));
+}