Automatically mount external drives to /media/LABEL on boot without a user logged in?

This question is similar, but kind of the opposite of what I want. I want external USB drives to be mounted automatically at boot, without anyone logged in, to locations like /media/<label>.

I don't want to have to enter all the data into fstab, partially because it's tedious and annoying, but mostly because I can't predict what I'll be plugging into it or how the partitions will change in the future.

I want the drives to be accessible to things like MPD, and available when I log in with SSH. gnome-mount seems to only mount things when you are locally logged into a Gnome graphical session.

Note for Ubuntu Server 11.10: This script fails on Ubuntu Server 11.10 due to the obsolete vol_id command. vol_id has been superseded by blkid. To fix the script, replace "vol_id" by "blkid -o udev" in the udev-auto-mount.sh script.

I've been banging my head around this for a while now, and I think I've found a working solution. This is developed and tested on a Debian-based system, so it should work on Ubuntu. I'll point out the assumptions it makes so it can be adapted to other systems as well.

It will automatically mount USB drives on plugin, and shouldn't take much to adapt for Firewire.
It uses UDEV, so no monkeying with HAL/DeviceKit/GNOME-Anything.
It automagically creates a /media/LABEL directory to mount the device to.
However, it may interfere with other automounters; I can't test for that. I expect that, with Gnome-VFS active, both may try to do the mount ... if Gnome-VFS fails the mount, it might not configure a desktop icon. Unmounting from Gnome should be possible, but might require gksudo or similar.

I have not tested this on system boot, but the only reason I can see that it might not work is if it tries to mount the USB drive before the system is ready for mounts. If that's the case, you'll probably need one additional tweak to the mount script. (I'm checking with ServerFault to see if there's any advice, but not much interest in it over there.)

On to it, then.

UDEV references:

Writing udev Rules (the reference for udev rules)
man udev (see your system for the latest version)
man udevadm (udev admin tool; again see your system for latest)
Backup to USB drive on mount (completely different problem, but helpful for understanding the solution)

Background (UDEV? Whuzzat?)

UDEV is the kernel's hotplug system. It's what automagically configures the proper devices and device symlinks (eg /dev/disk/by-label/<LABEL>), both at boot time and for devices added while the system is running.

D-Bus and HAL are used for sending hardware events to listeners like Desktop Environments. So when you log into GNOME and insert a CD or plug in a USB drive, that event follows this chain:

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

And presto, your drive gets mounted. But in a headless system, we don't want to have to log in to get the benefits of automounting.

Udev Rules

Since UDEV lets us write rules and run programs on device insertion, this is an ideal choice. We're going to take advantage of Debian/Ubuntu's existing rules, let them setup the /dev/disk/by-label/<LABEL> symlink for us, and add another rule that will mount the device for us.

UDEV's rules are kept in /etc/udev/rules.d (and /lib/udev/rules.d on Karmic), and are processed in numerical order. Any file not starting with a number gets processed after the numbered files. On my system, HAL rules are in a file called 90-hal.rules, so I put my rules in 89-local.rules so they get processed before they get to HAL. Primarily, you need to make sure these rules happen after the 60-persistent-storage.rules. local.rules may be good enough.

Put this in your new rules file:

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

Make sure there's no spaces after the \, just a newline (\n).
Change SUBSYSTEMS=="usb" to SUBSYSTEMS=="usb|ieee1394" for Firewire support.
If you want the device to always be owned by a particular user, add an OWNER="username" clause. If you just need the files owned by a particular user, tweak the mount script instead.

Reading the Rule

This adds a program to run to the device's list of programs to run. It identifies USB partition devices by <LABEL>, then passes this information to a script that performs the mount. Specifically, this rule is matching:

ENV{ID_FS_LABEL_ENC}=="?*" -- an environment variable set by an earlier system rule. Doesn't exist for non-filesystems, so that's why we check for it. We actually want to use ID_FS_LABEL for the mount point, but I haven't convinced UDEV to escape it for me, so we'll let the mount script handle that.

