Como montar a mídia removível em / media / <LABEL> automaticamente quando inserida, sem nenhum ambiente de área de trabalho?

Eu tenho um sistema sid Debian (Wheezy) (e o mesmo para arch), sem nenhum ambiente de desktop (e sem Xorg).

Posso montar meus cartões SD, pen drives, HDD externo por etiqueta em um diretório especificado /media/manualmente com mount/ umounte as entradas adequadas /etc/fstabou automaticamente no momento da inicialização, mas isso é atraente, restritivo e não é dinâmico o suficiente para minhas necessidades: se eu quiser que eles sejam montados /media/<LABEL>, cada dispositivo com uma diferente <LABEL>precisará de sua própria entrada e cada <LABEL>subdiretório também precisará ser criado / removido manualmente /media/).

Então, qual é a melhor maneira de montá-los automaticamente na /media/<LABEL> inserção (e desmontá-los do sistema de arquivos assim que são desconectados, não importa o risco para os dados )?

A solução ideal seria:

1. detectar quando um suporte de dados amovível está ligado à corrente (isto é, quando adicionado em /dev/quanto sdax, sdbx, ... por udev)
2. crie um diretório de /media/acordo com seu rótulo (rótulo da mídia removível)
3. monte-o no diretório /media/<LABEL>no RWmodo (se o sistema de arquivos suportar isso) com a flushopção (para a vfat)
4. detectar se a mídia foi desconectada
5. caso contrário, desmonte-o do sistema de arquivos
6. remova o diretório correspondente de /media/

(os dispositivos devem ser montados no modo síncrono de forma ovalada, para evitar perda de dados quando desconectados a quente devido à edição em cache :sync é demais para vfatmídia removível, por isso flush foi criado como um compromisso , menos seguro que sync, mas menos arriscado de acordo com a vida útil (motocicletas de memórias flash)

Eu encontrei algumas informações sobre autofs, HAL, udisks, udisks2, usbmountetc., mas não está claro qual é obsoleto ou preferencial, e de qualquer maneira, eu ainda não descobri como configurá-los facilmente no meu sistema para fazer isso, até agora ...

Eu acho que você está procurando pmount.

Se você deseja montar automaticamente após a inserção, consulte Montagem automática de pen drives no Debian .

Se o seu sistema usa udisks2 , essa é a maneira preferida de reagir à inserção de um dispositivo de armazenamento removível. Veja o Arch Wiki para obter dicas de configuração para Udisks.

Caso contrário, o programa que reage quando um novo dispositivo aparece é o udev ; portanto, a montagem automática é acionada por uma regra do udev . O pacote usbmount fornece regras do udev para montar automaticamente dispositivos de armazenamento USB e alguns outros. Chamar mountde regras do udev não funciona para sistemas de arquivos FUSE (como o ntfs-3g), portanto, use os udisks, se necessário.

Você não pode desmontar automaticamente as mídias quando elas são removidas porque a causalidade não funciona dessa maneira. A mídia deve ser desmontada antes de ser removida. Para mídia somente leitura, você pode desmontar após a remoção, embora isso possa confundir alguns aplicativos se eles tiverem arquivos abertos no sistema de arquivos desaparecido repentinamente. Para mídia gravável, se você desconectar um sistema de arquivos montado, é provável a corrupção de dados.

Aqui está como eu fiz recentemente, e estou muito feliz com essa abordagem agora. Isto é para o Ubuntu 12.04 + gentoo, mas acho que qualquer distro, que permita a instalação do udev e do autofs, deve funcionar.

Pré-requisitos: Você deve ter instalado o udev + autofs.

Passo 1)

Crie o seguinte arquivo "/etc/udev/rules.d/90-usbsd-auto.rules" (é claro que você pode usar qualquer nome desde que termine com ".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"

O que isso faz: Ele cria dois links simbólicos, um para a partição do dispositivo de armazenamento USB em "/ dev / usbdisks / <...>". Ele usará o rótulo da partição de armazenamento USB ou o nome do kernel, se não houver um rótulo. O segundo link simbólico será vinculado de "/ media / usb / <...>" para "/ media / autousb / <...>", para suporte ao montador automático (consulte a etapa 2).

Nota: originalmente eu não usei as regras com as variáveis ​​ID_FS_LABEL_ENC, pois isso é perigoso na minha opinião. O que acontece se você conectar dois pendrives que usam a mesma etiqueta?

Mas o pôster queria especificamente usar o rótulo do disco USB, então modifiquei as regras de acordo.

Para garantir que o udev leia essas regras, use

sudo udevadm control --reload-rules

Com esse arquivo de regras do udev, tudo é configurado para montar automaticamente a partição do dispositivo de armazenamento USB. Observe que, no momento, o dispositivo NÃO será montado automaticamente (intencionalmente). Ele será montado automaticamente quando você o usar com

Passo 2)

Configurar autofs para automount / media / autousb / <...>: Adicionei a seguinte linha ao meu arquivo "/etc/auto.master" (para Ubuntu 12.04):

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

