@photostructure/fs-metadata 0.3.3 → 0.5.0

package/src/darwin/raii_utils.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <sys/mount.h>
+
+namespace FSMeta {
+
+// Generic RAII wrapper for resources that need free()
+template <typename T> class ResourceRAII {
+private:
+  T *resource_;
+
+public:
+  ResourceRAII() : resource_(nullptr) {}
+  ~ResourceRAII() {
+    if (resource_) {
+      free(resource_);
+    }
+  }
+
+  T **ptr() { return &resource_; }
+  T *get() { return resource_; }
+
+  // Add move operations for better resource management
+  ResourceRAII(ResourceRAII &&other) noexcept : resource_(other.resource_) {
+    other.resource_ = nullptr;
+  }
+
+  ResourceRAII &operator=(ResourceRAII &&other) noexcept {
+    if (this != &other) {
+      if (resource_)
+        free(resource_);
+      resource_ = other.resource_;
+      other.resource_ = nullptr;
+    }
+    return *this;
+  }
+
+  // Prevent copying
+  ResourceRAII(const ResourceRAII &) = delete;
+  ResourceRAII &operator=(const ResourceRAII &) = delete;
+};
+
+// Specialized for mount info
+using MountBufferRAII = ResourceRAII<struct statfs>;
+
+// CoreFoundation RAII wrapper
+template <typename T> class CFReleaser {
+private:
+  T ref_;
+
+public:
+  explicit CFReleaser(T ref = nullptr) noexcept : ref_(ref) {}
+  ~CFReleaser() { reset(); }
+
+  void reset(T ref = nullptr) {
+    if (ref_) {
+      CFRelease(ref_);
+    }
+    ref_ = ref;
+  }
+
+  operator T() const noexcept { return ref_; }
+  T get() const noexcept { return ref_; }
+  bool isValid() const noexcept { return ref_ != nullptr; }
+
+  // Prevent copying
+  CFReleaser(const CFReleaser &) = delete;
+  CFReleaser &operator=(const CFReleaser &) = delete;
+
+  // Allow moving
+  CFReleaser(CFReleaser &&other) noexcept : ref_(other.ref_) {
+    other.ref_ = nullptr;
+  }
+  CFReleaser &operator=(CFReleaser &&other) noexcept {
+    if (this != &other) {
+      reset();
+      ref_ = other.ref_;
+      other.ref_ = nullptr;
+    }
+    return *this;
+  }
+};
+
+} // namespace FSMeta

package/src/darwin/volume_metadata.cpp

@@ -2,6 +2,7 @@
 
 #include "../common/debug_log.h"
 #include "./fs_meta.h"
+#include "./raii_utils.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <DiskArbitration/DiskArbitration.h>
@@ -36,55 +37,6 @@ static std::string CFStringToString(CFStringRef cfString) {
   return result;
 }
 
