it-swarm-eu.dev

Monta automaticamente unità esterne su / media / LABEL all'avvio senza che l'utente abbia effettuato l'accesso?

Questa domanda è simile, ma è l'opposto di quello che voglio. Voglio che le unità USB esterne vengano montate automaticamente all'avvio, senza che nessuno abbia effettuato l'accesso, in posizioni come /media/<label>.

Non voglio dover inserire tutti i dati in fstab, in parte perché è noioso e fastidioso, ma soprattutto perché non posso prevedere cosa inserirò in esso o come cambieranno le partizioni in futuro.

Voglio che le unità siano accessibili a cose come MPD , e disponibili quando accedo con SSH. gnome-mount sembra montare solo cose quando sei loggato localmente in una sessione grafica di Gnome.

72
endolith
  • Nota per Ubuntu Server 11.10: Questo script fallisce su Ubuntu Server 11.10 a causa dell'ormai obsoleto comando vol_id. vol_id è stato sostituito da blkid. Per correggere lo script, sostituire "vol_id" con "blkid -o udev" nello script udev-auto-mount.sh.

Ho battuto la testa su questo per un po 'di tempo, e penso di aver trovato una soluzione funzionante. Questo è sviluppato e testato su un sistema basato su Debian, quindi dovrebbe funzionare su Ubuntu. Indicheremo le ipotesi che fa in modo che possa essere adattato anche ad altri sistemi.

  • Monta automaticamente le unità USB sul plug-in e non richiede molto tempo per adattarsi a Firewire.
  • Usa UDEV, quindi niente monkeying con HAL/DeviceKit/GNOME-Anything.
  • Crea automaticamente una directory /media/LABEL per montare il dispositivo su.

  • Tuttavia, può interferire con altri automounters; Non posso testarlo per quello. Mi aspetto che, con Gnome-VFS attivo, entrambi possano provare a fare il mount ... se Gnome-VFS fallisce il mount, potrebbe non configurare un'icona sul desktop. Smontare da Gnome dovrebbe essere possibile, ma potrebbe richiedere gksudo o simile.

Non ho provato questo all'avvio del sistema, ma l'unica ragione per cui posso vedere che potrebbe non funzionare è se prova a montare l'unità USB prima che il sistema sia pronto per il montaggio. Se questo è il caso, probabilmente avrai bisogno di un tweak aggiuntivo per lo script di mount. (Sono controllo con ServerFault per vedere se c'è qualche consiglio, ma non c'è molto interesse in esso.)

Andiamo avanti, allora.


Riferimenti UDEV:


Sfondo (UDEV? Whuzzat?)

UDEV è il sistema hotplug del kernel. È ciò che configura automaticamente i dispositivi appropriati ei collegamenti simbolici del dispositivo (ad esempio /dev/disk/by-label/<LABEL>), sia all'avvio sia per i dispositivi aggiunti mentre il sistema è in esecuzione.

D-Bus e HAL vengono utilizzati per inviare eventi hardware a listener come Ambienti desktop. Quindi, quando si accede a GNOME e si inserisce un CD o si inserisce un'unità USB, tale evento segue questa catena:

kernel -> udev -> dbus -> hal -> gnome-vfs/nautilus (mount)

E presto, il tuo disco sarà montato. Ma in un sistema senza testa, non vogliamo dover accedere per ottenere i vantaggi di automounting.

Regole di Udev

Dato che UDEV ci consente di scrivere regole ed eseguire programmi sull'inserimento del dispositivo, questa è la scelta ideale. Approfitteremo delle regole esistenti di Debian/Ubuntu, permettiamo loro di impostare il link simbolico /dev/disk/by-label/<LABEL> per noi, e aggiungeremo un'altra regola che monterà il dispositivo per noi.

