path: root/usr/src/cmd/fs.d/dev/mount.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <locale.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/mntent.h>
#include <sys/fs/sdev_impl.h>


#define	READFLAG_RO	1
#define	READFLAG_RW	2


extern int	optind;
extern char	*optarg;

static char	typename[64], *myname;
static char	fstype[] = MNTTYPE_DEV;

static int	readflag;
static int	overlay;
static int	remount;

static char	*special;
static char	*mountpt;
static struct sdev_mountargs	mountargs;

static char	*myopts[] = {
#define	SUBOPT_READONLY		0
	"ro",
#define	SUBOPT_READWRITE	1
	"rw",
#define	SUBOPT_ATTRIBDIR	2
	"attrdir",
#define	SUBOPT_REMOUNT		3
	"remount",
	NULL
};


static void
usage(void)
{
	(void) fprintf(stderr, gettext(
	    "%s usage:\n%s [-F %s] [-r] [-o specific_options]"
	    " {special | mount_point}\n%s [-F %s] [-r] [-o specific_options]"
	    " special mount_point\n"), fstype, myname, fstype, myname, fstype);
	exit(1);
}


static int
do_mount(void)
{
	int	flags = MS_DATA;

	if (readflag == READFLAG_RO)
		flags |= MS_RDONLY;
	if (overlay)
		flags |= MS_OVERLAY;
	if (remount)
		flags |= MS_REMOUNT;

	if (mount(special, mountpt, flags, fstype, &mountargs,
	    sizeof (mountargs), NULL, 0)) {
		switch (errno) {
		case EPERM:
			(void) fprintf(stderr, gettext("%s: not super user\n"),
			    typename);
			break;
		case ENXIO:
			(void) fprintf(stderr, gettext("%s: %s no such "
			    "device\n"), typename, special);
			break;
		case ENOTDIR:
			(void) fprintf(stderr, gettext("%s: %s "
			    "not a directory\n"
			    "\tor a component of %s is not a directory\n"),
			    typename, mountpt, special);
			break;
		case ENOENT:
			(void) fprintf(stderr, gettext("%s: %s or %s, no such "
			    "file or directory\n"),
			    typename, special, mountpt);
			break;
		case EINVAL:
			(void) fprintf(stderr, gettext("%s: %s is not this "
			    "filesystem type.\n"), typename, special);
			break;
		case EBUSY:
			(void) fprintf(stderr, gettext("%s: %s "
			    "is already mounted, %s is busy,\n"
			    "\tor allowable number of mount points exceeded\n"),
			    typename, special, mountpt);
			break;
		case ENOTBLK:
			(void) fprintf(stderr, gettext("%s: %s not a block "
			    "device\n"), typename, special);
			break;
		case EROFS:
			(void) fprintf(stderr, gettext("%s: %s read-only "
			    "filesystem\n"), typename, special);
			break;
		case ENOSPC:
			(void) fprintf(stderr, gettext("%s: the state of %s "
			    "is not okay\n"
			    "\tand read/write mount was attempted\n"),
			    typename, special);
			break;
		default:
			(void) fprintf(stderr, gettext("%s: cannot mount %s: "
			    "%s\n"), typename, special, strerror(errno));
			break;
		}
		return (-1);
	}
	return (0);
}


/*
 * Wrapper around strdup().
 */
static char *
do_strdup(const char *s1)
{
	char	*str;

	str = strdup(s1);
	if (str == NULL) {
		(void) fprintf(stderr, gettext("%s: strdup failed: %s\n"),
		    typename, strerror(errno));
	}
	return (str);
}


/*
 * Wrapper around stat().
 */
static int
do_stat(const char *path, struct stat *buf)
{
	int	ret;

	ret = stat(path, buf);
	if (ret < 0) {
		(void) fprintf(stderr, gettext("%s: can't stat %s: %s\n"),
		    typename, path, strerror(errno));
	}
	return (ret);
}


/*
 * Wraper around realpath()
 */
static char *
do_realpath(const char *path, char *resolved_path)
{
	char	*ret;

	ret = realpath(path, resolved_path);
	if (ret == NULL) {
		(void) fprintf(stderr, gettext("%s: realpath %s failed: %s\n"),
		    typename, path, strerror(errno));
	}
	return (ret);
}