-// Improved CFReleaser with proper Core Foundation support
-template <typename T> class CFReleaser {
-private:
-  T ref_;
-
-public:
-  explicit CFReleaser(T ref = nullptr) noexcept : ref_(ref) {}
-
-  // Delete copy operations
-  CFReleaser(const CFReleaser &) = delete;
-  CFReleaser &operator=(const CFReleaser &) = delete;
-
-  // Move operations
-  CFReleaser(CFReleaser &&other) noexcept : ref_(other.ref_) {
-    other.ref_ = nullptr;
-  }
-
-  CFReleaser &operator=(CFReleaser &&other) noexcept {
-    if (this != &other) {
-      reset();
-      ref_ = other.ref_;
-      other.ref_ = nullptr;
-    }
-    return *this;
-  }
-
-  ~CFReleaser() { reset(); }
-
-  void reset(T ref = nullptr) {
-    if (ref_) {
-      CFRelease(ref_);
-    }
-    ref_ = ref;
-  }
-
-  // Implicit conversion operator for Core Foundation APIs
-  operator T() const noexcept { return ref_; }
-
-  T get() const noexcept { return ref_; }
-  bool isValid() const noexcept { return ref_ != nullptr; }
-
-  // Release ownership
-  T release() noexcept {
-    T temp = ref_;
-    ref_ = nullptr;
-    return temp;
-  }
-};
-
 class GetVolumeMetadataWorker : public MetadataWorkerBase {
 public:
   GetVolumeMetadataWorker(const std::string &mountPoint,
@@ -178,12 +130,12 @@ private:
     // Check if this is a network filesystem
     if (metadata.fstype == "smbfs" || metadata.fstype == "nfs" ||
         metadata.fstype == "afpfs" || metadata.fstype == "webdav") {
-      // For network filesystems, we consider them healthy even without DA info
       metadata.remote = true;
       metadata.status = "healthy";
       return;
     }
 
+    // Create session on current thread
     CFReleaser<DASessionRef> session(DASessionCreate(kCFAllocatorDefault));
     if (!session.isValid()) {
       DEBUG_LOG("[GetVolumeMetadataWorker] Failed to create DA session");
@@ -193,21 +145,39 @@ private:
     }
 
     try {
-      // RAII cleanup for RunLoop scheduling
+      // Get thread-local runloop or create new one if needed
+      CFRunLoopRef runLoop = CFRunLoopGetCurrent();
+      if (!runLoop) {
+        // If no runloop exists, create a new one for this thread
+        CFRunLoopRun();
+        runLoop = CFRunLoopGetCurrent();
+        if (!runLoop) {
+          throw std::runtime_error("Failed to create thread-local runloop");
+        }
+      }
+
+      // Schedule session with our runloop
+      DASessionScheduleWithRunLoop(session.get(), runLoop,
+                                   kCFRunLoopDefaultMode);
+
+      // Use RAII to ensure cleanup
       struct RunLoopCleaner {
         DASessionRef session;
-        explicit RunLoopCleaner(DASessionRef s) : session(s) {}
+        CFRunLoopRef runLoop;
+        bool shouldStop;
+        RunLoopCleaner(DASessionRef s, CFRunLoopRef l, bool stop = false)
+            : session(s), runLoop(l), shouldStop(stop) {}
         ~RunLoopCleaner() {
-          DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(),
+          DASessionUnscheduleFromRunLoop(session, runLoop,
                                          kCFRunLoopDefaultMode);
+          if (shouldStop) {
+            CFRunLoopStop(runLoop);
+          }
         }
-      };
+      } scopeGuard(session.get(), runLoop, !CFRunLoopGetCurrent());
 
-      // Schedule session with RunLoop
-      DASessionScheduleWithRunLoop(session.get(), CFRunLoopGetCurrent(),
-                                   kCFRunLoopDefaultMode);
-
-      auto scopeGuard = std::make_unique<RunLoopCleaner>(session.get());
+      // Run the run loop briefly to ensure DA is ready
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, true);
 
       CFReleaser<DADiskRef> disk(DADiskCreateFromBSDName(
           kCFAllocatorDefault, session.get(), metadata.mountFrom.c_str()));
@@ -228,12 +198,17 @@ private:
         return;
       }
 
+      // Ensure we have a complete description before continuing
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
+
+      // Process description synchronously since we're already on the right
+      // thread
       ProcessDiskDescription(description.get());
 
-      // Only set ready if we got this far without errors
       if (metadata.status != "partial") {
         metadata.status = "healthy";
       }
