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.

  • 4
    Great question, wish I had an answer for you, now I'm curious how this is solved.
    – invert
    Oct 30, 2009 at 9:32
  • 1
    I updated my answer. Oct 30, 2009 at 20:01
  • 1
    And I, for the record, do not have a problem with Gnome being installed, as I already do, but a solution for headless GUI-less servers would be best.
    – endolith
    Nov 2, 2009 at 16:10
  • 1
    ARRRGHH... bug in my answer. in the RUN. /usr/local/sbin/udev-automounter.sh mount %k should be /usr/local/sbin/udev-automounter.sh %k. sorry. Nov 4, 2009 at 4:28
  • 1
    OK, as of Update-3, it works with spaces. it does so by using an "encoded" version of <LABEL> that converts spaces into \x20's. so it's not pretty, but it will work. udev isn't handling the labels-with-spaces nicely, but there is another option that uses underscores instead of \x20's (so it at least looks nice). looks like space-handling has to go into the shellscripts. Nov 4, 2009 at 17:33

11 Answers 11

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

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:

  1. 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_LABEL=Travel Dawgs
  2. ACTION=="add" -- only match add events...

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

  4. 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:

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

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


# check input
if [ -z "$DEVICE" ]; then
   exit 1

# 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

# 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

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

   # all done here, return successful
   exit 0

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:

# USAGE: udev-unmounter.sh MOUNTPT
#   MOUNTPT is a mountpoint we want to unmount and delete.

if [ -z "$MOUNTPT" ]; then
   exit 1

# 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

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:

  1. Make sure system halevt-daemon is enabled in /etc/default/halevt
  2. Allow the system halevt user to mount devices in /etc/PolicyKit/PolicyKit.conf (see below; source)
  3. Modify HAL policy to copy the volume label into the preferred mountpoint in /etc/hal/fdi/policy/preferences.fdi (see below)
  4. If you want CD/DVD support, grab the eject.hal script from the above blogpost, modify, and save in /usr/local/bin.
  5. Modify halevt system config to enable mounts in /etc/halevt/halevt.xml
  6. 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"/>

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>

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

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

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
  • 3
    For people reading this in 2013, they should now know that HAL has been deprecated, and they should resort to udev based solutions such as the one quack quixote gave above.
    – oligofren
    May 7, 2013 at 7:28

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
  • 1
    THANK YOU.. this was the simplest way for what I wanted to accomplish. Even worked on Ubuntu Server 16 with an ntfs volume
    – ChrisPrime
    May 30, 2016 at 2:41

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.


To flush out quack quixote's excellent instructions for removal:

Add the following line to the udev rule file you made earlier (/etc/udev/rules.d)"

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

Next create the following script and chmod it executable (/usr/local/sbin/udev-autounmounter.sh) with the following contents:

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

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

