/*
* Mini umount implementation for busybox
*
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Copyright (C) 2005 by Rob Landley <rob@landley.net>
*
- * Copyright (C) 1999,2000,2001 by Lineo, inc.
- * Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.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
- *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
*/
-#include <limits.h>
-#include <stdio.h>
-#include <mntent.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-#include "busybox.h"
-
-
-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;
-
+//usage:#define umount_trivial_usage
+//usage: "[OPTIONS] FILESYSTEM|DIRECTORY"
+//usage:#define umount_full_usage "\n\n"
+//usage: "Unmount file systems\n"
+//usage: IF_FEATURE_UMOUNT_ALL(
+//usage: "\n -a Unmount all file systems" IF_FEATURE_MTAB_SUPPORT(" in /etc/mtab")
+//usage: )
+//usage: IF_FEATURE_MTAB_SUPPORT(
+//usage: "\n -n Don't erase /etc/mtab entries"
+//usage: )
+//usage: "\n -r Try to remount devices as read-only if mount is busy"
+//usage: "\n -l Lazy umount (detach filesystem)"
+//usage: "\n -f Force umount (i.e., unreachable NFS server)"
+//usage: IF_FEATURE_MOUNT_LOOP(
+//usage: "\n -D Don't free loop device even if it has been used"
+//usage: )
+//usage:
+//usage:#define umount_example_usage
+//usage: "$ umount /dev/hdc1\n"
-
-#if defined BB_FEATURE_MOUNT_FORCE
-static int doForce = FALSE;
-#endif
-#if defined BB_FEATURE_MOUNT_LOOP
-static int freeLoop = TRUE;
+#include <mntent.h>
+#include <sys/mount.h>
+#ifndef MNT_DETACH
+# define MNT_DETACH 0x00000002
#endif
-#if defined BB_FEATURE_MTAB_SUPPORT
-static int useMtab = TRUE;
+#include "libbb.h"
+#include "common_bufsiz.h"
+
+#if defined(__dietlibc__)
+// TODO: This does not belong here.
+/* 16.12.2006, Sampo Kellomaki (sampo@iki.fi)
+ * dietlibc-0.30 does not have implementation of getmntent_r() */
+static struct mntent *getmntent_r(FILE* stream, struct mntent* result,
+ char* buffer UNUSED_PARAM, int bufsize UNUSED_PARAM)
+{
+ struct mntent* ment = getmntent(stream);
+ return memcpy(result, ment, sizeof(*ment));
+}
#endif
-static int umountAll = FALSE;
-static int doRemount = FALSE;
-extern const char mtab_file[]; /* Defined in utility.c */
-
-
-/* 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
+/* Ignored: -v -t -i
+ * bbox always acts as if -d is present.
+ * -D can be used to suppress it (bbox extension).
+ * Rationale:
+ * (1) util-linux's umount does it if "loop=..." is seen in /etc/mtab:
+ * thus, on many systems, bare umount _does_ drop loop devices.
+ * (2) many users request this feature.
*/
-void mtab_read(void)
+#define OPTION_STRING "fldDnra" "vt:i"
+#define OPT_FORCE (1 << 0) // Same as MNT_FORCE
+#define OPT_LAZY (1 << 1) // Same as MNT_DETACH
+//#define OPT_FREE_LOOP (1 << 2) // -d is assumed always present
+#define OPT_DONT_FREE_LOOP (1 << 3)
+#define OPT_NO_MTAB (1 << 4)
+#define OPT_REMOUNT (1 << 5)
+#define OPT_ALL (ENABLE_FEATURE_UMOUNT_ALL ? (1 << 6) : 0)
+
+int umount_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int umount_main(int argc UNUSED_PARAM, char **argv)
{
- struct _mtab_entry_t *entry = NULL;
- struct mntent *e;
+ int doForce;
+ struct mntent me;
FILE *fp;
-
- if (mtab_cache != NULL)
- return;
-
- if ((fp = setmntent(mtab_file, "r")) == NULL) {
- error_msg("Cannot open %s", 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);
-}
-
-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 BB_FEATURE_MTAB_SUPPORT
- 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 */
- find_real_root_device_name( cur->device);
- return ( cur->device);
- }
-#endif
- return cur->device;
- }
+ char *fstype = NULL;
+ int status = EXIT_SUCCESS;
+ unsigned opt;
+ struct mtab_list {
+ char *dir;
+ char *device;
+ struct mtab_list *next;
+ } *mtl, *m;
+
+ opt = getopt32(argv, OPTION_STRING, &fstype);
+ //argc -= optind;
+ argv += optind;
+
+ // MNT_FORCE and MNT_DETACH (from linux/fs.h) must match
+ // OPT_FORCE and OPT_LAZY.
+ BUILD_BUG_ON(OPT_FORCE != MNT_FORCE || OPT_LAZY != MNT_DETACH);
+ doForce = opt & (OPT_FORCE|OPT_LAZY);
+
+ /* 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 = NULL;
+
+ // 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).
+ fp = setmntent(bb_path_mtab_file, "r");
+ if (!fp) {
+ if (opt & OPT_ALL)
+ bb_error_msg_and_die("can't open '%s'", bb_path_mtab_file);
+ } else {
+ setup_common_bufsiz();
+ while (getmntent_r(fp, &me, bb_common_bufsiz1, COMMON_BUFSIZE)) {
+ /* Match fstype if passed */
+ if (!match_fstype(&me, fstype))
+ continue;
+ m = xzalloc(sizeof(*m));
+ m->next = mtl;
+ m->device = xstrdup(me.mnt_fsname);
+ m->dir = xstrdup(me.mnt_dir);
+ mtl = m;
}
- cur = cur->next;
+ endmntent(fp);
}
- return NULL;
-}
-
-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);
-}
-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;
-}
-
-/* Don't bother to clean up, since exit() does that
- * automagically, so we can save a few bytes */
-#ifdef BB_FEATURE_CLEAN_UP
-void mtab_free(void)
-{
- struct _mtab_entry_t *this, *next;
-
- this = mtab_cache;
- while (this) {
- next = this->next;
- if (this->device)
- free(this->device);
- if (this->mountpt)
- free(this->mountpt);
- free(this);
- this = next;
+ // If we're not umounting all, we need at least one argument.
+ if (!(opt & OPT_ALL) && !fstype) {
+ if (!argv[0])
+ bb_show_usage();
+ m = NULL;
}
-}
-#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);
-
-#if defined BB_FEATURE_MOUNT_LOOP
- if (freeLoop == TRUE && blockDevice != NULL && !strncmp("/dev/loop", blockDevice, 9))
- /* this was a loop device, delete it */
- del_loop(blockDevice);
-#endif
-#if defined BB_FEATURE_MOUNT_FORCE
- if (status != 0 && doForce == TRUE) {
- status = umount2(blockDevice, MNT_FORCE);
- if (status != 0) {
- error_msg_and_die("forced umount of %s failed!", blockDevice);
+ // Loop through everything we're supposed to umount, and do so.
+ for (;;) {
+ int curstat;
+ char *zapit = *argv;
+ char *path;
+
+ // Do we already know what to umount this time through the loop?
+ if (m)
+ path = xstrdup(m->dir);
+ // For umount -a, end of mtab means time to exit.
+ else if (opt & OPT_ALL)
+ break;
+ // Use command line argument (and look it up in mtab list)
+ else {
+ if (!zapit)
+ break;
+ argv++;
+ path = xmalloc_realpath(zapit);
+ if (path) {
+ for (m = mtl; m; m = m->next)
+ if (strcmp(path, m->dir) == 0 || strcmp(path, m->device) == 0)
+ break;
+ }
}
- }
+ // If we couldn't find this sucker in /etc/mtab, punt by passing our
+ // command line argument straight to the umount syscall. Otherwise,
+ // umount the directory even if we were given the block device.
+ if (m) zapit = m->dir;
+
+// umount from util-linux 2.22.2 does not do this:
+// umount -f uses umount2(MNT_FORCE) immediately,
+// not trying umount() first.
+// (Strangely, umount -fl ignores -f: it is equivalent to umount -l.
+// We do pass both flags in this case)
+#if 0
+ // Let's ask the thing nicely to unmount.
+ curstat = umount(zapit);
+
+ // Unmount with force and/or lazy flags, if necessary.
+ if (curstat && doForce)
#endif
- if (status != 0 && doRemount == TRUE && errno == EBUSY) {
- status = mount(blockDevice, name, NULL,
- MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL);
- if (status == 0) {
- error_msg("%s busy - remounted read-only", blockDevice);
+ curstat = umount2(zapit, doForce);
+
+ // If still can't umount, maybe remount read-only?
+ if (curstat) {
+ if ((opt & OPT_REMOUNT) && errno == EBUSY && m) {
+ // Note! Even if we succeed here, later we should not
+ // free loop device or erase mtab entry!
+ const char *msg = "%s busy - remounted read-only";
+ curstat = mount(m->device, zapit, NULL, MS_REMOUNT|MS_RDONLY, NULL);
+ if (curstat) {
+ msg = "can't remount %s read-only";
+ status = EXIT_FAILURE;
+ }
+ bb_error_msg(msg, m->device);
+ } else {
+ status = EXIT_FAILURE;
+ bb_perror_msg("can't unmount %s", zapit);
+ }
} else {
- error_msg("Cannot remount %s read-only", blockDevice);
+ // De-allocate the loop device. This ioctl should be ignored on
+ // any non-loop block devices.
+ if (ENABLE_FEATURE_MOUNT_LOOP && !(opt & OPT_DONT_FREE_LOOP) && m)
+ del_loop(m->device);
+ if (ENABLE_FEATURE_MTAB_SUPPORT && !(opt & OPT_NO_MTAB) && m)
+ erase_mtab(m->dir);
}
- }
- if (status == 0) {
-#if defined BB_FEATURE_MTAB_SUPPORT
- if (useMtab == TRUE)
- erase_mtab(name);
-#endif
- return (TRUE);
- }
- return (FALSE);
-}
-static int umount_all(void)
-{
- int status = TRUE;
- char *mountpt;
- void *iter;
-
- 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) {
- 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;
- }
+ // Find next matching mtab entry for -a or umount /dev
+ // Note this means that "umount /dev/blah" will unmount all instances
+ // of /dev/blah, not just the most recent.
+ if (m) {
+ while ((m = m->next) != NULL)
+ // NB: if m is non-NULL, path is non-NULL as well
+ if ((opt & OPT_ALL) || strcmp(path, m->device) == 0)
+ break;
}
+ free(path);
}
- return (status);
-}
-
-extern int umount_main(int argc, char **argv)
-{
- char path[PATH_MAX];
-
- if (argc < 2) {
- show_usage();
- }
-#ifdef BB_FEATURE_CLEAN_UP
- atexit(mtab_free);
-#endif
- /* Parse any options */
- while (--argc > 0 && **(++argv) == '-') {
- while (*++(*argv))
- switch (**argv) {
- case 'a':
- umountAll = TRUE;
- break;
-#if defined BB_FEATURE_MOUNT_LOOP
- case 'l':
- freeLoop = FALSE;
- break;
-#endif
-#ifdef BB_FEATURE_MTAB_SUPPORT
- case 'n':
- useMtab = FALSE;
- break;
-#endif
-#ifdef BB_FEATURE_MOUNT_FORCE
- case 'f':
- doForce = TRUE;
- break;
-#endif
- case 'r':
- doRemount = TRUE;
- break;
- case 'v':
- break; /* ignore -v */
- default:
- show_usage();
- }
+ // 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;
+ }
}
- mtab_read();
- if (umountAll == TRUE) {
- if (umount_all() == TRUE)
- return EXIT_SUCCESS;
- else
- return EXIT_FAILURE;
- }
- if (realpath(*argv, path) == NULL)
- perror_msg_and_die("%s", path);
- if (do_umount(path) == TRUE)
- return EXIT_SUCCESS;
- perror_msg_and_die("%s", *argv);
+ return status;
}
-
projects / oweals / busybox.git / blobdiff