+
     } catch (const std::exception &e) {
       DEBUG_LOG("[GetVolumeMetadataWorker] Exception: %s", e.what());
       metadata.status = "error";

package/src/darwin/volume_mount_points.cpp

@@ -1,7 +1,8 @@
 // src/darwin/volume_mount_points.cpp
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
-#include "fs_meta.h"
+#include "./fs_meta.h"
+#include "./raii_utils.h"
 #include <chrono>
 #include <future>
 #include <sys/mount.h>
@@ -24,9 +25,12 @@ public:
   void Execute() override {
     DEBUG_LOG("[GetVolumeMountPointsWorker] Executing");
     try {
-      // Get mount list - this is fast
-      struct statfs *mntbufp;
-      int count = getmntinfo(&mntbufp, MNT_WAIT);
+      MountBufferRAII mntbuf;
+      // Use MNT_NOWAIT for better performance - we'll verify accessibility
+      // separately and our error handling already covers mount state changes
+      // See https://github.com/swiftlang/swift-corelibs-foundation/issues/4649
+
+      int count = getmntinfo_r_np(mntbuf.ptr(), MNT_NOWAIT);
 
       if (count <= 0) {
         throw std::runtime_error("Failed to get mount information");
@@ -34,36 +38,39 @@ public:
 
       for (int i = 0; i < count; i++) {
         MountPoint mp;
-        mp.mountPoint = mntbufp[i].f_mntonname;
-        mp.fstype = mntbufp[i].f_fstypename;
+        mp.mountPoint = mntbuf.get()[i].f_mntonname;
+        mp.fstype = mntbuf.get()[i].f_fstypename;
         mp.error = ""; // Initialize error field
 
         DEBUG_LOG("[GetVolumeMountPointsWorker] Checking mount point: %s",
                   mp.mountPoint.c_str());
 
         try {
-          // Use shared_future to allow multiple gets
-          std::shared_future<bool> future =
+          // Use RAII to manage future
+          auto future = std::make_shared<std::future<bool>>(
               std::async(std::launch::async, [path = mp.mountPoint]() {
-                return access(path.c_str(), R_OK) == 0;
-              }).share();
+                // Use faccessat for better security
+                return faccessat(AT_FDCWD, path.c_str(), R_OK, AT_EACCESS) == 0;
+              }));
 
-          auto status = future.wait_for(std::chrono::milliseconds(timeoutMs_));
+          auto status = future->wait_for(std::chrono::milliseconds(timeoutMs_));
 
-          if (status == std::future_status::timeout) {
+          switch (status) {
+          case std::future_status::timeout:
             mp.status = "disconnected";
             mp.error = "Access check timed out";
-            DEBUG_LOG(
-                "[GetVolumeMountPointsWorker] Access check timed out for: %s",
-                mp.mountPoint.c_str());
-          } else if (status == std::future_status::ready) {
+            DEBUG_LOG("[GetVolumeMountPointsWorker] Access check timed out: %s",
+                      mp.mountPoint.c_str());
+            break;
+
+          case std::future_status::ready:
             try {
-              bool isAccessible = future.get();
+              bool isAccessible = future->get();
               mp.status = isAccessible ? "healthy" : "inaccessible";
               if (!isAccessible) {
                 mp.error = "Path is not accessible";
               }
-              DEBUG_LOG("[GetVolumeMountPointsWorker] Access check %s for: %s",
+              DEBUG_LOG("[GetVolumeMountPointsWorker] Access check %s: %s",
                         isAccessible ? "succeeded" : "failed",
                         mp.mountPoint.c_str());
             } catch (const std::exception &e) {
@@ -71,12 +78,14 @@ public:
               mp.error = std::string("Access check failed: ") + e.what();
               DEBUG_LOG("[GetVolumeMountPointsWorker] Exception: %s", e.what());
             }
-          } else {
+            break;
+
+          default:
             mp.status = "error";
             mp.error = "Unexpected future status";
-            DEBUG_LOG(
-                "[GetVolumeMountPointsWorker] Unexpected future status for: %s",
-                mp.mountPoint.c_str());
+            DEBUG_LOG("[GetVolumeMountPointsWorker] Unexpected status: %s",
+                      mp.mountPoint.c_str());
+            break;
           }
         } catch (const std::exception &e) {
           mp.status = "error";

package/src/error.ts

@@ -1,8 +1,8 @@
 // src/error.ts
 
-import { isNumber } from "./number.js";
-import { compactValues, map, omit } from "./object.js";
-import { isBlank, isNotBlank } from "./string.js";
+import { isNumber } from "./number";
+import { compactValues, map, omit } from "./object";
+import { isBlank, isNotBlank } from "./string";
 
 function toMessage(context: string, cause: unknown): string {
   const causeStr =

package/src/fs.ts

@@ -3,7 +3,7 @@
 import { type PathLike, type StatOptions, Stats, statSync } from "node:fs";
 import { opendir, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { withTimeout } from "./async.js";
+import { withTimeout } from "./async";
 
 /**
  * Wrapping node:fs/promises.stat() so we can mock it in tests.

package/src/glob.ts

@@ -1,7 +1,7 @@
 // src/glob.ts
 
-import { isWindows } from "./platform.js";
-import { isNotBlank } from "./string.js";
+import { isWindows } from "./platform";
+import { isNotBlank } from "./string";
 
 const cache = new Map<string, RegExp>();
 

package/src/hidden.ts

@@ -2,12 +2,12 @@
 
 import { rename } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
-import { WrappedError } from "./error.js";
-import { canStatAsync, statAsync } from "./fs.js";
-import { isRootDirectory, normalizePath } from "./path.js";
-import { isWindows } from "./platform.js";
-import type { HiddenMetadata } from "./types/hidden_metadata.js";
-import type { NativeBindingsFn } from "./types/native_bindings.js";
+import { WrappedError } from "./error";
+import { canStatAsync, statAsync } from "./fs";
+import { isRootDirectory, normalizePath } from "./path";
+import { isWindows } from "./platform";
+import type { HiddenMetadata } from "./types/hidden_metadata";
+import type { NativeBindingsFn } from "./types/native_bindings";
 
 const HiddenSupportByPlatform: Partial<
   Record<NodeJS.Platform, Pick<HiddenMetadata, "supported">>

package/src/index.ts

@@ -1,17 +1,17 @@
 // src/index.ts
 
 import NodeGypBuild from "node-gyp-build";
-import { debug, debugLogContext, isDebugEnabled } from "./debuglog.js";
-import { defer } from "./defer.js";
-import { _dirname } from "./dirname.js";
-import { findAncestorDir } from "./fs.js";
-import type { HideMethod, SetHiddenResult } from "./hidden.js";
+import { debug, debugLogContext, isDebugEnabled } from "./debuglog";
+import { defer } from "./defer";
+import { _dirname } from "./dirname";
+import { findAncestorDir } from "./fs";
+import type { HideMethod, SetHiddenResult } from "./hidden";
 import {
   getHiddenMetadataImpl,
   isHiddenImpl,
   isHiddenRecursiveImpl,
   setHiddenImpl,
-} from "./hidden.js";
+} from "./hidden";
 import {
   IncludeSystemVolumesDefault,
   LinuxMountTablePathsDefault,
@@ -20,26 +20,22 @@ import {
   SystemFsTypesDefault,
   SystemPathPatternsDefault,
   TimeoutMsDefault,
-} from "./options.js";
-import type {
-  StringEnum,
-  StringEnumKeys,
-  StringEnumType,
-} from "./string_enum.js";
-import type { SystemVolumeConfig } from "./system_volume.js";
-import type { HiddenMetadata } from "./types/hidden_metadata.js";
-import type { MountPoint } from "./types/mount_point.js";
-import { NativeBindings } from "./types/native_bindings.js";
-import type { Options } from "./types/options.js";
-import type { VolumeMetadata } from "./types/volume_metadata.js";
-import type { VolumeHealthStatus } from "./volume_health_status.js";
-import { VolumeHealthStatuses } from "./volume_health_status.js";
+} from "./options";
+import type { StringEnum, StringEnumKeys, StringEnumType } from "./string_enum";
+import type { SystemVolumeConfig } from "./system_volume";
+import type { HiddenMetadata } from "./types/hidden_metadata";
+import type { MountPoint } from "./types/mount_point";
+import { NativeBindings } from "./types/native_bindings";
+import type { Options } from "./types/options";
+import type { VolumeMetadata } from "./types/volume_metadata";
+import type { VolumeHealthStatus } from "./volume_health_status";
+import { VolumeHealthStatuses } from "./volume_health_status";
 import {
   getAllVolumeMetadataImpl,
   getVolumeMetadataImpl,
-} from "./volume_metadata.js";
-import type { GetVolumeMountPointOptions } from "./volume_mount_points.js";
-import { getVolumeMountPointsImpl } from "./volume_mount_points.js";
+} from "./volume_metadata";
+import type { GetVolumeMountPointOptions } from "./volume_mount_points";
+import { getVolumeMountPointsImpl } from "./volume_mount_points";
 
 export type {
   GetVolumeMountPointOptions,

package/src/linux/blkid_cache.cpp

@@ -11,7 +11,7 @@ std::mutex BlkidCache::mutex_;
 
 // Constructor: Initializes the blkid cache with proper error handling
 BlkidCache::BlkidCache() : cache_(nullptr) {
-  std::lock_guard<std::mutex> lock(mutex_);
+  const std::lock_guard<std::mutex> lock(mutex_);
   DEBUG_LOG("[BlkidCache] initializing cache");
   if (blkid_get_cache(&cache_, nullptr) != 0) {
     DEBUG_LOG("[BlkidCache] failed to initialize cache");
@@ -23,17 +23,20 @@ BlkidCache::BlkidCache() : cache_(nullptr) {
 // Destructor: Safely releases the blkid cache resource
 BlkidCache::~BlkidCache() {
   if (cache_) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    DEBUG_LOG("[BlkidCache] releasing cache");
-    try {
-      blkid_put_cache(cache_);
-      cache_ = nullptr; // Avoid double-release
-      DEBUG_LOG("[BlkidCache] cache released successfully");
-    } catch (const std::exception &e) {
-      DEBUG_LOG("[BlkidCache] error releasing cache: %s", e.what());
-      // Optional: Log error during cache cleanup
-      // std::cerr << "Error while releasing blkid cache: " << e.what()
-      //           << std::endl;
+    const std::lock_guard<std::mutex> lock(mutex_);
+    if (cache_) { // Double-check after acquiring lock
+      DEBUG_LOG("[BlkidCache] releasing cache");
+      try {
+        blkid_put_cache(cache_);
+        cache_ = nullptr; // Avoid double-release
+        DEBUG_LOG("[BlkidCache] cache released successfully");
+      } catch (const std::exception &e) {
+        DEBUG_LOG("[BlkidCache] error releasing cache: %s", e.what());
+        cache_ = nullptr; // Ensure it's nulled even on error
+        // Optional: Log error during cache cleanup
+        // std::cerr << "Error while releasing blkid cache: " << e.what()
+        //           << std::endl;
+      }
     }
   }
 }

package/src/linux/dev_disk.ts

@@ -3,8 +3,8 @@
 import { Dirent } from "node:fs";
 import { readdir, readlink } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { debug } from "../debuglog.js";
-import { decodeEscapeSequences } from "../string.js";
+import { debug } from "../debuglog";
+import { decodeEscapeSequences } from "../string";
 
 /**
  * Gets the UUID from symlinks for a given device path asynchronously

package/src/linux/gio_mount_points.cpp

@@ -21,16 +21,16 @@ void GioMountPointsWorker::Execute() {
   try {
     DEBUG_LOG("[GioMountPoints] processing mounts");
 
-    MountIterator::forEachMount([this](GMount *mount, GFile *root) {
-      GCharPtr path(g_file_get_path(root));
+    MountIterator::forEachMount([this](GMount * /*mount*/, GFile *root) {
+      const GCharPtr path(g_file_get_path(root));
       if (path) {
-        GFileInfoPtr info(g_file_query_filesystem_info(
+        const GFileInfoPtr info(g_file_query_filesystem_info(
             root, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, nullptr, nullptr));
         if (info) {
           const char *fs_type_str = g_file_info_get_attribute_string(
               info.get(), G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
           if (fs_type_str) {
-            GCharPtr fs_type(g_strdup(fs_type_str));
+            const GCharPtr fs_type(g_strdup(fs_type_str));
             DEBUG_LOG("[GioMountPoints] found {mountPoint: %s, fsType: %s}",
                       path.get(), fs_type.get());
             MountPoint point{};
@@ -51,11 +51,11 @@ void GioMountPointsWorker::Execute() {
 }
 
 void GioMountPointsWorker::OnOK() {
-  Napi::HandleScope scope(Env());
-  Napi::Array result = Napi::Array::New(Env());
+  const Napi::HandleScope scope(Env());
+  const Napi::Array result = Napi::Array::New(Env());
 
   for (size_t i = 0; i < mountPoints.size(); i++) {
-    Napi::Object point = Napi::Object::New(Env());
+    const Napi::Object point = Napi::Object::New(Env());
     point.Set("mountPoint", mountPoints[i].mountPoint);
     point.Set("fstype", mountPoints[i].fstype);
     result.Set(i, point);

package/src/linux/gio_utils.cpp

@@ -41,17 +41,28 @@ void MountIterator::forEachMount(const MountCallback &callback) {
     // Take an extra reference on the mount while we work with it
     g_object_ref(mount);
 
-    GioResource<GFile> root(g_mount_get_root(mount));
-    if (G_IS_FILE(root.get())) {
-      bool continue_iteration = callback(mount, root.get());
-      g_object_unref(mount);
+    try {
+      const GioResource<GFile> root(g_mount_get_root(mount));
+
+      // Check both for null and valid GFile
+      if (root.get() && G_IS_FILE(root.get())) {
+        const bool continue_iteration = callback(mount, root.get());
+        g_object_unref(mount);
 
-      if (!continue_iteration) {
-        break;
+        if (!continue_iteration) {
+          break;
+        }
+      } else {
+        DEBUG_LOG(
+            "[gio::MountIterator::forEachMount] Invalid root file object");
+        g_object_unref(mount);
       }
-    } else {
-      DEBUG_LOG("[gio::MountIterator::forEachMount] Invalid root file object");
+    } catch (const std::exception &e) {
+      DEBUG_LOG("[gio::MountIterator::forEachMount] Exception during mount "
+                "processing: %s",
+                e.what());
       g_object_unref(mount);
+      throw; // Re-throw to maintain current behavior
     }
   }
 

package/src/linux/gio_volume_metadata.cpp

@@ -17,7 +17,7 @@ void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
             mountPoint.c_str());
 
   MountIterator::forEachMount([&](GMount *mount, GFile *root) {
-    GCharPtr path(g_file_get_path(root));
+    const GCharPtr path(g_file_get_path(root));
     if (!path || mountPoint != path.get()) {
       return true; // Continue iteration
     }
@@ -27,25 +27,25 @@ void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
               path.get());
 
     // Get volume information
-    GObjectPtr<GVolume> volume(g_mount_get_volume(mount));
-    if (volume) {
-      GCharPtr label(g_volume_get_name(volume.get()));
-      if (label) {
-        DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, label: %s",
+    const GObjectPtr<GVolume> volume(g_mount_get_volume(mount));
+    if (volume && volume.get()) {
+      const GCharPtr label(g_volume_get_name(volume.get()));
+      if (label && label.get()) {
+        DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, label: %s}",
                   path.get(), label.get());
         metadata.label = label.get();
       }
     }
 
-    GCharPtr mount_name(g_mount_get_name(mount));
+    const GCharPtr mount_name(g_mount_get_name(mount));
     if (mount_name) {
       metadata.mountName = mount_name.get();
     }
 
-    GObjectPtr<GFile> location(g_mount_get_default_location(mount));
-    if (location) {
-      GCharPtr uri(g_file_get_uri(location.get()));
-      if (uri) {
+    const GObjectPtr<GFile> location(g_mount_get_default_location(mount));
+    if (location && location.get()) {
+      const GCharPtr uri(g_file_get_uri(location.get()));
+      if (uri && uri.get()) {
         DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, uri: %s}",
                   path.get(), uri.get());
         metadata.uri = uri.get();
@@ -53,13 +53,13 @@ void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
     }
 
     if (metadata.fstype.empty()) {
-      GFileInfoPtr info(g_file_query_filesystem_info(
+      const GFileInfoPtr info(g_file_query_filesystem_info(
           root, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, nullptr, nullptr));
       if (info) {
         const char *fs_type_str = g_file_info_get_attribute_string(
             info.get(), G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
         if (fs_type_str) {
-          GCharPtr fs_type(g_strdup(fs_type_str));
+          const GCharPtr fs_type(g_strdup(fs_type_str));
           DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, fsType: %s}",
                     path.get(), fs_type.get());
           metadata.fstype = fs_type.get();
@@ -68,9 +68,9 @@ void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
     }
 
     if (metadata.mountFrom.empty()) {
-      GObjectPtr<GDrive> drive(g_mount_get_drive(mount));
+      const GObjectPtr<GDrive> drive(g_mount_get_drive(mount));
       if (drive) {
-        GCharPtr unix_device(g_drive_get_identifier(
+        const GCharPtr unix_device(g_drive_get_identifier(
             drive.get(), G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE));
         if (unix_device) {
           DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, mountFrom: %s}",