sviluppo-web-qa.it

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
109
Mark Biek

Evitare di utilizzare /etc/mtab perché potrebbe essere incoerente.

Evita il piping mount perché 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.)

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

o

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

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


Altri approcci hanno questi aspetti negativi:

  • grep -q e grep -s sono un ulteriore passaggio non necessario e non sono supportati ovunque.
  • /proc/\* non è supportato ovunque.
  • mountinfo si basa su/proc/..
  • cut -f3 -d' ' rovina gli spazi nei nomi dei percorsi
  • L'analisi dello spazio bianco mount è problematica. La sua pagina man ora dice:

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

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


Funzioni di 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
21
Elliptical view

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 Posix Shell 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.

7
chris

il seguente è quello che uso in uno dei miei cron-job di backup rsync. controlla se/backup è montato e prova a montarlo se non lo è (potrebbe non funzionare perché l'unità si trova in un alloggiamento hot-swap e potrebbe non essere nemmeno 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; quindi 
 se! mount/backup; quindi 
 echo "fallito" 
 uscita 1 
 fi 
 fi 
 echo "superato". 
 # fai cose qui 
6
cas

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 falso 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.

2
Brian Postow

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.

2
Kyle Brandt

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.

1
David

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 su Host:/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 su 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 al di fuori del chroot, all'interno del chroot, tramite una directory o un elenco di file arbitrari.

1
Craig

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à.)

0

Mi piacciono le risposte che usano /proc/mounts, ma non mi piace fare un grep semplice. Questo può darti falsi positivi. Quello che davvero vuoi sapere è "una delle righe ha questa stringa esatta per il campo numero 2". Quindi, fai questa domanda. (in questo caso sto controllando /opt)

awk -v status=1 '$2 == "/opt" {status=0} END {exit status}' /proc/mounts

# and you can use it in and if like so:

if awk -v status=1 '$2 == "/opt" {status=0} END {exit status}' /proc/mounts; then
  echo "yes"
else
  echo "no"
fi
0
Bruno Bronosky

Anche se questa è una domanda Linux, perché non renderla portatile quando è facile da fare?

La pagina di manuale di grep dice:

Gli script di Shell portatili dovrebbero evitare sia -q che -s e reindirizzare l'output standard ed errore a /dev/null anziché.

Quindi propongo la seguente soluzione:

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

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

0
Ophidian

Deve essere più complicato di così?

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

Questo?:

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

Da: n forum di Ubunt

0
RateControl

Crea file sotto il tuo mountpoint come check_mount e poi prova solo se esiste?

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