¿Cómo montar medios extraíbles en / media / <LABEL> automáticamente cuando se inserta, sin ningún entorno de escritorio?

Tengo un sistema Debian sid (Wheezy) (y lo mismo para arch), sin ningún entorno de escritorio (y sin Xorg en absoluto).

Puedo montar mis tarjetas SD, memorias USB, HDD externo por etiqueta en un directorio especificado de forma /media/manual con mount/ umounty las entradas adecuadas /etc/fstab, o automáticamente en el momento del arranque, pero esto es convincente, restrictivo y no lo suficientemente dinámico para mis necesidades: si quiero que se monten /media/<LABEL>, cada dispositivo con un dispositivo diferente <LABEL>necesita su propia entrada, y cada <LABEL>subdirectorio también debe crearse / eliminarse manualmente /media/).

Entonces, ¿cuál es la mejor manera de montarlos automáticamente en la /media/<LABEL> inserción (y desmontarlos del sistema de archivos tan pronto como se desconectan, no importa cuán riesgoso sea para los datos )?

La solución ideal sería:

1. detectar cuando un medio extraíble está enchufado-en (es decir, cuando se añade en /dev/como sdax, sdbx, ... by udev)
2. crear un directorio de /media/acuerdo con su etiqueta (etiqueta del medio extraíble)
3. móntelo en el directorio /media/<LABEL>en RWmodo (si su sistema de archivos lo admite) con la flushopción (para a vfat)
4. detectar si los medios han sido desconectados
5. si entonces, desmontarlo del sistema de archivos
6. eliminar el directorio correspondiente de /media/

(los dispositivos deben montarse en modo síncrono, obviamente, para evitar cualquier pérdida de datos cuando se desconecta en caliente debido a la edición en caché :sync es demasiado para los vfatmedios extraíbles, por lo que flush se ha creado como un compromiso , menos seguro que sync, pero menos riesgoso según la vida útil) -ciclos de memorias flash)

He encontrado algo de información acerca de autofs, HAL, udisks, udisks2, usbmountetc, pero no está claro cuál es obsoleto o preferidas, y de todos modos, no he encontrado la manera de configurar fácilmente en mi sistema para hacer eso, hasta ahora ...

Creo que lo estás buscando pmount.

Si desea el montaje automático después de la inserción, consulte Montaje de memorias USB en Debian .

Si su sistema usa udisks2 , esa es la forma preferida de reaccionar a la inserción de un dispositivo de almacenamiento extraíble. Consulte Arch Wiki para obtener consejos de configuración para Udisks.

De lo contrario, el programa que reacciona cuando aparece un nuevo dispositivo es udev , por lo que una regla de udev activa el montaje automático . El paquete usbmount proporciona reglas de udev para montar automáticamente dispositivos de almacenamiento USB y algunos otros. Llamar mountdesde las reglas de udev no funciona para los sistemas de archivos FUSE (como ntfs-3g), así que use udisks si lo necesita.

No puede desmontar automáticamente los medios cuando se eliminan porque la causalidad no funciona de esa manera. Los medios deben desmontarse antes de retirarlos. Para los medios de solo lectura, puede deshacerse del desmontaje después de la eliminación, aunque esto podría confundir a algunas aplicaciones si tienen archivos abiertos en el sistema de archivos desaparecido repentinamente. Para medios grabables, si desconecta un sistema de archivos montado, es probable que se dañen los datos.

Así es como lo hice recientemente, y ahora estoy bastante contento con este enfoque. Esto es para Ubuntu 12.04 + gentoo, pero supongo que cualquier distribución que permita instalar udev y autofs debería funcionar.

Requisitos previos: debe haber instalado udev + autofs.

Paso 1)

Cree el siguiente archivo "/etc/udev/rules.d/90-usbsd-auto.rules" (por supuesto, puede usar cualquier nombre siempre que termine 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"

Qué hace esto: crea dos enlaces simbólicos, uno para la partición del dispositivo de almacenamiento USB en "/ dev / usbdisks / <...>". Utilizará la etiqueta de la partición de almacenamiento USB o el nombre del kernel, si no hay una etiqueta. El segundo enlace simbólico se vinculará desde "/ media / usb / <...>" a "/ media / autousb / <...>", esto se hace para el soporte del montador automático (consulte el paso 2).

Nota: Originalmente no usé las reglas con las variables ID_FS_LABEL_ENC, ya que esto es peligroso en mi opinión. ¿Qué sucede si conecta dos memorias USB que usan la misma etiqueta?

Pero el póster específicamente quería usar la etiqueta del disco USB, por lo que modifiqué las reglas en consecuencia.

Para asegurarse de que udev lea estas reglas use

sudo udevadm control --reload-rules

Con este archivo de reglas de udev, todo está configurado para montar automáticamente la partición del dispositivo de almacenamiento USB. Sin embargo, tenga en cuenta que en este momento, el dispositivo NO se montará automáticamente (intencionalmente). Se montará automáticamente una vez que lo use con

Paso 2)

Configure autofs en automount / media / autousb / <...>: agregué la siguiente línea a mi archivo "/etc/auto.master" (para Ubuntu 12.04):

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

