Qual è il modo migliore per verificare se un volume è montato in uno script Bash?

Qual è il modo migliore per verificare se un volume è montato in uno script Bash?

Quello che mi piacerebbe davvero è un metodo che posso usare in questo modo:

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

Evitare l'uso /etc/mtabperché potrebbe essere incoerente.

Evita le tubazioni mountperché non deve essere così complicato.

Semplicemente:

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

(Lo spazio dopo il /mnt/fooè per evitare la corrispondenza ad es /mnt/foo-bar.)

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

o

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

findmnt -rno SOURCE,TARGET "$1"evita tutti i problemi nelle altre risposte. Fa chiaramente il lavoro con un solo comando.

Altri approcci hanno questi aspetti negativi:

• grep -qe grep -ssono un ulteriore passaggio non necessario e non sono supportati ovunque.
• /proc/\* non è supportato ovunque.
• mountinfo si basa su / proc / ..
• cut -f3 -d' ' incasina gli spazi nei nomi dei percorsi
• Lo spazio bianco del supporto di analisi è problematico. La sua pagina man ora dice:

.. la modalità elenco è mantenuta solo per compatibilità con le versioni precedenti.

Per un output più robusto e personalizzabile usa findmnt (8), specialmente nei tuoi script.

Funzioni 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

Esempi di utilizzo:

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

Una sceneggiatura come questa non sarà mai portatile. Un segreto sporco in unix è che solo il kernel sa dove sono i filesystem e, a meno di cose come / proc (non portatile), non ti darà mai una risposta diretta.

In genere uso df per scoprire qual è il punto di montaggio di una sottodirectory e in quale file system si trova.

Ad esempio (richiede shell posix come 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

Kinda ti dice informazioni utili.

il seguente è quello che uso in uno dei miei cron-job di backup rsync. controlla se / backup è montato e prova a montarlo in caso contrario (potrebbe non funzionare perché l'unità si trova in un alloggiamento hot-swap e potrebbe non essere presente nel sistema)

NOTA: il seguente funziona solo su Linux, perché greps / proc / monta - una versione più portatile eseguirà 'mount | grep / backup ', come nella risposta di Matthew ..

  Se ! grep -q / backup / proc / mounts; poi
    Se ! mount / backup; poi
      echo "fallito"
      uscita 1
    fi
  fi
  echo "superato".
  # fai cose qui

Dal momento che per montare, devi avere comunque una directory lì, che viene montata su, la mia strategia è sempre stata quella di creare un file fasullo con uno strano nome di file che non sarebbe mai stato usato, e controllare solo la sua esistenza. Se il file era lì, allora nulla è stato montato in quel punto ...

Non penso che questo funzioni per il montaggio di unità di rete o cose del genere. L'ho usato per le unità flash.

Che ne dici di confrontare i numeri dei dispositivi? Stavo solo cercando di pensare al modo più esoterico ..

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

C'è un difetto nella mia logica con quello ...

Come una funzione:

#!/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

I messaggi di errore dell'eco sono probabilmente ridondanti, poiché stat visualizzerà anche un errore.

Nessuno di questi soddisfa il caso d'uso in cui una determinata directory è una sottodirectory all'interno di un altro punto di montaggio. Ad esempio, potresti avere / cosa che è un mount NFS per ospitare: / real_thing. L'uso di grep a questo scopo su / proc / mounts / etc / mtab o 'mount' non funzionerà, perché stai cercando un mount point che non esiste. Ad esempio, / cosa / cosa non è un punto di montaggio, ma / cosa è montato sull'host: / real_thing. La migliore risposta votata qui NON è in realtà "il modo migliore per determinare se una directory / volumne è montata". Voterei a favore usando 'df -P' (modalità standard POS--P) come strategia più pulita:

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"
}

L'output dell'esecuzione sarà:

Mounted via: host:/real_thing

Se vuoi sapere qual è il vero mount point, nessun 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"
}

L'output di quel comando sarà:

Mounted on: /thing

Tutto ciò è molto utile se stai cercando di creare una sorta di chroot che rispecchi i punti di mount all'esterno del chroot, all'interno del chroot, tramite una directory o un elenco di file arbitrari.

Ci scusiamo per averlo sollevato, ma penso che sia abbastanza utile:

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

Questo ottiene la seconda colonna di / proc / mounts (seconda colonna = punti di mount).

Quindi greps l'output. Nota ^ e $, questo impedisce / backup di corrispondere / mnt / backup o / backup-old ecc.

grep / etc / mtab per il tuo mount point forse?

Questo?:

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

Da: un forum di Ubuntu

Sebbene questa sia una domanda Linux, perché non renderla portatile quando è facile da eseguire?

La pagina di manuale di grepdice:

Gli script di shell portatili dovrebbero evitare sia -q che -s e dovrebbero invece reindirizzare l'output standard e di errore /dev/null.

Quindi propongo la seguente soluzione:

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

Deve essere più complicato di così?

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

Dipende da ciò che sai sul volume che stai cercando.

Nel caso particolare che ho studiato di recente, dove ero preoccupato di scoprire se era montata una particolare unità flash, ciò che funziona più facilmente è verificare l'esistenza di / dev / disks / by-label /. Se il dispositivo è collegato, gli script udev assicurano che il collegamento esista (e che venga rimosso quando il dispositivo viene scollegato).

(Questa NON è una risposta altamente portatile; funziona su molte moderne distribuzioni Linux, tuttavia, e la domanda è stata taggata per Linux, ed è un approccio completamente diverso da qualsiasi cosa finora menzionata, quindi espande le possibilità.)

Crea un file sotto il tuo mountpoint come check_mounte poi prova se esiste?

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

Ho dovuto farlo in Chef per idempotenza poiché quando lo chef-client sarebbe stato eseguito, la corsa avrebbe avuto esito negativo a causa del volume già montato. Al momento in cui scrivo, la mountrisorsa Chef ha una specie di bug che non funzionerebbe con gli attributi nel modo in cui avevo bisogno, quindi ho montato il volume usando la executerisorsa. Ecco come l'ho fatto:

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

In caso di confusione, nel mio file degli attributi, ho il seguente:

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

La if not node['docker-server']['mountpoint'] == "none"è una parte di una casedichiarazione in cui, se il punto di montaggio sul server non viene specificato, le impostazioni predefinite punto di montaggio none.