Come montare i supporti rimovibili in / media / <LABEL> automaticamente quando inseriti, senza alcun ambiente desktop?


17

Ho un sistema sid Debian (Wheezy) (e lo stesso per arch), senza alcun ambiente desktop (e niente Xorg).

Posso montare le mie schede SD, chiavette USB, HDD esterno tramite etichetta in una directory specificata /media/manualmente con mount/ umounte le voci adatte in /etc/fstab, o automaticamente al momento dell'avvio, ma questo è convincente, abbastanza restrittivo e non abbastanza dinamico per le mie esigenze: se voglio che vengano montati /media/<LABEL>, ogni dispositivo con un diverso ha <LABEL>bisogno di una propria voce e ogni <LABEL>sottodirectory deve essere creata / rimossa manualmente /media/anche in).

Quindi, qual è il modo migliore per montarli automaticamente in /media/<LABEL> all'inserimento (e smontare loro dal filesystem non appena siano scollegati , non importa quanto sia rischioso per i dati )?

La soluzione ideale sarebbe:

  1. rilevare quando un supporto rimovibile è collegato all'alimentazione (cioè quando aggiunto /dev/come sdax, sdbx, ... di udev)
  2. creare una directory in /media/base alla sua etichetta (etichetta del supporto rimovibile)
  3. montalo nella directory /media/<LABEL>in RWmodalità (se il suo filesystem lo supporta) con l' flushopzione (per a vfat)
  4. rilevare se il supporto è stato scollegato
  5. se quindi, smontalo dal filesystem
  6. rimuovere la directory corrispondente da /media/

(i dispositivi devono essere montati in modalità sincrona in modo odioso, per evitare qualsiasi perdita di dati quando sono scollegati a caldo a causa della modifica della cache :sync è troppo per i vfatsupporti rimovibili, quindi flush è stato creato come un compromesso , meno sicuro di sync, ma meno rischioso in base alla vita -cicli di memorie flash)

Ho trovato alcune informazioni su autofs, HAL, udisks, udisks2, usbmountecc, ma non è chiaro quale è deprecato o preferito, e in ogni caso, non ho capito come configurare facilmente sul mio sistema per fare questo, fino ad ora ...


Innanzitutto, hai cercato domande simili? Ricordo che è già stato chiesto. In secondo luogo, lo smontaggio dovrebbe avvenire prima dello scollegamento.
enzotib,

1
Certo che l'ho fatto: o] Qui e su superutente. Il problema è che gli strumenti si evolvono (udisks / udev) o sono deprecati (HAL?), Altri "non preferiti" (udisks2?) E così via. Comunque, non sono stato in grado di trovare alcuna soluzione funzionante o chiara. Gran parte di ciò che ho scoperto per sapere si basa su un meccanismo di ambiente desktop (Gnome, KDE o XFCE); Non voglio installarne nessuno. A proposito di smontare, non necessariamente. Se il dispositivo è impostato su sync, un demone può smontare il dispositivo da fs se rileva che è stato scollegato senza perdita di dati. Tutte le distro desktop lo fanno. Lo voglio nel terminale.
Cedbeu,

Guarda questa sostituzione perhalevt . Per quanto riguarda lo smontaggio, in genere DE si aspetta che il dispositivo venga espulso dal file manager, prima di scollegarlo fisicamente.
enzotib,

Sì vero. Ma ho visto che alcuni demoni (usati in precedenza) potrebbero smontare i dispositivi da fs che non sono stati smontati prima di scollegare, e persino cancellare automaticamente la loro directory corrispondente da / media /, e che rimanendo nel normale modo di fare le cose (se i dispositivi sono configurati per essere sincroni ovviamente). Grazie per il tuo link. Darò un'occhiata non appena torno a casa su udisksevt. Ho già dato un'occhiata a Devmon e Udiskie ma non sono nei pacchetti Debian. Se riesco a trovare qualcos'altro, lo proverò ma non riesco a credere che non ci sia una soluzione nativa su Debian per farlo.
Cedbeu,