Isso significa que o AutoFS desmontará o dispositivo após 60 segundos de inatividade. Você pode querer usar menos ou mais, dependendo do seu gosto.

Para o Gentoo, você precisa modificar "/etc/autofs/auto.master" para que faça sentido usar

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

Agora eu criei "auto.usb" com o seguinte conteúdo:

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

Esse auto.usb precisa ser executável, para que o autofs use isso como um script (bash). Então por exemplo

sudo chmod 0755 /etc/auto.usb

O que isso faz: Este script informa ao AutoFS (/ usr / sbin / automount) como montar a partição do dispositivo de armazenamento usb.

O script primeiro usará "/ sbin / blkid" para descobrir que tipo de sistema de arquivos está na partição.

O script fornecerá as opções corretas de montagem, dependendo da partição do dispositivo.

Nota: Incluí código de amostra para os sistemas de arquivos "vfat" (provavelmente o mais comum para pendrives), "ntfs" e "xfs". Obviamente, é muito fácil estender isso para suportar mais sistemas de arquivos.

Etapa 3) Opcional ... Para "ejetar" == desmontar seu (s) pendrive (s) (ou partições no seu pendrive), crie um script em / sbin / usbeject:

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

Com esse script, você pode usar "sudo usbeject" para desmontar todas as partições de dispositivos USB montadas (dizendo ao automount para desmontá-las).

Claro que você pode simplesmente garantir que a partição não seja usada em nenhum lugar; o montador automático desmontará a partição após o tempo limite de 60 segundos ...

O verdadeiro truque aqui é usar links simbólicos de "/ media / usb" para "/ media / autousb":

• Os links simbólicos "/ media / usb" serão criados pelo udev, fornecendo ao usuário uma visão geral simples de quais partições de dispositivos de armazenamento USB existem
• O AutoFS monta automaticamente a partição sob demanda se você a usar via / media / usb
• Com o arquivo "auto.usb" com script, você pode oferecer suporte a qualquer tipo de sistema de arquivos e, além disso, também pode suportar qualquer tipo de esquema de nomeação.
• Essa abordagem oferece suporte a pen drives com várias partições, mesmo que essas partições usem tipos diferentes de sistemas de arquivos.

Ok, já faz muito tempo, mas ainda vou responder minha pergunta com a melhor opção que encontrei a partir de agora. Para resumir: crie uma udevregra associada a alguns scripts (que criarão / removerão diretórios e desmontarão dispositivos removíveis) e anexados ao udevtipo de evento do dispositivo = partition.

1 - Criando adicionar / remover scripts

Salve o script storage-automount.sha seguir /lib/udev/e torne-o executável ( 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

Salve o script storage-autounmount.sha seguir /lib/udev/e torne-o executável ( 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 - Criando a udevregra para anexar esses scripts aos eventos

E, finalmente, adicione uma udevregra /etc/udev/rules.d/, por exemplo 85-storage-automount.rules:

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

e torná-lo com as mesmas permissões que as outras regras nessa pasta / diretório

Agora, quando você conectar um dispositivo de armazenamento, um diretório será criado de /media/acordo com o nome da partição (não me lembro, mas acho que está funcionando com a partição NTFS) e sua partição será montada nele. É R / W para usuários se você tiver um plugdevgrupo em seu sistema. Além disso, os dispositivos são montados no modo síncrono para limitar os riscos de perda de dados em caso de desconexão a quente.

Quando o dispositivo é removido, ele é desmontado e o diretório é removido de /media

Além disso, a ferramenta para monitorar os udeveventos é udevadm monitor, com opções como --envou --property:

$ udevadm monitor --env

Isso foi testado e está funcionando bem no debian e no arch, mas provavelmente funciona em todas as distribuições em que se baseia udev.

Acho que é muito tarde, mas vou postar isso se alguém precisar: (também minha primeira resposta do StackExchange)

Depois de verificar a solução em muitos lugares, encontrei uma solução simples no Arch Wiki:

Link para o Arch Wiki .

Podemos adicionar uma regra udisks2 para alterar o diretório de montagem padrão de /run/media/$USER/para /media/<Label>.

Adicione a seguinte regra /etc/udev/rules.d/com nome como 99-udisks2.rules:

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

Depois, podemos instalar uma ferramenta simples como o Udiskie for automount.

Por favor, consulte a página do ArchWiki Udev . Você não deve executar a mountpartir das regras do Udev ou de scripts executados pelas regras do Udev.

No entanto, como mostrado no projeto udev-media-automount , é bastante simples invocando uma unidade Systemd da regra Udev, que então chama um script que faz a montagem. Diferentemente do udisks2 e de outras soluções, o udev-media-automount é voltado para o caso simples em que você deseja montar algo como rootusuário sem necessariamente esperar por um ambiente de desktop ou "sessão do usuário". Parece ser exatamente o que o OP está pedindo, e achei funcional e fácil de entender.

Eu encontrei uma maneira de fazer isso editando o arquivo / etc / fstab. Uma entrada simples se parece com:

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

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