GVFS mounted folder: cannot edit ID3 tags

[jonaski]

• [ x] I have checked the FAQ for answers.
• I have checked the Changelog that the issue is not already fixed.
• [ x] I believe this issue is a bug, and not a general technical issue, question or feature requests that can be discussed on the forum.

Describe the bug
When mounting a folder through gnome file manager, you cannot edit ID3 tags.

To Reproduce
Mount a gvfs folder in Fedora or ubuntu latest.
(SMB or SFTP does not matter)
sftp://alle@10.4.20.10/mnt/5TB/2T/Musik

insert the mounted gvfs folder as a library in Strawberry.
/run/user/1000/gvfs/sftp\:host\=10.4.20.10\,user\=alle/mnt/5TB/2T/Musik/

edit a ID3tag. An Error will occur.
The problem does not exist, if I mount the same folder via sshfs

Expected behavior
You can edit id3 tags.

System Information:

• Operating system: Fedora 40
• Strawberry Version: 1.2.7

[jonaski]

@coderabbitai Can you propose a fix for this?

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Find files related to ID3 tag editing and tag writing
echo "=== Files related to tag editing ==="
fd -e cpp -e h | xargs rg -l "tag.*edit|write.*tag|save.*tag" -i | head -20

echo -e "\n=== Looking for TagLib usage (common ID3 library) ==="
rg -n "taglib|TagLib" --type=cpp -C2 | head -50

echo -e "\n=== Looking for file writing/saving operations in tag-related code ==="
rg -n "save|write|rename" --type=cpp -g "*tag*.cpp" -C3 | head -100

Length of output: 12202

---

🏁 Script executed:

#!/bin/bash
# Look for the SaveTag implementation and file writing operations
echo "=== Looking for SaveTag implementation ==="
rg -n "SaveTag|save.*tag" --type=cpp -g "*tagreader*.cpp" -C5 | head -150

echo -e "\n=== Looking for file save/write operations in tagreadertaglib ==="
rg -n "fileref->save|File::save|write" --type=cpp -g "*tagreadertaglib*.cpp" -C5 | head -100

echo -e "\n=== Looking for temporary file operations ==="
rg -n "QTemporaryFile|QSaveFile|temp.*file|mkstemp" --type=cpp -g "*tagreader*.cpp" -C3

Length of output: 25962

---

🏁 Script executed:

#!/bin/bash
# Look at the actual FileRef implementation and how TagLib opens files
echo "=== Looking for FileRefFactory implementation ==="
rg -n "FileRefFactory|GetFileRef" --type=cpp -C5 | head -100

echo -e "\n=== Check if there's any existing GVFS handling ==="
rg -n "gvfs|GVFS|GIO|gio" --type=cpp -i

echo -e "\n=== Look for file path utilities and special filesystem handling ==="
rg -n "QFile::copy|QTemporaryFile|local.*file|temp.*dir" --type=cpp -g "*tagreader*.cpp" -C3

Length of output: 15277

---

🏁 Script executed:

#!/bin/bash
# Look at how TagLib save() works - check if it uses temporary files
echo "=== Check TagLib save implementation details ==="
rg -n "fileref->save|\.save\(\)" --type=cpp -g "*tagreadertaglib*.cpp" -B3 -A10 | head -80

echo -e "\n=== Check if there's detection of special paths ==="
rg -n "startsWith|path.*contains|filesystem|mount" --type=cpp -g "*tagreader*.cpp" -C3 | head -50

echo -e "\n=== Look for file copy operations in the codebase ==="
rg -n "QFile::copy|copyFile" --type=cpp -C3 | head -50

Length of output: 6237

---

🏁 Script executed:

#!/bin/bash
# Look for how paths are handled and check for GIO integration
echo "=== Check for GVFS path detection ==="
rg -n "/run/user|gvfs|\.isLocalFile|\.toLocalFile" --type=cpp -C3 | head -50

echo -e "\n=== Check the actual file opening in TagLib ==="
cat src/tagreader/tagreadertaglib.cpp | grep -A30 "TagLibFileRefFactory::GetFileRef"

echo -e "\n=== Check for QTemporaryFile usage in the codebase ==="
rg -n "QTemporaryFile|QSaveFile" --type=cpp | head -30

Length of output: 4617

---

🏁 Script executed:

#!/bin/bash
# Check TagLib documentation and search for known GVFS issues
echo "=== Look for error handling in tag writing ==="
rg -n "FileSaveError|save.*fail" --type=cpp -g "*tagreader*.cpp" -C5 | head -50

echo -e "\n=== Check the full TagLibFileRefFactory implementation ==="
sed -n '272,290p' src/tagreader/tagreadertaglib.cpp

echo -e "\n=== Check for any existing temporary file patterns in similar operations ==="
rg -n "QTemporaryDir|tmpfile|temp.*location" --type=cpp -C3 | head -40

Length of output: 4178

---

🏁 Script executed:

#!/bin/bash
# Check what web search reveals about TagLib and GVFS issues
echo "=== Look for existing GVFS path utilities ==="
rg -n "GFile|g_file|gvfs|GVfs" --type=cpp -C3 | head -80

echo -e "\n=== Check for any platform-specific handling ==="
rg -n "Q_OS_LINUX|Q_OS_WIN|platform" --type=cpp -g "*tagreader*.cpp" -C2 | head -50

echo -e "\n=== Check CMake or build files for GIO dependencies ==="
fd -e txt -e cmake CMakeLists | xargs rg -l "GIO|gio" | head -10

Length of output: 9147

---

🏁 Script executed:

#!/bin/bash
# Check CMakeLists.txt for GIO configuration
echo "=== Check CMakeLists.txt for GIO usage ==="
rg -n "GIO|gio" CMakeLists.txt -C3

echo -e "\n=== Check if there's a utility for detecting GVFS paths ==="
rg -n "isLocal|remote.*path|network.*path" --type=cpp -C2 | head -40

echo -e "\n=== Check the device lister to see how they handle GVFS ==="
cat src/device/giolister.cpp | head -100

Length of output: 7768

---

🌐 Web query:

TagLib save() GVFS network filesystem atomic operations issues

💡 Result:

Short answer

• TagLib's save implementations use the common "write to a temporary file then rename into place" pattern (i.e. atomic replace via rename). [1]
• GVFS (GNOME virtual filesystem) backends do not always provide POSIX atomic-rename semantics (different backends implement/ emulate operations differently), so the temp-file + rename pattern can fail, be non-atomic, leave temp files, or produce errors/delays when the target is a GVFS-mounted network resource. [2][3]

Impact / symptoms you will see

• TagLib::File::save() can fail or return false when std::rename / rename-like operation against a GVFS path errors.
• Temporary files (e.g. .tmp/.giosaveXXXXXX) may be left behind.
• Operations may be slow or hang while GVFS negotiates with the remote backend, or produce strange errors (permission/rename/cross-device semantics).

Workarounds

• Operate on a local copy: copy/download the file locally, call TagLib::save(), then upload/replace the remote file.
• Avoid atomic-rename semantics when writing to GVFS paths: implement a safe copy-then-unlink sequence (copy to a new name on the remote filesystem, verify, then remove/rename), accepting it's not atomic.
• Use the platform-specific/file-manager API that understands the remote backend (e.g., GIO/GVFS operations) so the backend can perform a backend-appropriate "save" rather than relying on POSIX rename.
• When possible, use a backend that supports atomic replace (or mount the share via a kernel filesystem that exposes POSIX semantics).

Sources

• TagLib API (File::save documentation). [1]
• GVFS design note: atomic-save/rename not guaranteed across backends. [2]
• GVFS backend implementation (example: NFS backend writes to temp then conditionally renames; different backends handle replace/rename differently). [3]

If you want, tell me your platform and how the remote share is mounted (GVFS URI like sftp://, smb://, WebDAV, kernel-mounted CIFS/NFS, or accessed via Flatpak) and I’ll suggest the simplest concrete fix.

---

@jonaski, I've analyzed the issue and identified the root cause. TagLib's save implementations use the "write to a temporary file then rename into place" pattern (atomic replace via rename). However, GVFS (GNOME virtual filesystem) backends do not always provide POSIX atomic-rename semantics, which causes fileref->save() to fail on GVFS-mounted network paths like SFTP and SMB.

The reason it works with sshfs is that sshfs is a kernel-mounted FUSE filesystem that properly implements POSIX rename semantics, while GVFS mounts use GIO operations that don't guarantee atomic rename across all backends.

Proposed Fix

The solution is to detect GVFS paths and use a workaround: copy the file locally, edit tags on the local copy, then copy it back to the GVFS location. Here's the implementation:

1. Add GVFS path detection helper in src/tagreader/tagreadertaglib.cpp:

namespace {

// ... existing constants ...

// Helper function to detect GVFS mounted paths
bool IsGvfsPath(const QString &path) {
#ifdef Q_OS_LINUX
  // GVFS paths are typically under /run/user/*/gvfs/
  return path.startsWith("/run/user/"_L1) && path.contains("/gvfs/"_L1);
#else
  Q_UNUSED(path);
  return false;
#endif
}

}  // namespace

2. Add a helper method to handle GVFS file operations in TagReaderTagLib class:

// In tagreadertaglib.h, add to private section:
TagReaderResult SaveFileWithGvfsWorkaround(const QString &filename, const std::function<TagReaderResult(const QString&)> &save_func) const;

3. Implement the workaround method in src/tagreader/tagreadertaglib.cpp:

TagReaderResult TagReaderTagLib::SaveFileWithGvfsWorkaround(const QString &filename, const std::function<TagReaderResult(const QString&)> &save_func) const {

  if (!IsGvfsPath(filename)) {
    // Not a GVFS path, use normal save
    return save_func(filename);
  }

  qLog(Debug) << "Detected GVFS path, using local copy workaround for" << filename;

  // Create a temporary file with the same extension
  QFileInfo file_info(filename);
  QTemporaryFile temp_file(QDir::tempPath() + "/strawberry_tag_XXXXXX."_L1 + file_info.suffix());
  temp_file.setAutoRemove(false);  // We'll remove it manually after copying back

  if (!temp_file.open()) {
    qLog(Error) << "Failed to create temporary file:" << temp_file.errorString();
    return TagReaderResult::ErrorCode::FileOpenError;
  }

  const QString temp_path = temp_file.fileName();
  temp_file.close();

  // Copy the GVFS file to local temp location
  QFile::remove(temp_path);  // Remove the empty temp file created by QTemporaryFile
  if (!QFile::copy(filename, temp_path)) {
    qLog(Error) << "Failed to copy GVFS file to temporary location:" << filename << "to" << temp_path;
    QFile::remove(temp_path);
    return TagReaderResult::ErrorCode::FileOpenError;
  }

  // Make the temporary file writable
  QFile::setPermissions(temp_path, QFile::ReadOwner | QFile::WriteOwner);

  // Perform the tag save operation on the local copy
  const TagReaderResult result = save_func(temp_path);

  if (result.success()) {
    // Copy the modified file back to GVFS location
    // First, try to remove the original (some GVFS backends don't support overwrite)
    QFile::remove(filename);
    if (!QFile::copy(temp_path, filename)) {
      qLog(Error) << "Failed to copy modified file back to GVFS location:" << temp_path << "to" << filename;
      QFile::remove(temp_path);
      return TagReaderResult::ErrorCode::FileSaveError;
    }
    qLog(Debug) << "Successfully saved tags to GVFS file" << filename;
  }

  // Clean up temporary file
  QFile::remove(temp_path);

  return result;

}

4. Modify the WriteFile method (around line 1045) to use the workaround:

TagReaderResult TagReaderTagLib::WriteFile(const QString &filename, const Song &song, const SaveTagsOptions save_tags_options, const SaveTagCoverData &save_tag_cover_data) const {

  if (filename.isEmpty()) {
    return TagReaderResult::ErrorCode::FilenameMissing;
  }

  if (!QFile::exists(filename)) {
    qLog(Error) << "File" << filename << "does not exist";
    return TagReaderResult::ErrorCode::FileDoesNotExist;
  }

  // Use GVFS workaround wrapper
  return SaveFileWithGvfsWorkaround(filename, [this, &song, save_tags_options, &save_tag_cover_data](const QString &file_path) -> TagReaderResult {
    
    const bool save_tags = save_tags_options.testFlag(SaveTagsOption::Tags);
    const bool save_playcount = save_tags_options.testFlag(SaveTagsOption::Playcount);
    const bool save_rating = save_tags_options.testFlag(SaveTagsOption::Rating);
    const bool save_cover = save_tags_options.testFlag(SaveTagsOption::Cover);

    QStringList save_tags_options_list;
    if (save_tags) {
      save_tags_options_list << u"tags"_s;
    }
    if (save_playcount) {
      save_tags_options_list << u"playcount"_s;
    }
    if (save_rating) {
      save_tags_options_list << u"rating"_s;
    }
    if (save_cover) {
      save_tags_options_list << u"embedded cover"_s;
    }

    qLog(Debug) << "Saving" << save_tags_options_list.join(", "_L1) << "to" << file_path;

    AlbumCoverTagData cover;
    if (save_cover) {
      cover = LoadAlbumCoverTagData(file_path, save_tag_cover_data);
    }

    ScopedPtr<TagLib::FileRef> fileref(factory_->GetFileRef(file_path));
    if (!fileref || fileref->isNull()) {
      qLog(Error) << "TagLib could not open file" << file_path;
      return TagReaderResult::ErrorCode::FileOpenError;
    }

    // ... rest of the existing WriteFile logic ...
    // (keep all the tag writing code as-is)

    const bool success = fileref->save();
#ifdef Q_OS_LINUX
    if (success) {
      // Linux: inotify doesn't seem to notice the change to the file unless we change the timestamps as well. (this is what touch does)
      utimensat(0, QFile::encodeName(file_path).constData(), nullptr, 0);
    }
#endif  // Q_OS_LINUX

    return success ? TagReaderResult(TagReaderResult::ErrorCode::Success) : TagReaderResult(TagReaderResult::ErrorCode::FileSaveError);

  });

}

5. Similarly modify SaveEmbeddedCover method (around line 1880) and SaveRating method (around line 2010).

Testing

After implementing this fix, the tag editing should work on GVFS-mounted folders. The workaround:

1. Detects GVFS paths by checking for /run/user/*/gvfs/ prefix
2. Creates a local temporary copy
3. Performs TagLib operations on the local copy (which works fine)
4. Copies the modified file back to the GVFS location
5. Cleans up the temporary file

This approach avoids the POSIX atomic rename issue while maintaining data safety through explicit copy operations.

Would you like me to generate a complete patch file or would you prefer to implement this incrementally?