1
Sono su Debian troppo e ho usare fdisk -le poi mount- questo è due comandi, ma OK, se lo vuoi automatizzata, dovrete per analizzare l' fdisk -luscita, e poi metterlo in mount- faccio cose del genere con head, tail, tr, cut, ecc. ma i professionisti di solito lo fanno con awko, ancora meglio, cercano i dati nel posto giusto. A proposito di cancellazione, almeno per me quando monto /mnt, è fatto automaticamente. A proposito del trigger (quando si collega) Non ho idea, ma per favore dicci quando lo risolvi.
Emanuel Berg,

Risposte:


10

Penso che tu stia cercando pmount.

Se si desidera il montaggio automatico al momento dell'inserimento, vedere Chiavette USB con montaggio automatico su Debian .

Se il tuo sistema utilizza udisks2 , questo è il modo preferito di reagire all'inserimento di un dispositivo di archiviazione rimovibile. Consulta Arch Wiki per i suggerimenti di configurazione per Udisks.

Altrimenti, il programma che reagisce quando appare un nuovo dispositivo è udev , quindi il montaggio automatico è attivato da una regola udev . Il pacchetto usbmount fornisce regole udev per montare automaticamente i dispositivi di archiviazione USB e pochi altri. La chiamata mountdalle regole di udev non funziona per i filesystem FUSE (come ntfs-3g), quindi usa udisks se ne hai bisogno.

Non è possibile smontare automaticamente i supporti quando vengono rimossi perché la causalità non funziona in questo modo. Il supporto deve essere smontato prima di essere rimosso. Per i supporti di sola lettura, è possibile evitare lo smontaggio dopo la rimozione, anche se ciò potrebbe confondere alcune applicazioni se hanno file aperti sul file system improvvisamente svanito. Per i supporti scrivibili, se si scollega un filesystem montato, è probabile che il danneggiamento dei dati.


Grazie mille per la risposta. Ci proverò appena possibile e lo farò sapere alla gente qui. A proposito di smontare. Ragazzi, per favore, smettetemi di dirmi che è una questione di causalità dove non lo è: o] Smontare dopo aver scollegato il dispositivo ha perfettamente senso (ed è possibile) non appena il dispositivo è configurato per essere sincrono. Quindi, è solo una questione di filesystem. Se i dati sono stati trasferiti senza memorizzazione nella cache (in modo sincrono), quindi nessun problema da scollegare senza smontare. Quindi, lo smontaggio può essere eseguito ed è utile solo per informare il sistema che il dispositivo non è più lì.
Cedbeu,

1
@cblab Stai semplificando troppo. Se un file è aperto per la scrittura e si estrae il dispositivo, è probabile che il file sia danneggiato; lo smontaggio assicura che nessun file sia aperto. Su molti filesystem (anche se non su FAT), smontare è più che impostare il bit sporco su 0, devono ad esempio svuotare un registro. Per i dispositivi flash, una delle principali preoccupazioni con i montaggi di sincronizzazione è che consuma il dispositivo molto più velocemente, poiché impedisce il raggruppamento delle scritture. Vedi superuser.com/questions/180722/… e readlist.com/lists/vger.kernel.org/linux-kernel/22/111748.html
Gilles 'SO- smetti di essere malvagio' il

Ciao @Gilles. Grazie per le tue risposte Non penso di essere troppo semplificato, però. Hai ragione su alcuni punti. Ma l'utente decide se vuole vivere rischioso. Sei d'accordo, il tuo post ha 7 anni; ora, flushun'opzione di montaggio progettata appositamente pervfat evitare questi problemi: la scrittura non viene eseguita dopo ogni blocco, ma non appena il dispositivo sembra essere inattivo. E i ricordi flash hanno notevolmente aumentato i loro cicli di vita senza uscita. Ora, ovviamente, l'utente deve essere consapevole di non scollegare i dispositivi mentre i file sono aperti o durante una copia (o subito dopo). Ma è il buon compromesso.
Cedbeu,

