Montar automaticamente unidades externas em / media / LABEL na inicialização sem um usuário conectado?

73

Essa pergunta é semelhante, mas meio oposta ao que eu quero. Eu quero que unidades USB externas sejam montadas automaticamente na inicialização, sem ninguém conectado, em locais como /media/<label>.

Não quero inserir todos os dados no fstab, em parte porque é tedioso e irritante, mas principalmente porque não posso prever o que vou conectar nele ou como as partições mudarão no futuro.

Desejo que as unidades estejam acessíveis para coisas como MPD e estejam disponíveis quando eu fizer login com SSH. gnome-mountparece montar coisas apenas quando você está logado localmente em uma sessão gráfica do Gnome.

endólito
fonte
4
Ótima pergunta, gostaria de ter uma resposta para você, agora estou curioso para resolver isso.
Invert
11
Eu atualizei minha resposta.
Ryan Thompson
11
E eu, para constar, não tenho um problema com o Gnome sendo instalado, como já o faço, mas uma solução para servidores sem interface gráfica sem interface seria a melhor.
Endolith 02/11/2009
11
ARRRGHH ... erro na minha resposta. no RUN. /usr/local/sbin/udev-automounter.sh mount %kdeveria ser /usr/local/sbin/udev-automounter.sh %k. desculpa.
quack quixote
11
OK, a partir da atualização 3, ele funciona com espaços. isso é feito usando uma versão "codificada" do <LABEL> que converte espaços em \x20's. então não é bonito, mas vai funcionar. O udev não está lidando bem com os rótulos com espaços, mas há outra opção que usa sublinhados em vez dos \x20'(portanto, pelo menos, parece bom). parece que a manipulação de espaço precisa ser inserida nos scripts de shell.
quack quixote

Respostas:

74
  • Nota para o Ubuntu Server 11.10: Este script falha no Ubuntu Server 11.10 devido ao vol_idcomando obsoleto . vol_idfoi substituído por blkid. Para corrigir o script, substitua "vol_id" por "blkid -o udev" no udev-auto-mount.shscript.

Eu já estou pensando nisso há um tempo e acho que encontrei uma solução funcional. Ele foi desenvolvido e testado em um sistema baseado no Debian, portanto, deve funcionar no Ubuntu. Apontarei as suposições que ele faz para que também possa ser adaptado a outros sistemas.

  • Ele montará automaticamente unidades USB no plug-in e não deve demorar muito para se adaptar ao Firewire.
  • Ele usa o UDEV, portanto, não se preocupe com o HAL / DeviceKit / GNOME-Anything.
  • Ele cria automaticamente um /media/LABELdiretório para montar o dispositivo.

  • No entanto, pode interferir com outros montadores automáticos; Não posso testar isso. Espero que, com o Gnome-VFS ativo, ambos possam tentar fazer a montagem ... se o Gnome-VFS falhar na montagem, ele poderá não configurar um ícone na área de trabalho. A desmontagem do Gnome deve ser possível, mas pode exigir gksudoou semelhante.

Não testei isso na inicialização do sistema, mas a única razão pela qual vejo que ele pode não funcionar é se ele tentar montar a unidade USB antes que o sistema esteja pronto para montagem. Se for esse o caso, você provavelmente precisará de um ajuste adicional no script de montagem. (Estou verificando com ServerFault para ver se há algum conselho, mas não há muito interesse nele por lá.)

Vamos lá, então.


Referências UDEV:


Antecedentes (UDEV? Whuzzat?)

UDEV é o sistema de hotplug do kernel. É o que configura automaticamente os dispositivos e links simbólicos adequados (por exemplo /dev/disk/by-label/<LABEL>), tanto no momento da inicialização quanto para os dispositivos adicionados enquanto o sistema está em execução.

D-Bus e HAL são usados ​​para enviar eventos de hardware para ouvintes como ambientes de desktop. Portanto, quando você faz login no GNOME e insere um CD ou conecta uma unidade USB, esse evento segue esta cadeia:

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

E pronto, sua unidade é montada. Mas em um sistema sem cabeça, não queremos fazer login para obter os benefícios da montagem automática.

Regras do Udev

