Ygtjki

I have a Debian sid system (Wheezy) (and same for arch), without any desktop environment (and no Xorg at all).

I can mount my SD-cards, USB sticks, external HDD by label into a specified directory in /media/ manually with mount / umount and the suitable entries in /etc/fstab, or automatically at boot time, but this is compelling, to restrictive and not dynamic enough for my needs: if I want them to be mounted in /media/<LABEL>, each device with a different <LABEL> needs its own entry, and each <LABEL> subdirectory needs to be created / removed manually in /media/ as well).

So, what is the best way to mount them automatically in /media/<LABEL> at insertion (and to unmount them from the filesystem as soon as they are unplugged no matter how risky it is for the data)?

The ideal solution would:

1. detect when a removable media is plugged-in (i.e. when added in /dev/ as
   sdax, sdbx, ... by udev)


2. create a directory in /media/ according to its label (label of the removable media)


3. mount it in the directory /media/<LABEL> in RW mode (if it's filesystem supports that) with flush option (for a vfat)


4. detect if the media has been unplugged


5. if then, unmount it from the filesystem


6. remove the corresponding directory from /media/
   

(the devices should be mounted in synchronous mode oviously, to avoid any data loss when hot unplugged because of caching edit: sync is way too much for vfat removable media so flush has been created as a compromise, less secure than sync, but less risky according to the life-cycles of flash memories)

I found some info about autofs, HAL, udisks, udisks2, usbmount etc., but it's unclear which one is deprecated or preferred, and anyway, I haven't figured out how to configure them easily on my system to do that, up to now ...

I think you're looking for pmount.

If you want automatic mounting upon insertion, see Automounting USB sticks on Debian.

If your system uses udisks2, that's the preferred way of reacting to the insertion of a removable storage device. See the Arch Wiki for configuration tips for Udisks.

Otherwise, the program that reacts when a new device appears is udev, so automatic mounting is triggered by a udev rule. The usbmount package provides udev rules to automatically mount USB storage devices and a few others. Calling mount from udev rules doesn't work for FUSE filesystems (such as ntfs-3g), so use udisks if you need that.

You cannot automatically unmount media when they are removed because causality doesn't work that way. The media must be unmounted before it is removed. For read-only media, you can get away with unmounting after removal, although this might confuse some applications if they have files open on the suddenly-vanished filesystem. For writable media, if you unplug a mounted filesystem, data corruption is likely.

Here is how I recently did it, and I am quite happy with this approach now.
This is for Ubuntu 12.04 + gentoo, but I guess any distro, which allows to install udev and autofs should work.

Prerequisites: You have to have installed udev + autofs.

Step 1)

Create the following "/etc/udev/rules.d/90-usbsd-auto.rules" file (of course you might use any name as long as it ends with ".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*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_FS_LABEL_ENC=="?*", 
 SYMLINK+="usbdisks/$envID_FS_LABEL_ENC", MODE:="0660", 
 RUN+="/bin/rm /media/usb/$envID_FS_LABEL_ENC", 
 RUN+="/bin/ln -sf /media/autousb/$envID_FS_LABEL_ENC /media/usb/$envID_FS_LABEL_ENC"

# Fallback: If partition has a NO label, use kernel name (sd[a-z][1-9])
ACTION=="add", KERNEL=="sd*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_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*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_FS_LABEL_ENC=="?*", 
 SYMLINK+="usbdisks/$envID_FS_LABEL_ENC", MODE:="0660"

# Fallback: If partition has NO label, use kernel name
ACTION=="change", KERNEL=="sd*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_FS_LABEL_ENC!="?*", 
 SYMLINK+="usbdisks/%k", MODE:="0660"


# When device is removed, also remove /media/usb/<label>
ACTION=="remove", KERNEL=="sd*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_FS_LABEL_ENC=="?*", 
 RUN+="/bin/rm /media/usb/$envID_FS_LABEL_ENC"

# Fallback: If partition has no label, remove /media/usb/%k
ACTION=="remove", KERNEL=="sd*", ENVDEVTYPE=="partition", 
 ENVID_BUS=="usb", ENVID_FS_LABEL_ENC!="?*", 
 RUN+="/bin/rm /media/usb/%k"

What does this do: It creates two symlinks, one for the USB storage device partition under "/dev/usbdisks/<...>". It will either use the label of the USB storage partition or the kernel name, if there is no label.
The second symlink will link from "/media/usb/<...>" to "/media/autousb/<...>" this is done for automounter support (see step 2).

Note: I originally did not use the rules with the ID_FS_LABEL_ENC variables, since this is dangerous in my opinion. What happens if you plug in two USB sticks which use the same label ?

But the poster specifically wanted to use the label of the USB disk, so I modified the rules accordingly.

To make sure udev reads these rules use

sudo udevadm control --reload-rules

With this udev rules file everything is setup to automount the USB storage device partition. Note though that right now, the device will NOT be automounted (intentionally). It will be automounted once you use it with

Step 2)