comunque, il usbmount avrebbe potuto essere la buona opzione per me, ma sfortunatamente, non monta i dispositivi su una cartella a seconda dei nomi delle loro etichette, ma in /media/usb-*, che non si adatta alle mie esigenze. Voglio essere in grado di montare automaticamente i dispositivi /media/<DEV_LABEL>con flushparametro quando vengono rilevati (se possibile con la creazione dinamica della directory), e di smontarli e rimuovere /media/automaticamente le directory se non vengono più rilevati. Il rischio che prendo dipende da me.
Cedbeu,

1
Fai attenzione che usbmountnon supporta più NTFS jessie: bugs.debian.org/774149
malat

2

Ecco come l'ho fatto di recente e sono abbastanza contento di questo approccio ora. Questo è per Ubuntu 12.04 + gentoo, ma suppongo che qualsiasi distro, che consente di installare udev e autofs dovrebbe funzionare.

Prerequisiti: devi aver installato udev + autofs.

Passo 1)

Crea il seguente file "/etc/udev/rules.d/90-usbsd-auto.rules" (ovviamente puoi usare qualsiasi nome purché termini con ".rules"). :

# Add symlink /dev/usbdisks/<label> to /dev/sd[a-z][1-9] 
# if partition has a label
# Add symlink /media/usb/<label> to /media/autousb/<label>
# for automounter support
ACTION=="add", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}=="?*", \
    SYMLINK+="usbdisks/$env{ID_FS_LABEL_ENC}", MODE:="0660", \
    RUN+="/bin/rm /media/usb/$env{ID_FS_LABEL_ENC}", \
    RUN+="/bin/ln -sf /media/autousb/$env{ID_FS_LABEL_ENC} /media/usb/$env{ID_FS_LABEL_ENC}"

# Fallback: If partition has a NO label, use kernel name (sd[a-z][1-9])
ACTION=="add", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}!="?*", \
    SYMLINK+="usbdisks/%k", MODE:="0660", \
    RUN+="/bin/rm /media/usb/%k", \
    RUN+="/bin/ln -sf /media/autousb/%k /media/usb/%k"

# Some FileSystems emit a "change" event when they are unmounted.
# UDEV seems to delete the device symlink in this case :-(
# So we need to re-create it here
ACTION=="change", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}=="?*", \
    SYMLINK+="usbdisks/$env{ID_FS_LABEL_ENC}", MODE:="0660"

# Fallback: If partition has NO label, use kernel name
ACTION=="change", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}!="?*", \
    SYMLINK+="usbdisks/%k", MODE:="0660"


# When device is removed, also remove /media/usb/<label>
ACTION=="remove", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}=="?*", \
    RUN+="/bin/rm /media/usb/$env{ID_FS_LABEL_ENC}"

# Fallback: If partition has no label, remove /media/usb/%k
ACTION=="remove", KERNEL=="sd*", ENV{DEVTYPE}=="partition", \
    ENV{ID_BUS}=="usb", ENV{ID_FS_LABEL_ENC}!="?*", \
    RUN+="/bin/rm /media/usb/%k"

Cosa fa: Crea due collegamenti simbolici, uno per la partizione del dispositivo di archiviazione USB in "/ dev / usbdisks / <...>". Utilizzerà l'etichetta della partizione di archiviazione USB o il nome del kernel, se non è presente un'etichetta. Il secondo link simbolico si collegherà da "/ media / usb / <...>" a "/ media / autousb / <...>" per il supporto dell'automounter (vedere il passaggio 2).

Nota: inizialmente non avevo usato le regole con le variabili ID_FS_LABEL_ENC, dal momento che questo è pericoloso secondo me. Cosa succede se si collegano due chiavette USB che utilizzano la stessa etichetta?

Ma il poster voleva specificamente utilizzare l'etichetta del disco USB, quindi ho modificato le regole di conseguenza.

Per assicurarti che udev legga queste regole usa

sudo udevadm control --reload-rules