Como o UDEV nos permite escrever regras e executar programas na inserção de dispositivos, essa é a escolha ideal. Vamos tirar proveito das regras existentes do Debian / Ubuntu, deixá-las configurar o /dev/disk/by-label/<LABEL>link simbólico para nós e adicionar outra regra que montará o dispositivo para nós.

As regras da UDEV são mantidas em /etc/udev/rules.d(e /lib/udev/rules.dno Karmic) e são processadas em ordem numérica. Qualquer arquivo que não comece com um número é processado após os arquivos numerados. No meu sistema, as regras HAL estão em um arquivo chamado 90-hal.rules, então eu as incluo 89-local.rulespara que elas sejam processadas antes de chegarem ao HAL. Principalmente, você precisa garantir que essas regras aconteçam após o 60-persistent-storage.rules. local.rulespode ser bom o suficiente.

Coloque isso no seu novo arquivo de regras:

# /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"
  • Verifique se não há espaços após o \, apenas um newline( \n).

  • Mude SUBSYSTEMS=="usb"para SUBSYSTEMS=="usb|ieee1394"para suporte ao Firewire.

  • Se você deseja que o dispositivo sempre seja de propriedade de um usuário específico, adicione uma OWNER="username"cláusula. Se você precisar apenas dos arquivos pertencentes a um usuário específico, ajuste o script de montagem.

Lendo a regra

Isso adiciona um programa a ser executado na lista de programas do dispositivo a ser executado. Ele identifica os dispositivos de partição USB <LABEL>e passa essas informações para um script que executa a montagem. Especificamente, esta regra é correspondente:

  1. ENV{ID_FS_LABEL_ENC}=="?*"- uma variável de ambiente definida por uma regra anterior do sistema. Não existe para sistemas que não são arquivos, é por isso que procuramos por ele. Na verdade, queremos usar ID_FS_LABELo ponto de montagem, mas eu não convenci o UDEV a escapar dele para mim, então vamos deixar o script de montagem lidar com isso.

    Esta e outras variáveis ​​de ambiente são obtidas pelo udev usando o vol_idcomando ( descontinuado ). É uma ferramenta útil para ver detalhes rápidos e agradáveis ​​em uma partição:

    $ 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"- corresponder apenas a addeventos ...

  3. SUBSYSTEMS=="usb"- corresponda apenas aos dispositivos que estão no barramento USB. Usamos SUBSYSTEMSaqui porque isso corresponde aos pais do nosso dispositivo; o dispositivo em que estamos interessados ​​será realmente SUBSYSTEM == "scsi". A correspondência com um dispositivo USB pai evita adicionar nosso programa às unidades internas.

  4. RUN+="..."- não uma correspondência, mas uma ação: adicione este programa à lista de programas a serem executados. Nos argumentos do programa, %ké expandido para o nome do dispositivo (por exemplo sdc1, não /dev/sdc1) e $env{FOO}obtém o conteúdo da variável de ambiente FOO.

Testando a regra

O primeiro link de referência (acima) é um excelente tutorial UDEV, mas está um pouco desatualizado. Os programas executados para testar suas regras ( udevtestem particular) foram substituídos pelo udevadmutilitário catch-all .

Depois de adicionar a regra, conecte seu dispositivo. Aguarde alguns segundos e verifique para qual dispositivo ele foi atribuído:

$ 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 a sua unidade removível contiver label_Baz, ela estará no dispositivo sdc1. Execute isso e observe a saída no final:

$ 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'

Procure o nome do script da nossa RUN+=regra nas últimas linhas (terceira da parte inferior neste exemplo). Você pode ver os argumentos que seriam usados ​​para este dispositivo. Você pode executar esse comando agora para verificar se os argumentos estão corretos; se funcionar em sua linha de comando, funcionará automaticamente quando um dispositivo for inserido.

Você também pode monitorar eventos UDEV em tempo real: execute sudo udevadm monitor(consulte man udevadmpara obter detalhes sobre os comutadores). Em seguida, basta conectar um novo dispositivo e assistir a rolagem de eventos. (Provavelmente um exagero, a menos que você goste de detalhes realmente de baixo nível ...)

Recarregando as regras