Setup autofs to automount /media/autousb/<...> :
I added the following line to my "/etc/auto.master" file (for Ubuntu 12.04):

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

This means that AutoFS will unmount the device after 60 seconds of inactivity. You might want to use less or more, dependent on your taste.

For Gentoo you have to modify "/etc/autofs/auto.master" so it makes sense to use

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

Now I created "auto.usb" with the following content:

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

This auto.usb needs to be executable, so that autofs uses this as a (bash) script. So for example

sudo chmod 0755 /etc/auto.usb

What does this do: This script will tell AutoFS (/usr/sbin/automount) how to mount the usb storage device partition.

The script will first use "/sbin/blkid" to find out what kind of file system is on the partition.

The script will then provide the right mount options depending on the device partition.

Note: I included sample code for "vfat" (probably most common for usb sticks), "ntfs" and "xfs" file systems. Of course it is quite easy to extend this to support more file systems.

Step 3)
Optional...
To "eject" == unmount your usb stick(s) (or partitions on your usb stick), create a script under /sbin/usbeject :

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

With this script you might use "sudo usbeject" to unmount all mounted USB device partitions (by telling automount to unmount them).

Of course you can simply make sure that the partition is not used anywhere; automounter will then unmount the partition after the 60 second timeout...

The real trick here is to use symlinks from "/media/usb" to "/media/autousb":

• The "/media/usb" symlinks will be created by udev, giving a user a simple overview which usb storage device partitions are there


• AutoFS will then automount the partition on demand if you use it via /media/usb


• With the scripted "auto.usb" file you might support any kind of file system and additionally you also are able to support any kind of naming scheme.


• This approach supports USB sticks with multiple partition, even if these partitions use different file system types.

Ok, it's been a long time, but I'll still answer my question with the best option I found as of now. To summarize: create a udev rule, associated with some scripts (that will create/remove directories and un/mount removable devices), and attached to udev device event type=partition.

1 - Creating add / remove scripts

Save following script storage-automount.sh to /lib/udev/ and make it executable (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

Save following script storage-autounmount.sh to /lib/udev/ and make it executable (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 - Creating the udev rule to attach those scripts to events

And finally, add a udev rule in /etc/udev/rules.d/, for instance 85-storage-automount.rules:

ENVDEVTYPE=="partition", RUN+="/lib/udev/storage-automount.sh", ENVREMOVE_CMD="/lib/udev/storage-autounmount.sh"

and make it have the same permissions as the other rules in that dir/folder

Now, when you plug a storage device in, a directory will be created in /media/ according to the partition name (I don't remember but I think it's working with NTFS partition as well) and your partition will be mounted into it. It's R/W for users if you have a plugdev group on your system. Also, the devices are mounted in synchronous mode in order to limit the risks of data loss in case of hot unplugging.

When the device is removed, it's unmounted and the directory is removed from /media

Also, the tool to monitor the udev events is udevadm monitor, with options like --env or --property:

$ udevadm monitor --env

This is tested and working fine on both debian and arch, but probably work on all distributions that rely on udev.