Con questo file di regole udev tutto è configurato per montare automaticamente la partizione del dispositivo di archiviazione USB. Si noti che in questo momento, il dispositivo NON verrà montato automaticamente (intenzionalmente). Verrà montato automaticamente dopo averlo utilizzato

Passo 2)

Imposta autofs su automount / media / autousb / <...>: ho aggiunto la seguente riga al mio file "/etc/auto.master" (per Ubuntu 12.04):

/media/autousb /etc/auto.usb --timeout=60

Ciò significa che AutoFS smonterà il dispositivo dopo 60 secondi di inattività. Potresti voler usare meno o più, a seconda dei tuoi gusti.

Per Gentoo devi modificare "/etc/autofs/auto.master" in modo che abbia senso usarlo

/media/autousb /etc/autofs/auto.usb --timeout=60

Ora ho creato "auto.usb" con il seguente contenuto:

#!/bin/bash

key=${1}
fstype=$(/sbin/blkid -o value -s TYPE /dev/usbdisks/${key})
if [ "${fstype}" = "vfat" ] ; then
  echo "-fstype=vfat,sync,uid=0,gid=plugdev,umask=007 :/dev/usbdisks/${key}"
  exit 0
fi
if [ "${fstype}" = "ntfs" ] ; then
  echo "-fstype=fuse.ntfs-3g,sync,uid=0,gid=plugdev,umask=007 :/dev/usbdisks/${key}"
  exit 0
fi
if [ "${fstype}" = "ext4" ] ; then
  echo "-fstype=ext4,sync,nocheck :/dev/usbdisks/${key}"
  exit 0
fi

exit 1

Questo auto.usb deve essere eseguibile, in modo che autofs lo usi come uno script (bash). Quindi per esempio

sudo chmod 0755 /etc/auto.usb

Cosa fa: Questo script dirà ad AutoFS (/ usr / sbin / automount) come montare la partizione del dispositivo di archiviazione USB.

Lo script utilizzerà prima "/ sbin / blkid" per scoprire quale tipo di file system è sulla partizione.

Lo script fornirà quindi le giuste opzioni di montaggio in base alla partizione del dispositivo.

Nota: ho incluso il codice di esempio per i file system "vfat" (probabilmente più comune per le chiavette USB), "ntfs" e "xfs". Ovviamente è abbastanza facile estenderlo per supportare più file system.

Passaggio 3) Opzionale ... Per "espellere" == smonta le tue chiavette USB (o partizioni sulla chiavetta USB), crea uno script sotto / sbin / usbeject:

#!/bin/bash
killall -s SIGUSR1 /usr/sbin/automount

Con questo script potresti usare "sudo usbeject" per smontare tutte le partizioni di dispositivi USB montate (dicendo a automount di smontarle).

Ovviamente puoi semplicemente assicurarti che la partizione non sia usata da nessuna parte; l'automounter smonterà quindi la partizione dopo il timeout di 60 secondi ...

Il vero trucco qui è usare i collegamenti simbolici da "/ media / usb" a "/ media / autousb":

  • I symlink "/ media / usb" saranno creati da udev, offrendo all'utente una semplice panoramica delle partizioni del dispositivo di archiviazione USB
  • AutoFS eseguirà il montaggio automatico della partizione su richiesta se la si utilizza tramite / media / usb
  • Con il file "auto.usb" con script potresti supportare qualsiasi tipo di file system e inoltre puoi supportare qualsiasi tipo di schema di denominazione.
  • Questo approccio supporta chiavette USB con più partizioni, anche se queste partizioni utilizzano tipi di file system diversi.

2

Ok, è passato molto tempo, ma risponderò comunque alla mia domanda con l'opzione migliore che ho trovato fin d'ora. Per riassumere: creare una udevregola, associata ad alcuni script (che creerà / rimuoverà le directory e disinserirà / monterà i dispositivi rimovibili) e collegata al udevtipo di evento del dispositivo = partition.

1 - Creazione di script di aggiunta / rimozione

