X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=util-linux%2Fumount.c;h=4ea15d91b94cc9dde9c04f6a0e5a8ab0faa549bd;hb=9a1c71a0f22e7113b87291f874281fb44a455aab;hp=4aed989fb730495492c0d44dc01976c15eff479e;hpb=e1e23eecab5bab12fbe025eea01e730a1e3e1f3f;p=oweals%2Fbusybox.git diff --git a/util-linux/umount.c b/util-linux/umount.c index 4aed989fb..4ea15d91b 100644 --- a/util-linux/umount.c +++ b/util-linux/umount.c @@ -2,304 +2,151 @@ /* * Mini umount implementation for busybox * + * Copyright (C) 1999-2004 by Erik Andersen + * Copyright (C) 2005 by Rob Landley * - * Copyright (C) 1999,2000 by Lineo, inc. - * Written by Erik Andersen , - * - * 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 GPL version 2, see file LICENSE in this tarball for details. */ -#include "internal.h" -#include -//#include +#include "busybox.h" #include -#include -#include - - -/* Include our own version of sys/mount.h, since libc5 doesn't - * know about umount2 */ -static _syscall1(int, umount, const char *, special_file); -static _syscall2(int, umount2, const char *, special_file, int, flags); -static _syscall5(int, mount, const char *, special_file, const char *, dir, - const char *, fstype, unsigned long int, rwflag, const void *, data); -#define MNT_FORCE 1 -#define MS_MGC_VAL 0xc0ed0000 /* Magic flag number to indicate "new" flags */ -#define MS_REMOUNT 32 /* Alter flags of a mounted FS. */ -#define MS_RDONLY 1 /* Mount read-only. */ - - -static const char umount_usage[] = - "umount [flags] filesystem|directory\n" -#ifndef BB_FEATURE_TRIVIAL_HELP - "Unmount file systems\n" - "\nFlags:\n" "\t-a:\tUnmount all file systems" -#ifdef BB_MTAB - " in /etc/mtab\n\t-n:\tDon't erase /etc/mtab entries\n" -#else - "\n" -#endif - "\t-r:\tTry to remount devices as read-only if mount is busy\n" -#if defined BB_FEATURE_MOUNT_FORCE - "\t-f:\tForce filesystem umount (i.e. unreachable NFS server)\n" -#endif -#if defined BB_FEATURE_MOUNT_LOOP - "\t-l:\tDo not free loop device (if a loop device has been used)\n" -#endif -#endif -; - -struct _mtab_entry_t { - char *device; - char *mountpt; - struct _mtab_entry_t *next; -}; - -static struct _mtab_entry_t *mtab_cache = NULL; - - - -#if defined BB_FEATURE_MOUNT_FORCE -static int doForce = FALSE; -#endif -#if defined BB_FEATURE_MOUNT_LOOP -static int freeLoop = TRUE; -#endif -static int useMtab = TRUE; -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 - */ -void mtab_read(void) +#include + +#define OPTION_STRING "flDnravd" +#define OPT_FORCE 1 +#define OPT_LAZY 2 +#define OPT_DONTFREELOOP 4 +#define OPT_NO_MTAB 8 +#define OPT_REMOUNT 16 +#define OPT_ALL (ENABLE_FEATURE_UMOUNT_ALL ? 32 : 0) + +int umount_main(int argc, char **argv); +int umount_main(int argc, char **argv) { - struct _mtab_entry_t *entry = NULL; - struct mntent *e; + int doForce; + char path[2*PATH_MAX]; + struct mntent me; FILE *fp; + int status = EXIT_SUCCESS; + unsigned opt; + struct mtab_list { + char *dir; + char *device; + struct mtab_list *next; + } *mtl, *m; - if (mtab_cache != NULL) - return; + /* Parse any options */ - if ((fp = setmntent(mtab_file, "r")) == NULL) { - fprintf(stderr, "Cannot open %s\n", 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); -} + opt = getopt32(argc, argv, OPTION_STRING); -char *mtab_getinfo(const char *match, const char which) -{ - struct _mtab_entry_t *cur = mtab_cache; + argc -= optind; + argv += optind; - while (cur) { - if (strcmp(cur->mountpt, match) == 0 || - strcmp(cur->device, match) == 0) { - if (which == MTAB_GETMOUNTPT) { - return cur->mountpt; - } else { -#if !defined BB_MTAB - 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; - } - } - cur = cur->next; - } - return NULL; -} + doForce = MAX((opt & OPT_FORCE), (opt & OPT_LAZY)); -char *mtab_first(void **iter) -{ - struct _mtab_entry_t *mtab_iter; + /* 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. */ - if (!iter) - return NULL; - mtab_iter = mtab_cache; - *iter = (void *) mtab_iter; - return mtab_next(iter); -} + m = mtl = 0; -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; -} + /* 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). */ -/* Don't bother to clean up, since exit() does that - * automagically, so we can save a few bytes */ -#if 0 -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; + fp = setmntent(bb_path_mtab_file, "r"); + if (!fp) { + if (opt & OPT_ALL) + bb_error_msg_and_die("cannot open %s", bb_path_mtab_file); + } else { + while (getmntent_r(fp, &me, path, sizeof(path))) { + m = xmalloc(sizeof(struct mtab_list)); + m->next = mtl; + m->device = xstrdup(me.mnt_fsname); + m->dir = xstrdup(me.mnt_dir); + mtl = m; + } + endmntent(fp); } -} -#endif -static int do_umount(const char *name, int useMtab) -{ - 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 we're not umounting all, we need at least one argument. */ + if (!(opt & OPT_ALL)) { + m = 0; + if (!argc) bb_show_usage(); + } -#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) { - fatalError("umount: forced umount of %s failed!\n", blockDevice); + // Loop through everything we're supposed to umount, and do so. + for (;;) { + int curstat; + char *zapit = *argv; + + // Do we already know what to umount this time through the loop? + if (m) safe_strncpy(path, m->dir, PATH_MAX); + // For umount -a, end of mtab means time to exit. + else if (opt & OPT_ALL) break; + // Get next command line argument (and look it up in mtab list) + else if (!argc--) break; + else { + argv++; + realpath(zapit, path); + for (m = mtl; m; m = m->next) + if (!strcmp(path, m->dir) || !strcmp(path, m->device)) + break; } - } -#endif - if (status != 0 && doRemount == TRUE && errno == EBUSY) { - status = mount(blockDevice, name, NULL, - MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL); - if (status == 0) { - fprintf(stderr, "umount: %s busy - remounted read-only\n", - blockDevice); - } else { - fprintf(stderr, "umount: Cannot remount %s read-only\n", - blockDevice); + // 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; + + // Let's ask the thing nicely to unmount. + curstat = umount(zapit); + + // Force the unmount, if necessary. + if (curstat && doForce) { + curstat = umount2(zapit, doForce); + if (curstat) + bb_error_msg("forced umount of %s failed!", zapit); } - } - if (status == 0) { -#if defined BB_MTAB - if (useMtab == TRUE) - erase_mtab(name); -#endif - return (TRUE); - } - return (FALSE); -} - -static int umount_all(int useMtab) -{ - 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; - status = do_umount(mountpt, useMtab); - if (status != 0) { - /* Don't bother retrying the umount on busy devices */ - if (errno == EBUSY) { - perror(mountpt); - continue; - } - status = do_umount(mountpt, useMtab); - if (status != 0) { - printf("Couldn't umount %s on %s: %s\n", - mountpt, mtab_getinfo(mountpt, MTAB_GETDEVICE), - strerror(errno)); - } + // If still can't umount, maybe remount read-only? + if (curstat && (opt & OPT_REMOUNT) && errno == EBUSY && m) { + curstat = mount(m->device, zapit, NULL, MS_REMOUNT|MS_RDONLY, NULL); + bb_error_msg(curstat ? "cannot remount %s read-only" : + "%s busy - remounted read-only", m->device); } - } - return (status); -} -extern int umount_main(int argc, char **argv) -{ - if (argc < 2) { - usage(umount_usage); - } + if (curstat) { + status = EXIT_FAILURE; + bb_perror_msg("cannot umount %s", zapit); + } else { + /* De-allocate the loop device. This ioctl should be ignored on + * any non-loop block devices. */ + if (ENABLE_FEATURE_MOUNT_LOOP && !(opt & OPT_DONTFREELOOP) && m) + del_loop(m->device); + if (ENABLE_FEATURE_MTAB_SUPPORT && !(opt & OPT_NO_MTAB) && m) + erase_mtab(m->dir); + } - /* 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; + // 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. + while (m && (m = m->next)) + if ((opt & OPT_ALL) || !strcmp(path, m->device)) break; -#endif -#ifdef BB_MTAB - 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: - usage(umount_usage); - } } - mtab_read(); - if (umountAll == TRUE) { - exit(umount_all(useMtab)); + // 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; + } } - if (do_umount(*argv, useMtab) == 0) - exit(TRUE); - perror("umount"); - return(FALSE); -} + return status; +}