Depois de verificar se a regra está sendo lida corretamente, você precisa dizer ao UDEV para recarregar suas regras para que a nova entre em vigor. Use qualquer um desses métodos (se o primeiro não funcionar, o segundo deve ... mas tente o primeiro primeiro):

  • corre sudo udevadm control --reload-rules

  • corre sudo /etc/init.d/udev reload

  • reiniciar


Roteiro! Na verdade, 2 scripts ...


Aqui está o primeiro script. Como o programa que executamos precisa ser concluído rapidamente, isso apenas gera o segundo script em segundo plano. Coloque isso em /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} &

Aqui está o segundo script. Isso faz um pouco mais de verificação de entrada. Coloque isso /usr/local/sbin/udev-auto-mount.sh. Você pode ajustar as opções de montagem abaixo. Este script agora lida com a localização da partição LABEL por conta própria; O UDEV envia apenas o nome do DISPOSITIVO.

Se houver um problema ao montar unidades no momento da inicialização , você pode colocar um bom tempo sleep 60nesse script, para dar tempo ao sistema para que ele avance antes que o script tente montar a unidade.

Dei uma sugestão nos comentários para saber como verificar (execute pspara verificar se um servidor da web está sendo executado), mas você precisará ajustá-la para o seu sistema. Eu acho que a maioria dos servidores de rede que você pode estar usando seria suficiente para esse fim - nfsd, smbd, apache, etc. O risco, é claro, é que o script mount falhe se o serviço não estiver sendo executado, então talvez testando um a existência de um arquivo específico seria uma solução melhor.

#!/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 de limpeza de super bônus!

Mais um script. Tudo isso é desmontar o dispositivo e remover os diretórios do ponto de montagem. Ele assume que ele tem privs para fazer isso, então você precisará executá-lo sudo. Este script agora pega o ponto de montagem completo na linha de comando, por exemplo:

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

Coloque isso em /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
charlatão quixote
fonte
3
Você é ótimo! :)
kolypto 4/11/2009
11
Se eu executar o auto-mount.sh manualmente, ele funcionará, mas não se eu conectar uma unidade e não na inicialização. : /
endolith 4/11/2009
então o problema está nas regras do UDEV. deixe-me expandir um pouco essa seção para ajudá-lo a depurar.
quack quixote
3
Eu montei todos os scripts no github: github.com/fatso83/Code-Snippets/tree/master/system-utils/… Eles funcionam bem no Ubuntu 10.10 e também incluem desmontagem automática
oligofren
11
Referência: udev_237 - man udev (Ubuntu_18.04) Observe que a execução de programas que acessam a rede ou monta / desmonta sistemas de arquivos não é permitida dentro das regras do udev , devido à sandbox padrão aplicada no systemd-udevd.service. source: unix.stackexchange.com/questions/200194/… Para uma solução, dê uma olhada em serverfault.com/questions/766506/…
Pro Backup
9

Uma opção final sugerida por outras pessoas na rede é ivman, mas parece depender pmount, da qual você já declarou que não funciona. pmounté abandonado e ivmané quase o mesmo.

A substituição para ivmané halevte está disponível no Karmic. É uma reimplementação de ivman(leia: "mantido" e "não depende do pmount"). O pacote não está disponível no Jaunty, embora você possa construí-lo você mesmo se não estiver planejando fazer o upgrade.

Ambas as ferramentas ficam acima das camadas DBus e HAL e respondem aos eventos delas. Aparentemente, ambos podem ser executados como um daemon do sistema ou como um gerenciador de montagem de sessão do usuário (à la Gnome-VFS) - os /etc/defaults/{ivman,halevt}arquivos são responsáveis ​​pelas configurações do sistema.

Aqui estão algumas instruções para ajustar o ivmanuso de /media/<LABEL>pontos de montagem. É provável que halevttenha uma maneira mais simples de fazer isso, mas talvez eles o ajudem a encontrar uma resposta.


Trabalhando com HALEVT

