Major rewrite of mount, umount, losetup. Untangled lots of code, shrunk

things down a bit, fixed a number of funky corner cases, added support for
several new features (things like mount --move, mount --bind, lazy unounts,
automatic detection of loop mounts, and so on).  Probably broke several
other things, but it's fixable.  (Bang on it, tell me what doesn't work for
you...)

Note: you no longer need to say "-o loop".  It does that for you when
necessary.

Still need to add "user mount" support, which involves making mount suid.  Not
too hard to do under the new infrastructure, just haven't done it yet...

The previous code had the following notes, that belong in the version
control comments:

- * 3/21/1999   Charles P. Wright <cpwright@cpwright.com>
- *             searches through fstab when -a is passed
- *             will try mounting stuff with all fses when passed -t auto
- *
- * 1999-04-17  Dave Cinege...Rewrote -t auto. Fixed ro mtab.
- *
- * 1999-10-07  Erik Andersen <andersen@codepoet.org>.
- *              Rewrite of a lot of code. Removed mtab usage (I plan on
- *              putting it back as a compile-time option some time),
- *              major adjustments to option parsing, and some serious
- *              dieting all around.
- *
- * 1999-11-06  mtab support is back - andersee
- *
- * 2000-01-12   Ben Collins <bcollins@debian.org>, Borrowed utils-linux's
- *              mount to add loop support.
- *
- * 2000-04-30  Dave Cinege <dcinege@psychosis.com>
- *             Rewrote fstab while loop and lower mount section. Can now do
- *             single mounts from fstab. Can override fstab options for single
- *             mount. Common mount_one call for single mounts and 'all'. Fixed
- *             mtab updating and stale entries. Removed 'remount' default.
- *




git-svn-id: svn://busybox.net/trunk/busybox@11099 69ca8d6d-28ef-0310-b511-8ec308f3f277

1 files changed, 107 insertions, 263 deletions

diff --git a/util-linux/umount.c b/util-linux/umount.c
index 21c2e6e4d..6de71b4ab 100644
--- a/util-linux/umount.c
+++ b/util-linux/umount.c
@@ -3,20 +3,11 @@
  * Mini umount implementation for busybox
  *
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Copyright (C) 2005 by Rob Landley <rob@landley.net>
+ * 
+ * This program is licensed under the GNU General Public license (GPL)
+ * version 2 or later, see http://www.fsf.org/licensing/licenses/gpl.html
+ * or the file "LICENSE" in the busybox source tarball for the full text.
  *
  */
 
@@ -26,273 +17,126 @@
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
+#include <sys/mount.h>
 #include "busybox.h"
 
