Qual é a melhor maneira de verificar se um volume está montado em um script Bash?

Qual é a melhor maneira de verificar se um volume está montado em um script Bash?

O que eu realmente gostaria é de um método que eu possa usar assim:

if <something is mounted at /mnt/foo> 
then
   <Do some stuff>
else
   <Do some different stuff>
fi

Evite usar, /etc/mtabpois pode ser inconsistente.

Evite tubulações, mountporque não precisa ser tão complicado.

Simplesmente:

if grep -qs '/mnt/foo ' /proc/mounts; then
    echo "It's mounted."
else
    echo "It's not mounted."
fi

(O espaço após o /mnt/fooé evitar correspondência, por exemplo /mnt/foo-bar.)

if mountpoint -q /mnt/foo 
then
   echo "mounted"
else
   echo "not mounted"
fi

ou

mountpoint -q /mnt/foo && echo "mounted" || echo "not mounted"

findmnt -rno SOURCE,TARGET "$1"evita todos os problemas nas outras respostas. Ele limpa o trabalho com apenas um comando.

Outras abordagens têm as seguintes desvantagens:

• grep -qe grep -ssão uma etapa extra desnecessária e não são suportadas em todos os lugares.
• /proc/\* não é suportado em qualquer lugar.
• mountinfo é baseado em / proc / ..
• cut -f3 -d' ' bagunça espaços nos nomes dos caminhos
• A análise do espaço em branco da montagem é problemática. É página de manual agora diz:

.. o modo de listagem é mantido apenas para compatibilidade com versões anteriores.

Para uma saída mais robusta e personalizável, use findmnt (8), especialmente em seus scripts.

Funções do Bash:

#These functions return exit codes: 0 = found, 1 = not found

isMounted    () { findmnt -rno SOURCE,TARGET "$1" >/dev/null;} #path or device
isDevMounted () { findmnt -rno SOURCE        "$1" >/dev/null;} #device only
isPathMounted() { findmnt -rno        TARGET "$1" >/dev/null;} #path   only

#where: -r = --raw, -n = --noheadings, -o = --output

Exemplos de uso:

if isPathMounted "/mnt/foo bar";      #Spaces in path names are ok.
   then echo "path is mounted"
   else echo "path is not mounted"
fi

if isDevMounted "/dev/sdb4"; 
   then echo "device is mounted"
   else echo "device is not mounted"
fi

#Universal:
if isMounted "/mnt/foo bar"; 
   then echo "device is mounted"
   else echo "device is not mounted"
fi

if isMounted "/dev/sdb4";
   then echo "device is mounted"
   else echo "device is not mounted"
fi

Um script como esse nem sempre será portátil. Um segredo sujo no unix é que apenas o kernel sabe quais são os sistemas de arquivos e, além de coisas como / proc (não portável), nunca fornecerá uma resposta direta.

Normalmente, uso o df para descobrir qual é o ponto de montagem de um subdiretório e em que sistema de arquivos ele está.

Por exemplo (requer shell posix como ash / AT&T ksh / bash / etc)

case $(df  $mount)
in
  $(df  /)) echo $mount is not mounted ;;
  *) echo $mount has a non-root filesystem mounted on it ;;
esac

Meio que lhe informa informações úteis.

a seguir é o que eu uso em um dos meus cron-jobs de backup rsync. ele verifica se / backup está montado e tenta montá-lo, se não estiver (pode falhar porque a unidade está em um compartimento de troca a quente e pode até não estar presente no sistema)

NOTA: o seguinte funciona apenas no linux, porque greps / proc / mounts - uma versão mais portátil executaria 'mount | grep / backup ', como na resposta de Matthew ..

  E se ! grep -q / backup / proc / montagens; então
    E se ! montagem / backup; então
      eco "falhou"
      saída 1
    fi
  fi
  eco "superado".
  # faça coisas aqui

Como para montar, você precisa ter um diretório lá de qualquer maneira, que seja montado, minha estratégia sempre foi criar um arquivo falso com um nome de arquivo estranho que nunca seria usado e apenas verificar sua existência. Se o arquivo estava lá, nada foi montado naquele local ...

Eu não acho que isso funcione para montar unidades de rede ou coisas assim. Eu usei para drives flash.

Que tal comparar números de dispositivos? Eu só estava tentando pensar da maneira mais esotérica ..

#!/bin/bash
if [[ $(stat -c "%d" /mnt) -ne $(stat -c "%d" /mnt/foo) ]]; then
    echo "Somethin mounted there I reckon"
fi

Há uma falha na minha lógica com isso ...

Como uma função:

#!/usr/bin/bash
function somethingMounted {
        mountpoint="$1"
        if ! device1=$(stat -c "%d" $mountpoint); then
                echo "Error on stat of mount point, maybe file doesn't exist?" 1>&2
                return 1
        fi
        if ! device2=$(stat -c "%d" $mountpoint/..); then
                echo "Error on stat one level up from mount point, maybe file doesn't exist?" 1>&2
                return 1
        fi

        if [[ $device1 -ne $device2 ]]; then
                #echo "Somethin mounted there I reckon"
                return 0
        else
                #echo "Nothin mounted it seems"
                return 1
        fi
}

