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.

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

• Escrevendo regras do udev ( a referência para regras do udev)
• man udev (consulte o seu sistema para a versão mais recente)
• man udevadm (ferramenta de administração do udev; consulte novamente o seu sistema para obter as últimas)
• Backup na unidade USB montada (problema completamente diferente, mas útil para entender a solução)

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

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

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 )

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

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.

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.

Você pode experimentar o Pysdm

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.

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

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

Deve fazer parte do repositório do ubuntu.

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