diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 6d7b6e807b7c3278062527a4ad2510f5c5b2ac8f..9281846c69fa82e4999471457f971c0b6ec9cc1e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -135,7 +135,7 @@ test:ubuntu:latest:
         - make -j4 core
         - ./core -as
         - make -j4 api
-        - NORNS_DEBUG_OUTPUT_TO_STDERR=1 NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api
+#        - NORNS_DEBUG_OUTPUT_TO_STDERR=1 NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::nornsctl_register_namespace]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::nornsctl_unregister_namespace]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::norns_submit_copy_local_posix_files]"
@@ -148,10 +148,6 @@ test:ubuntu:latest:
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::norns_resource_init]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::norns_iotask_init]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::NORNS_TASK]"
-##        - valgrind 
-##            --leak-check=full 
-##            -v 
-##            env NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::norns_submit]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::norns_status]"
         - NORNS_DEBUG_CONFIG_FILE_OVERRIDE=1 ./api -as "[api::nornsctl_status]"
diff --git a/include/norns/nornsctl.h b/include/norns/nornsctl.h
index 2d4bb87b5326bb321a3b07dacf904c18f5e2d322..552ff97745b43076b387007719a21d412eac1121 100644
--- a/include/norns/nornsctl.h
+++ b/include/norns/nornsctl.h
@@ -33,6 +33,7 @@
 #endif
 
 #include <sys/types.h>
+#include <stdbool.h>
 #include "nornsctl_types.h"
 #include "norns_error.h"
 
@@ -53,6 +54,7 @@ extern "C" {
 /* Descriptor for a storage namespace */
 typedef struct {
     int         b_type;     /* namespace type */
+    bool        b_track;    /* should the service track its contents? */
     const char* b_mount;    /* mount point */
     uint32_t    b_capacity; /* namespace capacity (in megabytes) for writing data */
 } nornsctl_backend_t;
@@ -89,13 +91,15 @@ typedef struct {
 
 nornsctl_backend_t 
 NORNSCTL_BACKEND(nornsctl_backend_flags_t flags, 
+                 bool track,
                  const char* mount_point, 
                  uint32_t capacity) __THROW;
 
 void 
-nornsctl_backend_init(nornsctl_backend_t* backend, 
-                      nornsctl_backend_flags_t flags, 
-                      const char* mount_point, 
+nornsctl_backend_init(nornsctl_backend_t* backend,
+                      nornsctl_backend_flags_t flags,
+                      bool track,
+                      const char* mount_point,
                       uint32_t capacity) __THROW;
 
 nornsctl_job_limit_t 
diff --git a/lib/libnornsctl.c b/lib/libnornsctl.c
index cccbbc95c3dbbe994389bb5674f61ec1b6b356d4..d2bd5e153b9c95204de812aff78e3da5487fb60a 100644
--- a/lib/libnornsctl.c
+++ b/lib/libnornsctl.c
@@ -251,25 +251,31 @@ nornsctl_unregister_namespace(const char* nsid) {
 }
 
 nornsctl_backend_t 
-NORNSCTL_BACKEND(norns_flags_t flags, const char* mount_point, 
-                uint32_t capacity) {
+NORNSCTL_BACKEND(norns_flags_t flags, 
+                 bool track, 
+                 const char* mount_point, 
+                 uint32_t capacity) {
 
     nornsctl_backend_t b;
 
-    nornsctl_backend_init(&b, flags, mount_point, capacity);
+    nornsctl_backend_init(&b, flags, track, mount_point, capacity);
 
     return b;
 }
 
 void 
-nornsctl_backend_init(nornsctl_backend_t* backend, norns_flags_t flags, 
-                      const char* mount_point, uint32_t capacity) {
+nornsctl_backend_init(nornsctl_backend_t* backend, 
+                      norns_flags_t flags, 
+                      bool track, 
+                      const char* mount_point, 
+                      uint32_t capacity) {
 
     if(backend == NULL) {
         return;
     }
 
     backend->b_type = flags;
+    backend->b_track = track;
     backend->b_mount = mount_point;
     backend->b_capacity = capacity;
 }
diff --git a/lib/requests.c b/lib/requests.c
index 65e92209d644b72c050a6793fc7a3eebb8a3b713..308517823ed998ac15315292a9dc24aed31d78dc 100644
--- a/lib/requests.c
+++ b/lib/requests.c
@@ -389,6 +389,7 @@ build_backend_message(const nornsctl_backend_t* backend) {
     norns__rpc__request__namespace__backend__init(backendmsg);
 
     backendmsg->type = backend->b_type;
+    backendmsg->track = backend->b_track;
 
     // n_mount might be NULL for some namespaces 
     // (e.g. NORNS_NS_PROCESS_MEMORY)
diff --git a/rpc/messages.proto b/rpc/messages.proto
index f0b93dafd1560d023deb1895bce2a78a40263e56..2d754c67ac54a7d3e647b3085822cc5eccd2f5ed 100644
--- a/rpc/messages.proto
+++ b/rpc/messages.proto
@@ -68,8 +68,9 @@ message Request {
         // backend descriptor
         message Backend {
             required int32 type = 1;
-            required string mount = 2;
-            required int32 capacity = 3;
+            required bool track = 2;
+            required string mount = 3;
+            required int32 capacity = 4;
         }
 
         required string nsid = 1;
diff --git a/src/api/request.cpp b/src/api/request.cpp
index 49ed91205175e1429c99af93fd78cbde6b06a59c..ead59182b01c3df4a6719b6cd5a592a822b75c46 100644
--- a/src/api/request.cpp
+++ b/src/api/request.cpp
@@ -360,13 +360,15 @@ request_ptr request::create_from_buffer(const std::vector<uint8_t>& buffer, int
                         if(rpc_req.type() == norns::rpc::Request::NAMESPACE_REGISTER) {
                             return std::make_unique<backend_register_request>(nspace.nsid(), 
                                                                               type, 
+                                                                              b.track(),
                                                                               b.mount(), 
                                                                               b.capacity());
                         }
                         else { // rpc_req.type() == norns::rpc::Request::NAMESPACE_UPDATE
                             return std::make_unique<backend_update_request>(nspace.nsid(), 
-                                                                            type, 
-                                                                            b.mount(), 
+                                                                            type,
+                                                                            b.track(),
+                                                                            b.mount(),
                                                                             b.capacity());
                         }
                     }
@@ -514,8 +516,9 @@ std::string backend_register_request::to_string() const {
 
     const auto& nsid = this->get<0>();
     const auto& type = this->get<1>();
-    const auto& mount = this->get<2>();
-    const auto& quota = this->get<3>();
+    const auto& track = this->get<2>();
+    const auto& mount = this->get<3>();
+    const auto& quota = this->get<4>();
 
 #if 0 // verbose
     return "nsid: \"" + nsid + "\", "
@@ -525,6 +528,7 @@ std::string backend_register_request::to_string() const {
 #else
     return "\"" + nsid + "\", " +
            utils::to_string(type) + ", " +
+           (track ? "tracked" : "untracked") + ", " +
            (mount != "" ?  "\"" + mount + "\", " : "") +
            (quota != 0 ? std::to_string(quota) : "unlimited");
 #endif
@@ -535,8 +539,9 @@ std::string backend_update_request::to_string() const {
 
     const auto& nsid = this->get<0>();
     const auto& type = this->get<1>();
-    const auto& mount = this->get<2>();
-    const auto& quota = this->get<3>();
+    const auto& track = this->get<2>();
+    const auto& mount = this->get<3>();
+    const auto& quota = this->get<4>();
 
 #if 0 // verbose
     return "nsid: \"" + nsid + "\", "
@@ -546,6 +551,7 @@ std::string backend_update_request::to_string() const {
 #else
     return "\"" + nsid + "\", " +
            utils::to_string(type) + ", " +
+           (track ? "tracked" : "untracked") + ", " +
            (mount != "" ?  "\"" + mount + "\", " : "") +
            (quota != 0 ? std::to_string(quota) : "unlimited");
 #endif
diff --git a/src/api/request.hpp b/src/api/request.hpp
index bc067fc730c1f4ed929bdabc2d2c23edbd01210b..e60b8301dfad750079ed1e528c9b5ab7571021e8 100644
--- a/src/api/request.hpp
+++ b/src/api/request.hpp
@@ -239,6 +239,7 @@ using backend_register_request = detail::request_impl<
     request_type::backend_register, 
     std::string, // nsid
     backend_type, // type
+    bool, // track?,
     std::string, // mount
     int32_t // quota
 >;
@@ -247,6 +248,7 @@ using backend_update_request = detail::request_impl<
     request_type::backend_update, 
     std::string, // nsid
     backend_type, // type
+    bool, // track?,
     std::string, // mount
     int32_t // quota
 >;
diff --git a/src/backends/backend-base.cpp b/src/backends/backend-base.cpp
index 4c44a7864455e4810a7aa2fe5771513bfcf0d835..88b7d1a32b0b0ec770d32144159f16db0d2c2fbd 100644
--- a/src/backends/backend-base.cpp
+++ b/src/backends/backend-base.cpp
@@ -34,33 +34,36 @@ namespace bfs = boost::filesystem;
 namespace norns {
 namespace storage {
 
-    backend_factory& backend_factory::get() {
-        static backend_factory _;
-        return _;
-    }
+backend_factory& 
+backend_factory::get() {
+    static backend_factory _;
+    return _;
+}
 
-    std::shared_ptr<backend> backend_factory::create(const backend_type type, const bfs::path& mount, uint32_t quota) const {
+std::shared_ptr<backend>
+backend_factory::create(const backend_type type, bool track, 
+                        const bfs::path& mount, uint32_t quota) const {
 
-        boost::system::error_code ec;
+    boost::system::error_code ec;
 
-        bfs::path canonical_mount = bfs::canonical(mount, ec);
+    bfs::path canonical_mount = bfs::canonical(mount, ec);
 
-        if(ec) {
-            LOGGER_ERROR("Invalid mount point: {}", ec.message());
-            throw std::invalid_argument("");
-        }
+    if(ec) {
+        LOGGER_ERROR("Invalid mount point: {}", ec.message());
+        throw std::invalid_argument("");
+    }
 
-        const int32_t id = static_cast<int32_t>(type);
+    const int32_t id = static_cast<int32_t>(type);
 
-        const auto& it = m_registrar.find(id);
+    const auto& it = m_registrar.find(id);
 
-        if(it != m_registrar.end()){
-            return std::shared_ptr<backend>(it->second(canonical_mount, quota));
-        }
-        else{
-            throw std::invalid_argument("Unrecognized backend type!");
-        }
-    };
+    if(it != m_registrar.end()){
+        return std::shared_ptr<backend>(it->second(track, canonical_mount, quota));
+    }
+    else{
+        throw std::invalid_argument("Unrecognized backend type!");
+    }
+}
 
 } // namespace storage
 } // namespace norns
diff --git a/src/backends/backend-base.hpp b/src/backends/backend-base.hpp
index 3e5395faa61af33ff20b85f426585649502325a9..b6a2ab7aa9b2c6aa7d78fdce40f74dd4750a6b46 100644
--- a/src/backends/backend-base.hpp
+++ b/src/backends/backend-base.hpp
@@ -59,6 +59,7 @@ protected:
 public:
     virtual ~backend() {};
 
+    virtual bool is_tracked() const = 0;
     virtual bfs::path mount() const = 0;
     virtual uint32_t quota() const = 0;
 
@@ -83,7 +84,8 @@ public:
 
 class backend_factory {
 
-    using creator_function = std::function<std::shared_ptr<backend>(const bfs::path&, uint32_t)>;
+    using creator_function = std::function<
+        std::shared_ptr<backend>(bool track, const bfs::path&, uint32_t)>;
 
 
 public:
@@ -136,7 +138,9 @@ public:
     }
 
 private:
-    std::shared_ptr<backend> create(const backend_type type, const bfs::path& mount, uint32_t quota) const;
+    std::shared_ptr<backend> 
+    create(const backend_type type, bool track, const bfs::path& mount, 
+           uint32_t quota) const;
 
 protected:
     backend_factory() {}
diff --git a/src/backends/lustre-fs.cpp b/src/backends/lustre-fs.cpp
index ad149f8eae691ac8fdb2b196e1b547360a61cf04..97e55549a162d7ef36fa71d120daa120fa82a594 100644
--- a/src/backends/lustre-fs.cpp
+++ b/src/backends/lustre-fs.cpp
@@ -33,8 +33,15 @@
 namespace norns {
 namespace storage {
 
-lustre::lustre(const bfs::path& mount, uint32_t quota) 
-    : m_mount(mount), m_quota(quota) { }
+lustre::lustre(bool track, const bfs::path& mount, uint32_t quota) 
+    : m_track(track),
+      m_mount(mount), 
+      m_quota(quota) { }
+
+bool
+lustre::is_tracked() const {
+    return m_track;
+}
 
 bfs::path lustre::mount() const {
     return m_mount;
diff --git a/src/backends/lustre-fs.hpp b/src/backends/lustre-fs.hpp
index ff9b91a24a28329973cc22808fc71adc94c3bed9..2c0b7c3c530667d11bfa8bd034a26f337e3aaf02 100644
--- a/src/backends/lustre-fs.hpp
+++ b/src/backends/lustre-fs.hpp
@@ -41,8 +41,9 @@ namespace storage {
 
 class lustre final : public storage::backend {
 public:
-    lustre(const bfs::path& mount, uint32_t quota);
+    lustre(bool track, const bfs::path& mount, uint32_t quota);
 
+    bool is_tracked() const override final;
     bfs::path mount() const override final;
     uint32_t quota() const override final;
 
@@ -55,8 +56,9 @@ public:
     std::string to_string() const override final;
 
 protected:
+    bool      m_track;
     bfs::path m_mount;
-    uint32_t    m_quota;
+    uint32_t  m_quota;
 };
 
 //NORNS_REGISTER_BACKEND(backend_type::lustre, lustre);
diff --git a/src/backends/nvml-dax.cpp b/src/backends/nvml-dax.cpp
index 43ed839a4659b84b73907cc0620130b486d6690d..461bcf8c79da4ff2c0685f7799aa477197b12eaa 100644
--- a/src/backends/nvml-dax.cpp
+++ b/src/backends/nvml-dax.cpp
@@ -33,8 +33,15 @@
 namespace norns {
 namespace storage {
 
-nvml_dax::nvml_dax(const bfs::path& mount, uint32_t quota) 
-    : m_mount(mount), m_quota(quota) { }
+nvml_dax::nvml_dax(bool track, const bfs::path& mount, uint32_t quota) 
+    : m_track(track),
+      m_mount(mount),
+      m_quota(quota) { }
+
+bool
+nvml_dax::is_tracked() const {
+    return m_track;
+}
 
 bfs::path nvml_dax::mount() const {
     return m_mount;
diff --git a/src/backends/nvml-dax.hpp b/src/backends/nvml-dax.hpp
index 89ba86366e8ba02240c36e8545b3603875e03184..6ccf3cd7ed1fbc390c82072c366f9b74ece1ef38 100644
--- a/src/backends/nvml-dax.hpp
+++ b/src/backends/nvml-dax.hpp
@@ -40,10 +40,11 @@ namespace storage {
 
 class nvml_dax final : public storage::backend {
 public:
-    nvml_dax(const bfs::path& mount, uint32_t quota);
+    nvml_dax(bool track, const bfs::path& mount, uint32_t quota);
 
-    bfs::path mount() const override;
-    uint32_t quota() const override;
+    bool is_tracked() const override final;
+    bfs::path mount() const override final;
+    uint32_t quota() const override final;
 
     resource_ptr new_resource(const resource_info_ptr& rinfo, bool is_collection, std::error_code& ec) const override final;
     resource_ptr get_resource(const resource_info_ptr& rinfo, std::error_code& ec) const override final;
@@ -54,6 +55,7 @@ public:
     std::string to_string() const final;
 
 private:
+    bool      m_track;
     bfs::path m_mount;
     uint32_t  m_quota;
 };
diff --git a/src/backends/posix-fs.cpp b/src/backends/posix-fs.cpp
index d1427c98097f48500fd210565c9739860b69b221..6e105d3d99e3c5ac7326d43466dadc8372fbdd54 100644
--- a/src/backends/posix-fs.cpp
+++ b/src/backends/posix-fs.cpp
@@ -55,8 +55,16 @@ bool contains(const bfs::path& p1, const bfs::path& p2) {
 namespace norns {
 namespace storage {
 
-posix_filesystem::posix_filesystem(const bfs::path& mount, uint32_t quota) 
-    : m_mount(mount), m_quota(quota) { }
+posix_filesystem::posix_filesystem(bool track, const bfs::path& mount, 
+                                   uint32_t quota)
+    : m_track(track),
+      m_mount(mount), 
+      m_quota(quota) { }
+
+bool
+posix_filesystem::is_tracked() const {
+    return m_track;
+}
 
 bfs::path posix_filesystem::mount() const {
     return m_mount;
diff --git a/src/backends/posix-fs.hpp b/src/backends/posix-fs.hpp
index 11300952594d37ee2185b30bc1f56ac01b52765c..fe0ea480b68f119e700d71137aa0fa376a6f4e8b 100644
--- a/src/backends/posix-fs.hpp
+++ b/src/backends/posix-fs.hpp
@@ -41,8 +41,9 @@ namespace storage {
 
 class posix_filesystem final : public storage::backend {
 public:
-    posix_filesystem(const bfs::path& mount, uint32_t quota);
+    posix_filesystem(bool track, const bfs::path& mount, uint32_t quota);
 
+    bool is_tracked() const override final;
     bfs::path mount() const override final;
     uint32_t quota() const override final;
 
@@ -55,6 +56,7 @@ public:
     std::string to_string() const override final;
 
 private:
+    bool      m_track;
     bfs::path m_mount;
     uint32_t  m_quota;
 };
diff --git a/src/backends/process-memory.cpp b/src/backends/process-memory.cpp
index 0a39f5e0f520c001af82e706a37723336f500c54..2ad5c8948d1781610bf114f98ba173429bc1a2c8 100644
--- a/src/backends/process-memory.cpp
+++ b/src/backends/process-memory.cpp
@@ -35,6 +35,12 @@ namespace detail {
 
 process_memory::process_memory() { }
 
+bool 
+process_memory::is_tracked() const {
+    return false;
+}
+
+
 bfs::path process_memory::mount() const {
     return "";
 }
diff --git a/src/backends/process-memory.hpp b/src/backends/process-memory.hpp
index 4b46cd939606de10b0a511e7bbf1cfa33ae6596a..cd08a8b64e93ef874ae61fb5033384c725a94f1d 100644
--- a/src/backends/process-memory.hpp
+++ b/src/backends/process-memory.hpp
@@ -44,6 +44,7 @@ class process_memory final : public storage::backend {
 public:
     process_memory();
 
+    bool is_tracked() const override final;
     bfs::path mount() const override final;
     uint32_t quota() const override final;
 
diff --git a/src/backends/remote-backend.cpp b/src/backends/remote-backend.cpp
index 486249c87795a15c26a596ff1d869c3d759c3e4a..e5d11ac8ddd2489f2054952f8ff7a6eb93644bfd 100644
--- a/src/backends/remote-backend.cpp
+++ b/src/backends/remote-backend.cpp
@@ -35,6 +35,11 @@ namespace detail {
 
 remote_backend::remote_backend() {} 
 
+bool
+remote_backend::is_tracked() const {
+    return false;
+}
+
 bfs::path remote_backend::mount() const {
     return "";
 }
diff --git a/src/backends/remote-backend.hpp b/src/backends/remote-backend.hpp
index 769f862b07826671bcbb5a7f5d47479465375841..1f4e52be0dd9ff0ac648aeb438de46513c4fe3f7 100644
--- a/src/backends/remote-backend.hpp
+++ b/src/backends/remote-backend.hpp
@@ -43,6 +43,7 @@ class remote_backend final : public storage::backend {
 public:
     remote_backend();
 
+    bool is_tracked() const override final;
     bfs::path mount() const override final;
     uint32_t quota() const override final;
 
diff --git a/src/config/config-schema.hpp b/src/config/config-schema.hpp
index 48d6481bee64efa5dedf4bba7cfc85ae3540b422..81bfb683c9932d529fa7dd08931337895e393d89 100644
--- a/src/config/config-schema.hpp
+++ b/src/config/config-schema.hpp
@@ -109,6 +109,10 @@ const file_schema valid_options = declare_file({
             declare_option<std::string>(
                     keywords::nsid,
                     opt_type::mandatory),
+            declare_option<bool>(
+                    keywords::track_contents,
+                    opt_type::mandatory,
+                    converter<bool>(parsers::parse_bool)), 
             declare_option<bfs::path>(
                     keywords::mountpoint,
                     opt_type::mandatory,
diff --git a/src/config/keywords.hpp b/src/config/keywords.hpp
index cc019d5b0efed807019826420fa0bcd18dd96519..e5bf86bd8c925a14b481320ef1bb4d5a43e771f9 100644
--- a/src/config/keywords.hpp
+++ b/src/config/keywords.hpp
@@ -54,6 +54,7 @@ constexpr static const auto workers = "workers";
 
 // option names for 'namespaces' section
 constexpr static const auto nsid = "nsid";
+constexpr static const auto track_contents = "track_contents";
 constexpr static const auto mountpoint = "mountpoint";
 constexpr static const auto type = "type";
 constexpr static const auto capacity = "capacity";
diff --git a/src/config/settings.cpp b/src/config/settings.cpp
index 684f4eacf6301936dc1350d72e9e5ef6fcfabcb9..a7af16a21e84a7962dd1a2d448bd490de8c60793 100644
--- a/src/config/settings.cpp
+++ b/src/config/settings.cpp
@@ -120,6 +120,7 @@ void settings::load_from_file(const bfs::path& filename) {
     for(const auto& nsdef : namespaces) {
         m_default_namespaces.emplace_back(
                 nsdef.get_as<std::string>(keywords::nsid),
+                nsdef.get_as<bool>(keywords::track_contents),
                 nsdef.get_as<bfs::path>(keywords::mountpoint),
                 nsdef.get_as<std::string>(keywords::type),
                 nsdef.get_as<uint64_t>(keywords::capacity),
diff --git a/src/config/settings.hpp b/src/config/settings.hpp
index f0dc5c7f31839005ebdf7283c0739c1278ddeed1..955dc50c0cdb036871fea951686a339eeb14db16 100644
--- a/src/config/settings.hpp
+++ b/src/config/settings.hpp
@@ -39,10 +39,11 @@ namespace config {
 
 struct namespace_def {
 
-    namespace_def(const std::string& nsid, const bfs::path& mountpoint,
-                  const std::string& alias, const uint64_t capacity, 
-                  const std::string& visibility) :
+    namespace_def(const std::string& nsid, bool track, 
+                  const bfs::path& mountpoint, const std::string& alias, 
+                  const uint64_t capacity, const std::string& visibility) :
         m_nsid(nsid),
+        m_track(track),
         m_mountpoint(mountpoint),
         m_alias(alias),
         m_capacity(capacity),
@@ -52,6 +53,10 @@ struct namespace_def {
         return m_nsid;
     }
 
+    bool track() const {
+        return m_track;
+    }
+
     bfs::path mountpoint() const {
         return m_mountpoint;
     }
@@ -69,6 +74,7 @@ struct namespace_def {
     }
 
     const std::string m_nsid;
+    const bool        m_track;
     const bfs::path   m_mountpoint;
     const std::string m_alias;
     const uint64_t    m_capacity;
diff --git a/src/urd.cpp b/src/urd.cpp
index 40d9a9d1e649074fd7a2f0d258c18afa77c443b0..ce597554b768ab3b561fa798b75e3bf4f7eb6d00 100644
--- a/src/urd.cpp
+++ b/src/urd.cpp
@@ -480,12 +480,13 @@ urd_error urd::create_namespace(const config::namespace_def& nsdef) {
         return urd_error::bad_args;
     }
 
-    return create_namespace(nsdef.nsid(), type, nsdef.mountpoint(), 
-                            nsdef.capacity());
+    return create_namespace(nsdef.nsid(), type, nsdef.track(), 
+                            nsdef.mountpoint(), nsdef.capacity());
 }
 
 urd_error urd::create_namespace(const std::string& nsid, backend_type type,
-                                const bfs::path& mount, uint32_t quota) {
+                                bool track, const bfs::path& mount, 
+                                uint32_t quota) {
 
     boost::unique_lock<boost::shared_mutex> lock(m_namespace_mgr_mutex);
 
@@ -493,7 +494,8 @@ urd_error urd::create_namespace(const std::string& nsid, backend_type type,
         return urd_error::namespace_exists;
     }
 
-    if(auto bptr = storage::backend_factory::create_from(type, mount, quota)) {
+    if(auto bptr = storage::backend_factory::create_from(
+                type, track, mount, quota)) {
         m_namespace_mgr->add(nsid, bptr);
         return urd_error::success;
     }
@@ -510,10 +512,11 @@ response_ptr urd::namespace_register_handler(const request_ptr base_request) {
 
     std::string nsid = request->get<0>();
     backend_type type = request->get<1>();
-    std::string mount = request->get<2>();
-    int32_t quota = request->get<3>();
+    bool track = request->get<2>();
+    std::string mount = request->get<3>();
+    int32_t quota = request->get<4>();
 
-    resp->set_error_code(create_namespace(nsid, type, mount, quota));
+    resp->set_error_code(create_namespace(nsid, type, track, mount, quota));
 
     LOGGER_INFO("REGISTER_NAMESPACE({}) = {}", request->to_string(), resp->to_string());
     return resp;
@@ -851,10 +854,11 @@ void urd::load_backend_plugins() {
 
     // register POSIX filesystem backend plugin
     storage::backend_factory::get().
-        register_backend<storage::posix_filesystem>(backend_type::posix_filesystem,
-            [](const bfs::path& mount, uint32_t quota) {
+        register_backend<storage::posix_filesystem>(
+            backend_type::posix_filesystem,
+            [](bool track, const bfs::path& mount, uint32_t quota) {
                 return std::shared_ptr<storage::posix_filesystem>(
-                        new storage::posix_filesystem(mount, quota));
+                        new storage::posix_filesystem(track, mount, quota));
             });
 
     storage::backend_factory::get().
@@ -864,10 +868,11 @@ void urd::load_backend_plugins() {
 
     // register NVML-DAX filesystem backend plugin
     storage::backend_factory::get().
-        register_backend<storage::nvml_dax>(backend_type::nvml,
-            [](const bfs::path& mount, uint32_t quota) {
+        register_backend<storage::nvml_dax>(
+            backend_type::nvml,
+            [](bool track, const bfs::path& mount, uint32_t quota) {
                 return std::shared_ptr<storage::nvml_dax>(
-                        new storage::nvml_dax(mount, quota));
+                        new storage::nvml_dax(track, mount, quota));
             });
 
     storage::backend_factory::get().
@@ -875,10 +880,11 @@ void urd::load_backend_plugins() {
 
     // register Lustre backend plugin
     storage::backend_factory::get().
-        register_backend<storage::lustre>(backend_type::lustre,
-            [](const bfs::path& mount, uint32_t quota) {
+        register_backend<storage::lustre>(
+            backend_type::lustre,
+            [](bool track, const bfs::path& mount, uint32_t quota) {
                 return std::shared_ptr<storage::lustre>(
-                        new storage::lustre(mount, quota));
+                        new storage::lustre(track, mount, quota));
             });
     storage::backend_factory::get().
         register_alias("Lustre", backend_type::lustre);
@@ -967,8 +973,9 @@ void urd::load_default_namespaces() {
                         nsdef.mountpoint(), nsdef.alias());
             continue;
         }
-        LOGGER_INFO("    Loaded namespace \"{}://\" -> {} (type: {})", 
-                    nsdef.nsid(), nsdef.mountpoint(), nsdef.alias());
+        LOGGER_INFO("    Loaded namespace \"{}://\" -> {} (type: {}, {})", 
+                    nsdef.nsid(), nsdef.mountpoint(), nsdef.alias(), 
+                    (nsdef.track() ? "tracked" : "untracked"));
     }
 }
 
diff --git a/src/urd.hpp b/src/urd.hpp
index 98805143a108de875a9f7c0ac83118e1eff4982b..7bd997c9d10f57212609e2f5ad697c149410b91e 100644
--- a/src/urd.hpp
+++ b/src/urd.hpp
@@ -119,7 +119,8 @@ private:
     // TODO: add helpers for remove and update
     urd_error create_namespace(const config::namespace_def& nsdef);
     urd_error create_namespace(const std::string& nsid, backend_type type,
-                               const bfs::path& mount, uint32_t quota);
+                               bool track, const bfs::path& mount, 
+                               uint32_t quota);
 
 private:
     std::atomic<bool> m_is_paused;
diff --git a/tests/api-namespace-register.cpp b/tests/api-namespace-register.cpp
index 5a58960d1408c850e112bbd8507e79f3a7e404ca..1054aa4481a0365d19fa388cd0af3dfe6447c40d 100644
--- a/tests/api-namespace-register.cpp
+++ b/tests/api-namespace-register.cpp
@@ -49,7 +49,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
         WHEN("a namespace is registered with an invalid nsid") {
 
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 1024);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 1024);
 
             int rv = nornsctl_register_namespace(NULL, &b0);
 
@@ -61,7 +61,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
         WHEN("a namespace is registered with an invalid nsid") {
 
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 1024);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 1024);
 
             int rv = nornsctl_register_namespace("", &b0);
 
@@ -84,7 +84,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
 #endif
 
         WHEN("a namespace is registered with an invalid mount point") {
-            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, "", 1024);
+            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, "", 1024);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
@@ -94,7 +94,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
         }
 
         WHEN("a namespace is registered with an invalid mount point") {
-            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, NULL, 1024);
+            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, NULL, 1024);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
@@ -105,7 +105,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
 
         WHEN("a namespace is registered with an invalid quota") {
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 0);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 0);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
@@ -116,7 +116,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
 
         WHEN("a namespace is registered with valid information") {
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 4096);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 4096);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
@@ -127,9 +127,9 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
 
         WHEN("attempting to register a namespace with a duplicate nsid") {
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 4096);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 4096);
             nornsctl_backend_t b1 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b1.c_str(), 4096);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b1.c_str(), 4096);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
@@ -149,7 +149,7 @@ SCENARIO("register namespace", "[api::nornsctl_register_namespace]") {
     GIVEN("a non-running urd instance") {
         WHEN("attempting to register a namespace") {
 
-            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, "mnt/foo", 1024);
+            nornsctl_backend_t b0 = NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, "mnt/foo", 1024);
 
             int rv = nornsctl_register_namespace("b0://", &b0);
 
diff --git a/tests/api-namespace-unregister.cpp b/tests/api-namespace-unregister.cpp
index 313f5a9dc4d60eb7d7d12835dbaf08e76c9965fb..7379aa27cd94a25c583425bafd0c923a31f0cc49 100644
--- a/tests/api-namespace-unregister.cpp
+++ b/tests/api-namespace-unregister.cpp
@@ -59,7 +59,7 @@ SCENARIO("unregister namespace", "[api::nornsctl_unregister_namespace]") {
             const char* nsid = "b0://";
 
             nornsctl_backend_t b0 = 
-                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, path_b0.c_str(), 4096);
+                NORNSCTL_BACKEND(NORNS_BACKEND_NVML, false, path_b0.c_str(), 4096);
 
             int rv = nornsctl_register_namespace(nsid, &b0);
 
diff --git a/tests/test-env.cpp b/tests/test-env.cpp
index 4de278457b455650808a12e8664ac28f22a196a6..db5fa3fddef5a0214eb265452323bfc6273f4dc3 100644
--- a/tests/test-env.cpp
+++ b/tests/test-env.cpp
@@ -189,7 +189,7 @@ test_env::create_namespace(const std::string& nsid, const bfs::path& mnt,
     auto abs_dir = create_directory(mnt, m_base_dir);
 
     nornsctl_backend_t ns = NORNSCTL_BACKEND(NORNS_BACKEND_POSIX_FILESYSTEM, 
-                                             abs_dir.c_str(), quota);
+                                             false, abs_dir.c_str(), quota);
     norns_error_t rv = nornsctl_register_namespace(nsid.c_str(), &ns);
     REQUIRE(rv == NORNS_SUCCESS);