Comment monter automatiquement un support amovible dans / media / <LABEL> lorsqu'il est inséré, sans environnement de bureau?

J'ai un système Sid Debian (Wheezy) (et même pour arch), sans environnement de bureau (et pas Xorg du tout).

Je peux monter mes cartes SD, clés USB, disque dur externe par étiquette dans un répertoire spécifié /media/manuellement avec mount/ umountet les entrées appropriées dans /etc/fstab, ou automatiquement au démarrage, mais cela est convaincant, trop restrictif et pas assez dynamique pour mes besoins: si je veux qu'ils soient montés /media/<LABEL>, chaque appareil avec un autre a <LABEL>besoin de sa propre entrée, et chaque <LABEL>sous-répertoire doit être créé / supprimé manuellement /media/également).

Alors, quelle est la meilleure façon de les monter automatiquement dans /media/<LABEL> lors de l' insertion (et de les démonter du système de fichiers dès qu'ils sont débranchés , peu importe la façon dont il est risqué pour les données )?

La solution idéale serait:

1. détecter le moment où est branchée (ie lorsqu'il est ajouté dans un support amovible /dev/comme sdax, sdbx... par udev)
2. créer un répertoire en /media/fonction de son étiquette (étiquette du support amovible)
3. le monter dans le répertoire /media/<LABEL>en RWmode (si son système de fichiers le supporte) avec l' flushoption (pour a vfat)
4. détecter si le média a été débranché
5. si alors, démontez-le du système de fichiers
6. supprimer le répertoire correspondant de /media/

(les appareils doivent être montés en mode synchrone de façon ovale, pour éviter toute perte de données lorsqu'ils sont débranchés à chaud en raison de la mise en cache : sync c'est beaucoup trop pour les vfatsupports amovibles, donc flush a été créé comme un compromis , moins sécurisé que sync, mais moins risqué selon la durée de vie -des cycles de mémoires flash)

J'ai trouvé quelques informations sur autofs, HAL, udisks, udisks2, usbmountetc., mais on ne sait pas que l' on est dépréciée ou préféré, et de toute façon, je n'ai pas compris comment les configurer facilement sur mon système pour le faire, jusqu'à maintenant ...

Je pense que vous cherchez pmount.

Si vous souhaitez un montage automatique lors de l'insertion, voir Montage automatique de clés USB sur Debian .

Si votre système utilise udisks2 , c'est la façon préférée de réagir à l'insertion d'un périphérique de stockage amovible. Voir le wiki Arch pour des conseils de configuration pour les Udisks.

Sinon, le programme qui réagit lorsqu'un nouveau périphérique apparaît est udev , donc le montage automatique est déclenché par une règle udev . Le package usbmount fournit des règles udev pour monter automatiquement des périphériques de stockage USB et quelques autres. L'appel à mountpartir des règles udev ne fonctionne pas pour les systèmes de fichiers FUSE (tels que ntfs-3g), utilisez donc les udisks si vous en avez besoin.

Vous ne pouvez pas démonter automatiquement les médias lorsqu'ils sont supprimés car la causalité ne fonctionne pas de cette façon. Le support doit être démonté avant d' être retiré. Pour les supports en lecture seule, vous pouvez éviter le démontage après la suppression, bien que cela puisse confondre certaines applications si des fichiers sont ouverts sur le système de fichiers soudainement disparu. Pour les supports inscriptibles, si vous débranchez un système de fichiers monté, une corruption des données est probable.

Voici comment je l'ai fait récemment, et je suis assez satisfait de cette approche maintenant. C'est pour Ubuntu 12.04 + gentoo, mais je suppose que toute distribution, qui permet d'installer udev et autofs devrait fonctionner.

Prérequis: Vous devez avoir installé udev + autofs.

Étape 1)

Créez le fichier "/etc/udev/rules.d/90-usbsd-auto.rules" suivant (vous pouvez bien sûr utiliser n'importe quel nom tant qu'il se termine par ".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'est-ce que cela fait: Il crée deux liens symboliques, un pour la partition du périphérique de stockage USB sous "/ dev / usbdisks / <...>". Il utilisera soit l'étiquette de la partition de stockage USB, soit le nom du noyau, s'il n'y a pas d'étiquette. Le deuxième lien symbolique reliera de "/ media / usb / <...>" à "/ media / autousb / <...>" ceci est fait pour la prise en charge des montages automatiques (voir l'étape 2).

Remarque: à l'origine, je n'ai pas utilisé les règles avec les variables ID_FS_LABEL_ENC, car cela est dangereux à mon avis. Que se passe-t-il si vous branchez deux clés USB qui utilisent la même étiquette?

Mais l'affiche voulait spécifiquement utiliser l'étiquette du disque USB, j'ai donc modifié les règles en conséquence.

Pour vous assurer que udev lit ces règles, utilisez

sudo udevadm control --reload-rules

Avec ce fichier de règles udev, tout est configuré pour monter automatiquement la partition du périphérique de stockage USB. Notez cependant que pour le moment, l'appareil ne sera PAS monté automatiquement (intentionnellement). Il sera monté automatiquement une fois que vous l'utiliserez avec

Étape 2)

Configurer autofs pour monter automatiquement / media / autousb / <...>: J'ai ajouté la ligne suivante à mon fichier "/etc/auto.master" (pour Ubuntu 12.04):

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

