Como obter o ponto de montagem do sistema de arquivos contendo o arquivo fornecido

Question

Estou procurando uma maneira rápida de encontrar o ponto de montagem do sistema de arquivos que contém um determinado FILE. Existe alguma coisa mais simples ou direta do que a minha solução abaixo?

df -h FILE |tail -1 | awk -F% '{print $NF}' | tr -d ' '

Uma pergunta semelhante " Is existe um comando para ver onde um disco é montado? "usa o nó de dispositivo do disco atual como entrada, e não um arquivo arbitrário do disco ...

    

Answer 1

Você poderia fazer algo como

df -P FILE | awk 'NR==2{print $NF}'

ou até mesmo

df -P FILE | awk 'END{print $NF}'

Como o awk divide em espaços em branco por padrão, você não precisa especificar o -F e também não precisa cortar o espaço em branco com tr . Finalmente, especificando o número da linha de interesse ( NR==2 ) você também pode acabar com tail .

    

Answer 2

No GNU / Linux, se você tem o GNU stat do coreutils 8.6 ou acima, você poderia fazer:

stat -c %m -- "$file"

Caso contrário:

mount_point_of() {
  f=$(readlink -e -- "$1") &&
    until mountpoint -q -- "$f"; do
      f=${f%/*}; f=${f:-/}
    done &&
    printf '%s\n' "$f"
}

Sua abordagem é válida, mas assume que o ponto de montagem não contém espaço,%, nova linha ou outros caracteres não imprimíveis, você pode simplificá-la com versões mais recentes do GNU df (8.21 ou superior):

df --output=target FILE | tail -n +2

    

Answer 3

Para o Linux, encontramos o findmnt do util-linux feito exatamente para isso

findmnt -n -o TARGET --target /path/to/FILE

Note que algum tipo de ponto de montagem aleatório pode ser retornado caso haja várias montagens de bind. Usando df tem o mesmo problema.

    

Answer 4

Como stat retorna um campo "Dispositivo", fiquei curioso para ver como a chamada subjacente da biblioteca stat() poderia ser usada para obter essas informações programaticamente de uma maneira compatível com POSIX.

Este snippet de código C:

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>

int main (int argc, const char *argv[]) {
    struct stat info;
    stat(argv[1], &info);
    printf("min: %d maj: %d\n",
        minor(info.st_dev),
        major(info.st_dev)
    );

    return 0;
}  

Os IDs de dispositivos principais e secundários serão fornecidos para o dispositivo que contém o arquivo listado na linha de comando ( argv[1] ). Infelizmente, major() e minor() não são POSIX, embora o man page afirme que eles estão "presentes em muitos outros sistemas" além do GNU / linux.

Você pode então obter uma correspondência entre o número principal / secundário do dispositivo e o nó do dispositivo, por exemplo, /proc/diskstats , e mapeá-lo para montar pontos de /proc/mounts , também conhecido como. /etc/mtab .

Portanto, um utilitário de linha de comando para isso seria bem simples.

    

Answer 5

Aqui está mais código C ++ se você quiser fazer isso em C ++ ...

  #include <boost/filesystem.hpp>
  #include <sys/stat.h>

  /// returns true if the path is a mount point
  bool Stat::IsMount(const std::string& path)
  {

      if (path == "") return false;
      if (path == "/") return true;

      boost::filesystem::path path2(path);
      auto parent = path2.parent_path();

      struct stat sb_path;
      if (lstat(path.c_str(), &sb_path) == -1) return false; // path does not exist
      if (!S_ISDIR(sb_path.st_mode)) return false; // path is not a directory

      struct stat sb_parent;
      if (lstat(parent.string().c_str(), &sb_parent) == -1 ) return false; // parent does not exist

      if (sb_path.st_dev == sb_parent.st_dev) return false; // parent and child have same device id

      return true;

  }

  /// returns the path to the mount point that contains the path
  std::string Stat::MountPoint(const std::string& path0)
  {
      // first find the first "real" part of the path, because this file may not exist yet
      boost::filesystem::path path(path0);
      while(!boost::filesystem::exists(path) )
      {
          path = path.parent_path();
      }

      // then look for the mount point
      path = boost::filesystem::canonical(path);
      while(! IsMount(path.string()) )
      {
          path = path.parent_path();
      }

      return path.string();
  }

Mais links para formas programáticas

• link