Finally the unmount script itself (udev-auto-unmount.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.


# check input
if [ -z "$DEVICE" ]; then
   exit 1

#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

# 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

echo "error: ${MOUNTPT} does not exist"
exit 1

So with the other instructions, the directory will auto appear and disappear on udev events.

  • I think if [ -n "$device_is_mounted" ]; then should be if [ -z "${MOUNTPT}" ]; then, shouldn't it?
    – eresonance
    Oct 19, 2014 at 14:29

You might want to try out Pysdm


You can try putting su username -c gnome-volume-manager in /etc/rc.local. It might be enough to simply have gnome-volume-manager running.

Edit: It seems that gnome-volume-manager is no longer part of the default distribution, even on Ubuntu desktop.

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

However, maybe if you install it, it will still work. It's worth a try. If it doesn't work, remove it again.

There's also the usbmount package, which does what you want, but might possibly interfere with normal automounting.

  • Unknown command “gnome-volume-manager”. I'm in Ubuntu Jaunty.
    – endolith
    Oct 11, 2009 at 22:50
  • There is a /usr/lib/gnome-volume-manager/gnome-volume-manager, but it does nothing.
    – endolith
    Oct 11, 2009 at 22:57
  • Oh I see. There's a package called gnome-volume-manager, too. Related: crunchbanglinux.org/forums/topic/239/…
    – endolith
    Oct 31, 2009 at 0:04
  • It looks like gnome-volume-manager uses HAL to mount things? And "As of 2009, HAL is in process of being deprecated in favor of DeviceKit." Why is everything in Linux always like this? They just start to get something working almost right and then they gut it out and replace it with something new that doesn't work.
    – endolith
    Oct 31, 2009 at 1:00
  • pmount doesn't even work anymore. > pmount /dev/disk/by-label/STORAGE Error: device /dev/sdc1 is not removable togaware.com/linux/survivor/Using_Gnome_Volume_Manager.html
    – endolith
    Oct 31, 2009 at 1:06

My edited addendums for quack quixote's udev-based solution were rejected, so I'm gonna put them here. Please refer to his post first.

First of all, if you want your udev rule to act when any device is attached via the SCSI subsystem (which includes both USB, FireWire, and eSATA), change the SUBSYSTEMS match in the udev rule to SUBSYSTEMS=="scsi".

Do keep in mind, though, that this will automatically mount pretty much anything, including internal drives if you hotplug them while the system is running, so it may not be what you want.

Secondly, here is the script I'm using which replaces all the scripts in that post. It also automatically cleans up created mountpoints in /media/ as soon as the mounted block device is removed — no need for manual intervention. Further, rather than calling a different script to run in the background, it puts itself in the background when it isn't executed from a terminal (e.g. when executed via udev).

It uses inotifywait to wait until the device which was mounted disappears, and then removes the directory it created. Therefore, you need to have inotify-tools installed on your system. On Debian-based distros (including Ubuntu), sudo apt-get install inotify-tools should suffice.

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


# 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 &)

# 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
    while mountpoint "$MOUNTPOINT $NUM" &> /dev/null; do NUM=$((NUM+1)); done

# 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:
while [[ -e "$MOUNTPOINT" ]] && [[ $TRIES -lt 300 ]]; do
    rmdir "$MOUNTPOINT"
    sleep 1s

You'll note that I mount devices without sync, and read-only. That's just because 99% of the time, my use case is reading from an external drive, and whenever I need to write to it, I'm gonna be active on the server anyway, and can easily issue a mount -o remount,rw <mountpoint> command. Edit to suit your needs :)

  • How do you run this script? halevt doesn't seem to be a current apt-getable package for modern versions.
    – Campbeln
    Sep 21, 2019 at 1:03
  • Agh... maybe if I follow the TOP / Accepted Answer entry from quack quixote's... Would still be nice to have a fuller answer here :)
    – Campbeln
    Sep 21, 2019 at 1:16

Try configuring via mountmanager, so that you do not have to enter data manually.

It should be a part of the ubuntu repository.

  • You'll need to enable the universe section to get it. Oct 11, 2009 at 19:21
  • apt:mountmanager?section=universe ;)
    – endolith
    Oct 11, 2009 at 22:36
  • Is that just going to set up an fstab for me?
    – endolith
    Oct 11, 2009 at 22:47
  • @endolith: Wouldn't apt:universe?install=mountmanager be more logical? ;)
    – Bobby
    Nov 3, 2009 at 13:08
  • Does that format work? It doesn't say so in the man page manpages.ubuntu.com/manpages/karmic/en/man8/apturl.8.html
    – endolith
    Nov 3, 2009 at 15:25

If you only have one drive mounted at a time, you can simply edit this into your /etc/fstab file. Something along the lines of:

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

This should mount it at boot, and make it accessible to anyone with perms. If you have more than one drive, you can still do this with:

/dev/sdb1     /mnt/usbdrive1     ext3     defaults 0   0
/dev/sdc1     /mnt/usbdrive2     ext3     defaults 0   0
  • 6
    clearly not what the question asks. Oct 30, 2009 at 21:33

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .