* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
-/* Design notes: There is no spec for mount. Remind me to write one.
-
- 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.
-*/
+// Design notes: There is no spec for mount. Remind me to write one.
+//
+// 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.
+//
#include <mntent.h>
#include <syslog.h>
#include "volume_id.h"
#endif
-/* Needed for nfs support only */
+// Needed for nfs support only
#include <sys/utsname.h>
#undef TRUE
#undef FALSE
#ifndef MS_SILENT
#define MS_SILENT (1 << 15)
#endif
-/* Grab more as needed from util-linux's mount/mount_constants.h */
+// Grab more as needed from util-linux's mount/mount_constants.h
#ifndef MS_DIRSYNC
-#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
+#define MS_DIRSYNC 128 // Directory modifications are synchronous
#endif
#if defined(__dietlibc__)
-/* 16.12.2006, Sampo Kellomaki (sampo@iki.fi)
- * dietlibc-0.30 does not have implementation of getmntent_r() */
+// 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)
{
};
-#define OPTION_STR "o:t:rwanfvsi"
+#define OPTION_STR "o:t:rwanfvsiO:"
enum {
OPT_o = (1 << 0),
OPT_t = (1 << 1),
OPT_v = (1 << 7),
OPT_s = (1 << 8),
OPT_i = (1 << 9),
+ OPT_O = (1 << 10),
};
#if ENABLE_FEATURE_MTAB_SUPPORT
-#define useMtab (!(option_mask32 & OPT_n))
+#define USE_MTAB (!(option_mask32 & OPT_n))
#else
-#define useMtab 0
+#define USE_MTAB 0
#endif
#if ENABLE_FEATURE_MOUNT_FAKE
-#define fakeIt (option_mask32 & OPT_f)
+#define FAKE_IT (option_mask32 & OPT_f)
#else
-#define fakeIt 0
+#define FAKE_IT 0
+#endif
+
+#if ENABLE_FEATURE_MOUNT_HELPERS
+#define HELPERS_ALLOWED (!(option_mask32 & OPT_i))
+#else
+#define HELPERS_ALLOWED 0
#endif
// This may be useful e.g. for /dev/fd if a login script makes
// the console user owner of this device.
-/* Standard mount options (from -o options or --options), with corresponding
- * flags */
-
+// Standard mount options (from -o options or --options),
+// with corresponding flags
static const int32_t mount_options[] = {
// MS_FLAGS set a bit. ~MS_FLAGS disable that bit. 0 flags are NOPs.
- USE_FEATURE_MOUNT_LOOP(
+ IF_FEATURE_MOUNT_LOOP(
/* "loop" */ 0,
)
- USE_FEATURE_MOUNT_FSTAB(
+ IF_FEATURE_MOUNT_FSTAB(
/* "defaults" */ 0,
/* "quiet" 0 - do not filter out, vfat wants to see it */
/* "noauto" */ MOUNT_NOAUTO,
/* "sw" */ MOUNT_SWAP,
/* "swap" */ MOUNT_SWAP,
- USE_DESKTOP(/* "user" */ MOUNT_USERS,)
- USE_DESKTOP(/* "users" */ MOUNT_USERS,)
+ IF_DESKTOP(/* "user" */ MOUNT_USERS,)
+ IF_DESKTOP(/* "users" */ MOUNT_USERS,)
/* "_netdev" */ 0,
)
- USE_FEATURE_MOUNT_FLAGS(
+ IF_FEATURE_MOUNT_FLAGS(
// vfs flags
/* "nosuid" */ MS_NOSUID,
/* "suid" */ ~MS_NOSUID,
/* "nodiratime" */ MS_NODIRATIME,
/* "mand" */ MS_MANDLOCK,
/* "nomand" */ ~MS_MANDLOCK,
+ /* "relatime" */ MS_RELATIME,
+ /* "norelatime" */ ~MS_RELATIME,
/* "loud" */ ~MS_SILENT,
// action flags
};
static const char mount_option_str[] =
- USE_FEATURE_MOUNT_LOOP(
- "loop" "\0"
+ IF_FEATURE_MOUNT_LOOP(
+ "loop\0"
)
- USE_FEATURE_MOUNT_FSTAB(
- "defaults" "\0"
- /* "quiet" "\0" - do not filter out, vfat wants to see it */
- "noauto" "\0"
- "sw" "\0"
- "swap" "\0"
- USE_DESKTOP("user" "\0")
- USE_DESKTOP("users" "\0")
- "_netdev" "\0"
+ IF_FEATURE_MOUNT_FSTAB(
+ "defaults\0"
+ // "quiet\0" - do not filter out, vfat wants to see it
+ "noauto\0"
+ "sw\0"
+ "swap\0"
+ IF_DESKTOP("user\0")
+ IF_DESKTOP("users\0")
+ "_netdev\0"
)
- USE_FEATURE_MOUNT_FLAGS(
+ IF_FEATURE_MOUNT_FLAGS(
// vfs flags
- "nosuid" "\0"
- "suid" "\0"
- "dev" "\0"
- "nodev" "\0"
- "exec" "\0"
- "noexec" "\0"
- "sync" "\0"
- "dirsync" "\0"
- "async" "\0"
- "atime" "\0"
- "noatime" "\0"
- "diratime" "\0"
- "nodiratime" "\0"
- "mand" "\0"
- "nomand" "\0"
- "loud" "\0"
+ "nosuid\0"
+ "suid\0"
+ "dev\0"
+ "nodev\0"
+ "exec\0"
+ "noexec\0"
+ "sync\0"
+ "dirsync\0"
+ "async\0"
+ "atime\0"
+ "noatime\0"
+ "diratime\0"
+ "nodiratime\0"
+ "mand\0"
+ "nomand\0"
+ "relatime\0"
+ "norelatime\0"
+ "loud\0"
// action flags
- "bind" "\0"
- "move" "\0"
- "shared" "\0"
- "slave" "\0"
- "private" "\0"
- "unbindable" "\0"
- "rshared" "\0"
- "rslave" "\0"
- "rprivate" "\0"
- "runbindable" "\0"
+ "bind\0"
+ "move\0"
+ "shared\0"
+ "slave\0"
+ "private\0"
+ "unbindable\0"
+ "rshared\0"
+ "rslave\0"
+ "rprivate\0"
+ "runbindable\0"
)
// Always understood.
- "ro" "\0" // vfs flag
- "rw" "\0" // vfs flag
- "remount" "\0" // action flag
+ "ro\0" // vfs flag
+ "rw\0" // vfs flag
+ "remount\0" // action flag
;
#define verbose_mount(...) mount(__VA_ARGS__)
#endif
-static int resolve_mount_spec(char **fsname)
+#if ENABLE_FEATURE_MOUNT_LABEL
+static void resolve_mount_spec(char **fsname)
{
char *tmp = NULL;
-#if ENABLE_FEATURE_MOUNT_LABEL
if (!strncmp(*fsname, "UUID=", 5))
tmp = get_devname_from_uuid(*fsname + 5);
else if (!strncmp(*fsname, "LABEL=", 6))
tmp = get_devname_from_label(*fsname + 6);
-#endif
- if (tmp) {
+ if (tmp)
*fsname = tmp;
- return 1;
- }
- return 0;
}
+#else
+#define resolve_mount_spec(fsname) ((void)0)
+#endif
-/* Append mount options to string */
+// Append mount options to string
static void append_mount_options(char **oldopts, const char *newopts)
{
if (*oldopts && **oldopts) {
- /* do not insert options which are already there */
+ // Do not insert options which are already there
while (newopts[0]) {
char *p;
int len = strlen(newopts);
}
}
-/* Use the mount_options list to parse options into flags.
- * Also return list of unrecognized options if unrecognized!=NULL */
+// 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)
{
long flags = MS_SILENT;
if (comma) *comma = '\0';
-/* FIXME: use hasmntopt() */
+// FIXME: use hasmntopt()
// Find this option in mount_options
for (i = 0; i < ARRAY_SIZE(mount_options); i++) {
if (!strcasecmp(option_str, options)) {
}
option_str += strlen(option_str) + 1;
}
- // If unrecognized not NULL, append unrecognized mount options */
+ // If unrecognized not NULL, append unrecognized mount options
if (unrecognized && i == ARRAY_SIZE(mount_options)) {
// Add it to strflags, to pass on to kernel
i = *unrecognized ? strlen(*unrecognized) : 0;
- *unrecognized = xrealloc(*unrecognized, i+strlen(options)+2);
+ *unrecognized = xrealloc(*unrecognized, i + strlen(options) + 2);
// Comma separated if it's not the first one
if (i) (*unrecognized)[i++] = ',';
}
// Return a list of all block device backed filesystems
-
static llist_t *get_block_backed_filesystems(void)
{
static const char filesystems[2][sizeof("/proc/filesystems")] = {
"/proc/filesystems",
};
char *fs, *buf;
- llist_t *list = 0;
+ llist_t *list = NULL;
int i;
FILE *f;
for (i = 0; i < 2; i++) {
- f = fopen(filesystems[i], "r");
+ f = fopen_for_read(filesystems[i]);
if (!f) continue;
while ((buf = xmalloc_fgetline(f)) != NULL) {
- if (!strncmp(buf, "nodev", 5) && isspace(buf[5]))
+ if (strncmp(buf, "nodev", 5) == 0 && isspace(buf[5]))
continue;
fs = skip_whitespace(buf);
- if (*fs=='#' || *fs=='*' || !*fs) continue;
+ if (*fs == '#' || *fs == '*' || !*fs)
+ continue;
llist_add_to_end(&list, xstrdup(fs));
free(buf);
{
int rc = 0;
- if (fakeIt) {
+ if (FAKE_IT) {
if (verbose >= 2)
bb_error_msg("would do mount('%s','%s','%s',0x%08lx,'%s')",
mp->mnt_fsname, mp->mnt_dir, mp->mnt_type,
// If mount failed, try
// helper program mount.<mnt_type>
- if (ENABLE_FEATURE_MOUNT_HELPERS && rc) {
- char *args[6];
+ if (HELPERS_ALLOWED && rc) {
+ char *args[8];
int errno_save = errno;
args[0] = xasprintf("mount.%s", mp->mnt_type);
rc = 1;
+ if (FAKE_IT)
+ args[rc++] = (char *)"-f";
+ if (ENABLE_FEATURE_MTAB_SUPPORT && !USE_MTAB)
+ args[rc++] = (char *)"-n";
+ args[rc++] = mp->mnt_fsname;
+ args[rc++] = mp->mnt_dir;
if (filteropts) {
args[rc++] = (char *)"-o";
args[rc++] = filteropts;
}
- args[rc++] = mp->mnt_fsname;
- args[rc++] = mp->mnt_dir;
args[rc] = NULL;
rc = wait4pid(spawn(args));
free(args[0]);
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 the mount was successful, and we're maintaining an old-style
+ // mtab file by hand, add the new entry to it now.
mtab:
- if (useMtab && !rc && !(vfsflags & MS_REMOUNT)) {
+ if (USE_MTAB && !rc && !(vfsflags & MS_REMOUNT)) {
char *fsname;
FILE *mountTable = setmntent(bb_path_mtab_file, "a+");
const char *option_str = mount_option_str;
mp->mnt_dir = bb_simplify_path(mp->mnt_dir);
fsname = 0;
- if (!mp->mnt_type || !*mp->mnt_type) { /* bind mount */
+ if (!mp->mnt_type || !*mp->mnt_type) { // bind mount
mp->mnt_fsname = fsname = bb_simplify_path(mp->mnt_fsname);
mp->mnt_type = (char*)"bind";
}
NFS_MOUNT_TCP = 0x0040, /* 2 */
NFS_MOUNT_VER3 = 0x0080, /* 3 */
NFS_MOUNT_KERBEROS = 0x0100, /* 3 */
- NFS_MOUNT_NONLM = 0x0200 /* 3 */
+ NFS_MOUNT_NONLM = 0x0200, /* 3 */
+ NFS_MOUNT_NORDIRPLUS = 0x4000
};
#define EDQUOT ENOSPC
#endif
-// Convert each NFSERR_BLAH into EBLAH
-
+/* Convert each NFSERR_BLAH into EBLAH */
static const struct {
short stat;
short errnum;
{28,ENOSPC}, {30,EROFS}, {63,ENAMETOOLONG}, {66,ENOTEMPTY}, {69,EDQUOT},
{70,ESTALE}, {71,EREMOTE}, {-1,EIO}
};
-
static char *nfs_strerror(int status)
{
int i;
if (!xdr_fhandle3(xdrs, &objp->fhandle))
return FALSE;
if (!xdr_array(xdrs, &(objp->auth_flavours.auth_flavours_val), &(objp->auth_flavours.auth_flavours_len), ~0,
- sizeof (int), (xdrproc_t) xdr_int))
+ sizeof(int), (xdrproc_t) xdr_int))
return FALSE;
return TRUE;
}
#if BB_MMU
static int daemonize(void)
{
- int fd;
int pid = fork();
if (pid < 0) /* error */
return -errno;
if (pid > 0) /* parent */
return 0;
/* child */
- fd = xopen(bb_dev_null, O_RDWR);
- dup2(fd, 0);
- dup2(fd, 1);
- dup2(fd, 2);
- while (fd > 2) close(fd--);
+ close(0);
+ xopen(bb_dev_null, O_RDWR);
+ xdup2(0, 1);
+ xdup2(0, 2);
setsid();
openlog(applet_name, LOG_PID, LOG_DAEMON);
logmode = LOGMODE_SYSLOG;
static inline int daemonize(void) { return -ENOSYS; }
#endif
-// TODO
+/* TODO */
static inline int we_saw_this_host_before(const char *hostname UNUSED_PARAM)
{
return 0;
bb_error_msg("%.*s", len, msg);
}
-// NB: mp->xxx fields may be trashed on exit
-static int nfsmount(struct mntent *mp, long vfsflags, char *filteropts)
+/* NB: mp->xxx fields may be trashed on exit */
+static NOINLINE int nfsmount(struct mntent *mp, long vfsflags, char *filteropts)
{
CLIENT *mclient;
char *hostname;
char *pathname;
char *mounthost;
+ /* prior to 2.6.23, kernel took NFS options in a form of this struct
+ * only. 2.6.23+ looks at data->version, and if it's not 1..6,
+ * then data pointer is interpreted as a string. */
struct nfs_mount_data data;
char *opt;
struct hostent *hp;
int mountport;
int proto;
#if BB_MMU
- int bg = 0;
+ smallint bg = 0;
#else
enum { bg = 0 };
#endif
- int soft;
- int intr;
- int posix;
- int nocto;
- int noac;
- int nolock;
int retry;
- int tcp;
int mountprog;
int mountvers;
int nfsprog;
int nfsvers;
int retval;
+ /* these all are one-bit really. gcc 4.3.1 likes this combination: */
+ smallint tcp;
+ smallint soft;
+ int intr;
+ int posix;
+ int nocto;
+ int noac;
+ int nordirplus;
+ int nolock;
find_kernel_nfs_mount_version();
* let the kernel decide.
* timeo is filled in after we know whether it'll be TCP or UDP. */
memset(&data, 0, sizeof(data));
- data.retrans = 3;
- data.acregmin = 3;
- data.acregmax = 60;
- data.acdirmin = 30;
- data.acdirmax = 60;
- data.namlen = NAME_MAX;
+ data.retrans = 3;
+ data.acregmin = 3;
+ data.acregmax = 60;
+ data.acdirmin = 30;
+ data.acdirmax = 60;
+ data.namlen = NAME_MAX;
soft = 0;
intr = 0;
nocto = 0;
nolock = 0;
noac = 0;
+ nordirplus = 0;
retry = 10000; /* 10000 minutes ~ 1 week */
tcp = 0;
"ac\0"
"tcp\0"
"udp\0"
- "lock\0";
+ "lock\0"
+ "rdirplus\0";
int val = 1;
if (!strncmp(opt, "no", 2)) {
val = 0;
else
bb_error_msg("warning: option nolock is not supported");
break;
+ case 11: //rdirplus
+ nordirplus = !val;
+ break;
default:
bb_error_msg("unknown nfs mount option: %s%s", val ? "" : "no", opt);
goto fail;
| (intr ? NFS_MOUNT_INTR : 0)
| (posix ? NFS_MOUNT_POSIX : 0)
| (nocto ? NFS_MOUNT_NOCTO : 0)
- | (noac ? NFS_MOUNT_NOAC : 0);
+ | (noac ? NFS_MOUNT_NOAC : 0)
+ | (nordirplus ? NFS_MOUNT_NORDIRPLUS : 0);
if (nfs_mount_version >= 2)
data.flags |= (tcp ? NFS_MOUNT_TCP : 0);
if (nfs_mount_version >= 3)
}
}
- /* create mount daemon client */
+ /* Create mount daemon client */
/* See if the nfs host = mount host. */
if (mounthost) {
if (mounthost[0] >= '0' && mounthost[0] <= '9') {
retry_timeout.tv_usec = 0;
total_timeout.tv_sec = 20;
total_timeout.tv_usec = 0;
+/* FIXME: use monotonic()? */
timeout = time(NULL) + 60 * retry;
prevt = 0;
t = 30;
retry:
- /* be careful not to use too many CPU cycles */
+ /* Be careful not to use too many CPU cycles */
if (t - prevt < 30)
sleep(30);
error_msg_rpc(clnt_spcreateerror(" "));
} else {
enum clnt_stat clnt_stat;
- /* try to mount hostname:pathname */
+
+ /* Try to mount hostname:pathname */
mclient->cl_auth = authunix_create_default();
- /* make pointers in xdr_mountres3 NULL so
+ /* Make pointers in xdr_mountres3 NULL so
* that xdr_array allocates memory for us
*/
memset(&status, 0, sizeof(status));
}
/* Timeout. We are going to retry... maybe */
-
if (!bg)
goto fail;
if (!daemonized) {
data.flags |= NFS_MOUNT_VER3;
}
- /* create nfs socket for kernel */
-
+ /* Create nfs socket for kernel */
if (tcp) {
if (nfs_mount_version < 3) {
bb_error_msg("NFS over TCP is not supported");
}
server_addr.sin_port = htons(port);
- /* prepare data structure for kernel */
-
+ /* Prepare data structure for kernel */
data.fd = fsock;
memcpy((char *) &data.addr, (char *) &server_addr, sizeof(data.addr));
strncpy(data.hostname, hostname, sizeof(data.hostname));
- /* clean up */
-
+ /* Clean up */
auth_destroy(mclient->cl_auth);
clnt_destroy(mclient);
close(msock);
if (!daemonized) {
daemonized = daemonize();
if (daemonized <= 0) { /* parent or error */
- // FIXME: parent doesn't close fsock - ??!
+/* FIXME: parent doesn't close fsock - ??! */
retval = -daemonized;
goto ret;
}
}
}
- do_mount: /* perform actual mount */
-
+ /* Perform actual mount */
+ do_mount:
mp->mnt_type = (char*)"nfs";
retval = mount_it_now(mp, vfsflags, (char*)&data);
goto ret;
- fail: /* abort */
-
+ /* Abort */
+ fail:
if (msock >= 0) {
if (mclient) {
auth_destroy(mclient->cl_auth);
return retval;
}
-#else /* !ENABLE_FEATURE_MOUNT_NFS */
+#else // !ENABLE_FEATURE_MOUNT_NFS
-/* Never called. Call should be optimized out. */
+// Never called. Call should be optimized out.
int nfsmount(struct mntent *mp, long vfsflags, char *filteropts);
-#endif /* !ENABLE_FEATURE_MOUNT_NFS */
+#endif // !ENABLE_FEATURE_MOUNT_NFS
// Mount one directory. Handles CIFS, NFS, loopback, autobind, and filesystem
// type detection. Returns 0 for success, nonzero for failure.
{
int rc = -1;
long vfsflags;
- char *loopFile = 0, *filteropts = 0;
- llist_t *fl = 0;
+ char *loopFile = NULL, *filteropts = NULL;
+ llist_t *fl = NULL;
struct stat st;
vfsflags = parse_mount_options(mp->mnt_opts, &filteropts);
- // Treat fstype "auto" as unspecified.
-
+ // Treat fstype "auto" as unspecified
if (mp->mnt_type && strcmp(mp->mnt_type, "auto") == 0)
mp->mnt_type = NULL;
// Might this be a virtual filesystem?
-
- if (ENABLE_FEATURE_MOUNT_HELPERS
- && (strchr(mp->mnt_fsname, '#'))
- ) {
- char *s, *p, *args[35];
- int n = 0;
-// FIXME: does it allow execution of arbitrary commands?!
-// What args[0] can end up with?
- for (s = p = mp->mnt_fsname; *s && n < 35-3; ++s) {
- if (s[0] == '#' && s[1] != '#') {
- *s = '\0';
- args[n++] = p;
- p = s + 1;
+ if (ENABLE_FEATURE_MOUNT_HELPERS && strchr(mp->mnt_fsname, '#')) {
+ char *args[35];
+ char *s;
+ int n;
+ // fsname: "cmd#arg1#arg2..."
+ // WARNING: allows execution of arbitrary commands!
+ // Try "mount 'sh#-c#sh' bogus_dir".
+ // It is safe ONLY because non-root
+ // cannot use two-argument mount command
+ // and using one-argument "mount 'sh#-c#sh'" doesn't work:
+ // "mount: can't find sh#-c#sh in /etc/fstab"
+ // (if /etc/fstab has it, it's ok: root sets up /etc/fstab).
+
+ s = mp->mnt_fsname;
+ n = 0;
+ args[n++] = s;
+ while (*s && n < 35 - 2) {
+ if (*s++ == '#' && *s != '#') {
+ s[-1] = '\0';
+ args[n++] = s;
}
}
- args[n++] = p;
args[n++] = mp->mnt_dir;
args[n] = NULL;
rc = wait4pid(xspawn(args));
}
// Might this be an CIFS filesystem?
-
if (ENABLE_FEATURE_MOUNT_CIFS
&& (!mp->mnt_type || strcmp(mp->mnt_type, "cifs") == 0)
&& (mp->mnt_fsname[0] == '/' || mp->mnt_fsname[0] == '\\')
&& mp->mnt_fsname[0] == mp->mnt_fsname[1]
) {
+#if 0 /* reported to break things */
len_and_sockaddr *lsa;
char *ip, *dotted;
char *s;
- rc = 1;
// Replace '/' with '\' and verify that unc points to "//server/share".
-
for (s = mp->mnt_fsname; *s; ++s)
if (*s == '/') *s = '\\';
- // get server IP
-
+ // Get server IP
s = strrchr(mp->mnt_fsname, '\\');
- if (s <= mp->mnt_fsname+1) goto report_error;
+ if (s <= mp->mnt_fsname+1)
+ goto report_error;
*s = '\0';
lsa = host2sockaddr(mp->mnt_fsname+2, 0);
*s = '\\';
- if (!lsa) goto report_error;
-
- // insert ip=... option into string flags.
+ if (!lsa)
+ goto report_error;
+ // Insert ip=... option into string flags.
dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
ip = xasprintf("ip=%s", dotted);
parse_mount_options(ip, &filteropts);
- // compose new unc '\\server-ip\share'
+ // Compose new unc '\\server-ip\share'
// (s => slash after hostname)
-
mp->mnt_fsname = xasprintf("\\\\%s%s", dotted, s);
-
- // lock is required
+#endif
+ // Lock is required [why?]
vfsflags |= MS_MANDLOCK;
-
mp->mnt_type = (char*)"cifs";
rc = mount_it_now(mp, vfsflags, filteropts);
+#if 0
if (ENABLE_FEATURE_CLEAN_UP) {
free(mp->mnt_fsname);
free(ip);
free(dotted);
free(lsa);
}
+#endif
goto report_error;
}
// Might this be an NFS filesystem?
-
if (ENABLE_FEATURE_MOUNT_NFS
&& (!mp->mnt_type || !strcmp(mp->mnt_type, "nfs"))
&& strchr(mp->mnt_fsname, ':') != NULL
// a synthetic filesystem like proc or sysfs.)
// (We use stat, not lstat, in order to allow
// mount symlink_to_file_or_blkdev dir)
-
if (!stat(mp->mnt_fsname, &st)
&& !(vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE))
) {
// Do we need to allocate a loopback device for it?
-
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 */
+ mp->mnt_fsname = NULL; // will receive malloced loop dev name
if (set_loop(&(mp->mnt_fsname), loopFile, 0) < 0) {
if (errno == EPERM || errno == EACCES)
bb_error_msg(bb_msg_perm_denied_are_you_root);
}
// 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 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);
else {
// Loop through filesystem types until mount succeeds
// or we run out
- /* Initialize list of block backed filesystems. This has to be
- * done here so that during "mount -a", mounts after /proc shows up
- * can autodetect. */
-
+ // 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)
for (fl = fslist; fl; fl = fl->link) {
mp->mnt_type = fl->data;
rc = mount_it_now(mp, vfsflags, filteropts);
- if (!rc) break;
+ if (!rc)
+ break;
}
}
// 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) {
return rc;
}
+/* -O support
+ * Unlike -t, -O should interpret "no" prefix differently:
+ * -t noa,b,c = -t no(a,b,c) = mount all except fs'es with types a,b, and c
+ * -O noa,b,c = -O noa,b,c = mount all with without option a,
+ * or with option b or c.
+ * But for now we do not support -O a,b,c at all (only -O a).
+ *
+ * Another difference from -t support (match_fstype) is that
+ * we need to examine the _list_ of options in fsopt, not just a string.
+ */
+static int match_opt(const char *fs_opt, const char *O_opt)
+{
+ int match = 1;
+ int len;
+
+ if (!O_opt)
+ return match;
+
+ if (O_opt[0] == 'n' && O_opt[1] == 'o') {
+ match--;
+ O_opt += 2;
+ }
+
+ len = strlen(O_opt);
+ while (1) {
+ if (strncmp(fs_opt, O_opt, len) == 0
+ && (fs_opt[len] == '\0' || fs_opt[len] == ',')
+ ) {
+ return match;
+ }
+ fs_opt = strchr(fs_opt, ',');
+ if (!fs_opt)
+ break;
+ fs_opt++;
+ }
+
+ return !match;
+}
+
// Parse options, if necessary parse fstab/mtab, and call singlemount for
// each directory to be mounted.
-
static const char must_be_root[] ALIGN1 = "you must be root";
int mount_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int mount_main(int argc UNUSED_PARAM, char **argv)
{
- char *cmdopts = xstrdup("");
+ char *cmdopts = xzalloc(1);
char *fstype = NULL;
+ char *O_optmatch = NULL;
char *storage_path;
- char *opt_o;
+ llist_t *lst_o = NULL;
const char *fstabname;
FILE *fstab;
int i, j, rc = 0;
unsigned opt;
struct mntent mtpair[2], *mtcur = mtpair;
- SKIP_DESKTOP(const int nonroot = 0;)
+ IF_NOT_DESKTOP(const int nonroot = 0;)
- USE_DESKTOP(int nonroot = ) sanitize_env_if_suid();
+ IF_DESKTOP(int nonroot = ) sanitize_env_if_suid();
// Parse long options, like --bind and --move. Note that -o option
// and --option are synonymous. Yes, this means --remount,rw works.
argv[j] = NULL;
// Parse remaining options
- // Max 2 params; -v is a counter
- opt_complementary = "?2" USE_FEATURE_MOUNT_VERBOSE(":vv");
- opt = getopt32(argv, OPTION_STR, &opt_o, &fstype
- USE_FEATURE_MOUNT_VERBOSE(, &verbose));
- if (opt & OPT_o) append_mount_options(&cmdopts, opt_o); // -o
+ // Max 2 params; -o is a list, -v is a counter
+ opt_complementary = "?2o::" IF_FEATURE_MOUNT_VERBOSE("vv");
+ opt = getopt32(argv, OPTION_STR, &lst_o, &fstype, &O_optmatch
+ 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
if (opt & OPT_w) append_mount_options(&cmdopts, "rw"); // -w
argv += optind;
mtpair->mnt_dir = argv[1];
mtpair->mnt_type = fstype;
mtpair->mnt_opts = cmdopts;
- if (ENABLE_FEATURE_MOUNT_LABEL) {
- resolve_mount_spec(&mtpair->mnt_fsname);
- }
+ resolve_mount_spec(&mtpair->mnt_fsname);
rc = singlemount(mtpair, 0);
return rc;
}
// Past this point, we are handling either "mount -a [opts]"
// or "mount [opts] single_param"
- i = parse_mount_options(cmdopts, 0); // FIXME: should be "long", not "int"
+ i = parse_mount_options(cmdopts, NULL); // FIXME: should be "long", not "int"
if (nonroot && (i & ~MS_SILENT)) // Non-root users cannot specify flags
bb_error_msg_and_die(must_be_root);
if (ENABLE_FEATURE_MOUNT_FLAGS
&& (i & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
) {
- rc = verbose_mount(/*source:*/ "", /*target:*/ argv[0],
- /*type:*/ "", /*flags:*/ i, /*data:*/ "");
+ // verbose_mount(source, target, type, flags, data)
+ rc = verbose_mount("", argv[0], "", i, "");
if (rc)
bb_simple_perror_msg_and_die(argv[0]);
return rc;
// If we're mounting all
} else {
- // Do we need to match a filesystem type?
- if (fstype && match_fstype(mtcur, fstype))
+ // No, mount -a won't mount anything,
+ // even user mounts, for mere humans
+ if (nonroot)
+ bb_error_msg_and_die(must_be_root);
+
+ // Does type match? (NULL matches always)
+ if (!match_fstype(mtcur, fstype))
continue;
// Skip noauto and swap anyway.
- if (parse_mount_options(mtcur->mnt_opts, 0) & (MOUNT_NOAUTO | MOUNT_SWAP))
+ if ((parse_mount_options(mtcur->mnt_opts, NULL) & (MOUNT_NOAUTO | MOUNT_SWAP))
+ // swap is bogus "fstype", parse_mount_options can't check fstypes
+ || strcasecmp(mtcur->mnt_type, "swap") == 0
+ ) {
continue;
+ }
- // No, mount -a won't mount anything,
- // even user mounts, for mere humans
- if (nonroot)
- bb_error_msg_and_die(must_be_root);
+ // Does (at least one) option match?
+ // (NULL matches always)
+ if (!match_opt(mtcur->mnt_opts, O_optmatch))
+ continue;
- // Mount this thing
- if (ENABLE_FEATURE_MOUNT_LABEL)
- resolve_mount_spec(&mtpair->mnt_fsname);
+ resolve_mount_spec(&mtcur->mnt_fsname);
// NFS mounts want this to be xrealloc-able
mtcur->mnt_opts = xstrdup(mtcur->mnt_opts);
+
+ // Mount this thing
if (singlemount(mtcur, 1)) {
// Count number of failed mounts
rc++;
// End of fstab/mtab is reached.
// Were we looking for something specific?
if (argv[0]) {
+ long l;
+
// If we didn't find anything, complain
if (!mtcur->mnt_fsname)
bb_error_msg_and_die("can't find %s in %s",
argv[0], fstabname);
+
+ // What happens when we try to "mount swap_partition"?
+ // (fstab containts "swap_partition swap swap defaults 0 0")
+ // util-linux-ng 2.13.1 does this:
+ // stat("/sbin/mount.swap", 0x7fff62a3a350) = -1 ENOENT (No such file or directory)
+ // mount("swap_partition", "swap", "swap", MS_MGC_VAL, NULL) = -1 ENOENT (No such file or directory)
+ // lstat("swap", 0x7fff62a3a640) = -1 ENOENT (No such file or directory)
+ // write(2, "mount: mount point swap does not exist\n", 39) = 39
+ // exit_group(32) = ?
+#if 0
+ // In case we want to simply skip swap partitions:
+ l = parse_mount_options(mtcur->mnt_opts, NULL);
+ if ((l & MOUNT_SWAP)
+ // swap is bogus "fstype", parse_mount_options can't check fstypes
+ || strcasecmp(mtcur->mnt_type, "swap") == 0
+ ) {
+ goto ret;
+ }
+#endif
if (nonroot) {
// fstab must have "users" or "user"
- if (!(parse_mount_options(mtcur->mnt_opts, 0) & MOUNT_USERS))
+ l = parse_mount_options(mtcur->mnt_opts, NULL);
+ if (!(l & MOUNT_USERS))
bb_error_msg_and_die(must_be_root);
}
// Mount the last thing we found
mtcur->mnt_opts = xstrdup(mtcur->mnt_opts);
append_mount_options(&(mtcur->mnt_opts), cmdopts);
- if (ENABLE_FEATURE_MOUNT_LABEL) {
- resolve_mount_spec(&mtpair->mnt_fsname);
- }
+ resolve_mount_spec(&mtpair->mnt_fsname);
rc = singlemount(mtcur, 0);
if (ENABLE_FEATURE_CLEAN_UP)
free(mtcur->mnt_opts);
}
+ //ret:
if (ENABLE_FEATURE_CLEAN_UP)
endmntent(fstab);
if (ENABLE_FEATURE_CLEAN_UP) {