static int
parse_subopts(char *subopts)
{
	char	*value;
	char	path[PATH_MAX + 1];

	while (*subopts != '\0') {
		switch (getsubopt(&subopts, myopts, &value)) {
		case SUBOPT_READONLY:
			if (readflag == READFLAG_RW) {
				(void) fprintf(stderr, gettext("%s: both "
				    "read-only and read-write options "
				    "specified\n"), typename);
				return (-1);
			}
			readflag = READFLAG_RO;
			break;

		case SUBOPT_READWRITE:
			if (readflag == READFLAG_RO) {
				(void) fprintf(stderr, gettext("%s: both "
				    "read-only and read-write options "
				    "specified\n"), typename);
				return (-1);
			}
			readflag = READFLAG_RW;
			break;

		case SUBOPT_ATTRIBDIR:
			if (value == NULL) {
				(void) fprintf(stderr, gettext("%s: no "
				    "attribute directory\n"), typename);
				return (-1);
			} else {
				if (do_realpath(value, path) == NULL)
					return (-1);
				mountargs.sdev_attrdir =
				    (uint64_t)(uintptr_t)do_strdup(path);
				if (mountargs.sdev_attrdir == 0)
					return (-1);
			}
			break;

		case SUBOPT_REMOUNT:
			remount = 1;
			break;

		default:
			(void) fprintf(stderr, gettext("%s: illegal -o "
			    "suboption: %s\n"), typename, value);
			return (-1);
		}
	}
	return (0);
}


int
main(int argc, char **argv)
{
	struct stat	st;
	char		mntpath[PATH_MAX + 1];
	int		cc;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	if (myname = strrchr(argv[0], '/'))
		myname++;
	else
		myname = argv[0];
	(void) snprintf(typename, sizeof (typename), "%s %s", fstype, myname);
	argv[0] = typename;

	while ((cc = getopt(argc, argv, "?o:rmO")) != -1) {
		switch (cc) {
		case 'r':
			if (readflag == READFLAG_RW) {
				(void) fprintf(stderr, gettext("%s: both "
				    "read-only and read-write options "
				    "specified\n"), typename);
				return (1);
			}
			readflag = READFLAG_RO;
			break;

		case 'O':
			overlay = 1;
			break;

		case 'o':
			if (parse_subopts(optarg))
				return (1);
			break;

		default:
			usage();
			break;
		}
	}

	/*
	 * There must be at least 2 more arguments, the
	 * special file and the directory.
	 */
	if ((argc - optind) != 2)
		usage();

	special = argv[optind++];

	if (do_realpath(argv[optind++], mntpath) == NULL)
		return (1);
	mountpt = mntpath;

	if (mountpt) {
		if (do_stat(mountpt, &st) < 0)
			return (1);
		if (! S_ISDIR(st.st_mode)) {
			(void) fprintf(stderr, gettext("%s: %s is not a "
			    "directory\n"), typename, mountpt);
			return (1);
		}
	}

	if (mountargs.sdev_attrdir) {
		if (do_stat((const char *)(uintptr_t)mountargs.sdev_attrdir,
		    &st) < 0)
			return (1);
		if (! S_ISDIR(st.st_mode)) {
			(void) fprintf(stderr, gettext("%s: %s is not a "
			    "directory\n"), typename, mountargs.sdev_attrdir);
			return (1);
		}
	}

	/* Special checks if /dev is the mount point */
	/* Remount of /dev requires an attribute directory */
	if (strcmp(mountpt, "/dev") == 0 && remount &&
	    mountargs.sdev_attrdir == 0) {
		(void) fprintf(stderr, gettext("%s: missing attribute "
		    "directory\n"), typename);
		return (1);
	}

	(void) signal(SIGHUP,  SIG_IGN);
	(void) signal(SIGQUIT, SIG_IGN);
	(void) signal(SIGINT,  SIG_IGN);

	/* Perform the mount  */
	if (do_mount())
		return (1);

	return (0);
}