Esto significa que AutoFS desmontará el dispositivo después de 60 segundos de inactividad. Es posible que desee usar menos o más, dependiendo de su gusto.

Para Gentoo, debe modificar "/etc/autofs/auto.master" para que tenga sentido usar

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

Ahora creé "auto.usb" con el siguiente contenido:

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

Este auto.usb debe ser ejecutable, de modo que autofs use esto como un script (bash). Así por ejemplo

sudo chmod 0755 /etc/auto.usb

Qué hace esto: este script le dirá a AutoFS (/ usr / sbin / automount) cómo montar la partición del dispositivo de almacenamiento usb.

El script primero usará "/ sbin / blkid" para averiguar qué tipo de sistema de archivos hay en la partición.

El script proporcionará las opciones de montaje adecuadas según la partición del dispositivo.

Nota: Incluí código de muestra para los sistemas de archivos "vfat" (probablemente el más común para memorias USB), "ntfs" y "xfs". Por supuesto, es bastante fácil extender esto para admitir más sistemas de archivos.

Paso 3) Opcional ... Para "expulsar" == desmontar su (s) dispositivo (s) USB (o particiones en su dispositivo USB), cree un script en / sbin / usbeject:

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

Con este script, puede usar "sudo usbeject" para desmontar todas las particiones de dispositivos USB montadas (diciéndole a automount que las desmonte).

Por supuesto, simplemente puede asegurarse de que la partición no se use en ninguna parte; automounter desmontará la partición después del tiempo de espera de 60 segundos ...

El verdadero truco aquí es usar enlaces simbólicos de "/ media / usb" a "/ media / autousb":

• Los enlaces simbólicos "/ media / usb" serán creados por udev, dando al usuario una visión general simple de qué particiones de dispositivos de almacenamiento usb existen
• AutoFS montará automáticamente la partición a pedido si la usa a través de / media / usb
• Con el archivo "auto.usb" con script, puede admitir cualquier tipo de sistema de archivos y, además, también puede admitir cualquier tipo de esquema de nomenclatura.
• Este enfoque admite memorias USB con múltiples particiones, incluso si estas particiones usan diferentes tipos de sistemas de archivos.

Ok, ha pasado mucho tiempo, pero aún responderé mi pregunta con la mejor opción que encontré hasta ahora. Para resumir: cree una udevregla, asociada con algunas secuencias de comandos (que creará / eliminará directorios y eliminará / montará dispositivos extraíbles) y adjuntará al udevtipo de evento de dispositivo = partition.

1 - Crear scripts de agregar / quitar

Guarde el siguiente script storage-automount.shen /lib/udev/y hágalo ejecutable ( 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

Guarde el siguiente script storage-autounmount.shen /lib/udev/y hágalo ejecutable ( 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 - Crear la udevregla para adjuntar esos scripts a eventos

Y finalmente, agregue una udevregla /etc/udev/rules.d/, por ejemplo 85-storage-automount.rules:

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

y hacer que tenga los mismos permisos que las otras reglas en ese directorio / carpeta

Ahora, cuando conecte un dispositivo de almacenamiento, se creará un directorio de /media/acuerdo con el nombre de la partición (no recuerdo, pero creo que también funciona con la partición NTFS) y su partición se montará en él. Es R / W para usuarios si tiene un plugdevgrupo en su sistema. Además, los dispositivos se montan en modo síncrono para limitar los riesgos de pérdida de datos en caso de desconexión en caliente.

Cuando se elimina el dispositivo, se desmonta y el directorio se elimina de /media

Además, la herramienta para monitorear los udeveventos es udevadm monitor, con opciones como --envo --property:

$ udevadm monitor --env

Esto está probado y funciona bien tanto en Debian como en Arch, pero probablemente funcione en todas las distribuciones en las que se basa udev.

Creo que es bastante tarde, pero lo publicaré si alguien lo necesita: (también mi primera respuesta de StackExchange)

Después de buscar la solución en muchos lugares, encontré una solución simple en Arch Wiki:

Enlace a Arch Wiki .

Podemos agregar una regla udisks2 para cambiar el directorio de montaje predeterminado de /run/media/$USER/a /media/<Label>.

Agregue la siguiente regla /etc/udev/rules.d/con un nombre como 99-udisks2.rules:

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

Entonces podemos instalar una herramienta simple como Udiskie para el montaje automático .

Por favor, consulte la página ArchWiki Udev . Se supone que no debe ejecutar mountdesde reglas Udev o desde scripts que se ejecutan mediante reglas Udev.

Sin embargo, como se muestra en el proyecto udev-media-automount , es bastante simple hacerlo invocando una unidad Systemd desde la regla Udev, que luego llama a un script que realiza el montaje. A diferencia de udisks2 y otras soluciones, udev-media-automount está orientado al caso simple en el que desea montar algo como rootusuario sin esperar necesariamente a que esté presente un entorno de escritorio o "sesión de usuario". Parece ser exactamente lo que está pidiendo el OP, y me pareció funcional y fácil de entender.

Encontré una manera de hacer esto editando el archivo / etc / fstab. Una entrada simple se ve así:

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

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