X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=mount.c;h=5b6ec1e71ff64c834e8858878f84dfe42666eb0c;hb=4949faf4b2090ca23c2aeb34535fdbe57754913a;hp=010757d1ec5dabb6b1447010ee4a0e7a0de7dbbd;hpb=cc8ed39b240180b58810784f844e253263594ac3;p=oweals%2Fbusybox.git diff --git a/mount.c b/mount.c index 010757d1e..5b6ec1e71 100644 --- a/mount.c +++ b/mount.c @@ -1,430 +1,473 @@ +/* vi: set sw=4 ts=4: */ /* - 3/21/1999 Charles P. Wright - searches through fstab when -a is passed - will try mounting stuff with all fses when passed -t auto + * Mini mount implementation for busybox + * + * Copyright (C) 1995, 1996 by Bruce Perens . + * + * 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 + * 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 , . + * 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 , Borrowed utils-linux's + * mount to add loop support. + * + * 2000-04-30 Dave Cinege + * 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. + * + */ - 1999-04-17 Dave Cinege...Rewrote -t auto. Fixed ro mtab. -*/ - -#include "internal.h" #include #include #include #include #include #include -#include #include +#if defined BB_FEATURE_USE_DEVPS_PATCH +#include /* For Erik's nifty devmtab device driver */ +#endif +#include "busybox.h" + +enum { + MS_MGC_VAL = 0xc0ed0000, /* Magic number indicatng "new" flags */ + MS_RDONLY = 1, /* Mount read-only */ + MS_NOSUID = 2, /* Ignore suid and sgid bits */ + MS_NODEV = 4, /* Disallow access to device special files */ + MS_NOEXEC = 8, /* Disallow program execution */ + MS_SYNCHRONOUS = 16, /* Writes are synced at once */ + MS_REMOUNT = 32, /* Alter flags of a mounted FS */ + MS_MANDLOCK = 64, /* Allow mandatory locks on an FS */ + S_QUOTA = 128, /* Quota initialized for file/directory/symlink */ + S_APPEND = 256, /* Append-only file */ + S_IMMUTABLE = 512, /* Immutable file */ + MS_NOATIME = 1024, /* Do not update access times. */ + MS_NODIRATIME = 2048, /* Do not update directory access times */ +}; + + +#if defined BB_FEATURE_MOUNT_LOOP +#include +#include +static int use_loop = FALSE; +#endif -const char mount_usage[] = "mount\n" -"\t\tmount [flags] special-device directory\n" -"\n" -"Flags:\n" -"\t-a:\tMount all file systems in fstab.\n" -"\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" -"\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" -"\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"; +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); + +extern int sysfs( int option, unsigned int fs_index, char * buf); + +extern const char mtab_file[]; /* Defined in utility.c */ struct mount_options { - const char * name; - unsigned long and; - unsigned long or; + const char *name; + unsigned long and; + unsigned long or; }; -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 } +static const struct mount_options mount_options[] = { + {"async", ~MS_SYNCHRONOUS, 0}, + {"atime", ~0, ~MS_NOATIME}, + {"defaults", ~0, 0}, + {"dev", ~MS_NODEV, 0}, + {"diratime", ~0, ~MS_NODIRATIME}, + {"exec", ~MS_NOEXEC, 0}, + {"noatime", ~0, MS_NOATIME}, + {"nodev", ~0, MS_NODEV}, + {"nodiratime", ~0, MS_NODIRATIME}, + {"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} }; -static void -show_flags(unsigned long flags, char * buffer) +static int +do_mount(char *specialfile, char *dir, char *filesystemtype, + long flags, void *string_flags, int useMtab, int fakeIt, + char *mtab_opts) { - const struct mount_options * f = mount_options; - while ( f->name ) { - if ( flags & f->and ) { - int length = strlen(f->name); - memcpy(buffer, f->name, length); - buffer += length; - *buffer++ = ','; - *buffer = '\0'; + int status = 0; +#if defined BB_FEATURE_MOUNT_LOOP + char *lofile = NULL; +#endif + + if (fakeIt == FALSE) + { +#if defined BB_FEATURE_MOUNT_LOOP + if (use_loop==TRUE) { + int loro = flags & MS_RDONLY; + + lofile = specialfile; + + specialfile = find_unused_loop_device(); + if (specialfile == NULL) { + error_msg_and_die("Could not find a spare loop device"); + } + if (set_loop(specialfile, lofile, 0, &loro)) { + error_msg_and_die("Could not setup loop device"); + } + if (!(flags & MS_RDONLY) && loro) { /* loop is ro, but wanted rw */ + error_msg("WARNING: loop device is read-only"); + flags &= ~MS_RDONLY; + } + } +#endif + status = mount(specialfile, dir, filesystemtype, flags, string_flags); + if (errno == EROFS) { + error_msg("%s is write-protected, mounting read-only", specialfile); + status = mount(specialfile, dir, filesystemtype, flags |= MS_RDONLY, string_flags); } - f++; } -} -static void -one_option( - char * option -,unsigned long * flags -,char * data) -{ - const struct mount_options * f = mount_options; - while ( f->name != 0 ) { - if ( strcasecmp(f->name, option) == 0 ) { - *flags &= f->and; - *flags |= f->or; - return; + /* If the mount was sucessful, do anything needed, then return TRUE */ + if (status == 0 || fakeIt==TRUE) { + +#if defined BB_FEATURE_MTAB_SUPPORT + if (useMtab == TRUE) { + erase_mtab(specialfile); // Clean any stale entries + write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts); } - f++; +#endif + return (TRUE); } - if ( *data ) { - data += strlen(data); - *data++ = ','; + + /* Bummer. mount failed. Clean up */ +#if defined BB_FEATURE_MOUNT_LOOP + if (lofile != NULL) { + del_loop(specialfile); + } +#endif + + if (errno == EPERM) { + error_msg_and_die("permission denied. Are you root?"); } - strcpy(data, option); + + return (FALSE); } + + +/* Seperate standard mount options from the nonstandard string options */ static void -parse_mount_options( - char * options -,unsigned long * flags -,char * data) +parse_mount_options(char *options, int *flags, char *strflags) { - while ( *options ) { - char * comma = strchr(options, ','); - if ( comma ) + while (options) { + int gotone = FALSE; + char *comma = strchr(options, ','); + const struct mount_options *f = mount_options; + + if (comma) *comma = '\0'; - one_option(options, flags, data); - if ( comma ) { + + while (f->name != 0) { + if (strcasecmp(f->name, options) == 0) { + + *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; + + temp += strlen(strflags); + *temp++ = ','; + *temp++ = '\0'; + } + if (gotone == FALSE) + strcat(strflags, options); + if (comma) { *comma = ','; options = ++comma; - } - else + } else { break; + } } } -int -mount_one( - char * blockDevice -,char * directory -,char * filesystemType -,unsigned long flags -,char * string_flags -,int noMtab -,int fake) +extern int +mount_one(char *blockDevice, char *directory, char *filesystemType, + unsigned long flags, char *string_flags, int useMtab, int fakeIt, + char *mtab_opts, int whineOnErrors) { - int error = 0; - int status = 0; - - char buf[255]; - - if (!fake) { - if (*filesystemType == 'a') { //Will fail on real FS starting with 'a' - - FILE *f = fopen("/proc/filesystems", "r"); - - if (f == NULL) return 1; - - while (fgets(buf, sizeof(buf), f) != NULL) { - filesystemType = buf; - if (*filesystemType == '\t') { // Not a nodev filesystem - - while (*filesystemType && *filesystemType != '\n') filesystemType++; - *filesystemType = '\0'; - - filesystemType = buf; - filesystemType++; //hop past tab - - status = mount(blockDevice, directory, filesystemType, - flags|MS_MGC_VAL ,string_flags); - error = errno; - - if (status == 0) break; + int status = 0; + + if (strcmp(filesystemType, "auto") == 0) { + static const char *noauto_array[] = { "tmpfs", "shm", "proc", "ramfs", "devpts", "devfs", 0 }; + const char **noauto_fstype; + const int num_of_filesystems = sysfs(3, 0, 0); + char buf[255]; + int i=0; + + filesystemType=buf; + + while(i < num_of_filesystems) { + sysfs(2, i++, filesystemType); + for (noauto_fstype = noauto_array; *noauto_fstype; noauto_fstype++) { + if (!strcmp(filesystemType, *noauto_fstype)) { + break; } } - fclose(f); - } else { - - status = mount( blockDevice, directory, filesystemType, - flags|MS_MGC_VAL ,string_flags); - error = errno; - } - } - - if ( status == 0 ) { - char * s = &string_flags[strlen(string_flags)]; - FILE * mountTable; - if ( s != string_flags ) { - *s++ = ','; - show_flags(flags, s); - } - if ( !noMtab && (mountTable = setmntent("/etc/mtab", "a+")) ) { - int length = strlen(directory); - struct mntent m; - - if ( length > 1 && directory[length - 1] == '/' ) - directory[length - 1] = '\0'; - - if ( filesystemType == 0 ) { - struct mntent * p - = findMountPoint(blockDevice, "/proc/mounts"); - - if ( p && p->mnt_type ) - filesystemType = p->mnt_type; + if (!*noauto_fstype) { + status = do_mount(blockDevice, directory, filesystemType, + flags | MS_MGC_VAL, string_flags, + useMtab, fakeIt, mtab_opts); + if (status == TRUE) + break; } - m.mnt_fsname = blockDevice; - m.mnt_dir = directory; - m.mnt_type = filesystemType ? filesystemType : "default"; - - if (*string_flags) { - m.mnt_opts = string_flags; - } else { - if ( (flags | MS_RDONLY) == flags ) - m.mnt_opts = "ro"; - else - m.mnt_opts = "rw"; - } - - m.mnt_freq = 0; - m.mnt_passno = 0; - addmntent(mountTable, &m); - endmntent(mountTable); } - return 0; } else { - fprintf(stderr, "Mount %s", blockDevice); - if ( filesystemType && *filesystemType ) - fprintf(stderr, " (type %s)", filesystemType); - - fprintf( - stderr - ," on %s: " - ,directory); - - switch ( error ) { - case EPERM: - if (geteuid() == 0) - fprintf( - stderr - ,"mount point %s is not a directory" - ,blockDevice); - else - fprintf( - stderr - ,"must be superuser to use mount"); - break; - case EBUSY: - fprintf( - stderr - ,"%s already mounted or %s busy" - ,blockDevice - ,directory); - break; - case ENOENT: - { - struct stat statbuf; - if ( stat(directory, &statbuf) != 0 ) - fprintf( - stderr - ,"directory %s does not exist" - ,directory); - else if ( stat(blockDevice, &statbuf) != 0 ) - fprintf( - stderr - ,"block device %s does not exist" - ,blockDevice); - else - fprintf( - stderr - ,"%s is not mounted on %s, but the mount table says it is." - ,blockDevice - ,directory); - break; - } - case ENOTDIR: - fprintf( - stderr - ,"%s is not a directory" - ,directory); - break; - case EINVAL: - fprintf( - stderr - ,"wrong filesystem type, or bad superblock on %s" - ,blockDevice); - break; - case EMFILE: - fprintf(stderr, "mount table full"); - break; - case EIO: - fprintf( - stderr - ,"I/O error reading %s" - ,blockDevice); - break; - case ENODEV: - { - FILE * f = fopen("/proc/filesystems", "r"); - - fprintf( - stderr - ,"filesystem type %s not in kernel.\n" - ,filesystemType); - fprintf(stderr, "Do you need to load a module?\n"); - if ( f ) { - char buf[100]; - - fprintf( - stderr - ,"Here are the filesystem types the kernel" - " can mount:\n"); - while ( fgets(buf, sizeof(buf), f) != 0 ) - fprintf(stderr, "\t%s", buf); - fclose(f); - } - break; - } - case ENOTBLK: - fprintf( - stderr - ,"%s is not a block device" - ,blockDevice); - break; - case ENXIO: - fprintf( - stderr - ,"%s is not a valid block device" - ,blockDevice); - break; - default: - fputs(strerror(errno), stderr); + status = do_mount(blockDevice, directory, filesystemType, + flags | MS_MGC_VAL, string_flags, useMtab, + fakeIt, mtab_opts); + } + + if (status == FALSE) { + if (whineOnErrors == TRUE) { + perror_msg("Mounting %s on %s failed", blockDevice, directory); } - putc('\n', stderr); - return -1; + return (FALSE); } + return (TRUE); } -extern int -mount_main(struct FileInfo * i, int argc, char * * argv) +extern int mount_main(int argc, char **argv) { - char string_flags[1024]; - unsigned long flags = 0; - char * filesystemType = "auto"; - int fake = 0; - int noMtab = 0; - int all = 0; - - *string_flags = '\0'; - - if ( argc == 1 ) { - FILE * mountTable; - if ( (mountTable = setmntent("/etc/mtab", "r")) ) { - struct mntent * m; - while ( (m = getmntent(mountTable)) != 0 ) { - printf( - "%s on %s type %s (%s)\n" - ,m->mnt_fsname - ,m->mnt_dir - ,m->mnt_type - ,m->mnt_opts); - } - endmntent(mountTable); + char string_flags_buf[1024] = ""; + char *string_flags = string_flags_buf; + char *extra_opts = string_flags_buf; + int flags = 0; + char *filesystemType = "auto"; + char *device = NULL; + char *directory = NULL; + int all = FALSE; + int fakeIt = FALSE; + int useMtab = TRUE; + int i; + int rc = EXIT_FAILURE; + int fstabmount = FALSE; + +#if defined BB_FEATURE_USE_DEVPS_PATCH + 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) + perror_msg_and_die("open failed for `%s'", device); + + /* How many mounted filesystems? We need to know to + * allocate enough space for later... */ + numfilesystems = ioctl (fd, DEVMTAB_COUNT_MOUNTS); + if (numfilesystems<0) + perror_msg_and_die( "\nDEVMTAB_COUNT_MOUNTS"); + mntentlist = (struct k_mntent *) xcalloc ( numfilesystems, sizeof(struct k_mntent)); + + /* Grab the list of mounted filesystems */ + if (ioctl (fd, DEVMTAB_GET_MOUNTS, mntentlist)<0) + perror_msg_and_die( "\nDEVMTAB_GET_MOUNTS"); + + for( i = 0 ; i < numfilesystems ; i++) { + printf( "%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); } - return 0; +#ifdef BB_FEATURE_CLEAN_UP + /* Don't bother to close files or free memory. Exit + * does that automagically, so we can save a few bytes */ + free( mntentlist); + close(fd); +#endif + return EXIT_SUCCESS; } +#else + if (argc == 1) { + FILE *mountTable = setmntent(mtab_file, "r"); - while ( argc >= 2 && argv[1][0] == '-' ) { - switch ( argv[1][1] ) { - case 'f': - fake = 1; - break; - case 'n': - noMtab = 1; - break; - case 'o': - if ( argc < 3 ) { - usage(mount_usage); - return 1; + if (mountTable) { + struct mntent *m; + + while ((m = getmntent(mountTable)) != 0) { + char *blockDevice = m->mnt_fsname; + if (strcmp(blockDevice, "/dev/root") == 0) { + find_real_root_device_name( blockDevice); + } + printf("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir, + m->mnt_type, m->mnt_opts); } - parse_mount_options(argv[2], &flags, string_flags); - argc--; - argv++; - break; - case 'r': - flags |= MS_RDONLY; - break; - case 't': - if ( argc < 3 ) { - usage(mount_usage); - return 1; + endmntent(mountTable); + } else { + perror_msg_and_die("%s", mtab_file); + } + return EXIT_SUCCESS; + } +#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; + case 'f': + fakeIt = TRUE; + break; +#ifdef BB_FEATURE_MTAB_SUPPORT + case 'n': + useMtab = FALSE; + break; +#endif + case 'v': + break; /* ignore -v */ + case 'h': + case '-': + goto goodbye; + } + } else { + if (device == NULL) + device = *argv; + else if (directory == NULL) + directory = *argv; + else { + goto goodbye; } - filesystemType = argv[2]; - argc--; - argv++; - break; - case 'v': - break; - case 'w': - flags &= ~MS_RDONLY; - break; - case 'a': - all = 1; - break; - default: - usage(mount_usage); - return 1; } - argc--; + i--; argv++; } - if (all == 1) { - struct mntent *m; - FILE *f = setmntent("/etc/fstab", "r"); - - if (f == NULL) { - return 1; - } + if (all == TRUE || directory == NULL) { + struct mntent *m; + FILE *f = setmntent("/etc/fstab", "r"); + fstabmount = TRUE; - // FIXME: Combine read routine (make new function) with unmount_all to save space. + if (f == NULL) + perror_msg_and_die( "\nCannot read /etc/fstab"); - while ((m = getmntent(f)) != NULL) { - // If the file system isn't noauto, and isn't mounted on /, mount it - if ((!strstr(m->mnt_opts, "noauto")) && (m->mnt_dir[1] != '\0') - && !((m->mnt_type[0] == 's') && (m->mnt_type[1] == 'w')) - && !((m->mnt_type[0] == 'n') && (m->mnt_type[1] == 'f'))) { - mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type, flags, m->mnt_opts, noMtab, fake); + while ((m = getmntent(f)) != NULL) { + if (all == FALSE && directory == NULL && ( + (strcmp(device, m->mnt_fsname) != 0) && + (strcmp(device, m->mnt_dir) != 0) ) ) { + continue; } + + if (all == TRUE && ( // If we're mounting 'all' + (strstr(m->mnt_opts, "noauto")) || // and the file system isn't noauto, + (strstr(m->mnt_type, "swap")) || // and isn't swap or nfs, then mount it + (strstr(m->mnt_type, "nfs")) ) ) { + continue; + } + + if (all == TRUE || flags == 0) { // Allow single mount to override fstab flags + flags = 0; + *string_flags = '\0'; + parse_mount_options(m->mnt_opts, &flags, string_flags); + } + + device = strdup(m->mnt_fsname); + directory = strdup(m->mnt_dir); + filesystemType = strdup(m->mnt_type); +singlemount: + string_flags = strdup(string_flags); + rc = EXIT_SUCCESS; +#ifdef BB_NFSMOUNT + if (strchr(device, ':') != NULL) + filesystemType = "nfs"; + if (strcmp(filesystemType, "nfs") == 0) { + if (nfsmount (device, directory, &flags, &extra_opts, + &string_flags, 1)) { + perror_msg("nfsmount failed"); + rc = EXIT_FAILURE; + } + } +#endif + if (!mount_one(device, directory, filesystemType, flags, + string_flags, useMtab, fakeIt, extra_opts, TRUE)) + rc = EXIT_FAILURE; + + if (all == FALSE) + break; } - - endmntent(f); - } else { - if ( argc >= 3 ) { - if ( mount_one( argv[1], argv[2], filesystemType, flags, string_flags, noMtab, fake) == 0 ) - return 0; - else - return 1; - } else { - usage(mount_usage); - return 1; - } + if (fstabmount == TRUE) + endmntent(f); + + if (all == FALSE && fstabmount == TRUE && directory == NULL) + fprintf(stderr, "Can't find %s in /etc/fstab\n", device); + + return rc; } - return 0; + + goto singlemount; + +goodbye: + show_usage(); }