* Mini mount implementation for busybox
*
* Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Copyright (C) 2005-2006 by Rob Landley <rob@landley.net>
*
- * 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
- *
- * 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@lineo.com>, <andersee@debian.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 suppport is back - andersee
- *
- * 2000-01-12 Ben Collins <bcollins@debian.org>, Borrowed utils-linux's
- * mount to add loop support.
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
-#include "internal.h"
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <stdio.h>
-#include <mntent.h>
-#include <sys/mount.h>
-#include <ctype.h>
-#include <fstab.h>
-#if defined BB_FEATURE_USE_DEVPS_N_DEVMTAB
-#include <linux/devmtab.h>
-#endif
+/* todo:
+ * bb_getopt_ulflags();
+ */
+/* Design notes: There is no spec for mount. Remind me to write one.
-#if defined BB_FEATURE_MOUNT_LOOP
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/loop.h>
+ mount_main() calls singlemount() which calls mount_it_now().
+ mount_main() can loop through /etc/fstab for mount -a
+ singlemount() can loop through /etc/filesystems for fstype detection.
+ mount_it_now() does the actual mount.
+*/
-static int use_loop = FALSE;
-#endif
-
-extern const char mtab_file[]; /* Defined in utility.c */
+#include "busybox.h"
+#include <mntent.h>
-static const char mount_usage[] = "\tmount [flags]\n"
- "\tmount [flags] device directory [-o options,more-options]\n"
- "\n" "Flags:\n" "\t-a:\tMount all file systems in fstab.\n"
-#ifdef BB_MTAB
- "\t-f:\t\"Fake\" mount. Add entry to mount table but don't mount it.\n"
- "\t-n:\tDon't write a mount table entry.\n"
+// These two aren't always defined in old headers
+#ifndef MS_BIND
+#define MS_BIND 4096
#endif
- "\t-o option:\tOne of many filesystem options, listed below.\n"
- "\t-r:\tMount the filesystem read-only.\n"
- "\t-t filesystem-type:\tSpecify the filesystem type.\n"
- "\t-w:\tMount for reading and writing (default).\n"
- "\n"
- "Options for use with the \"-o\" flag:\n"
- "\tasync / sync:\tWrites are asynchronous / synchronous.\n"
- "\tdev / nodev:\tAllow use of special device files / disallow them.\n"
- "\texec / noexec:\tAllow use of executable files / disallow them.\n"
-#if defined BB_FEATURE_MOUNT_LOOP
- "\tloop: Mounts a file via loop device.\n"
+#ifndef MS_MOVE
+#define MS_MOVE 8192
+#endif
+#ifndef MS_SILENT
+#define MS_SILENT 32768
#endif
- "\tsuid / nosuid:\tAllow set-user-id-root programs / disallow them.\n"
- "\tremount: Re-mount a currently-mounted filesystem, changing its flags.\n"
- "\tro / rw: Mount for read-only / read-write.\n"
- "\t"
-
- "There are EVEN MORE flags that are specific to each filesystem.\n"
- "You'll have to see the written documentation for those.\n";
+// Not real flags, but we want to be able to check for this.
+#define MOUNT_NOAUTO (1<<29)
+#define MOUNT_SWAP (1<<30)
+/* Standard mount options (from -o options or --options), with corresponding
+ * flags */
-struct mount_options {
+struct {
const char *name;
- unsigned long and;
- unsigned long or;
+ long flags;
+} static const mount_options[] = {
+ // NOP flags.
+
+ {"loop", 0},
+ {"defaults", 0},
+ {"quiet", 0},
+
+ // vfs flags
+
+ {"ro", MS_RDONLY},
+ {"rw", ~MS_RDONLY},
+ {"nosuid", MS_NOSUID},
+ {"suid", ~MS_NOSUID},
+ {"dev", ~MS_NODEV},
+ {"nodev", MS_NODEV},
+ {"exec", ~MS_NOEXEC},
+ {"noexec", MS_NOEXEC},
+ {"sync", MS_SYNCHRONOUS},
+ {"async", ~MS_SYNCHRONOUS},
+ {"atime", ~MS_NOATIME},
+ {"noatime", MS_NOATIME},
+ {"diratime", ~MS_NODIRATIME},
+ {"nodiratime", MS_NODIRATIME},
+ {"loud", ~MS_SILENT},
+
+ // action flags
+
+ {"remount", MS_REMOUNT},
+ {"bind", MS_BIND},
+ {"move", MS_MOVE},
+ {"noauto",MOUNT_NOAUTO},
+ {"swap",MOUNT_SWAP}
};
-static const struct mount_options mount_options[] = {
- {"async", ~MS_SYNCHRONOUS, 0},
- {"defaults", ~0, 0},
- {"dev", ~MS_NODEV, 0},
- {"exec", ~MS_NOEXEC, 0},
- {"nodev", ~0, MS_NODEV},
- {"noexec", ~0, MS_NOEXEC},
- {"nosuid", ~0, MS_NOSUID},
- {"remount", ~0, MS_REMOUNT},
- {"ro", ~0, MS_RDONLY},
- {"rw", ~MS_RDONLY, 0},
- {"suid", ~MS_NOSUID, 0},
- {"sync", ~0, MS_SYNCHRONOUS},
- {0, 0, 0}
-};
+/* Append mount options to string */
+static void append_mount_options(char **oldopts, char *newopts)
+{
+ if(*oldopts && **oldopts) {
+ char *temp=xasprintf("%s,%s",*oldopts,newopts);
+ free(*oldopts);
+ *oldopts=temp;
+ } else {
+ if (ENABLE_FEATURE_CLEAN_UP) free(*oldopts);
+ *oldopts = xstrdup(newopts);
+ }
+}
-static int
-do_mount(char *specialfile, char *dir, char *filesystemtype,
- long flags, void *string_flags, int useMtab, int fakeIt,
- char *mtab_opts)
+/* Use the mount_options list to parse options into flags.
+ * Return list of unrecognized options in *strflags if strflags!=NULL */
+static int parse_mount_options(char *options, char **unrecognized)
{
- int status = 0;
- char *lofile = NULL;
+ int flags = MS_SILENT;
-#if defined BB_MTAB
- if (fakeIt == FALSE)
-#endif
- {
-#if defined BB_FEATURE_MOUNT_LOOP
- if (use_loop==TRUE) {
- int loro = flags & MS_RDONLY;
- char *lofile = specialfile;
-
- specialfile = find_unused_loop_device();
- if (specialfile == NULL) {
- fprintf(stderr, "Could not find a spare loop device\n");
- return (FALSE);
- }
- if (set_loop(specialfile, lofile, 0, &loro)) {
- fprintf(stderr, "Could not setup loop device\n");
- return (FALSE);
- }
- if (!(flags & MS_RDONLY) && loro) { /* loop is ro, but wanted rw */
- fprintf(stderr, "WARNING: loop device is read-only\n");
- flags &= ~MS_RDONLY;
+ // Loop through options
+ for (;;) {
+ int i;
+ char *comma = strchr(options, ',');
+
+ if (comma) *comma = 0;
+
+ // Find this option in mount_options
+ for (i = 0; i < (sizeof(mount_options) / sizeof(*mount_options)); i++) {
+ if (!strcasecmp(mount_options[i].name, options)) {
+ long fl = mount_options[i].flags;
+ if(fl < 0) flags &= fl;
+ else flags |= fl;
+ break;
}
- use_loop = FALSE;
}
-#endif
- status =
- mount(specialfile, dir, filesystemtype, flags, string_flags);
+ // If unrecognized not NULL, append unrecognized mount options */
+ if (unrecognized
+ && i == (sizeof(mount_options) / sizeof(*mount_options)))
+ {
+ // Add it to strflags, to pass on to kernel
+ i = *unrecognized ? strlen(*unrecognized) : 0;
+ *unrecognized = xrealloc(*unrecognized, i+strlen(options)+2);
+
+ // Comma separated if it's not the first one
+ if (i) (*unrecognized)[i++] = ',';
+ strcpy((*unrecognized)+i, options);
+ }
+
+ // Advance to next option, or finish
+ if(comma) {
+ *comma = ',';
+ options = ++comma;
+ } else break;
}
+ return flags;
+}
+
+// Return a list of all block device backed filesystems
+
+static llist_t *get_block_backed_filesystems(void)
+{
+ char *fs, *buf,
+ *filesystems[] = {"/etc/filesystems", "/proc/filesystems", 0};
+ llist_t *list = 0;
+ int i;
+ FILE *f;
+
+ for(i = 0; filesystems[i]; i++) {
+ if(!(f = fopen(filesystems[i], "r"))) continue;
+
+ for(fs = buf = 0; (fs = buf = bb_get_chomped_line_from_file(f));
+ free(buf))
+ {
+ if(!strncmp(buf,"nodev",5) && isspace(buf[5])) continue;
- /* If the mount was sucessful, do anything needed, then return TRUE */
- if (status == 0) {
+ while(isspace(*fs)) fs++;
+ if(*fs=='#' || *fs=='*') continue;
+ if(!*fs) continue;
-#if defined BB_MTAB
- if (useMtab == TRUE) {
- write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts);
+ llist_add_to_end(&list,xstrdup(fs));
}
-#endif
- return (TRUE);
+ if (ENABLE_FEATURE_CLEAN_UP) fclose(f);
}
- /* Bummer. mount failed. Clean up */
-#if defined BB_FEATURE_MOUNT_LOOP
- if (lofile != NULL) {
- del_loop(specialfile);
- }
-#endif
- return (FALSE);
+ return list;
}
+llist_t *fslist = 0;
-
-/* Seperate standard mount options from the nonstandard string options */
-static void
-parse_mount_options(char *options, unsigned long *flags, char *strflags)
+#if ENABLE_FEATURE_CLEAN_UP
+static void delete_block_backed_filesystems(void)
{
- while (options) {
- int gotone = FALSE;
- char *comma = strchr(options, ',');
- const struct mount_options *f = mount_options;
+ llist_free(fslist, free);
+}
+#else
+void delete_block_backed_filesystems(void);
+#endif
- if (comma)
- *comma = '\0';
+#if ENABLE_FEATURE_MTAB_SUPPORT
+static int useMtab;
+static int fakeIt;
+#else
+#define useMtab 0
+#define fakeIt 0
+#endif
- while (f->name != 0) {
- if (strcasecmp(f->name, options) == 0) {
+// Perform actual mount of specific filesystem at specific location.
- *flags &= f->and;
- *flags |= f->or;
- gotone = TRUE;
- break;
- }
- f++;
- }
-#if defined BB_FEATURE_MOUNT_LOOP
- if (gotone == FALSE && !strcasecmp("loop", options)) { /* loop device support */
- use_loop = TRUE;
- gotone = TRUE;
- }
-#endif
- if (*strflags && strflags != '\0' && gotone == FALSE) {
- char *temp = strflags;
+static int mount_it_now(struct mntent *mp, int vfsflags, char *filteropts)
+{
+ int rc;
- temp += strlen(strflags);
- *temp++ = ',';
- *temp++ = '\0';
- }
- if (gotone == FALSE)
- strcat(strflags, options);
- if (comma) {
- *comma = ',';
- options = ++comma;
- } else {
+ if (fakeIt) { return 0; }
+
+ // Mount, with fallback to read-only if necessary.
+
+ for(;;) {
+ rc = mount(mp->mnt_fsname, mp->mnt_dir, mp->mnt_type,
+ vfsflags, filteropts);
+ if(!rc || (vfsflags&MS_RDONLY) || (errno!=EACCES && errno!=EROFS))
break;
- }
+ bb_error_msg("%s is write-protected, mounting read-only",
+ mp->mnt_fsname);
+ vfsflags |= MS_RDONLY;
}
+
+ // Abort entirely if permission denied.
+
+ if (rc && errno == EPERM)
+ bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+
+ /* If the mount was successful, and we're maintaining an old-style
+ * mtab file by hand, add the new entry to it now. */
+
+ if(ENABLE_FEATURE_MTAB_SUPPORT && useMtab && !rc) {
+ FILE *mountTable = setmntent(bb_path_mtab_file, "a+");
+ int i;
+
+ if(!mountTable)
+ bb_error_msg("No %s\n",bb_path_mtab_file);
+
+ // Add vfs string flags
+
+ for(i=0; mount_options[i].flags != MS_REMOUNT; i++)
+ if (mount_options[i].flags > 0)
+ append_mount_options(&(mp->mnt_opts),
+// Shut up about the darn const. It's not important. I don't care.
+ (char *)mount_options[i].name);
+
+ // Remove trailing / (if any) from directory we mounted on
+
+ i = strlen(mp->mnt_dir);
+ if(i>1 && mp->mnt_dir[i-1] == '/') mp->mnt_dir[i-1] = 0;
+
+ // Write and close.
+
+ if(!mp->mnt_type || !*mp->mnt_type) mp->mnt_type="--bind";
+ addmntent(mountTable, mp);
+ endmntent(mountTable);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ if(strcmp(mp->mnt_type,"--bind")) mp->mnt_type = 0;
+ }
+
+ return rc;
}
-int
-mount_one(char *blockDevice, char *directory, char *filesystemType,
- unsigned long flags, char *string_flags, int useMtab, int fakeIt,
- char *mtab_opts, int whineOnErrors)
+
+// Mount one directory. Handles NFS, loopback, autobind, and filesystem type
+// detection. Returns 0 for success, nonzero for failure.
+
+static int singlemount(struct mntent *mp, int ignore_busy)
{
- int status = 0;
+ int rc = -1, vfsflags;
+ char *loopFile = 0, *filteropts = 0;
+ llist_t *fl = 0;
+ struct stat st;
+
+ vfsflags = parse_mount_options(mp->mnt_opts, &filteropts);
-#if defined BB_FEATURE_USE_PROCFS
- char buf[255];
- if (strcmp(filesystemType, "auto") == 0) {
- FILE *f = fopen("/proc/filesystems", "r");
+ // Treat fstype "auto" as unspecified.
- if (f == NULL)
- return (FALSE);
+ if (mp->mnt_type && !strcmp(mp->mnt_type,"auto")) mp->mnt_type = 0;
- while (fgets(buf, sizeof(buf), f) != NULL) {
- filesystemType = buf;
- if (*filesystemType == '\t') { // Not a nodev filesystem
+ // Might this be an NFS filesystem?
+
+ if (ENABLE_FEATURE_MOUNT_NFS &&
+ (!mp->mnt_type || !strcmp(mp->mnt_type,"nfs")) &&
+ strchr(mp->mnt_fsname, ':') != NULL)
+ {
+ if (nfsmount(mp->mnt_fsname, mp->mnt_dir, &vfsflags, &filteropts, 1)) {
+ bb_perror_msg("nfsmount failed");
+ goto report_error;
+ } else {
+ // Strangely enough, nfsmount() doesn't actually mount() anything.
+ mp->mnt_type = "nfs";
+ rc = mount_it_now(mp, vfsflags, filteropts);
+ if (ENABLE_FEATURE_CLEAN_UP) free(filteropts);
+
+ goto report_error;
+ }
+ }
- // Add NULL termination to each line
- while (*filesystemType && *filesystemType != '\n')
- filesystemType++;
- *filesystemType = '\0';
+ // Look at the file. (Not found isn't a failure for remount, or for
+ // a synthetic filesystem like proc or sysfs.)
- filesystemType = buf;
- filesystemType++; // hop past tab
+ if (lstat(mp->mnt_fsname, &st));
+ else if (!(vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE))) {
+ // Do we need to allocate a loopback device for it?
- status = do_mount(blockDevice, directory, filesystemType,
- flags | MS_MGC_VAL, string_flags,
- useMtab, fakeIt, mtab_opts);
- if (status == TRUE)
+ if (ENABLE_FEATURE_MOUNT_LOOP && S_ISREG(st.st_mode)) {
+ loopFile = bb_simplify_path(mp->mnt_fsname);
+ mp->mnt_fsname = 0;
+ switch(set_loop(&(mp->mnt_fsname), loopFile, 0)) {
+ case 0:
+ case 1:
break;
+ default:
+ bb_error_msg( errno == EPERM || errno == EACCES
+ ? bb_msg_perm_denied_are_you_root
+ : "Couldn't setup loop device");
+ return errno;
}
+
+ // Autodetect bind mounts
+
+ } else if (S_ISDIR(st.st_mode) && !mp->mnt_type) vfsflags |= MS_BIND;
+ }
+
+ /* If we know the fstype (or don't need to), jump straight
+ * to the actual mount. */
+
+ if (mp->mnt_type || (vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE)))
+ rc = mount_it_now(mp, vfsflags, filteropts);
+
+ // Loop through filesystem types until mount succeeds or we run out
+
+ else {
+
+ /* Initialize list of block backed filesystems. This has to be
+ * done here so that during "mount -a", mounts after /proc shows up
+ * can autodetect. */
+
+ if (!fslist) {
+ fslist = get_block_backed_filesystems();
+ if (ENABLE_FEATURE_CLEAN_UP && fslist)
+ atexit(delete_block_backed_filesystems);
}
- fclose(f);
- } else
-#endif
-#if defined BB_FEATURE_USE_DEVPS_N_DEVMTAB
- if (strcmp(filesystemType, "auto") == 0) {
- int fd, i, numfilesystems;
- char device[] = "/dev/mtab";
- struct k_fstype *fslist;
-
- /* open device */
- fd = open(device, O_RDONLY);
- if (fd < 0)
- fatalError("open failed for `%s': %s\n", device, strerror (errno));
-
- /* How many filesystems? We need to know to allocate enough space */
- numfilesystems = ioctl (fd, DEVMTAB_COUNT_FILESYSTEMS);
- if (numfilesystems<0)
- fatalError("\nDEVMTAB_COUNT_FILESYSTEMS: %s\n", strerror (errno));
- fslist = (struct k_fstype *) calloc ( numfilesystems, sizeof(struct k_fstype));
-
- /* Grab the list of available filesystems */
- status = ioctl (fd, DEVMTAB_GET_FILESYSTEMS, fslist);
- if (status<0)
- fatalError("\nDEVMTAB_GET_FILESYSTEMS: %s\n", strerror (errno));
-
- /* Walk the list trying to mount filesystems
- * that do not claim to be nodev filesystems */
- for( i = 0 ; i < numfilesystems ; i++) {
- if (fslist[i].mnt_nodev)
- continue;
- status = do_mount(blockDevice, directory, fslist[i].mnt_type,
- flags | MS_MGC_VAL, string_flags,
- useMtab, fakeIt, mtab_opts);
- if (status == TRUE)
- break;
+
+ for (fl = fslist; fl; fl = fl->link) {
+ mp->mnt_type = fl->data;
+
+ if (!(rc = mount_it_now(mp,vfsflags, filteropts))) break;
+
+ mp->mnt_type = 0;
}
- free( fslist);
- close(fd);
- } else
-#endif
- {
- status = do_mount(blockDevice, directory, filesystemType,
- flags | MS_MGC_VAL, string_flags, useMtab,
- fakeIt, mtab_opts);
}
- if (status == FALSE && whineOnErrors == TRUE) {
- if (whineOnErrors == TRUE) {
- fprintf(stderr, "Mounting %s on %s failed: %s\n",
- blockDevice, directory, strerror(errno));
+ if (ENABLE_FEATURE_CLEAN_UP) free(filteropts);
+
+ // If mount failed, clean up loop file (if any).
+
+ if (ENABLE_FEATURE_MOUNT_LOOP && rc && loopFile) {
+ del_loop(mp->mnt_fsname);
+ if (ENABLE_FEATURE_CLEAN_UP) {
+ free(loopFile);
+ free(mp->mnt_fsname);
}
- return (FALSE);
}
- return (TRUE);
+report_error:
+ if (rc && errno == EBUSY && ignore_busy) rc = 0;
+ if (rc < 0)
+ bb_perror_msg("Mounting %s on %s failed", mp->mnt_fsname, mp->mnt_dir);
+
+ return rc;
}
-extern int mount_main(int argc, char **argv)
+// Parse options, if necessary parse fstab/mtab, and call singlemount for
+// each directory to be mounted.
+
+int mount_main(int argc, char **argv)
{
- char string_flags_buf[1024] = "";
- char *string_flags = string_flags_buf;
- char *extra_opts = string_flags_buf;
- unsigned long flags = 0;
- char *filesystemType = "auto";
- char *device = NULL;
- char *directory = NULL;
- int all = FALSE;
- int fakeIt = FALSE;
- int useMtab = TRUE;
- int i;
+ char *cmdopts = xstrdup(""), *fstabname, *fstype=0, *storage_path=0;
+ FILE *fstab;
+ int i, opt, all = FALSE, rc = 0;
+ struct mntent mtpair[2], *mtcur = mtpair;
+
+ /* parse long options, like --bind and --move. Note that -o option
+ * and --option are synonymous. Yes, this means --remount,rw works. */
+
+ for (i = opt = 0; i < argc; i++) {
+ if (argv[i][0] == '-' && argv[i][1] == '-') {
+ append_mount_options(&cmdopts,argv[i]+2);
+ } else argv[opt++] = argv[i];
+ }
+ argc = opt;
+
+ // Parse remaining options
- /* Only compiled in if BB_MTAB is not defined */
- whine_if_fstab_is_missing();
-
-#if defined BB_FEATURE_USE_DEVPS_N_DEVMTAB
- if (argc == 1) {
- int fd, i, numfilesystems;
- char device[] = "/dev/mtab";
- struct k_mntent *mntentlist;
-
- /* open device */
- fd = open(device, O_RDONLY);
- if (fd < 0)
- fatalError("open failed for `%s': %s\n", device, strerror (errno));
-
- /* How many mounted filesystems? We need to know to
- * allocate enough space for later... */
- numfilesystems = ioctl (fd, DEVMTAB_COUNT_MOUNTS);
- if (numfilesystems<0)
- fatalError( "\nDEVMTAB_COUNT_MOUNTS: %s\n", strerror (errno));
- mntentlist = (struct k_mntent *) calloc ( numfilesystems, sizeof(struct k_mntent));
-
- /* Grab the list of mounted filesystems */
- if (ioctl (fd, DEVMTAB_GET_MOUNTS, mntentlist)<0)
- fatalError( "\nDEVMTAB_GET_MOUNTS: %s\n", strerror (errno));
-
- for( i = 0 ; i < numfilesystems ; i++) {
- fprintf( stdout, "%s %s %s %s %d %d\n", mntentlist[i].mnt_fsname,
- mntentlist[i].mnt_dir, mntentlist[i].mnt_type,
- mntentlist[i].mnt_opts, mntentlist[i].mnt_freq,
- mntentlist[i].mnt_passno);
+ while ((opt = getopt(argc, argv, "o:t:rwavnf")) > 0) {
+ switch (opt) {
+ case 'o':
+ append_mount_options(&cmdopts, optarg);
+ break;
+ case 't':
+ fstype = optarg;
+ break;
+ case 'r':
+ append_mount_options(&cmdopts, "ro");
+ break;
+ case 'w':
+ append_mount_options(&cmdopts, "rw");
+ break;
+ case 'a':
+ all = TRUE;
+ break;
+ case 'n':
+ USE_FEATURE_MTAB_SUPPORT(useMtab = FALSE;)
+ break;
+ case 'f':
+ USE_FEATURE_MTAB_SUPPORT(fakeIt = FALSE;)
+ break;
+ case 'v':
+ break; // ignore -v
+ default:
+ bb_show_usage();
}
- free( mntentlist);
- close(fd);
- exit(TRUE);
}
-#else
- if (argc == 1) {
- FILE *mountTable = setmntent(mtab_file, "r");
-
- if (mountTable) {
- struct mntent *m;
-
- while ((m = getmntent(mountTable)) != 0) {
- struct fstab *fstabItem;
- char *blockDevice = m->mnt_fsname;
-
- /* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */
- if (strcmp(blockDevice, "/dev/root") == 0) {
- fstabItem = getfsfile("/");
- if (fstabItem != NULL)
- blockDevice = fstabItem->fs_spec;
- }
- printf("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir,
- m->mnt_type, m->mnt_opts);
+
+ // Three or more non-option arguments? Die with a usage message.
+
+ if (optind-argc>2) bb_show_usage();
+
+ // If we have no arguments, show currently mounted filesystems
+
+ if (optind == argc) {
+ if (!all) {
+ FILE *mountTable = setmntent(bb_path_mtab_file, "r");
+
+ if(!mountTable) bb_error_msg_and_die("No %s",bb_path_mtab_file);
+
+ while (getmntent_r(mountTable,mtpair,bb_common_bufsiz1,
+ sizeof(bb_common_bufsiz1)))
+ {
+ // Don't show rootfs.
+ if (!strcmp(mtpair->mnt_fsname, "rootfs")) continue;
+
+ if (!fstype || !strcmp(mtpair->mnt_type, fstype))
+ printf("%s on %s type %s (%s)\n", mtpair->mnt_fsname,
+ mtpair->mnt_dir, mtpair->mnt_type,
+ mtpair->mnt_opts);
}
- endmntent(mountTable);
- } else {
- perror(mtab_file);
+ if (ENABLE_FEATURE_CLEAN_UP) endmntent(mountTable);
+ return EXIT_SUCCESS;
}
- exit(TRUE);
}
-#endif
- /* Parse options */
- i = --argc;
- argv++;
- while (i > 0 && **argv) {
- if (**argv == '-') {
- char *opt = *argv;
-
- while (i > 0 && *++opt)
- switch (*opt) {
- case 'o':
- if (--i == 0) {
- goto goodbye;
- }
- parse_mount_options(*(++argv), &flags, string_flags);
- break;
- case 'r':
- flags |= MS_RDONLY;
- break;
- case 't':
- if (--i == 0) {
- goto goodbye;
- }
- filesystemType = *(++argv);
- break;
- case 'w':
- flags &= ~MS_RDONLY;
- break;
- case 'a':
- all = TRUE;
- break;
-#ifdef BB_MTAB
- case 'f':
- fakeIt = TRUE;
- break;
- case 'n':
- useMtab = FALSE;
- break;
-#endif
- case 'v':
- case 'h':
- case '-':
- goto goodbye;
- }
- } else {
- if (device == NULL)
- device = *argv;
- else if (directory == NULL)
- directory = *argv;
- else {
- goto goodbye;
- }
- }
- i--;
- argv++;
+ // When we have two arguments, the second is the directory and we can
+ // skip looking at fstab entirely. We can always abspath() the directory
+ // argument when we get it.
+
+ if (optind+2 == argc) {
+ mtpair->mnt_fsname = argv[optind];
+ mtpair->mnt_dir = argv[optind+1];
+ mtpair->mnt_type = fstype;
+ mtpair->mnt_opts = cmdopts;
+ rc = singlemount(mtpair, 0);
+ goto clean_up;
}
- if (all == TRUE) {
- struct mntent *m;
- FILE *f = setmntent("/etc/fstab", "r");
-
- if (f == NULL)
- fatalError( "\nCannot ream /etc/fstab: %s\n", strerror (errno));
-
- while ((m = getmntent(f)) != NULL) {
- // If the file system isn't noauto,
- // and isn't swap or nfs, then mount it
- if ((!strstr(m->mnt_opts, "noauto")) &&
- (!strstr(m->mnt_type, "swap")) &&
- (!strstr(m->mnt_type, "nfs"))) {
- flags = 0;
- *string_flags = '\0';
- parse_mount_options(m->mnt_opts, &flags, string_flags);
- /* If the directory is /, try to remount
- * with the options specified in fstab */
- if (m->mnt_dir[0] == '/' && m->mnt_dir[1] == '\0') {
- flags |= MS_REMOUNT;
- }
- if (mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type,
- flags, string_flags, useMtab, fakeIt,
- extra_opts, FALSE))
- {
- /* Try again, but this time try a remount */
- mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type,
- flags|MS_REMOUNT, string_flags, useMtab, fakeIt,
- extra_opts, TRUE);
- }
+ // If we have at least one argument, it's the storage location
+
+ if (optind < argc) storage_path = bb_simplify_path(argv[optind]);
+
+ // Open either fstab or mtab
+
+ if (parse_mount_options(cmdopts,0) & MS_REMOUNT)
+ fstabname = (char *)bb_path_mtab_file; // Again with the evil const.
+ else fstabname="/etc/fstab";
+
+ if (!(fstab=setmntent(fstabname,"r")))
+ bb_perror_msg_and_die("Cannot read %s",fstabname);
+
+ // Loop through entries until we find what we're looking for.
+
+ memset(mtpair,0,sizeof(mtpair));
+ for (;;) {
+ struct mntent *mtnext = mtpair + (mtcur==mtpair ? 1 : 0);
+
+ // Get next fstab entry
+
+ if (!getmntent_r(fstab, mtcur, bb_common_bufsiz1
+ + (mtcur==mtpair ? sizeof(bb_common_bufsiz1)/2 : 0),
+ sizeof(bb_common_bufsiz1)/2))
+ {
+ // Were we looking for something specific?
+
+ if (optind != argc) {
+
+ // If we didn't find anything, complain.
+
+ if (!mtnext->mnt_fsname)
+ bb_error_msg_and_die("Can't find %s in %s",
+ argv[optind], fstabname);
+
+ // Mount the last thing we found.
+
+ mtcur = mtnext;
+ mtcur->mnt_opts = xstrdup(mtcur->mnt_opts);
+ append_mount_options(&(mtcur->mnt_opts),cmdopts);
+ rc = singlemount(mtcur, 0);
+ free(mtcur->mnt_opts);
}
+ goto clean_up;
}
- endmntent(f);
- } else {
- if (device && directory) {
-#ifdef BB_NFSMOUNT
- if (strcmp(filesystemType, "nfs") == 0) {
- if (nfsmount
- (device, directory, &flags, &extra_opts, &string_flags,
- 1) != 0)
- exit(FALSE);
- }
-#endif
- exit(mount_one(device, directory, filesystemType,
- flags, string_flags, useMtab, fakeIt,
- extra_opts, TRUE));
+
+ /* If we're trying to mount something specific and this isn't it,
+ * skip it. Note we must match both the exact text in fstab (ala
+ * "proc") or a full path from root */
+
+ if (optind != argc) {
+
+ // Is this what we're looking for?
+
+ if(strcmp(argv[optind],mtcur->mnt_fsname) &&
+ strcmp(storage_path,mtcur->mnt_fsname) &&
+ strcmp(argv[optind],mtcur->mnt_dir) &&
+ strcmp(storage_path,mtcur->mnt_dir)) continue;
+
+ // Remember this entry. Something later may have overmounted
+ // it, and we want the _last_ match.
+
+ mtcur = mtnext;
+
+ // If we're mounting all.
+
} else {
- goto goodbye;
+
+ // Do we need to match a filesystem type?
+ if (fstype && strcmp(mtcur->mnt_type,fstype)) continue;
+
+ // Skip noauto and swap anyway.
+
+ if (parse_mount_options(mtcur->mnt_opts,0)
+ & (MOUNT_NOAUTO | MOUNT_SWAP)) continue;
+
+ // Mount this thing.
+
+ if (singlemount(mtcur, 1)) {
+ /* Count number of failed mounts */
+ rc++;
+ }
}
}
- exit(TRUE);
+ if (ENABLE_FEATURE_CLEAN_UP) endmntent(fstab);
+
+clean_up:
+
+ if (ENABLE_FEATURE_CLEAN_UP) {
+ free(storage_path);
+ free(cmdopts);
+ }
- goodbye:
- usage(mount_usage);
+ return rc;
}