Salvare il seguente script storage-automount.shin /lib/udev/e renderlo eseguibile ( sudo chmod a+x /lib/udev/storage-automount.sh):

#!/bin/sh

# set the mountpoint name according to partition or device name
mount_point=$ID_FS_LABEL
if [ -z $mount_point ]; then
    mount_point=${DEVNAME##*/}
fi

# if a plugdev group exist, retrieve it's gid set & it as owner of mountpoint
plugdev_gid="$(grep plugdev /etc/group|cut -f3 -d:)"
if [ -z $plugdev_gid ]; then
    gid=''
else
    chown root:plugdev $mount_point
    gid=",gid=$plugdev_gid"
fi

# create the mountpoint directory in /media/ (if not empty)
if [ -n $mount_point ]; then
    mkdir -p /media/$mount_point
    # other options (breaks POSIX): noatime,nodiratime,nosuid,nodev
    mount -t $ID_FS_TYPE \
      -o rw,flush,user,uid=0$gid,umask=002,dmask=002,fmask=002 \
      $DEVNAME /media/$mount_point
fi

Salvare il seguente script storage-autounmount.shin /lib/udev/e renderlo eseguibile ( sudo chmod a+x /lib/udev/storage-autounmount.sh):

#!/bin/sh

# set the mountpoint name according to partition or device name
mount_point=$ID_FS_LABEL
if [ -z $mount_point ]; then
    mount_point=${DEVNAME##*/}
fi

# remove the mountpoint directory from /media/ (if not empty)
if [ -n $mount_point ]; then
    umount -l /media/$mount_point
    rm -R /media/$mount_point
fi

2 - Creazione della udevregola per allegare quegli script agli eventi

E infine, aggiungi una udevregola in /etc/udev/rules.d/, ad esempio 85-storage-automount.rules:

ENV{DEVTYPE}=="partition", RUN+="/lib/udev/storage-automount.sh", ENV{REMOVE_CMD}="/lib/udev/storage-autounmount.sh"

e renderlo avere le stesse autorizzazioni delle altre regole in quella cartella / directory

Ora, quando si collega un dispositivo di archiviazione, verrà creata una directory in /media/base al nome della partizione (non ricordo ma penso che funzioni anche con la partizione NTFS) e la partizione verrà montata in essa. È R / W per gli utenti se hai un plugdevgruppo sul tuo sistema. Inoltre, i dispositivi sono montati in modalità sincrona al fine di limitare i rischi di perdita di dati in caso di scollegamento a caldo.

Quando il dispositivo viene rimosso, viene smontato e la directory viene rimossa da /media

Inoltre, lo strumento per monitorare gli udeveventi è udevadm monitor, con opzioni come --envo --property:

$ udevadm monitor --env

Questo è testato e funziona bene su debian e arch, ma probabilmente funziona su tutte le distribuzioni su cui si basano udev.


Penso che + r debba essere sostituito da + x in "impostalo su eseguibile (sudo chmod + r /lib/udev/storage-autounmount.sh)"
Jeremy,

Ho una nuova installazione di jessie su cui ho seguito da vicino le tue indicazioni, ma non riesco a far eseguire l'automount da tty1, anche dopo il riavvio (che non è nelle tue istruzioni, ma non ho nemmeno il pre-riavvio dell'automount). Viene rilevato l'inserimento dell'unità USB (ricevo i messaggi della console), ma non è visibile nulla in / media / (tranne cdrom). Posso montare manualmente l'unità USB, quindi so che funziona anche. [continua nel seguente commento]
TomRoche,

[continua dal commento precedente] Ho il pacchetto = udev installato, ho dirs = {/ etc / udev / rules.d /, / lib / udev /} pre-popolato e ho eseguibile = udevadm in $ PATH. Mi piacerebbe sapere (1) in quale versione di Debian hai fatto in modo che funzionasse? (Sto assumendo wheezy) (2) quali pacchetti Debian hai installato oltre udev?
TomRoche,

@TomRoche Era Wheezy, al momento, in effetti, e non avevo installato alcun pacchetto speciale, stavo cercando di fare una configurazione minimalista e stavo cercando di evitare il più possibile di usare pacchetti che non erano forniti dall'installazione minima. Non ho avuto bisogno di riavviare, è per questo che non è nelle mie istruzioni. È da parecchio tempo che non mi ci tuffo ... Potrei riprovare presto.
Cedbeu,

1

Penso che sia piuttosto tardi ma pubblicherò questo se qualcuno ne ha bisogno: (anche la mia prima risposta StackExchange)

Dopo aver verificato la soluzione in molti punti, ho trovato una soluzione semplice in Arch Wiki:

Link ad Arch Wiki .

È possibile aggiungere una regola udisks2 per modificare la directory di montaggio predefinita da /run/media/$USER/a /media/<Label>.

Aggiungi la seguente regola /etc/udev/rules.d/con un nome simile 99-udisks2.rules:

ENV{ID_FS_USAGE}=="filesystem|other|crypto", ENV{UDISKS_FILESYSTEM_SHARED}="1"

Quindi possiamo semplicemente installare un semplice strumento come Udiskie per il montaggio automatico.


Ciao e benvenuto qui. Grazie per la tua opzione Per Udiskie, in realtà volevo un'opzione di riga di comando completa (nessun Xorg né alcuna interfaccia grafica disponibile sul sistema). E ... La domanda ha 6,5 ​​anni (ohm, cavolo!), Immagino che le cose siano cambiate ora :) Ma comunque, +1 per la tua prima risposta, grazie.
Cedbeu,

1

Si prega di consultare la pagina ArchWiki Udev . Non dovresti eseguiremount dalle regole Udev o dagli script eseguiti dalle regole Udev.

Tuttavia, come mostrato nel progetto udev-media-automount , è abbastanza semplice farlo invocando un'unità Systemd dalla regola Udev, che quindi chiama uno script che esegue il montaggio. A differenza di udisks2 e di altre soluzioni, udev-media-automount è orientato al semplice caso in cui si desidera montare qualcosa come rootutente senza attendere necessariamente la presenza di un ambiente desktop o di una "sessione utente". Sembra essere esattamente ciò che l'OP chiede e l'ho trovato funzionale e di facile comprensione.


Bello grazie. È una domanda piuttosto vecchia che ho fatto (quasi 7 anni fa ... non mi fa sentire più giovane ^^). Tuttavia, darò un'occhiata alla tua proposta. Immagino che l'ambiente di sistema sia diventato molto più maturo da allora. Grazie, lo controllerò!
Cedbeu,

0

Ho trovato un modo per farlo modificando il file / etc / fstab. Una semplice voce assomiglia a:

/dev/sdb1 /media/robot/hdd1 ntfs defaults 0 0

<file system> <mount point> <type> <options> <dump> <pass>


I montaggi /etc/fstabvengono montati automaticamente solo all'avvio.
Graeme,

@Graeme, ho una sdcard che monto tramite / etc / fstab. Come test, ho provato a smontare e rimuovere fisicamente la scheda SD dal mio computer. Ho verificato che il mount non fosse più mostrato tramite 'df'. Quando ho reinserito la mia sdcard, la montatura è riapparsa anche se non l'avevo rimontata esplicitamente. Questo è su Ubuntu 16.04.
Gino,

@Gino, Ubuntu ha eseguito automaticamente il montaggio automatico per un po 'di tempo.
Graeme,

@Graeme, sembra che l'automounter Ubuntu stia scegliendo il mount corretto da / etc / fstab, se esiste lì. Quindi, almeno su Ubuntu 16.04, il mount viene automaticamente montato all'avvio e dopo successivi reinserimenti nella porta USB, se ce ne sono ..
Gino

@Gino Non ho usato Ubuntu per un po ', ma sono abbastanza sicuro che si monterà automaticamente sulla tua scheda SD indipendentemente da ciò che è nel fstab. Fstab riguarda più la configurazione di elementi di sistema di base che dischi aggiuntivi su sistemi moderni.
Graeme,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.