Le regole di UDEV sono mantenute in /etc/udev/rules.d (e /lib/udev/rules.d su Karmic) e sono elaborate in ordine numerico. Qualsiasi file che non inizia con un numero viene elaborato dopo i file numerati. Sul mio sistema, le regole HAL si trovano in un file chiamato 90-hal.rules, quindi ho inserito le mie regole in 89-local.rules in modo che vengano elaborate prima di arrivare a HAL. In primo luogo, è necessario assicurarsi che queste regole avvengano dopo 60-persistent-storage.rules. local.rules potrebbe essere abbastanza buono.

Metti questo nel tuo nuovo file delle regole:

# /etc/udev/rules.d/local.rules 
# /etc/udev/rules.d/89-local.rules
# ADD rule: if we have a valid ID_FS_LABEL_ENC, and it's USB, mkdir and mount
ENV{ID_FS_LABEL_ENC}=="?*",   ACTION=="add",      SUBSYSTEMS=="usb", \
         RUN+="/usr/local/sbin/udev-automounter.sh %k"
  • Assicurati che non ci siano spazi dopo \, solo un newline (\n).

  • Cambia SUBSYSTEMS=="usb" in SUBSYSTEMS=="usb|ieee1394" per il supporto Firewire.

  • Se si desidera che il dispositivo sia sempre di proprietà di un determinato utente, aggiungere una clausola OWNER="username". Se hai solo bisogno dei file di proprietà di un particolare utente, modifica lo script di mount.

Leggendo la regola

Questo aggiunge un programma da eseguire nell'elenco dei programmi del dispositivo da eseguire. Identifica i dispositivi di partizione USB con <LABEL>, quindi passa queste informazioni a uno script che esegue il mount. In particolare, questa regola corrisponde a:

  1. ENV{ID_FS_LABEL_ENC}=="?*" - una variabile di ambiente impostata da una precedente regola di sistema. Non esiste per i non file system, ecco perché lo controlliamo. In realtà vogliamo utilizzare ID_FS_LABEL per il punto di montaggio, ma non ho convinto UDEV a fuggire per me, quindi lasceremo che lo script di mount gestisca quello.

    Questa e altre variabili d'ambiente sono ottenute da udev usando il comando vol_id ( deprecato ). È uno strumento utile per vedere i dettagli rapidi di Nice su una partizione:

    $ Sudo vol_id /dev/sdc1
    ID_FS_TYPE=ext2
    ID_FS_UUID=a40d282a-4a24-4593-a0ab-6f2600f920dd
    ID_FS_LABEL=Travel Dawgs
    ID_FS_LABEL_ENC=Travel\x20Dawgs
    ID_FS_LABEL_SAFE=Travel_Dawgs
    
  2. ACTION=="add" - corrisponde solo agli eventi add ...

  3. SUBSYSTEMS=="usb" - abbina solo i dispositivi che si trovano sul bus USB. Usiamo SUBSYSTEMS qui perché corrisponde ai genitori del nostro dispositivo; il dispositivo a cui siamo interessati sarà in realtà SUBSYSTEM == "scsi". La corrispondenza con un dispositivo USB padre evita di aggiungere il nostro programma alle unità interne.

  4. RUN+="..." - non una corrispondenza, ma un'azione: aggiungi questo programma all'elenco dei programmi da eseguire. Negli argomenti del programma, %k viene espanso al nome del dispositivo (ad esempio sdc1, non /dev/sdc1) e $env{FOO} ottiene il contenuto della variabile di ambiente FOO.

Test della regola

Il primo link di riferimento (sopra) è un eccellente tutorial su UDEV, ma è leggermente aggiornato. I programmi che esegue per testare le regole (udevtest in particolare) sono stati sostituiti dall'utilità udevadm catch-all.

Dopo aver aggiunto la regola, collega il dispositivo. Dagli qualche secondo, quindi controlla per vedere a quale dispositivo è stato assegnato:

$ ls -l /dev/disk/by-label/*
lrwxrwxrwx 1 root root 10 2009-10-25 07:27 label_Foo -> ../../sda1
lrwxrwxrwx 1 root root 10 2009-10-25 07:27 label_Bar -> ../../sdb1
lrwxrwxrwx 1 root root 10 2009-10-25 07:27 label_Baz -> ../../sdc1

Se la tua unità rimovibile contiene label_Baz, è sul dispositivo sdc1. Esegui questo e guarda l'output verso la fine:

$ Sudo udevadm test /sys/block/sdc/sdc1
parse_file: reading (...)                           (many lines about files it reads)
import_uevent_var: import into environment: (...)   (many lines about env variables)
(...)                                               (many lines tracing rule matches & programs run)
update_link: found 1 devices with name 'disk/by-label/LABEL_BAZ'
update_link: found '/block/sdc/sdc1' for 'disk/by-label/LABEL_BAZ'
update_link: compare (our own) priority of '/block/sdc/sdc1' 0 >= 0
update_link: 'disk/by-label/LABEL_BAZ' with target 'sdc1' has the highest priority 0, create it
udevtest: run: '/usr/local/sbin/udev-automounter.sh sdc1 LABEL_BAZ'
udevtest: run: 'socket:/org/freedesktop/hal/udev_event'
udevtest: run: 'socket:@/org/kernel/udev/monitor'

Cerca il nome dello script dalla nostra regola RUN+= nelle ultime righe (3 ° in basso in questo esempio). Puoi vedere gli argomenti che verrebbero usati per questo dispositivo. È possibile eseguire questo comando ora per verificare che gli argomenti siano validi; se funziona sulla tua linea di comando, dovrebbe funzionare automaticamente quando viene inserito un dispositivo.

Puoi anche monitorare gli eventi UDEV in tempo reale: esegui Sudo udevadm monitor (vedi man udevadm per i dettagli sugli switch). Quindi basta collegare un nuovo dispositivo e guardare gli eventi scorrere. (Probabilmente eccessivo a meno che non ci si trovi in ​​dettagli davvero di basso livello ...)

Ricaricare le regole

Una volta verificato che la regola viene letta correttamente, devi dire a UDEV di ricaricare le sue regole in modo che la nuova abbia effetto. Usa uno di questi metodi (se il primo non funziona, il secondo dovrebbe ... ma prova il primo):

  • eseguire Sudo udevadm control --reload-rules

  • eseguire Sudo /etc/init.d/udev reload

  • riavvio


Script! In realtà, 2 script ...


Ecco il primo script. Dal momento che il programma che eseguiamo deve essere completato rapidamente, basta far ruotare il secondo script in background. Metti questo in /usr/local/sbin/udev-automounter.sh:

#!/bin/sh
#
# USAGE: usb-automounter.sh DEVICE 
#   DEVICE   is the actual device node at /dev/DEVICE

/usr/local/sbin/udev-auto-mount.sh ${1} &

Ecco il secondo script. Questo fa un po 'più controllo di input. Metti questo in /usr/local/sbin/udev-auto-mount.sh. Potresti voler modificare le opzioni di montaggio di seguito. Questo script ora gestisce individualmente la partizione LABEL; UDEV invia solo il nome DEVICE.

Se c'è un problema nel montare le unità al momento dell'avvio , puoi inserire un lungo sleep 60 in questo script, per dare al sistema il tempo di arrivare fino in fondo prima che lo script tenti di montare l'unità.

Ho dato un suggerimento nei commenti su come controllare (eseguire ps per vedere se un webserver è in esecuzione), ma vorrai tweakarlo per il tuo sistema. Penso che la maggior parte dei server di rete che potresti utilizzare sarebbero sufficienti per questo scopo: nfsd, smbd, Apache, ecc. Il rischio, naturalmente, è che lo script di mount fallirà se il servizio non è in esecuzione, quindi forse testare un l'esistenza di un particolare file sarebbe una soluzione migliore.

#!/bin/sh
#
# USAGE: udev-auto-mount.sh DEVICE
#   DEVICE   is the actual device node at /dev/DEVICE
# 
# This script takes a device name, looks up the partition label and
# type, creates /media/LABEL and mounts the partition.  Mount options
# are hard-coded below.

DEVICE=$1

# check input
if [ -z "$DEVICE" ]; then
   exit 1
fi

# test that this device isn't already mounted
device_is_mounted=`grep ${DEVICE} /etc/mtab`
if [ -n "$device_is_mounted" ]; then
   echo "error: seems /dev/${DEVICE} is already mounted"
   exit 1
fi

# If there's a problem at boot-time, this is where we'd put
# some test to check that we're booting, and then run
#     sleep 60
# so the system is ready for the mount below.
#
# An example to experiment with:
# Assume the system is "booted enough" if the HTTPD server is running.
# If it isn't, sleep for half a minute before checking again.
#
# The risk: if the server fails for some reason, this mount script
# will just keep waiting for it to show up.  A better solution would
# be to check for some file that exists after the boot process is complete.
#
# HTTPD_UP=`ps -ax | grep httpd | grep -v grep`
# while [ -z "$HTTPD_UP" ]; do
#    sleep 30
#    HTTPD_UP=`ps -ax | grep httpd | grep -v grep`
# done


# pull in useful variables from vol_id, quote everything Just In Case
eval `/sbin/vol_id /dev/${DEVICE} | sed 's/^/export /; s/=/="/; s/$/"/'`

if [ -z "$ID_FS_LABEL" ] || [ -z "$ID_FS_TYPE" ]; then
   echo "error: ID_FS_LABEL is empty! did vol_id break? tried /dev/${DEVICE}"
   exit 1
fi


# test mountpoint - it shouldn't exist
if [ ! -e "/media/${ID_FS_LABEL}" ]; then

   # make the mountpoint
   mkdir "/media/${ID_FS_LABEL}"

   # mount the device
   # 
   # If expecting thumbdrives, you probably want 
   #      mount -t auto -o sync,noatime [...]
   # 
   # If drive is VFAT/NFTS, this mounts the filesystem such that all files
   # are owned by a std user instead of by root.  Change to your user's UID
   # (listed in /etc/passwd).  You may also want "gid=1000" and/or "umask=022", eg:
   #      mount -t auto -o uid=1000,gid=1000 [...]
   # 
   # 
   case "$ID_FS_TYPE" in

       vfat)  mount -t vfat -o sync,noatime,uid=1000 /dev/${DEVICE} "/media/${ID_FS_LABEL}"
              ;;

              # I like the locale setting for ntfs
       ntfs)  mount -t auto -o sync,noatime,uid=1000,locale=en_US.UTF-8 /dev/${DEVICE} "/media/${ID_FS_LABEL}"
              ;;

              # ext2/3/4 don't like uid option
       ext*)  mount -t auto -o sync,noatime /dev/${DEVICE} "/media/${ID_FS_LABEL}"
              ;;
   esac

   # all done here, return successful
   exit 0
fi

exit 1

Script di pulizia Super Bonus!

Un altro script. Tutto ciò è smontare il dispositivo e rimuovere le directory mountpoint. Si presuppone che abbia i privilegi a farlo, quindi è necessario eseguirlo con Sudo. Questo script ora utilizza il mountpoint completo sulla riga di comando, ad esempio:

$ /usr/local/sbin/udev-unmounter.sh "/media/My Random Disk"

Metti questo in /usr/local/sbin/udev-unmounter.sh:

#!/bin/sh
#
# USAGE: udev-unmounter.sh MOUNTPT
#   MOUNTPT is a mountpoint we want to unmount and delete.
MOUNTPT="$1"

if [ -z "$MOUNTPT" ]; then
   exit 1
fi


# test mountpoint - it should exist
if [ -e "${MOUNTPT}" ]; then

   # very naive; just run and pray
   umount -l "${MOUNTPT}" && rmdir "${MOUNTPT}" && exit 0

   echo "error: ${MOUNTPT} failed to unmount."
   exit 1
fi

echo "error: ${MOUNTPT} does not exist"
exit 1
73
quack quixote

Un'ultima opzione che altri hanno suggerito in rete è ivman, ma sembra dipendere da pmount, che tu hai già dichiarato non funziona. pmount è abbandonato e ivman è quasi lo stesso.

La sostituzione di ivman è halevt ed è disponibile in Karmic. È una reimplementazione di ivman (leggi: "mantenuto" e "non dipende da pmount"). Il pacchetto non è disponibile su Jaunty, anche se potresti essere in grado di costruirlo da solo se non hai intenzione di eseguire l'aggiornamento.

Entrambi questi strumenti si trovano sopra i livelli DBus e HAL e rispondono agli eventi da essi. Apparentemente entrambi possono essere eseguiti come un demone di sistema o come un gestore di mount sessione utente (a la Gnome-VFS) - i file /etc/defaults/{ivman,halevt} sono responsabili delle impostazioni di sistema.

Ecco alcune istruzioni per modificare ivman per usare /media/<LABEL> mountpoints. È probabile che halevt abbia un modo più semplice per farlo, ma forse ti aiuteranno a trovare una risposta.


Lavorare con HALEVT

Aggiornamento : Nell'interesse di ottenere montaggi CD automatici, che la mia risposta UDEV non fornisce, ho guardato più in profondità halevt. Ho trovato questo post sul blog che mi ha aiutato a spiegare molto sul processo. Ho dovuto compilare il mio pacchetto halevt per Debian Lenny (fortunatamente tutte le dipendenze erano nella sezione lenny-backports). Una volta installato, il processo non era per niente orribile:

  1. Assicurati che il sistema halevt-daemon sia abilitato in /etc/default/halevt
  2. Permetti al sistema di elevare l'utente a montare dispositivi in ​​/etc/PolicyKit/PolicyKit.conf (vedi sotto; source )
  3. Modifica il criterio HAL per copiare l'etichetta del volume nel punto di montaggio preferito in /etc/hal/fdi/policy/preferences.fdi (vedi sotto)
  4. Se vuoi supporto per CD/DVD, prendi lo script eject.hal dal blogpost sopra, modifica e salva in /usr/local/bin.
  5. Modifica la configurazione del sistema halevt per abilitare i mount in /etc/halevt/halevt.xml
  6. Aggiungi codice agli script di pre-sessione e post-sessione del tuo gestore di accesso per arrestare il sistema halevt-daemon quando qualcuno effettua l'accesso e riavvialo quando si disconnettono.

Se è necessario riavviare i daemon HAL e HALEVT per verificare le nuove configurazioni, utilizzarle per ottenere l'ordine corretto:

Sudo sh -c "/etc/init.d/halevt stop ; /etc/init.d/hal restart ; /etc/init.d/halevt start"

Passo 1

Controlla che START_DAEMON=yes in /etc/default/halevt.

Passo 2

In /etc/PolicyKit/PolicyKit.conf, aggiungi questo all'interno della sezione <config></config>:

<match action="org.freedesktop.hal.storage.mount-removable">
   <match user="halevt">
      <return result="yes"/>
   </match>
</match>

Passaggio 3

In /etc/hal/fdi/policy/preferences.fdi, aggiungi questo all'interno della sezione `:

<match key="volume.label" empty="false">
    <match key="volume.label" is_absolute_path="false">
        <merge key="volume.policy.desired_mount_point" type="copy_property">volume.label</merge>
    </match>
</match>

Passaggio 4

Lo script è buono ma deve eseguire /bin/bash; alcuni sistemi potrebbero effettivamente utilizzare /bin/dash quando viene chiamato /bin/sh. Quindi modifica la riga superiore dello script per assicurarti di ottenere quello giusto:

#!/bin/sh         <------ old first line

#!/bin/bash       <------ new first line

Passaggio 5

Questa è la parte divertente. Il tuo sistema potrebbe già fornire un /etc/halevt/halevt.xml di base, quindi dovrai personalizzarlo a tuo piacimento. Nel mio caso, il mio sistema ha già fornito il supporto rimovibile di base, ma ho dovuto aggiungere il supporto per il montaggio del CDROM e il pulsante di espulsione.

Il post del blog che ho citato ha una buona configurazione XML di esempio per cercare le tue modifiche. Si tratta principalmente della creazione di una sostituzione gnome-mount per l'ambiente fluxbox dell'autore, quindi il suo XML di esempio fa più di quanto vorrai, ma è un ottimo modo per avere un'idea di cosa puoi fare. Ci sono anche alcuni buoni esempi in /usr/share/doc/halevt/examples.

Dovevo anche eseguire Sudo sh -c "mkdir /var/halevt ; chown halevt:plugdev /var/halevt" prima che tutto funzionasse.

Ecco le mie aggiunte per realizzare un CD/DVD automounting:

<!-- CD/DVD mount -->
<halevt:Device match="hal.block.device &amp; hal.block.is_volume = true  &amp; hal.volume.is_disc = true &amp; hal.volume.disc.has_data = true">
   <halevt:Property name="hal.volume.is_mounted">
      <halevt:Action value="true" exec="halevt-mount -u $hal.udi$ -p $hal.volume.policy.desired_mount_point$ -m 002"/>
   </halevt:Property>
</halevt:Device>

<!-- CD/DVD eject button support -->
<halevt:Device match="hal.storage.drive_type = cdrom">
   <halevt:Condition name="EjectPressed" exec='/usr/local/bin/eject.hal $hal.block.device$'/>
</halevt:Device>

Passaggio 6

Una volta ottenuto il funzionamento del sistema halevt-daemon, è necessario disabilitarlo quando si accede a GNOME e riavviarlo di nuovo quando si esegue il logout. (Vedi la mia risposta a questa domanda per i gestori di login non GDM.) Questa roba è teorica poiché non la uso, ma dovrebbe funzionare.

In /etc/gdm/PreSession/Default, aggiungi questo per fermare il sistema halevt-daemon:

/etc/init.d/halevt stop

In /etc/gdm/PostSession/Default, aggiungere questo per riavviare il sistema halevt-daemon:

/etc/init.d/halevt start
9
quack quixote

Con il passare del tempo, appaiono soluzioni più semplici.

Questa soluzione si basa sul pacchetto software udevil che è stato scritto per questo scopo e non richiede di armeggiare con le regole di udev. Probabilmente è preferibile (ai nuovi e ai vecchi utenti) come soluzione immediata.

Lo script devmon di udevil fa tutta la magia mentre dipende solo da udev e glib. Funziona quasi senza bisogno di configurazione iniziale.

Tutto quello che ho fatto sulla mia workstation è stato chiamare devmon da rc.local in questo modo:
devmon 2>&1 >> /var/log/devmon &
Per tua comodità potresti voler incorporare questo in uno script di init invece di rc.local usando uno strumento automatico come pleaserun per crearlo: https://unix.stackexchange.com/a/124609/42673

Dopo averlo in esecuzione, lo spazio di archiviazione che si collega viene ispezionato (cerca le partizioni e, se trovato, controlla le etichette del filesystem) e montato su /media/FILESYSTEM_LABEL.
Non riuscivo a immaginare niente di più semplice di questo tranne forse che il (in) famoso sistema avrebbe incorporato questa funzionalità in futuro.

udevil A A Glance ( github.io/udevil )
Script: devmon ( igurublog/script-devmon )

6
Costin Gușă

Per i sistemi basati su Debian (ad esempio Ubuntu, ecc.) C'è il pacchetto usbmount che monta automaticamente le unità USB. Fondamentalmente utilizza un approccio basato su udev come già delineato - solo che è solo una semplice installazione del pacchetto. Sembra che l'autore originale del pacchetto abbia esaurito Steam ma Ubuntu/Debian sembra ancora mantenerlo (immagino che non sia così complesso) - quindi è ancora disponibile nelle ultime versioni.

Gli script installati possono essere configurati (/etc/usbmount/usbmount.conf) per fornire i punti di montaggio appropriati.

3
Pierz

la risposta di quack quixote non funziona su Ubuntu Lucid Lynx (10.04) - non esiste un comando /sbin/vol_id.

Piuttosto che essere fantasioso e usare udev, mettilo nel tuo /etc/rc.local e fallo:

for dev in $(ls -1 /dev/disk/by-label/* | grep -v EFI) ; do
  label=$(basename $dev)
  mkdir -p /media/$label
  $(mount | grep -q /media/$label) || mount $dev /media/$label
done
3
mrm

Per scovare le eccellenti istruzioni di rimozione di quack quixote:

Aggiungi la seguente riga al file di regole di udev che hai creato in precedenza (/etc/udev/rules.d) "

ENV{ID_FS_LABEL_ENC}=="?*",   ACTION=="remove",      SUBSYSTEMS=="usb", \
         RUN+="/usr/local/sbin/udev-autounmounter.sh %k"

Quindi crea il seguente script e chmod it eseguibile (/usr/local/sbin/udev-autounmounter.sh) con i seguenti contenuti:

#!/bin/sh
#
# USAGE: usb-autounmounter.sh DEVICE 
#   DEVICE   is the actual device node at /dev/DEVICE

/usr/local/sbin/udev-auto-unmount.sh ${1} &

Infine lo script di smontaggio stesso (udev-auto-unmount.sh):

#!/bin/sh
#
# USAGE: udev-auto-unmount.sh DEVICE
#   DEVICE   is the actual device node at /dev/DEVICE
# 
# This script takes a device name, looks up the partition label and
# type, creates /media/LABEL and mounts the partition.  Mount options
# are hard-coded below.

DEVICE=$1

# check input
if [ -z "$DEVICE" ]; then
   exit 1
fi

#test that the device is already mounted
MOUNTPT=`mount | grep ${DEVICE} | cut -d ' ' -f 3`
if [ -z "${MOUNTPT}" ]; then
   echo "error: the device is not already mounted"
   exit 1
fi

# test mountpoint - it should exist
if [ -e "${MOUNTPT}" ]; then

   # very naive; just run and pray
   umount -l "${MOUNTPT}" && rmdir "${MOUNTPT}" && exit 0

   echo "error: ${MOUNTPT} failed to unmount."
   exit 1
fi

echo "error: ${MOUNTPT} does not exist"
exit 1

Quindi con le altre istruzioni, la directory apparirà e scomparirà automaticamente sugli eventi udev.

3
chotchki

Potresti voler provare Pysdm

2
Sathyajith Bhat

Puoi provare a mettere su username -c gnome-volume-manager in /etc/rc.local. Potrebbe essere sufficiente avere semplicemente gnome-volume-manager in esecuzione.

Modifica: Sembra che gnome-volume-manager non faccia più parte della distribuzione predefinita, anche sul desktop di Ubuntu.

wajig policy  gnome-volume-manager
gnome-volume-manager:
  Installed: (none)
  Candidate: 2.24.0-0ubuntu1
  Version table:
     2.24.0-0ubuntu1 0
        500 http://ubuntu.secs.oakland.edu jaunty/universe Packages

Tuttavia, forse se lo installi, funzionerà comunque. Vale la pena provarlo. Se non funziona, rimuovilo di nuovo.

C'è anche il pacchetto usbmount, che fa quello che vuoi, ma potrebbe eventualmente interferire con il normale automounting.

2
Ryan Thompson

I miei addendum modificati per la soluzione basata su udev di quack quixote sono stati respinti, quindi li inserirò qui. Si prega di fare riferimento al suo post prima.

Prima di tutto, se vuoi che la tua regola udev agisca quando ogni dispositivo è collegato tramite il sottosistema SCSI (che include sia USB, FireWire che eSATA) , modifica la corrispondenza SUBSYSTEMS nella regola udev su SUBSYSTEMS=="scsi".

Tieni presente, tuttavia, che questo installerà automaticamente praticamente qualsiasi cosa, incluse le unità interne, se le avvii a caldo mentre il sistema è in esecuzione, quindi potrebbe non essere quello che desideri.

In secondo luogo, ecco lo script che sto usando che sostituisce tutti gli script in quel post. Inoltre, pulisce automaticamente i punti di montaggio creati in/media/non appena viene rimosso il dispositivo a blocchi montato, senza necessità di intervento manuale. Inoltre, anziché chiamare uno script diverso per l'esecuzione in background, si mette in secondo piano quando non viene eseguito da un terminale (ad esempio quando viene eseguito tramite udev).

Usa inotifywait per aspettare fino a quando il dispositivo che è stato montato scompare, e quindi rimuove la directory creata. Pertanto, è necessario disporre di strumenti inotify installati sul sistema. Su distro basati su Debian (inclusa Ubuntu), Sudo apt-get install inotify-tools dovrebbe essere sufficiente.

#!/bin/bash
#
# Auto-mounter script, to be executed by udev on the addition of a
# mass storage device.
#
# Takes one argument; the base block device partition, e.g. "sdb3".
#
# Creates a mountpoint for the partition using its FS label, in
# /media/{fslabel} and mounts it there, read-only, unsynced.
#
# If the filesystem has no label, "Untitled" is used instead.
#
# If another filesystem is already mounted at that location, the
# newcomer will be mounted with an integer number appended to its
# label.

MOUNT_OPTS="ro,noatime,nodiratime"



# If we're called from a non-tty and not explicitly told to continue,
# we call ourselves in a subshell and thus return immediately (udev
# gets impatient):
if [[ "$2" != "backgrounded" ]] && ! tty &> /dev/null; then
    ($0 $1 backgrounded &)
    exit
fi



# Determine the desired mountpoint from the label of the fs on the partition:
MOUNTPOINT="/media/$(blkid /dev/$1 | grep LABEL | sed -E 's:^.+LABEL="([^"]+).+:\1:')"

# If it had no label, use "Untitled":
[[ "$MOUNTPOINT" = "/media/" ]] && MOUNTPOINT="/media/Untitled"

# If something's already mounted there, append a number:
if [[ -e "$MOUNTPOINT" ]] && mountpoint "$MOUNTPOINT" &> /dev/null; then
    NUM=1
    while mountpoint "$MOUNTPOINT $NUM" &> /dev/null; do NUM=$((NUM+1)); done
    MOUNTPOINT="$MOUNTPOINT $NUM"
fi

# Create the mountpoint and mount there:
mkdir "$MOUNTPOINT" && mount -o $MOUNT_OPTS /dev/$1 "$MOUNTPOINT"



# Wait until the device is removed (the block device is "deleted"):
inotifywait -e delete /dev/$1

# Then clean up. If it fails, retry every second for up to 5 mins:
TRIES=0
while [[ -e "$MOUNTPOINT" ]] && [[ $TRIES -lt 300 ]]; do
    rmdir "$MOUNTPOINT"
    sleep 1s
    TRIES=$((TRIES+1))
done

Noterai che monto dispositivi senza sincronizzazione e sola lettura. Questo è solo perché il 99% delle volte, il mio caso d'uso sta leggendo da un'unità esterna, e ogni volta che ho bisogno di scriverlo, sarò comunque attivo sul server e posso facilmente emettere un comando mount -o remount,rw <mountpoint>. Modifica in base alle tue esigenze :)

1

Prova a configurare tramite mountmanager, in modo da non dover inserire i dati manualmente.

Dovrebbe essere una parte del repository di Ubuntu.

1
Abhinav