如何利用inode号创建硬链接，构建空间优化的备份系统？

Great question! Let's break this down—since hard links are tied to filesystem paths (not directly to inodes) in standard system calls, you'll need a small workaround to map your stored inodes back to usable paths first. Here's how to do it effectively:

Since inodes are unique only within a single filesystem, your first step is to connect the inode to its parent filesystem, then locate a valid path for that inode. Once you have a path, you can use standard link creation tools/APIs as usual.

Step 1: Track Filesystem Context Alongside Inodes #

First, optimize your index to avoid future headaches: when you first generate a hash/inode entry for a file, you already have access to its path—save that path in your index alongside the hash and inode. This skips the need to look up the inode later entirely.

If you need to work with existing entries that don't have paths stored, also track the mount point of the filesystem where the file resides. You can get this when building the index:

• Command line:

  df -P /path/to/target/file | tail -1 | awk '{print $6}'
  

• Python example:

  import os
  from pathlib import Path
  
  def get_mount_point(file_path):
      resolved_path = Path(file_path).resolve()
      while not resolved_path.is_mount():
          resolved_path = resolved_path.parent
      return str(resolved_path)
  
  # When adding to your index
  target_file = "/backup/storage/doc.pdf"
  file_stat = os.stat(target_file)
  mount_point = get_mount_point(target_file)
  # Store: hash_value, inode=file_stat.st_ino, mount_point, original_path=target_file
  

Step 2: Locate a Path for an Existing Inode #

If you don't have the original path saved, scan the filesystem's mount point to find any valid path linked to the inode:

• Command line (fast for most cases):

  # Stop searching after the first valid path (any path works for linking)
  find /your/mount/point -inum <target-inode> -type f -print -quit
  

• Python (more efficient for large filesystems):

  import os
  
  def find_path_by_inode(mount_point, target_inode):
      for root, _, files in os.walk(mount_point):
          for file in files:
              full_path = os.path.join(root, file)
              try:
                  # Use lstat to avoid following symlinks (they have their own inodes)
                  stat = os.lstat(full_path)
                  if stat.st_ino == target_inode:
                      return full_path
              except OSError:
                  # Skip unreadable files/directories
                  continue
      return None
  

Step 3: Create the Hard Link #

Once you have a valid source path, use standard tools to create the hard link:

• Command line:

  ln /found/source/path /new/backup/destination/linked_file
  

• Python:

  import os
  
  source_path = find_path_by_inode(saved_mount_point, target_inode)
  if source_path:
      os.link(source_path, "/backup/new_location/duplicate_file.txt")
  else:
      print("Error: No path found for the target inode")
  

Key Notes #

• Inode Uniqueness: Never forget—inode numbers are only unique per filesystem. Always pair inodes with their mount points if your backup spans multiple storage devices.
• Efficiency: Storing the original path in your index is the fastest solution. Avoid scanning filesystems whenever possible.
• Symlink Caution: Use lstat instead of stat when checking inodes to avoid accidentally following symbolic links, which have their own distinct inodes.

内容的提问来源于stack exchange，提问作者tony wallace