Atualização : No interesse de obter montagens de CD auto-mágicas também, que a minha resposta UDEV não fornece, examinei mais detalhadamente halevt. Encontrei este post do blog que ajudou a explicar muito sobre o processo. Eu tive que compilar meu próprio halevtpacote para o Debian Lenny (felizmente todas as dependências estavam na seção lenny-backports). Uma vez instalado, o processo não era horrível:

  1. Verifique se o sistema halevt-daemon está ativado em /etc/default/halevt
  2. Permitir que o usuário da metade do sistema monte dispositivos /etc/PolicyKit/PolicyKit.conf(veja abaixo; fonte )
  3. Modifique a política HAL para copiar o rótulo do volume no ponto de montagem preferido em /etc/hal/fdi/policy/preferences.fdi(veja abaixo)
  4. Se você deseja suporte para CD / DVD, pegue o eject.halscript no blog acima, modifique e salve /usr/local/bin.
  5. Modifique a configuração do sistema halevt para ativar montagens /etc/halevt/halevt.xml
  6. Adicione código aos scripts pré e pós-sessão do seu gerenciador de login para parar o sistema halevt-daemon quando alguém efetuar logon e reinicie-o quando efetuar logoff.

Se você precisar reiniciar os daemons HAL e HALEVT para verificar suas novas configurações, use isso para obtê-los na ordem correta:

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

Passo 1

Verifique se START_DAEMON=yesno /etc/default/halevt.

Passo 2

Em /etc/PolicyKit/PolicyKit.conf, adicione isso dentro da <config></config>seção:

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

etapa 3

