// singlemount() can loop through /etc/filesystems for fstype detection.
// mount_it_now() does the actual mount.
//
+
+//config:config MOUNT
+//config: bool "mount (30 kb)"
+//config: default y
+//config: select PLATFORM_LINUX
+//config: help
+//config: All files and filesystems in Unix are arranged into one big directory
+//config: tree. The 'mount' utility is used to graft a filesystem onto a
+//config: particular part of the tree. A filesystem can either live on a block
+//config: device, or it can be accessible over the network, as is the case with
+//config: NFS filesystems.
+//config:
+//config:config FEATURE_MOUNT_FAKE
+//config: bool "Support -f (fake mount)"
+//config: default y
+//config: depends on MOUNT
+//config: help
+//config: Enable support for faking a file system mount.
+//config:
+//config:config FEATURE_MOUNT_VERBOSE
+//config: bool "Support -v (verbose)"
+//config: default y
+//config: depends on MOUNT
+//config: help
+//config: Enable multi-level -v[vv...] verbose messages. Useful if you
+//config: debug mount problems and want to see what is exactly passed
+//config: to the kernel.
+//config:
+//config:config FEATURE_MOUNT_HELPERS
+//config: bool "Support mount helpers"
+//config: default n
+//config: depends on MOUNT
+//config: help
+//config: Enable mounting of virtual file systems via external helpers.
+//config: E.g. "mount obexfs#-b00.11.22.33.44.55 /mnt" will in effect call
+//config: "obexfs -b00.11.22.33.44.55 /mnt"
+//config: Also "mount -t sometype [-o opts] fs /mnt" will try
+//config: "sometype [-o opts] fs /mnt" if simple mount syscall fails.
+//config: The idea is to use such virtual filesystems in /etc/fstab.
+//config:
+//config:config FEATURE_MOUNT_LABEL
+//config: bool "Support specifying devices by label or UUID"
+//config: default y
+//config: depends on MOUNT
+//config: select VOLUMEID
+//config: help
+//config: This allows for specifying a device by label or uuid, rather than by
+//config: name. This feature utilizes the same functionality as blkid/findfs.
+//config:
+//config:config FEATURE_MOUNT_NFS
+//config: bool "Support mounting NFS file systems on Linux < 2.6.23"
+//config: default n
+//config: depends on MOUNT
+//config: select FEATURE_HAVE_RPC
+//config: select FEATURE_SYSLOG
+//config: help
+//config: Enable mounting of NFS file systems on Linux kernels prior
+//config: to version 2.6.23. Note that in this case mounting of NFS
+//config: over IPv6 will not be possible.
+//config:
+//config: Note that this option links in RPC support from libc,
+//config: which is rather large (~10 kbytes on uclibc).
+//config:
+//config:config FEATURE_MOUNT_CIFS
+//config: bool "Support mounting CIFS/SMB file systems"
+//config: default y
+//config: depends on MOUNT
+//config: help
+//config: Enable support for samba mounts.
+//config:
+//config:config FEATURE_MOUNT_FLAGS
+//config: depends on MOUNT
+//config: bool "Support lots of -o flags"
+//config: default y
+//config: help
+//config: Without this, mount only supports ro/rw/remount. With this, it
+//config: supports nosuid, suid, dev, nodev, exec, noexec, sync, async, atime,
+//config: noatime, diratime, nodiratime, loud, bind, move, shared, slave,
+//config: private, unbindable, rshared, rslave, rprivate, and runbindable.
+//config:
+//config:config FEATURE_MOUNT_FSTAB
+//config: depends on MOUNT
+//config: bool "Support /etc/fstab and -a (mount all)"
+//config: default y
+//config: help
+//config: Support mount all and looking for files in /etc/fstab.
+//config:
+//config:config FEATURE_MOUNT_OTHERTAB
+//config: depends on FEATURE_MOUNT_FSTAB
+//config: bool "Support -T <alt_fstab>"
+//config: default y
+//config: help
+//config: Support mount -T (specifying an alternate fstab)
+
+/* On full-blown systems, requires suid for user mounts.
+ * But it's not unthinkable to have it available in non-suid flavor on some systems,
+ * for viewing mount table.
+ * Therefore we use BB_SUID_MAYBE instead of BB_SUID_REQUIRE: */
+//applet:IF_MOUNT(APPLET(mount, BB_DIR_BIN, IF_DESKTOP(BB_SUID_MAYBE) IF_NOT_DESKTOP(BB_SUID_DROP)))
+
+//kbuild:lib-$(CONFIG_MOUNT) += mount.o
+
+//usage:#define mount_trivial_usage
+//usage: "[OPTIONS] [-o OPT] DEVICE NODE"
+//usage:#define mount_full_usage "\n\n"
+//usage: "Mount a filesystem. Filesystem autodetection requires /proc.\n"
+//usage: "\n -a Mount all filesystems in fstab"
+//usage: IF_FEATURE_MOUNT_FAKE(
+//usage: IF_FEATURE_MTAB_SUPPORT(
+//usage: "\n -f Update /etc/mtab, but don't mount"
+//usage: )
+//usage: IF_NOT_FEATURE_MTAB_SUPPORT(
+//usage: "\n -f Dry run"
+//usage: )
+//usage: )
+//usage: IF_FEATURE_MOUNT_HELPERS(
+//usage: "\n -i Don't run mount helper"
+//usage: )
+//usage: IF_FEATURE_MTAB_SUPPORT(
+//usage: "\n -n Don't update /etc/mtab"
+//usage: )
+//usage: IF_FEATURE_MOUNT_VERBOSE(
+//usage: "\n -v Verbose"
+//usage: )
+////usage: "\n -s Sloppy (ignored)"
+//usage: "\n -r Read-only mount"
+////usage: "\n -w Read-write mount (default)"
+//usage: "\n -t FSTYPE[,...] Filesystem type(s)"
+//usage: IF_FEATURE_MOUNT_OTHERTAB(
+//usage: "\n -T FILE Read FILE instead of /etc/fstab"
+//usage: )
+//usage: "\n -O OPT Mount only filesystems with option OPT (-a only)"
+//usage: "\n-o OPT:"
+//usage: IF_FEATURE_MOUNT_LOOP(
+//usage: "\n loop Ignored (loop devices are autodetected)"
+//usage: )
+//usage: IF_FEATURE_MOUNT_FLAGS(
+//usage: "\n [a]sync Writes are [a]synchronous"
+//usage: "\n [no]atime Disable/enable updates to inode access times"
+//usage: "\n [no]diratime Disable/enable atime updates to directories"
+//usage: "\n [no]relatime Disable/enable atime updates relative to modification time"
+//usage: "\n [no]dev (Dis)allow use of special device files"
+//usage: "\n [no]exec (Dis)allow use of executable files"
+//usage: "\n [no]suid (Dis)allow set-user-id-root programs"
+//usage: "\n [r]shared Convert [recursively] to a shared subtree"
+//usage: "\n [r]slave Convert [recursively] to a slave subtree"
+//usage: "\n [r]private Convert [recursively] to a private subtree"
+//usage: "\n [un]bindable Make mount point [un]able to be bind mounted"
+//usage: "\n [r]bind Bind a file or directory [recursively] to another location"
+//usage: "\n move Relocate an existing mount point"
+//usage: )
+//usage: "\n remount Remount a mounted filesystem, changing flags"
+//usage: "\n ro Same as -r"
+//usage: "\n"
+//usage: "\nThere are filesystem-specific -o flags."
+//usage:
+//usage:#define mount_example_usage
+//usage: "$ mount\n"
+//usage: "/dev/hda3 on / type minix (rw)\n"
+//usage: "proc on /proc type proc (rw)\n"
+//usage: "devpts on /dev/pts type devpts (rw)\n"
+//usage: "$ mount /dev/fd0 /mnt -t msdos -o ro\n"
+//usage: "$ mount /tmp/diskimage /opt -t ext2 -o loop\n"
+//usage: "$ mount cd_image.iso mydir\n"
+//usage:#define mount_notes_usage
+//usage: "Returns 0 for success, number of failed mounts for -a, or errno for one mount."
+
#include <mntent.h>
#include <syslog.h>
#include <sys/mount.h>
#ifndef MS_RELATIME
# define MS_RELATIME (1 << 21)
#endif
+#ifndef MS_STRICTATIME
+# define MS_STRICTATIME (1 << 24)
+#endif
+
+/* Any ~MS_FOO value has this bit set: */
+#define BB_MS_INVERTED_VALUE (1u << 31)
#include "libbb.h"
+#include "common_bufsiz.h"
#if ENABLE_FEATURE_MOUNT_LABEL
# include "volume_id.h"
#else
/* This is just a warning of a common mistake. Possibly this should be a
* uclibc faq entry rather than in busybox... */
# if defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_RPC__)
-# error "You need to build uClibc with UCLIBC_HAS_RPC for NFS support"
+# warning "You probably need to build uClibc with UCLIBC_HAS_RPC for NFS support"
+ /* not #error, since user may be using e.g. libtirpc instead */
# endif
# include <rpc/rpc.h>
# include <rpc/pmap_prot.h>
// Not real flags, but we want to be able to check for this.
enum {
- MOUNT_USERS = (1 << 28) * ENABLE_DESKTOP,
+ MOUNT_USERS = (1 << 27) * ENABLE_DESKTOP,
+ MOUNT_NOFAIL = (1 << 28) * ENABLE_DESKTOP,
MOUNT_NOAUTO = (1 << 29),
MOUNT_SWAP = (1 << 30),
+ MOUNT_FAKEFLAGS = MOUNT_USERS | MOUNT_NOFAIL | MOUNT_NOAUTO | MOUNT_SWAP
};
-#define OPTION_STR "o:t:rwanfvsiO:"
+#define OPTION_STR "o:*t:rwanfvsiO:" IF_FEATURE_MOUNT_OTHERTAB("T:")
enum {
OPT_o = (1 << 0),
OPT_t = (1 << 1),
OPT_s = (1 << 8),
OPT_i = (1 << 9),
OPT_O = (1 << 10),
+ OPT_T = (1 << 11),
};
#if ENABLE_FEATURE_MTAB_SUPPORT
/* "swap" */ MOUNT_SWAP,
IF_DESKTOP(/* "user" */ MOUNT_USERS,)
IF_DESKTOP(/* "users" */ MOUNT_USERS,)
+ IF_DESKTOP(/* "nofail" */ MOUNT_NOFAIL,)
/* "_netdev" */ 0,
+ IF_DESKTOP(/* "comment=" */ 0,) /* systemd uses this in fstab */
)
IF_FEATURE_MOUNT_FLAGS(
/* "nomand" */ ~MS_MANDLOCK,
/* "relatime" */ MS_RELATIME,
/* "norelatime" */ ~MS_RELATIME,
+ /* "strictatime" */ MS_STRICTATIME,
/* "loud" */ ~MS_SILENT,
+ /* "rbind" */ MS_BIND|MS_RECURSIVE,
// action flags
/* "union" */ MS_UNION,
/* "unbindable" */ MS_UNBINDABLE,
/* "rshared" */ MS_SHARED|MS_RECURSIVE,
/* "rslave" */ MS_SLAVE|MS_RECURSIVE,
- /* "rprivate" */ MS_SLAVE|MS_RECURSIVE,
+ /* "rprivate" */ MS_PRIVATE|MS_RECURSIVE,
/* "runbindable" */ MS_UNBINDABLE|MS_RECURSIVE,
)
/* "remount" */ MS_REMOUNT // action flag
};
-static const char mount_option_str[] =
+static const char mount_option_str[] ALIGN1 =
IF_FEATURE_MOUNT_LOOP(
"loop\0"
)
"swap\0"
IF_DESKTOP("user\0")
IF_DESKTOP("users\0")
+ IF_DESKTOP("nofail\0")
"_netdev\0"
+ IF_DESKTOP("comment=\0") /* systemd uses this in fstab */
)
IF_FEATURE_MOUNT_FLAGS(
// vfs flags
"nomand\0"
"relatime\0"
"norelatime\0"
+ "strictatime\0"
"loud\0"
+ "rbind\0"
// action flags
"union\0"
"bind\0"
"move\0"
- "shared\0"
- "slave\0"
- "private\0"
- "unbindable\0"
- "rshared\0"
- "rslave\0"
- "rprivate\0"
- "runbindable\0"
+ "make-shared\0"
+ "make-slave\0"
+ "make-private\0"
+ "make-unbindable\0"
+ "make-rshared\0"
+ "make-rslave\0"
+ "make-rprivate\0"
+ "make-runbindable\0"
)
// Always understood.
char getmntent_buf[1];
} FIX_ALIASING;
enum { GETMNTENT_BUFSIZE = COMMON_BUFSIZE - offsetof(struct globals, getmntent_buf) };
-#define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
#define nfs_mount_version (G.nfs_mount_version)
#if ENABLE_FEATURE_MOUNT_VERBOSE
#define verbose (G.verbose )
#endif
#define fslist (G.fslist )
#define getmntent_buf (G.getmntent_buf )
+#define INIT_G() do { setup_common_bufsiz(); } while (0)
+
+#if ENABLE_FEATURE_MTAB_SUPPORT
+/*
+ * update_mtab_entry_on_move() is used to update entry in case of mount --move.
+ * we are looking for existing entries mnt_dir which is equal to mnt_fsname of
+ * input mntent and replace it by new one.
+ */
+static void FAST_FUNC update_mtab_entry_on_move(const struct mntent *mp)
+{
+ struct mntent *entries, *m;
+ int i, count;
+ FILE *mountTable;
+
+ mountTable = setmntent(bb_path_mtab_file, "r");
+ if (!mountTable) {
+ bb_perror_msg(bb_path_mtab_file);
+ return;
+ }
+
+ entries = NULL;
+ count = 0;
+ while ((m = getmntent(mountTable)) != NULL) {
+ entries = xrealloc_vector(entries, 3, count);
+ entries[count].mnt_fsname = xstrdup(m->mnt_fsname);
+ entries[count].mnt_dir = xstrdup(m->mnt_dir);
+ entries[count].mnt_type = xstrdup(m->mnt_type);
+ entries[count].mnt_opts = xstrdup(m->mnt_opts);
+ entries[count].mnt_freq = m->mnt_freq;
+ entries[count].mnt_passno = m->mnt_passno;
+ count++;
+ }
+ endmntent(mountTable);
+
+ mountTable = setmntent(bb_path_mtab_file, "w");
+ if (mountTable) {
+ for (i = 0; i < count; i++) {
+ if (strcmp(entries[i].mnt_dir, mp->mnt_fsname) != 0)
+ addmntent(mountTable, &entries[i]);
+ else
+ addmntent(mountTable, mp);
+ }
+ endmntent(mountTable);
+ } else if (errno != EROFS)
+ bb_perror_msg(bb_path_mtab_file);
+ if (ENABLE_FEATURE_CLEAN_UP) {
+ for (i = 0; i < count; i++) {
+ free(entries[i].mnt_fsname);
+ free(entries[i].mnt_dir);
+ free(entries[i].mnt_type);
+ free(entries[i].mnt_opts);
+ }
+ free(entries);
+ }
+}
+#endif
#if ENABLE_FEATURE_MOUNT_VERBOSE
static int verbose_mount(const char *source, const char *target,
}
// Use the mount_options list to parse options into flags.
-// Also return list of unrecognized options if unrecognized != NULL
-static long parse_mount_options(char *options, char **unrecognized)
+// Also update list of unrecognized options if unrecognized != NULL
+static unsigned long parse_mount_options(char *options, char **unrecognized)
{
- long flags = MS_SILENT;
+ unsigned long flags = MS_SILENT;
// Loop through options
for (;;) {
// FIXME: use hasmntopt()
// Find this option in mount_options
for (i = 0; i < ARRAY_SIZE(mount_options); i++) {
- if (!strcasecmp(option_str, options)) {
- long fl = mount_options[i];
- if (fl < 0) flags &= fl;
- else flags |= fl;
- break;
+ unsigned opt_len = strlen(option_str);
+
+ if (strncasecmp(option_str, options, opt_len) == 0
+ && (options[opt_len] == '\0'
+ /* or is it "comment=" thingy in fstab? */
+ IF_FEATURE_MOUNT_FSTAB(IF_DESKTOP( || option_str[opt_len-1] == '=' ))
+ )
+ ) {
+ unsigned long fl = mount_options[i];
+ if (fl & BB_MS_INVERTED_VALUE)
+ flags &= fl;
+ else
+ flags |= fl;
+ goto found;
}
- option_str += strlen(option_str) + 1;
+ option_str += opt_len + 1;
}
- // If unrecognized not NULL, append unrecognized mount options
- if (unrecognized && i == ARRAY_SIZE(mount_options)) {
+ // We did not recognize this option.
+ // If "unrecognized" is not NULL, append option there.
+ // Note that we should not append *empty* option -
+ // in this case we want to pass NULL, not "", to "data"
+ // parameter of mount(2) syscall.
+ // This is crucial for filesystems that don't accept
+ // any arbitrary mount options, like cgroup fs:
+ // "mount -t cgroup none /mnt"
+ if (options[0] && unrecognized) {
// Add it to strflags, to pass on to kernel
- i = *unrecognized ? strlen(*unrecognized) : 0;
- *unrecognized = xrealloc(*unrecognized, i + strlen(options) + 2);
+ char *p = *unrecognized;
+ unsigned len = p ? strlen(p) : 0;
+ *unrecognized = p = xrealloc(p, len + strlen(options) + 2);
// Comma separated if it's not the first one
- if (i) (*unrecognized)[i++] = ',';
- strcpy((*unrecognized)+i, options);
+ if (len) p[len++] = ',';
+ strcpy(p + len, options);
}
-
+ found:
if (!comma)
break;
// Advance to next option
if (!f) continue;
while ((buf = xmalloc_fgetline(f)) != NULL) {
- if (strncmp(buf, "nodev", 5) == 0 && isspace(buf[5]))
- continue;
+ if (is_prefixed_with(buf, "nodev") && isspace(buf[5]))
+ goto next;
fs = skip_whitespace(buf);
if (*fs == '#' || *fs == '*' || !*fs)
- continue;
+ goto next;
llist_add_to_end(&list, xstrdup(fs));
+ next:
free(buf);
}
if (ENABLE_FEATURE_CLEAN_UP) fclose(f);
// Perform actual mount of specific filesystem at specific location.
// NB: mp->xxx fields may be trashed on exit
-static int mount_it_now(struct mntent *mp, long vfsflags, char *filteropts)
+static int mount_it_now(struct mntent *mp, unsigned long vfsflags, char *filteropts)
{
int rc = 0;
+ vfsflags &= ~(unsigned long)MOUNT_FAKEFLAGS;
+
if (FAKE_IT) {
if (verbose >= 2)
bb_error_msg("would do mount('%s','%s','%s',0x%08lx,'%s')",
int i;
if (!mountTable) {
- bb_error_msg("no %s", bb_path_mtab_file);
+ bb_perror_msg(bb_path_mtab_file);
goto ret;
}
// Add vfs string flags
-
for (i = 0; mount_options[i] != MS_REMOUNT; i++) {
if (mount_options[i] > 0 && (mount_options[i] & vfsflags))
append_mount_options(&(mp->mnt_opts), option_str);
}
// Remove trailing / (if any) from directory we mounted on
-
i = strlen(mp->mnt_dir) - 1;
- if (i > 0 && mp->mnt_dir[i] == '/') mp->mnt_dir[i] = '\0';
+ while (i > 0 && mp->mnt_dir[i] == '/')
+ mp->mnt_dir[i--] = '\0';
// Convert to canonical pathnames as needed
-
mp->mnt_dir = bb_simplify_path(mp->mnt_dir);
- fsname = 0;
+ fsname = NULL;
if (!mp->mnt_type || !*mp->mnt_type) { // bind mount
mp->mnt_fsname = fsname = bb_simplify_path(mp->mnt_fsname);
mp->mnt_type = (char*)"bind";
}
mp->mnt_freq = mp->mnt_passno = 0;
- // Write and close.
-
- addmntent(mountTable, mp);
+ // Write and close
+#if ENABLE_FEATURE_MTAB_SUPPORT
+ if (vfsflags & MS_MOVE)
+ update_mtab_entry_on_move(mp);
+ else
+#endif
+ addmntent(mountTable, mp);
endmntent(mountTable);
+
if (ENABLE_FEATURE_CLEAN_UP) {
free(mp->mnt_dir);
free(fsname);
*/
struct nfs2_fh {
- char data[32];
+ char data[32];
};
struct nfs3_fh {
- unsigned short size;
- unsigned char data[64];
+ unsigned short size;
+ unsigned char data[64];
};
struct nfs_mount_data {
- int version; /* 1 */
- int fd; /* 1 */
- struct nfs2_fh old_root; /* 1 */
- int flags; /* 1 */
- int rsize; /* 1 */
- int wsize; /* 1 */
- int timeo; /* 1 */
- int retrans; /* 1 */
- int acregmin; /* 1 */
- int acregmax; /* 1 */
- int acdirmin; /* 1 */
- int acdirmax; /* 1 */
- struct sockaddr_in addr; /* 1 */
- char hostname[256]; /* 1 */
- int namlen; /* 2 */
- unsigned int bsize; /* 3 */
- struct nfs3_fh root; /* 4 */
+ int version; /* 1 */
+ int fd; /* 1 */
+ struct nfs2_fh old_root; /* 1 */
+ int flags; /* 1 */
+ int rsize; /* 1 */
+ int wsize; /* 1 */
+ int timeo; /* 1 */
+ int retrans; /* 1 */
+ int acregmin; /* 1 */
+ int acregmax; /* 1 */
+ int acdirmin; /* 1 */
+ int acdirmax; /* 1 */
+ struct sockaddr_in addr; /* 1 */
+ char hostname[256]; /* 1 */
+ int namlen; /* 2 */
+ unsigned int bsize; /* 3 */
+ struct nfs3_fh root; /* 4 */
};
/* bits in the flags field */
NFS_MOUNT_VER3 = 0x0080, /* 3 */
NFS_MOUNT_KERBEROS = 0x0100, /* 3 */
NFS_MOUNT_NONLM = 0x0200, /* 3 */
+ NFS_MOUNT_NOACL = 0x0800, /* 4 */
NFS_MOUNT_NORDIRPLUS = 0x4000
};
# define EDQUOT ENOSPC
#endif
/* Convert each NFSERR_BLAH into EBLAH */
-static const uint8_t nfs_err_stat[] = {
+static const uint8_t nfs_err_stat[] ALIGN1 = {
1, 2, 5, 6, 13, 17,
19, 20, 21, 22, 27, 28,
30, 63, 66, 69, 70, 71
#else
typedef uint16_t nfs_err_type;
#endif
-static const nfs_err_type nfs_err_errnum[] = {
+static const nfs_err_type nfs_err_errnum[] ALIGN2 = {
EPERM , ENOENT , EIO , ENXIO , EACCES, EEXIST,
ENODEV, ENOTDIR , EISDIR , EINVAL, EFBIG , ENOSPC,
EROFS , ENAMETOOLONG, ENOTEMPTY, EDQUOT, ESTALE, EREMOTE
static bool_t xdr_fhstatus(XDR *xdrs, fhstatus *objp)
{
if (!xdr_u_int(xdrs, &objp->fhs_status))
- return FALSE;
+ return FALSE;
if (objp->fhs_status == 0)
return xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle);
return TRUE;
static bool_t xdr_fhandle3(XDR *xdrs, fhandle3 *objp)
{
return xdr_bytes(xdrs, (char **)&objp->fhandle3_val,
- (unsigned int *) &objp->fhandle3_len,
- FHSIZE3);
+ (unsigned int *) &objp->fhandle3_len,
+ FHSIZE3);
}
static bool_t xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)
if (!xdr_fhandle3(xdrs, &objp->fhandle))
return FALSE;
return xdr_array(xdrs, &(objp->auth_flavours.auth_flavours_val),
- &(objp->auth_flavours.auth_flavours_len),
- ~0,
- sizeof(int),
- (xdrproc_t) xdr_int);
+ &(objp->auth_flavours.auth_flavours_len),
+ ~0,
+ sizeof(int),
+ (xdrproc_t) xdr_int);
}
static bool_t xdr_mountstat3(XDR *xdrs, mountstat3 *objp)
}
/* NB: mp->xxx fields may be trashed on exit */
-static NOINLINE int nfsmount(struct mntent *mp, long vfsflags, char *filteropts)
+static NOINLINE int nfsmount(struct mntent *mp, unsigned long vfsflags, char *filteropts)
{
CLIENT *mclient;
char *hostname;
int noac;
int nordirplus;
int nolock;
+ int noacl;
find_kernel_nfs_mount_version();
pathname = s + 1;
*s = '\0';
/* Ignore all but first hostname in replicated mounts
- until they can be fully supported. (mack@sgi.com) */
+ * until they can be fully supported. (mack@sgi.com) */
s = strchr(hostname, ',');
if (s) {
*s = '\0';
nolock = 0;
noac = 0;
nordirplus = 0;
+ noacl = 0;
retry = 10000; /* 10000 minutes ~ 1 week */
- tcp = 0;
+ tcp = 1; /* nfs-utils uses tcp per default */
mountprog = MOUNTPROG;
mountvers = 0;
strcspn(opteq, " \t\n\r,"));
continue;
case 18: // "proto"
- if (!strncmp(opteq, "tcp", 3))
+ if (is_prefixed_with(opteq, "tcp"))
tcp = 1;
- else if (!strncmp(opteq, "udp", 3))
+ else if (is_prefixed_with(opteq, "udp"))
tcp = 0;
else
bb_error_msg("warning: unrecognized proto= option");
continue;
case 20: // "addr" - ignore
continue;
+ case -1: // unknown
+ if (vfsflags & MS_REMOUNT)
+ continue;
}
val = xatoi_positive(opteq);
"tcp\0"
"udp\0"
"lock\0"
- "rdirplus\0";
+ "rdirplus\0"
+ "acl\0";
int val = 1;
- if (!strncmp(opt, "no", 2)) {
+ if (is_prefixed_with(opt, "no")) {
val = 0;
opt += 2;
}
case 11: //rdirplus
nordirplus = !val;
break;
+ case 12: // acl
+ noacl = !val;
+ break;
default:
bb_error_msg("unknown nfs mount option: %s%s", val ? "" : "no", opt);
goto fail;
| (posix ? NFS_MOUNT_POSIX : 0)
| (nocto ? NFS_MOUNT_NOCTO : 0)
| (noac ? NFS_MOUNT_NOAC : 0)
- | (nordirplus ? NFS_MOUNT_NORDIRPLUS : 0);
+ | (nordirplus ? NFS_MOUNT_NORDIRPLUS : 0)
+ | (noacl ? NFS_MOUNT_NOACL : 0);
if (nfs_mount_version >= 2)
data.flags |= (tcp ? NFS_MOUNT_TCP : 0);
if (nfs_mount_version >= 3)
switch (pm_mnt.pm_prot) {
case IPPROTO_UDP:
mclient = clntudp_create(&mount_server_addr,
- pm_mnt.pm_prog,
- pm_mnt.pm_vers,
- retry_timeout,
- &msock);
+ pm_mnt.pm_prog,
+ pm_mnt.pm_vers,
+ retry_timeout,
+ &msock);
if (mclient)
break;
mount_server_addr.sin_port = htons(pm_mnt.pm_port);
msock = RPC_ANYSOCK;
case IPPROTO_TCP:
mclient = clnttcp_create(&mount_server_addr,
- pm_mnt.pm_prog,
- pm_mnt.pm_vers,
- &msock, 0, 0);
+ pm_mnt.pm_prog,
+ pm_mnt.pm_vers,
+ &msock, 0, 0);
break;
default:
mclient = NULL;
if (pm_mnt.pm_vers == 3)
clnt_stat = clnt_call(mclient, MOUNTPROC3_MNT,
- (xdrproc_t) xdr_dirpath,
- (caddr_t) &pathname,
- (xdrproc_t) xdr_mountres3,
- (caddr_t) &status,
- total_timeout);
+ (xdrproc_t) xdr_dirpath,
+ (caddr_t) &pathname,
+ (xdrproc_t) xdr_mountres3,
+ (caddr_t) &status,
+ total_timeout);
else
clnt_stat = clnt_call(mclient, MOUNTPROC_MNT,
- (xdrproc_t) xdr_dirpath,
- (caddr_t) &pathname,
- (xdrproc_t) xdr_fhstatus,
- (caddr_t) &status,
- total_timeout);
+ (xdrproc_t) xdr_dirpath,
+ (caddr_t) &pathname,
+ (xdrproc_t) xdr_fhstatus,
+ (caddr_t) &status,
+ total_timeout);
if (clnt_stat == RPC_SUCCESS)
goto prepare_kernel_data; /* we're done */
/* Perform actual mount */
do_mount:
- mp->mnt_type = (char*)"nfs";
retval = mount_it_now(mp, vfsflags, (char*)&data);
goto ret;
#else // !ENABLE_FEATURE_MOUNT_NFS
-// Never called. Call should be optimized out.
-int nfsmount(struct mntent *mp, long vfsflags, char *filteropts);
+/* Linux 2.6.23+ supports nfs mounts with options passed as a string.
+ * For older kernels, you must build busybox with ENABLE_FEATURE_MOUNT_NFS.
+ * (However, note that then you lose any chances that NFS over IPv6 would work).
+ */
+static int nfsmount(struct mntent *mp, unsigned long vfsflags, char *filteropts)
+{
+ len_and_sockaddr *lsa;
+ char *opts;
+ char *end;
+ char *dotted;
+ int ret;
+
+# if ENABLE_FEATURE_IPV6
+ end = strchr(mp->mnt_fsname, ']');
+ if (end && end[1] == ':')
+ end++;
+ else
+# endif
+ /* mount_main() guarantees that ':' is there */
+ end = strchr(mp->mnt_fsname, ':');
+
+ *end = '\0';
+ lsa = xhost2sockaddr(mp->mnt_fsname, /*port:*/ 0);
+ *end = ':';
+ dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
+ if (ENABLE_FEATURE_CLEAN_UP) free(lsa);
+ opts = xasprintf("%s%saddr=%s",
+ filteropts ? filteropts : "",
+ filteropts ? "," : "",
+ dotted
+ );
+ if (ENABLE_FEATURE_CLEAN_UP) free(dotted);
+ ret = mount_it_now(mp, vfsflags, opts);
+ if (ENABLE_FEATURE_CLEAN_UP) free(opts);
+
+ return ret;
+}
#endif // !ENABLE_FEATURE_MOUNT_NFS
// NB: mp->xxx fields may be trashed on exit
static int singlemount(struct mntent *mp, int ignore_busy)
{
+ int loopfd = -1;
int rc = -1;
- long vfsflags;
+ unsigned long vfsflags;
char *loopFile = NULL, *filteropts = NULL;
llist_t *fl = NULL;
struct stat st;
) {
int len;
char c;
+ char *hostname, *share;
len_and_sockaddr *lsa;
- char *hostname, *dotted, *ip;
+
+ // Parse mp->mnt_fsname of the form "//hostname/share[/dir1/dir2]"
hostname = mp->mnt_fsname + 2;
len = strcspn(hostname, "/\\");
- if (len == 0 || hostname[len] == '\0')
+ share = hostname + len + 1;
+ if (len == 0 // 3rd char is a [back]slash (IOW: empty hostname)
+ || share[-1] == '\0' // no [back]slash after hostname
+ || share[0] == '\0' // empty share name
+ ) {
goto report_error;
- c = hostname[len];
- hostname[len] = '\0';
+ }
+ c = share[-1];
+ share[-1] = '\0';
+ len = strcspn(share, "/\\");
+
+ // "unc=\\hostname\share" option is mandatory
+ // after CIFS option parsing was rewritten in Linux 3.4.
+ // Must use backslashes.
+ // If /dir1/dir2 is present, also add "prefixpath=dir1/dir2"
+ {
+ char *unc = xasprintf(
+ share[len] != '\0' /* "/dir1/dir2" exists? */
+ ? "unc=\\\\%s\\%.*s,prefixpath=%s"
+ : "unc=\\\\%s\\%.*s",
+ hostname,
+ len, share,
+ share + len + 1 /* "dir1/dir2" */
+ );
+ parse_mount_options(unc, &filteropts);
+ if (ENABLE_FEATURE_CLEAN_UP) free(unc);
+ }
+
lsa = host2sockaddr(hostname, 0);
- hostname[len] = c;
+ share[-1] = c;
if (!lsa)
goto report_error;
- // Insert "ip=..." option into options
- dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
- if (ENABLE_FEATURE_CLEAN_UP) free(lsa);
- ip = xasprintf("ip=%s", dotted);
- if (ENABLE_FEATURE_CLEAN_UP) free(dotted);
- parse_mount_options(ip, &filteropts);
- if (ENABLE_FEATURE_CLEAN_UP) free(ip);
+ // If there is no "ip=..." option yet
+ if (!is_prefixed_with(filteropts, ",ip="+1)
+ && !strstr(filteropts, ",ip=")
+ ) {
+ char *dotted, *ip;
+ // Insert "ip=..." option into options
+ dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
+ if (ENABLE_FEATURE_CLEAN_UP) free(lsa);
+ ip = xasprintf("ip=%s", dotted);
+ if (ENABLE_FEATURE_CLEAN_UP) free(dotted);
+// Note: IPv6 scoped addresses ("host%iface", see RFC 4007) should be
+// handled by libc in getnameinfo() (inside xmalloc_sockaddr2dotted_noport()).
+// Currently, glibc does not support that (has no NI_NUMERICSCOPE),
+// musl apparently does. This results in "ip=numericIPv6%iface_name"
+// (instead of _numeric_ iface_id) with glibc.
+// This probably should be fixed in glibc, not here.
+// The workaround is to manually specify correct "ip=ADDR%n" option.
+ parse_mount_options(ip, &filteropts);
+ if (ENABLE_FEATURE_CLEAN_UP) free(ip);
+ }
- // "-o mand" is required [why?]
- vfsflags |= MS_MANDLOCK;
mp->mnt_type = (char*)"cifs";
rc = mount_it_now(mp, vfsflags, filteropts);
}
// Might this be an NFS filesystem?
- if (ENABLE_FEATURE_MOUNT_NFS
- && (!mp->mnt_type || strcmp(mp->mnt_type, "nfs") == 0)
+ if ((!mp->mnt_type || is_prefixed_with(mp->mnt_type, "nfs"))
&& strchr(mp->mnt_fsname, ':') != NULL
) {
+ if (!mp->mnt_type)
+ mp->mnt_type = (char*)"nfs";
rc = nfsmount(mp, vfsflags, filteropts);
goto report_error;
}
if (ENABLE_FEATURE_MOUNT_LOOP && S_ISREG(st.st_mode)) {
loopFile = bb_simplify_path(mp->mnt_fsname);
mp->mnt_fsname = NULL; // will receive malloced loop dev name
- if (set_loop(&mp->mnt_fsname, loopFile, 0) < 0) {
+
+ // mount always creates AUTOCLEARed loopdevs, so that umounting
+ // drops them without any code in the userspace.
+ // This happens since circa linux-2.6.25:
+ // commit 96c5865559cee0f9cbc5173f3c949f6ce3525581
+ // Date: Wed Feb 6 01:36:27 2008 -0800
+ // Subject: Allow auto-destruction of loop devices
+ loopfd = set_loop(&mp->mnt_fsname,
+ loopFile,
+ 0,
+ ((vfsflags & MS_RDONLY) ? BB_LO_FLAGS_READ_ONLY : 0)
+ | BB_LO_FLAGS_AUTOCLEAR
+ );
+ if (loopfd < 0) {
if (errno == EPERM || errno == EACCES)
bb_error_msg(bb_msg_perm_denied_are_you_root);
else
// 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);
+ char *next;
+ for (;;) {
+ next = mp->mnt_type ? strchr(mp->mnt_type, ',') : NULL;
+ if (next)
+ *next = '\0';
+ rc = mount_it_now(mp, vfsflags, filteropts);
+ if (rc == 0 || !next)
+ break;
+ mp->mnt_type = next + 1;
+ }
} else {
// Loop through filesystem types until mount succeeds
// or we run out
for (fl = fslist; fl; fl = fl->link) {
mp->mnt_type = fl->data;
rc = mount_it_now(mp, vfsflags, filteropts);
- if (!rc)
+ if (rc == 0)
break;
}
}
// If mount failed, clean up loop file (if any).
+ // (Newer kernels which support LO_FLAGS_AUTOCLEAR should not need this,
+ // merely "close(loopfd)" should do it?)
if (ENABLE_FEATURE_MOUNT_LOOP && rc && loopFile) {
del_loop(mp->mnt_fsname);
if (ENABLE_FEATURE_CLEAN_UP) {
free(loopFile);
- free(mp->mnt_fsname);
+ /* No, "rc != 0" needs it: free(mp->mnt_fsname); */
}
}
if (ENABLE_FEATURE_CLEAN_UP)
free(filteropts);
+ if (loopfd >= 0)
+ close(loopfd);
+
if (errno == EBUSY && ignore_busy)
return 0;
+ if (errno == ENOENT && (vfsflags & MOUNT_NOFAIL))
+ return 0;
if (rc != 0)
bb_perror_msg("mounting %s on %s failed", mp->mnt_fsname, mp->mnt_dir);
return rc;
char *O_optmatch = NULL;
char *storage_path;
llist_t *lst_o = NULL;
- const char *fstabname;
+ const char *fstabname = "/etc/fstab";
FILE *fstab;
int i, j;
int rc = EXIT_SUCCESS;
+ unsigned long cmdopt_flags;
unsigned opt;
struct mntent mtpair[2], *mtcur = mtpair;
IF_NOT_DESKTOP(const int nonroot = 0;)
IF_DESKTOP(int nonroot = ) sanitize_env_if_suid();
+ INIT_G();
+
// Parse long options, like --bind and --move. Note that -o option
// and --option are synonymous. Yes, this means --remount,rw works.
for (i = j = 1; argv[i]; i++) {
// Parse remaining options
// Max 2 params; -o is a list, -v is a counter
- opt_complementary = "?2o::" IF_FEATURE_MOUNT_VERBOSE("vv");
+ opt_complementary = "?2" IF_FEATURE_MOUNT_VERBOSE("vv");
opt = getopt32(argv, OPTION_STR, &lst_o, &fstype, &O_optmatch
+ IF_FEATURE_MOUNT_OTHERTAB(, &fstabname)
IF_FEATURE_MOUNT_VERBOSE(, &verbose));
while (lst_o) append_mount_options(&cmdopts, llist_pop(&lst_o)); // -o
if (opt & OPT_r) append_mount_options(&cmdopts, "ro"); // -r
// Past this point, we are handling either "mount -a [opts]"
// or "mount [opts] single_param"
- i = parse_mount_options(cmdopts, NULL); // FIXME: should be "long", not "int"
- if (nonroot && (i & ~MS_SILENT)) // Non-root users cannot specify flags
+ cmdopt_flags = parse_mount_options(cmdopts, NULL);
+ if (nonroot && (cmdopt_flags & ~MS_SILENT)) // Non-root users cannot specify flags
bb_error_msg_and_die(bb_msg_you_must_be_root);
// If we have a shared subtree flag, don't worry about fstab or mtab.
if (ENABLE_FEATURE_MOUNT_FLAGS
- && (i & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
+ && (cmdopt_flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
) {
// verbose_mount(source, target, type, flags, data)
- rc = verbose_mount("", argv[0], "", i, "");
+ rc = verbose_mount("", argv[0], "", cmdopt_flags, "");
if (rc)
bb_simple_perror_msg_and_die(argv[0]);
return rc;
}
+ // A malicious user could overmount /usr without this.
+ if (ENABLE_FEATURE_MOUNT_OTHERTAB && nonroot)
+ fstabname = "/etc/fstab";
// Open either fstab or mtab
- fstabname = "/etc/fstab";
- if (i & MS_REMOUNT) {
+ if (cmdopt_flags & MS_REMOUNT) {
// WARNING. I am not sure this matches util-linux's
// behavior. It's possible util-linux does not
// take -o opts from mtab (takes only mount source).
bb_error_msg_and_die(bb_msg_you_must_be_root);
// Does type match? (NULL matches always)
- if (!match_fstype(mtcur, fstype))
+ if (!fstype_matches(mtcur->mnt_type, fstype))
continue;
// Skip noauto and swap anyway
// End of fstab/mtab is reached.
// Were we looking for something specific?
if (argv[0]) { // yes
- long l;
+ unsigned long l;
// If we didn't find anything, complain
if (!mtcur->mnt_fsname)
projects / oweals / busybox.git / blobdiff