Cela signifie qu'AutoFS démontera l'appareil après 60 secondes d'inactivité. Vous voudrez peut-être en utiliser moins ou plus, selon votre goût.

Pour Gentoo, vous devez modifier "/etc/autofs/auto.master" afin qu'il soit logique d'utiliser

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

Maintenant, j'ai créé "auto.usb" avec le contenu suivant:

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

Ce fichier auto.usb doit être exécutable, afin que autofs l'utilise comme un script (bash). Donc par exemple

sudo chmod 0755 /etc/auto.usb

Qu'est-ce que cela fait: ce script indiquera à AutoFS (/ usr / sbin / automount) comment monter la partition du périphérique de stockage USB.

Le script utilisera d'abord "/ sbin / blkid" pour savoir quel type de système de fichiers se trouve sur la partition.

Le script fournira alors les bonnes options de montage en fonction de la partition du périphérique.

Remarque: J'ai inclus un exemple de code pour "vfat" (probablement le plus courant pour les clés USB), "ntfs" et "xfs". Bien sûr, il est assez facile de l'étendre pour prendre en charge davantage de systèmes de fichiers.

Étape 3) Facultatif ... Pour "éjecter" == démonter votre clé USB (ou vos partitions sur votre clé USB), créez un script sous / sbin / usbeject:

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

Avec ce script, vous pouvez utiliser "sudo usbeject" pour démonter toutes les partitions de périphérique USB montées (en disant à automount de les démonter).

Bien sûr, vous pouvez simplement vous assurer que la partition n'est utilisée nulle part; automounter démontera ensuite la partition après l'expiration du délai de 60 secondes ...

Le vrai truc ici est d'utiliser des liens symboliques de "/ media / usb" vers "/ media / autousb":

• Les liens symboliques "/ media / usb" seront créés par udev, donnant à l'utilisateur un aperçu simple des partitions des périphériques de stockage usb présentes
• AutoFS montera ensuite automatiquement la partition à la demande si vous l'utilisez via / media / usb
• Avec le fichier scripté "auto.usb", vous pouvez prendre en charge tout type de système de fichiers et vous pouvez également prendre en charge tout type de schéma de dénomination.
• Cette approche prend en charge les clés USB avec plusieurs partitions, même si ces partitions utilisent différents types de système de fichiers.

D'accord, cela fait longtemps, mais je vais quand même répondre à ma question avec la meilleure option que j'ai trouvée à partir de maintenant. Pour résumer: créez une udevrègle, associée à certains scripts (qui va créer / supprimer des répertoires et démonter / monter des périphériques amovibles), et attachée au udevtype d'événement de périphérique = partition.

1 - Création de scripts d'ajout / suppression

Enregistrez le script suivant storage-automount.shdans /lib/udev/et rendez-le exécutable ( 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

Enregistrez le script suivant storage-autounmount.shdans /lib/udev/et rendez-le exécutable ( 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 - Création de la udevrègle pour attacher ces scripts aux événements

Et enfin, ajoutez une udevrègle /etc/udev/rules.d/, par exemple 85-storage-automount.rules:

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

et lui faire avoir les mêmes autorisations que les autres règles dans ce dossier dir /

Maintenant, lorsque vous branchez un périphérique de stockage, un répertoire sera créé en /media/fonction du nom de la partition (je ne me souviens pas, mais je pense que cela fonctionne également avec la partition NTFS) et votre partition y sera montée. C'est R / W pour les utilisateurs si vous avez un plugdevgroupe sur votre système. De plus, les appareils sont montés en mode synchrone afin de limiter les risques de perte de données en cas de débranchement à chaud.

Lorsque le périphérique est supprimé, il est démonté et le répertoire est supprimé de /media

De plus, l'outil pour surveiller les udevévénements est udevadm monitor, avec des options comme --envou --property:

$ udevadm monitor --env

Ceci est testé et fonctionne très bien sur Debian et Arch, mais fonctionne probablement sur toutes les distributions qui en dépendent udev.

Je pense que c'est assez tard mais je posterai ceci si quelqu'un en a besoin: (aussi ma première réponse StackExchange)

Après avoir vérifié la solution dans de nombreux endroits, j'ai trouvé une solution simple dans Arch Wiki:

Lien vers Arch Wiki .

Nous pouvons ajouter une règle udisks2 pour changer le répertoire de montage par défaut de /run/media/$USER/à/media/<Label> .

Ajoutez la règle suivante /etc/udev/rules.d/avec un nom comme 99-udisks2.rules:

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

Ensuite, nous pouvons simplement installer un outil simple comme Udiskie pour le montage automatique .

Veuillez consulter la page ArchWiki Udev . Vous n'êtes pas censé exécutermount partir de règles Udev ou à partir de scripts exécutés par des règles Udev.

Cependant, comme le montre le projet udev-media-automount , il est assez simple de le faire en appelant une unité Systemd à partir de la règle Udev, qui appelle ensuite un script qui fait le montage. Contrairement à udisks2 et à d'autres solutions, udev-media-automount est conçu pour le cas simple où vous souhaitez monter quelque chose en tant rootqu'utilisateur sans nécessairement attendre qu'un environnement de bureau ou une "session utilisateur" soit présent. Cela semble être exactement ce que le PO demande, et je l'ai trouvé fonctionnel et facile à comprendre.

J'ai trouvé un moyen de le faire en éditant le fichier / etc / fstab. Une entrée simple ressemble à:

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

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