if somethingMounted /tmp; then
        echo "Yup"
fi

As mensagens de erro de eco provavelmente são redundantes, porque o stat também exibirá o erro.

Nenhuma delas satisfaz o caso de uso em que um determinado diretório é um subdiretório dentro de outro ponto de montagem. Por exemplo, você pode ter / coisa que é uma montagem NFS para hospedar: / real_thing. Usar grep para esse fim em / proc / mounts / etc / mtab ou 'mount' não funcionará, porque você estará procurando um ponto de montagem que não existe. Por exemplo, / thing / thingy não é um ponto de montagem, mas / thing está montado no host: / real_thing. A melhor resposta votada aqui NÃO é "a melhor maneira de determinar se um diretório / volume está montado". Eu votaria a favor usando 'df -P' (modo de padrões -P POSIX) como uma estratégia mais limpa:

dev=`df -P /thing/thingy | awk 'BEGIN {e=1} $NF ~ /^\/.+/ { e=0 ; print $1 ; exit } END { exit e }'` && {
    echo "Mounted via: $dev"
} || {
    echo "Not mounted"
}

A saída da execução disso será:

Mounted via: host:/real_thing

Se você deseja saber qual é o verdadeiro ponto de montagem, não há problema:

mp=`df -P /thing/thingy | awk 'BEGIN {e=1} $NF ~ /^\/.+/ { e=0 ; print $NF ; exit } END { exit e }'` && {
    echo "Mounted on: $mp"
} || {
    echo "Not mounted"
}

A saída desse comando será:

Mounted on: /thing

Tudo isso é muito útil se você estiver tentando criar algum tipo de chroot que espelhe pontos de montagem fora do chroot, dentro do chroot, por meio de um diretório ou lista de arquivos arbitrários.

Desculpe por trazer isso à tona, mas acho que isso é bastante útil:

if awk '{print $2}' /proc/mounts | grep -qs "^/backup$"; then
    echo "It's mounted."
else
    echo "It's not mounted."
fi

Isso obtém a segunda coluna de / proc / mounts (segunda coluna = pontos de montagem).

Então ele recebe a saída. Observe ^ e $, isso impede / backup de corresponder / mnt / backup ou / backup-old etc.

grep / etc / mtab para o seu ponto de montagem, talvez?

Este?:

volume="/media/storage"
if mount|grep $volume; then
echo "mounted"
else
echo "not mounted"
if

De: Um fórum do Ubuntu

Embora essa seja uma pergunta sobre o Linux, por que não torná-lo portátil quando é fácil?

A página do manual grepdiz:

Os scripts de shell portáteis devem evitar -q e -s e, em /dev/nullvez disso, devem redirecionar a saída padrão e de erro .

Então, proponho a seguinte solução:

if grep /mnt/foo /proc/mounts > /dev/null 2>&1; then
        echo "Mounted"
else
        echo "NOT mounted"
fi

Precisa ser mais complicado que isso?

mount \
    | cut -f 3 -d ' ' \
    | grep -q /mnt/foo \
  && echo "mounted" || echo "not mounted"

Depende do que você sabe sobre o volume que está verificando.

No caso específico que pesquisei recentemente, em que estava preocupado em descobrir se uma unidade flash específica foi montada, o que funciona mais facilmente é verificar a existência de / dev / disks / by-label /. Se o dispositivo estiver conectado, os scripts do udev garantem que o link exista (e que ele seja removido quando o dispositivo estiver desconectado).

(Essa NÃO é uma resposta altamente portátil; funciona em muitas distribuições modernas do Linux, e a pergunta foi marcada para Linux, e é uma abordagem completamente diferente de qualquer coisa mencionada até agora, para expandir as possibilidades.)

Crie um arquivo sob o seu ponto de montagem check_mounte teste apenas se ele existe?

if [[ -f /something/check_mount ]]; then
   echo "Mounted
   RC=$?
else
   Echo "Not mounted"
   RC=0
fi
exit $RC

Eu tive que fazer isso no Chef por idempotência, já que quando o chef-client seria executado, a execução falharia devido ao volume já estar montado. No momento em que escrevo isso, o mountrecurso Chef possui algum tipo de erro que não funcionaria com os atributos da maneira que eu precisava, então montei o volume usando o executerecurso. Aqui está como eu fiz isso:

if not node['docker-server']['mountpoint'] == "none"
  execute "set up mount" do
    user "root"
    command "mount -t ext4 #{node['docker-server']['mountpoint']} #{node['docker-server']['data-dir']}"
    not_if "grep -qs #{node['docker-server']['data-dir']} /proc/mounts"
  end
end

Em caso de confusão, no meu arquivo de atributos, tenho o seguinte:

default['docker-server']['mountpoint'] = "/dev/vdc"
default['docker-server']['data-dir'] = "/data"

Isso if not node['docker-server']['mountpoint'] == "none"faz parte de uma caseinstrução em que, se o ponto de montagem no servidor não for especificado, o ponto de montagem será o padrão none.