This and other environment variables are obtained by udev using the vol_id command (deprecated). It's a handy tool to see nice quick details on a partition:
```
$ 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
```
ACTION=="add" -- only match add events...
SUBSYSTEMS=="usb" -- only match devices that are on the USB bus. We use SUBSYSTEMS here because this matches against our device's parents; the device we're interested in will actually be SUBSYSTEM=="scsi". Matching against a parent USB device avoids adding our program to the internal drives.
RUN+="..." -- not a match, but an action: add this program to the list of programs to run. In the program's arguments, %k gets expanded to the device name (eg sdc1, not /dev/sdc1) and $env{FOO} gets the contents of environment variable FOO.

Testing the Rule

The first reference link (above) is an excellent UDEV tutorial, but it's slightly out of date. The programs it runs for testing your rules (udevtest in particular) have been replaced by the catch-all udevadm utility.

After you've added the rule, plug in your device. Give it a few seconds, then check to see what device it's been assigned to with:

$ 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

If your removeable drive contains label_Baz, it's on device sdc1. Run this and look at the output towards the end:

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

Look for the script name from our RUN+= rule in the last few lines (3rd from the bottom in this example). You can see the arguments that would be used for this device. You can run that command now to check that the arguments are sound; if it works on your commandline, it should work automatically when a device is inserted.

You can also monitor UDEV events in realtime: run sudo udevadm monitor (see man udevadm for details on the switches). Then just plug in a new device and watch events scroll by. (Probably overkill unless you're into really low-level details...)

Reloading the Rules

Once you've verified the rule is getting read properly, you need to tell UDEV to reload its rules so the new one takes effect. Use any of these methods (if the first doesn't work, the second should... but try the first first):

run sudo udevadm control --reload-rules
run sudo /etc/init.d/udev reload
reboot

Script! Actually, 2 Scripts...

Here's the first script. Since the program we run needs to complete quickly, this just spins the second script off in the background. Put this in /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} &

Here's the second script. This does a bit more input checking. Put this in /usr/local/sbin/udev-auto-mount.sh. You may want to tweak the mount options below. This script now handles finding the partition LABEL on its own; UDEV only sends the DEVICE name.

If there's a problem mounting drives at boot-time, you can put a nice long sleep 60 in this script, to give the system time to come all the way up before the script attempts to mount the drive.

I've given a suggestion in the comments for how to check (run ps to see if a webserver is running), but you'll want to tweak that for your system. I think most any network servers you might be using would suffice for this purpose -- nfsd, smbd, apache, etc. The risk, of course, is that the mount script will fail if the service isn't running, so maybe testing a particular file's existence would be a better solution.

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

Super Bonus Cleanup Script!

One more script. All this does is unmount the device and remove the mountpoint directories. It assumes it has privs to do this, so you'll need to run it with sudo. This script now takes the full mountpoint on the commandline, eg:

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

Put this in /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

One final option that others have suggested around the net is ivman, but that appears to depend on pmount, which you've already stated doesn't work. pmount is abandoned and ivman is nearly the same.

The replacement for ivman is halevt, and it's available in Karmic. It is a reimplementation of ivman (read: "maintained" and "doesn't depend on pmount"). The package isn't available on Jaunty, although you may be able to build it yourself if you aren't planning to upgrade.

Both of these tools sit above the DBus and HAL layers and respond to events from them. Apparently both can run either as a system daemon or as a user-session mount manager (a la Gnome-VFS) -- the /etc/defaults/{ivman,halevt} files are in charge of system settings.

Here are some instructions for tweaking ivman to use /media/<LABEL> mountpoints. It's likely that halevt has a simpler way to do it, but perhaps they'll help you find an answer.

Working with HALEVT

Update: In the interest of getting automagical CD mounts as well, which my UDEV answer doesn't provide, I looked deeper at halevt. I found this blog post which helped explain a lot about the process. I did have to compile my own halevt package for Debian Lenny (fortunately all dependencies were in the lenny-backports section). Once installed, the process was mostly not-horrible:

Make sure system halevt-daemon is enabled in /etc/default/halevt
Allow the system halevt user to mount devices in /etc/PolicyKit/PolicyKit.conf (see below; source)
Modify HAL policy to copy the volume label into the preferred mountpoint in /etc/hal/fdi/policy/preferences.fdi (see below)
If you want CD/DVD support, grab the eject.hal script from the above blogpost, modify, and save in /usr/local/bin.
Modify halevt system config to enable mounts in /etc/halevt/halevt.xml
Add code to your login manager's pre- and post-session scripts to stop the system halevt-daemon when someone logs on, and restart it when they log off.

If you need to restart the HAL and HALEVT daemons to check your new configurations, use this to get them in the right order:

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

Step 1

Check that START_DAEMON=yes in /etc/default/halevt.

Step 2

In /etc/PolicyKit/PolicyKit.conf, add this inside the <config></config> section:

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

Step 3

In /etc/hal/fdi/policy/preferences.fdi, add this inside the ` section:

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

Step 4

The script is good but needs to run /bin/bash; some systems may actually use /bin/dash when /bin/sh is called. So change the top line in the script to make sure you get the right one:

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

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

Step 5

This is the fun part. Your system may provide a basic /etc/halevt/halevt.xml already, so you'll have to tailor this for your own use. In my case, my system already provided basic removeables mounting, but I had to add support for CDROM mounting and the eject button.

The blog post I mentioned has a good example XML configuration to look at for your own tweaks. It's mostly about setting up a gnome-mount replacement for the author's fluxbox environment, so his example XML does more than you'll want, but it's a great way to get a feel for what you can do. There are also some good examples in /usr/share/doc/halevt/examples.

I also had to run sudo sh -c "mkdir /var/halevt ; chown halevt:plugdev /var/halevt" before everything would work.

Here's my additions to make automounting CD/DVD work:

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

Step 6

Once you've gotten the system halevt-daemon working, you'll need to disable it when you login to GNOME, and restart it again when you log out. (See my answer to this question for non-GDM login managers.) This stuff is theoretical since I don't use it, but it should work.

In /etc/gdm/PreSession/Default, add this to stop the system halevt-daemon:

/etc/init.d/halevt stop

In /etc/gdm/PostSession/Default, add this to restart the system halevt-daemon:

/etc/init.d/halevt start

As time goes by, easier solutions appear.

This solution relies on the udevil software package which was written for this purpose and requires no tinkering with udev rules. It is probably preferable (to new and old users) as a straight-forward solution.

The devmon script from udevil does all the magic while only depending on udev and glib. Works almost out of the box without needing initial configuration.

All I have done on my workstation was to call devmon from rc.local like this:
devmon 2>&1 >> /var/log/devmon &
For your comfort you might want to embed this into an init script instead of rc.local using an automated tool such as pleaserun to create it: https://unix.stackexchange.com/a/124609/42673

After having it running, storage that I plug is inspected (it looks for partitions and if found looks at their filesystem labels) then mounted into /media/FILESYSTEM_LABEL.
Could not imagine anything simpler than that except maybe that the (in)famous systemd to incorporate this functionality at some point in the future.

udevil At A Glance (github.io/udevil)
Script: devmon (igurublog/script-devmon)

quack quixote's answer doesn't work on Ubuntu Lucid Lynx (10.04) -- there's no /sbin/vol_id command.

Rather than being fancy and using udev, put this into your /etc/rc.local and be done:

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

For Debian based systems (e.g. Ubuntu etc) there's the usbmount package that automatically mounts USB drives for you. It basically uses a udev based approach as already outlined - only it's just a simple package install. It seems the original author of the package has run out of steam but Ubuntu/Debian still appears to maintain it (I guess it's not that complex) - so it's still available in the latest releases.

The installed scripts can be configured (/etc/usbmount/usbmount.conf) to provide the appropriate mount points.