Em /etc/hal/fdi/policy/preferences.fdi, adicione isto dentro da seção `:

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

Passo 4

O script é bom, mas precisa ser executado /bin/bash; alguns sistemas podem realmente usar /bin/dashquando /bin/shé chamado. Portanto, altere a linha superior do script para garantir a correta:

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

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

Etapa 5

Esta é a parte divertida. Seu sistema já pode fornecer um básico /etc/halevt/halevt.xml, portanto você precisará adaptá-lo para seu próprio uso. No meu caso, meu sistema já fornecia montagem removível básica, mas tive que adicionar suporte para montagem de CDROM e o botão de ejeção.

A postagem do blog que mencionei tem um bom exemplo de configuração XML para analisar seus próprios ajustes. Trata-se principalmente de configurar uma substituição de montagem gnome para o fluxboxambiente do autor , para que o exemplo de XML faça mais do que você deseja, mas é uma ótima maneira de ter uma ideia do que você pode fazer. Existem também alguns bons exemplos em /usr/share/doc/halevt/examples.

Eu também tive que correr sudo sh -c "mkdir /var/halevt ; chown halevt:plugdev /var/halevt"antes que tudo desse certo.

Aqui estão minhas adições para fazer o CD / DVD de montagem automática funcionar:

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

Etapa 6

Depois de colocar o sistema halevt-daemon em funcionamento, será necessário desativá-lo quando você fizer login no GNOME e reiniciá-lo novamente quando sair. (Veja minha resposta a esta pergunta para gerenciadores de login que não são do GDM.) Esse material é teórico, pois eu não o uso, mas deve funcionar.

Em /etc/gdm/PreSession/Default, adicione isto para parar o sistema halevt-daemon:

/etc/init.d/halevt stop

Em /etc/gdm/PostSession/Default, adicione isto para reiniciar o sistema halevt-daemon:

/etc/init.d/halevt start
charlatão quixote
fonte
3
Para as pessoas que leem isso em 2013, agora devem saber que o HAL foi descontinuado e devem recorrer a soluções baseadas no udev, como o quixote que o charlatão deu acima.
Oligofren
6

Com o passar do tempo, soluções mais fáceis aparecem.

Esta solução depende do pacote de software udevil que foi escrito para esse fim e não requer ajustes nas regras do udev. Provavelmente é preferível (para usuários novos e antigos) como uma solução direta.

O devmonscript do udevil faz toda a mágica, dependendo apenas do udev e do glib. Funciona quase que imediatamente, sem a necessidade de configuração inicial.

Tudo o que fiz na minha estação de trabalho foi chamar devmon rc.localdesta forma:
devmon 2>&1 >> /var/log/devmon &
para seu conforto, você pode incorporar isso em um script init em vez de rc.localusar uma ferramenta automatizada como pleaseruncriá-lo: https://unix.stackexchange.com/ a / 124609/42673

Depois de executá-lo, o armazenamento que eu conecto é inspecionado (ele procura partições e, se encontrado, olha para os rótulos dos sistemas de arquivos) e depois é montado /media/FILESYSTEM_LABEL.
Não poderia imaginar nada mais simples do que isso, exceto talvez o (in) famoso sistemad para incorporar essa funcionalidade em algum momento no futuro.

Visão Geral do udevil ( github.io/udevil )
Script: devmon ( igurublog / script-devmon )

Costin Gușă
fonte
3

A resposta do quack quixote não funciona no Ubuntu Lucid Lynx (10.04) - não há /sbin/vol_idcomando.

Em vez de ser extravagante e usar o udev, coloque isso no seu /etc/rc.local e pronto:

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
srm
fonte
11
OBRIGADO .. essa foi a maneira mais simples para o que eu queria realizar. Mesmo trabalhou em Ubuntu Servidor 16 com um volume NTFS
ChrisPrime
3

Para sistemas baseados no Debian (por exemplo, Ubuntu etc.), existe o pacote usbmount que monta automaticamente unidades USB para você. Ele basicamente usa uma abordagem baseada no udev, como já descrito - apenas é apenas uma instalação simples do pacote. Parece que o autor original do pacote ficou sem vapor, mas o Ubuntu / Debian ainda parece mantê-lo (acho que não é tão complexo) - por isso ainda está disponível nas versões mais recentes.

Os scripts instalados podem ser configurados (/etc/usbmount/usbmount.conf) para fornecer os pontos de montagem apropriados.

Pierz
fonte
11
Porém, o Usbmount não pode ser montado por etiqueta, a menos que você preencha a lista de etiquetas no arquivo de configuração.
Gilles 'SO- stop be evil'
11
Consulte a publicação esite.ch/2014/04/11/… se você quiser adicionar montagem à etiqueta no usbmount sem manter uma lista.
Oliver Sauder
3

Para liberar as excelentes instruções de remoção do Quack Quixote:

Adicione a seguinte linha ao arquivo de regras do udev que você criou anteriormente (/etc/udev/rules.d) "

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

Em seguida, crie o seguinte script e execute o chmod it (/usr/local/sbin/udev-autounmounter.sh) com o seguinte conteúdo:

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

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

Finalmente, o próprio script desmontar (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

Portanto, com as outras instruções, o diretório aparecerá automaticamente e desaparecerá nos eventos do udev.

chotchki
fonte
Eu acho que if [ -n "$device_is_mounted" ]; thendeveria ser if [ -z "${MOUNTPT}" ]; then, não deveria?
eresonance
2

Você pode experimentar o Pysdm

Sathyajith Bhat
fonte
Esse é apenas mais um editor de fstab, não é?
Endolith 30/10/09
Sim, mas "Ele também permite a criação de regras do udev para configuração dinâmica de dispositivos de armazenamento"
Sathyajith Bhat
A "criação de regras do udev" me ajudaria de alguma forma? Eu não tenho idéia do que isso significa. Ele monta dispositivos removíveis anteriormente desconhecidos sem um usuário conectado localmente?
Endolith 02/11/2009
Desculpe, não tenho nenhuma pista sobre as regras do udev. Você poderia ter um olhar para fredericiana.com/2006/03/15/writing-udev-rules-short-notes e reactivated.net/writing_udev_rules.html
Sathyajith Bhat
2

Você pode tentar colocar su username -c gnome-volume-manager/etc/rc.local. Pode ser suficiente simplesmente ter o gnome-volume-manager em execução.

Edit: Parece que o gnome-volume-manager não faz mais parte da distribuição padrão, mesmo na área de trabalho do 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

No entanto, talvez se você o instalar, ele ainda funcionará. Vale a tentativa. Se não funcionar, remova-o novamente.

Há também o usbmountpacote, que faz o que você deseja, mas pode interferir na montagem automática normal.

Ryan Thompson
fonte
Comando desconhecido "gnome-volume-manager". Estou no Ubuntu Jaunty.
Endolith 11/10/2009
Existe um / usr / lib / gnome-volume-manager / gnome-volume-manager, mas ele não faz nada.
Endolith 11/10/2009
Ah eu vejo. Também existe um pacote chamado gnome-volume-manager. Veja também: crunchbanglinux.org/forums/topic/239/…
endolith 31/10/2009
Parece que o gnome-volume-manager usa o HAL para montar coisas? E "A partir de 2009, o HAL está sendo preterido em favor do DeviceKit". Por que tudo no Linux sempre é assim? Eles simplesmente começam a fazer algo funcionar quase certo e depois estripam e substituem por algo novo que não funciona.
Endolith 31/10/2009
pmount nem funciona mais. > Pmount / dev / disk / by-label / ARMAZENAMENTO Erro: dispositivo / dev / sdc1 não é removível togaware.com/linux/survivor/Using_Gnome_Volume_Manager.html
endolith
2

Meus adendos editados para a solução baseada em udev do Quack Quixote foram rejeitados, então eu os colocarei aqui. Por favor, consulte o post dele primeiro.

Antes de tudo, se você deseja que sua regra do udev atue quando qualquer dispositivo é conectado por meio do subsistema SCSI (que inclui USB, FireWire e eSATA), altere a correspondência SUBSYSTEMS na regra do udev para SUBSYSTEMS=="scsi".

Lembre-se, no entanto, de que isso montará automaticamente praticamente qualquer coisa, incluindo unidades internas, se você conectá-las enquanto o sistema estiver em execução; portanto, pode não ser o que você deseja.

Em segundo lugar, aqui está o script que estou usando, que substitui todos os scripts desse post. Ele também limpa automaticamente os pontos de montagem criados em / media / assim que o dispositivo de bloco montado é removido - sem necessidade de intervenção manual. Além disso, em vez de chamar um script diferente para ser executado em segundo plano, ele se coloca em segundo plano quando não é executado a partir de um terminal (por exemplo, quando executado via udev).

Ele usa inotifywait para aguardar o desaparecimento do dispositivo montado e, em seguida, remove o diretório que ele criou. Portanto, você precisa ter o inotify-tools instalado no seu sistema. Em distribuições baseadas no Debian (incluindo Ubuntu), sudo apt-get install inotify-toolsdeve ser suficiente.

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

Você notará que eu monto dispositivos sem sincronização e somente leitura. Isso ocorre porque, em 99% das vezes, meu caso de uso é lido em uma unidade externa e, sempre que eu precisar escrever nele, estarei ativo no servidor de qualquer maneira e posso emitir facilmente um mount -o remount,rw <mountpoint>comando. Edite para atender às suas necessidades :)

DanielSmedegaardBuus
fonte
Como você executa esse script? halevtnão parece ser um apt-getpacote capaz atualmente para versões modernas.
Campbeln em 21/09
Agh ... talvez se eu seguir a entrada TOP / Resposta Aceita do quack quixote's ... Ainda seria bom ter uma resposta mais completa aqui :)
Campbeln
1

Tente configurar via mountmanager, para que você não precise inserir dados manualmente.

Deve fazer parte do repositório do ubuntu.

Abhinav
fonte
Você precisará habilitar a seção do universo para obtê-lo.
quack quixote
? apt: MountManager section = universo;)
endolith
Isso só vai configurar um fstab para mim?
Endolith
@ endolith: O apt: universe? install = mountmanager não seria mais lógico? ;)
Bobby
Esse formato funciona? Ele não disse isso na página man manpages.ubuntu.com/manpages/karmic/en/man8/apturl.8.html
endolith
-5

Se você tiver apenas uma unidade montada por vez, basta editá-la no seu /etc/fstabarquivo. Algo ao longo das linhas de:

/dev/sdb1     /mnt/usbdrive     ext3     defaults 0   0

Isso deve montá-lo na inicialização e torná-lo acessível a qualquer pessoa com permissões permanentes. Se você tiver mais de uma unidade, ainda poderá fazer isso com:

/dev/sdb1     /mnt/usbdrive1     ext3     defaults 0   0
/dev/sdc1     /mnt/usbdrive2     ext3     defaults 0   0
Jack M.
fonte
6
claramente não é o que a pergunta faz.
quack quixote