-/* Teach libc5 about realpath -- it includes it but the
- * prototype is missing... */
-#if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 1)
-extern char *realpath(const char *path, char *resolved_path);
-#endif
-
-static const int MNT_FORCE = 1;
-static const int MS_MGC_VAL = 0xc0ed0000; /* Magic number indicatng "new" flags */
-static const int MS_REMOUNT = 32;       /* Alter flags of a mounted FS.  */
-static const int MS_RDONLY = 1; /* Mount read-only.  */
-
-extern int mount (__const char *__special_file, __const char *__dir,
-                        __const char *__fstype, unsigned long int __rwflag,
-                        __const void *__data);
-extern int umount (__const char *__special_file);
-extern int umount2 (__const char *__special_file, int __flags);
-
-struct _mtab_entry_t {
-        char *device;
-        char *mountpt;
-        struct _mtab_entry_t *next;
-};
-
-static struct _mtab_entry_t *mtab_cache = NULL;
-
-
-
-#if defined CONFIG_FEATURE_MOUNT_FORCE
-static int doForce = FALSE;
-#endif
-#if defined CONFIG_FEATURE_MOUNT_LOOP
-static int freeLoop = TRUE;
-#endif
-#if defined CONFIG_FEATURE_MTAB_SUPPORT
-static int useMtab = TRUE;
-#endif
-static int umountAll = FALSE;
-static int doRemount = FALSE;
-
-
-
-/* These functions are here because the getmntent functions do not appear
- * to be re-entrant, which leads to all sorts of problems when we try to
- * use them recursively - randolph
- *
- * TODO: Perhaps switch to using Glibc's getmntent_r
- *        -Erik
- */
-static void mtab_read(void)
+extern int umount_main(int argc, char **argv)
 {
-        struct _mtab_entry_t *entry = NULL;
-        struct mntent *e;
+        int doForce = 0;
+        int freeLoop = ENABLE_FEATURE_MOUNT_LOOP;
+        int useMtab = ENABLE_FEATURE_MTAB_SUPPORT;
+        int umountAll = FALSE;
+        int doRemount = FALSE;
+        char path[2*PATH_MAX];
+        struct mntent me;
         FILE *fp;
-
-        if (mtab_cache != NULL)
-                return;
-
-        if ((fp = setmntent(bb_path_mtab_file, "r")) == NULL) {
-                bb_error_msg("Cannot open %s", bb_path_mtab_file);
-                return;
-        }
-        while ((e = getmntent(fp))) {
-                entry = xmalloc(sizeof(struct _mtab_entry_t));
-                entry->device = strdup(e->mnt_fsname);
-                entry->mountpt = strdup(e->mnt_dir);
-                entry->next = mtab_cache;
-                mtab_cache = entry;
-        }
-        endmntent(fp);
-}
-
-static char *mtab_getinfo(const char *match, const char which)
-{
-        struct _mtab_entry_t *cur = mtab_cache;
-
-        while (cur) {
-                if (strcmp(cur->mountpt, match) == 0 ||
-                        strcmp(cur->device, match) == 0) {
-                        if (which == MTAB_GETMOUNTPT) {
-                                return cur->mountpt;
-                        } else {
-#if !defined CONFIG_FEATURE_MTAB_SUPPORT
-                                if (strcmp(cur->device, "rootfs") == 0) {
-                                        continue;
-                                } else if (strcmp(cur->device, "/dev/root") == 0) {
-                                        /* Adjusts device to be the real root device,
-                                         * or leaves device alone if it can't find it */
-                                        cur->device = find_real_root_device_name();
-                                }
-#endif
-                                return cur->device;
-                        }
+        int status=EXIT_SUCCESS;
+        struct mtab_list {
+                char *dir;
+                char *device;
+                struct mtab_list *next;
+        } *mtl, *m;
+
+        if(argc < 2) bb_show_usage();
+        
+        /* Parse any options */
+        while (--argc > 0 && **(++argv) == '-') {
+                while (*++(*argv)) {
+                        if(**argv=='a') umountAll = TRUE;
+                        else if(ENABLE_FEATURE_MOUNT_LOOP && **argv=='D') freeLoop = FALSE;
+                        else if(ENABLE_FEATURE_MTAB_SUPPORT && **argv=='n') useMtab = FALSE;
+                        else if(**argv=='f') doForce = 1;   // MNT_FORCE
+                        else if(**argv=='l') doForce = 2;   // MNT_DETACH
+                        else if(**argv=='r') doRemount = TRUE;
+                        else if(**argv=='v');
+                        else bb_show_usage();
                 }
-                cur = cur->next;
         }
-        return NULL;
-}
-
-static char *mtab_next(void **iter)
-{
-        char *mp;
 
-        if (iter == NULL || *iter == NULL)
-                return NULL;
-        mp = ((struct _mtab_entry_t *) (*iter))->mountpt;
-        *iter = (void *) ((struct _mtab_entry_t *) (*iter))->next;
-        return mp;
-}
-
-static char *mtab_first(void **iter)
-{
-        struct _mtab_entry_t *mtab_iter;
-
-        if (!iter)
-                return NULL;
-        mtab_iter = mtab_cache;
-        *iter = (void *) mtab_iter;
-        return mtab_next(iter);
-}
-
-/* Don't bother to clean up, since exit() does that
- * automagically, so we can save a few bytes */
-#ifdef CONFIG_FEATURE_CLEAN_UP
-static void mtab_free(void)
-{
-        struct _mtab_entry_t *this, *next;
-
-        this = mtab_cache;
-        while (this) {
-                next = this->next;
-                free(this->device);
-                free(this->mountpt);
-                free(this);
-                this = next;
+        /* Get a list of mount points from mtab.  We read them all in now mostly
+         * for umount -a (so we don't have to worry about the list changing while
+         * we iterate over it, or about getting stuck in a loop on the same failing
+         * entry.  Notice that this also naturally reverses the list so that -a
+         * umounts the most recent entries first. */
+        
+        m=mtl=0;
+        if(!(fp = setmntent(bb_path_mtab_file, "r")))
+                bb_error_msg_and_die("Cannot open %s", bb_path_mtab_file);
+        while (getmntent_r(fp,&me,path,sizeof(path))) {
+                m=xmalloc(sizeof(struct mtab_list));
+                m->next=mtl;
+                m->device=bb_xstrdup(me.mnt_fsname);
+                m->dir=bb_xstrdup(me.mnt_dir);
+                mtl=m;
         }
-}
-#endif
-
-static int do_umount(const char *name)
-{
-        int status;
-        char *blockDevice = mtab_getinfo(name, MTAB_GETDEVICE);
-
-        if (blockDevice && strcmp(blockDevice, name) == 0)
-                name = mtab_getinfo(blockDevice, MTAB_GETMOUNTPT);
-
-        status = umount(name);
+        endmntent(fp);
 
-#if defined CONFIG_FEATURE_MOUNT_LOOP
-        if (freeLoop && blockDevice != NULL && !strncmp("/dev/loop", blockDevice, 9))
-                /* this was a loop device, delete it */
-                del_loop(blockDevice);
-#endif
-#if defined CONFIG_FEATURE_MOUNT_FORCE
-        if (status != 0 && doForce) {
-                status = umount2(blockDevice, MNT_FORCE);
-                if (status != 0) {
-                        bb_error_msg_and_die("forced umount of %s failed!", blockDevice);
-                }
-        }
-#endif
-        if (status != 0 && doRemount && errno == EBUSY) {
-                status = mount(blockDevice, name, NULL,
-                                           MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL);
-                if (status == 0) {
-                        bb_error_msg("%s busy - remounted read-only", blockDevice);
-                } else {
-                        bb_error_msg("Cannot remount %s read-only", blockDevice);
+        /* If we're umounting all, then m points to the start of the list and
+         * the argument list should be empty (which will match all). */
+        if(!umountAll) m=0;
+
+        // Loop through everything we're supposed to umount, and do so.
+        for(;;) {
+                int curstat;
+                
+                // Do we alrady know what to umount this time through the loop?
+                if(m) safe_strncpy(path,m->dir,PATH_MAX);
+                // For umountAll, end of mtab means time to exit.
+                else if(umountAll) break;
+                // Get next command line argument (and look it up in mtab list)
+                else if(!argc--) break;
+                else {
+                        // Get next command line argument (and look it up in mtab list)
+                        realpath(*argv++, path);
+                        for(m = mtl; m; m = m->next)
+                                if(!strcmp(path, m->dir) || !strcmp(path, m->device))
+                                        break;
                 }
-        }
-        if (status == 0) {
-#if defined CONFIG_FEATURE_MTAB_SUPPORT
-                if (useMtab)
-                        erase_mtab(name);
-#endif
-                return (TRUE);
-        }
-        return (FALSE);
-}
 
-static int umount_all(void)
-{
-        int status = TRUE;
-        char *mountpt;
-        void *iter;
+                // Let's ask the thing nicely to unmount.
+                curstat = umount(path);
 
-        for (mountpt = mtab_first(&iter); mountpt; mountpt = mtab_next(&iter)) {
-                /* Never umount /proc on a umount -a */
-                if (strstr(mountpt, "proc")!= NULL)
-                        continue;
-                if (!do_umount(mountpt)) {
-                        /* Don't bother retrying the umount on busy devices */
-                        if (errno == EBUSY) {
-                                bb_perror_msg("%s", mountpt);
-                                status = FALSE;
-                                continue;
-                        }
-                        if (!do_umount(mountpt)) {
-                                printf("Couldn't umount %s on %s: %s\n",
-                                           mountpt, mtab_getinfo(mountpt, MTAB_GETDEVICE),
-                                           strerror(errno));
-                                status = FALSE;
-                        }
+                // Force the unmount, if necessary.
+                if(curstat && doForce) {
+                        curstat = umount2(path, doForce);
+                        if(curstat)
+                                bb_error_msg_and_die("forced umount of %s failed!", path);
                 }
-        }
-        return (status);
-}
 
-extern int umount_main(int argc, char **argv)
-{
-        char path[PATH_MAX], result = 0;
+                // If still can't umount, maybe remount read-only?      
+                if (curstat && doRemount && errno == EBUSY && m) {
+                        curstat = mount(m->device, path, NULL, MS_REMOUNT|MS_RDONLY, NULL);
+                        bb_error_msg(curstat ? "Cannot remount %s read-only" :
+                                                 "%s busy - remounted read-only", m->device);
+                }
 
-        if (argc < 2) {
-                bb_show_usage();
-        }
-#ifdef CONFIG_FEATURE_CLEAN_UP
-        atexit(mtab_free);
-#endif
+                /* De-allcate the loop device.  This ioctl should be ignored on any
+                 * non-loop block devices. */
+                if(ENABLE_FEATURE_MOUNT_LOOP && freeLoop && m)
+                        del_loop(m->device);
 
-        /* Parse any options */
-        while (--argc > 0 && **(++argv) == '-') {
-                while (*++(*argv))
-                        switch (**argv) {
-                        case 'a':
-                                umountAll = TRUE;
-                                break;
-#if defined CONFIG_FEATURE_MOUNT_LOOP
-                        case 'l':
-                                freeLoop = FALSE;
-                                break;
-#endif
-#ifdef CONFIG_FEATURE_MTAB_SUPPORT
-                        case 'n':
-                                useMtab = FALSE;
-                                break;
-#endif
-#ifdef CONFIG_FEATURE_MOUNT_FORCE
-                        case 'f':
-                                doForce = TRUE;
-                                break;
-#endif
-                        case 'r':
-                                doRemount = TRUE;
-                                break;
-                        case 'v':
-                                break; /* ignore -v */
-                        default:
-                                bb_show_usage();
-                        }
+                if(curstat) {
+                        if(useMtab && m) erase_mtab(m->dir);
+                        status = EXIT_FAILURE;
+                        bb_perror_msg("Couldn't umount %s\n", path);
+                }
+                // Find next matching mtab entry for -a or umount /dev
+                while(m && (m = m->next)) 
+                        if(umountAll || !strcmp(path,m->device))
+                                break;
         }
 
-        mtab_read();
-        if (umountAll) {
-                if (umount_all())
-                        return EXIT_SUCCESS;
-                else
-                        return EXIT_FAILURE;
+        // Free mtab list if necessary
+        
+        if(ENABLE_FEATURE_CLEAN_UP) {
+                while(mtl) {
+                        m=mtl->next;
+                        free(mtl->device);
+                        free(mtl->dir);
+                        free(mtl);
+                        mtl=m;
+                }
         }
 
-        do {
-                if (realpath(*argv, path) != NULL)
-                        if (do_umount(path))
-                                continue;
-                bb_perror_msg("%s", path);
-                result++;
-        } while (--argc > 0 && ++argv);
-        return result;
+        return status;
 }