xref: /onnv-gate/usr/src/cmd/fs.d/ufs/roll_log/roll_log.c (revision 392:68e38aa09ba8)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * This file contains functions that allow applications to roll the log.
 * It is intended for use by applications that open a raw device with the
 * understanding that it contains a Unix File System.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <sys/filio.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <sys/mount.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fs/ufs_mount.h>
#include <sys/fs/ufs_log.h>
#include <libintl.h>
#include "roll_log.h"

/*
 * The following is the template string passed to mktemp(3C).  This
 * string is used as the name of a temporary mount point which is
 * used to roll the log.
 */
#define	RLG_TEMPLATE	".rlg.XXXXXX"

#define	SYSERR		(-1)

#define	RLM_RW		0
#define	RLM_RO		1

/*
 * Structure definitions:
 */

typedef struct log_info {
	char *li_blkname;	/* Path of block device. */
	char *li_mntpoint;	/* Path of mounted device. */
	char *li_tmpmp_parent;	/* Temporary parent directory of mount point */
	char *li_tmpmp;		/* Temporary mount point. */
} log_info_t;

/*
 * Static function declarations:
 */

static rl_result_t	is_mounted(log_info_t *lip, char *dev);
static void		cleanup(log_info_t *lip);
static rl_result_t	make_mp(log_info_t *lip);
static rl_result_t	rlflush(log_info_t *lip);
static rl_result_t	rlmount(log_info_t *lip, int mntopt);
static rl_result_t	rlumount(log_info_t *lip);

/*
 * NAME
 *	rl_roll_log
 *
 * SYNOPSIS
 *	rl_roll_log(block_dev)
 *
 * DESCRIPTION
 *	Roll the log for the block device "block_dev".
 */

rl_result_t
rl_roll_log(char *bdev)
{
	log_info_t		li;
	rl_result_t		rv = RL_SUCCESS;

	(void) memset((void *)&li, 0, (size_t)sizeof (li));
	if (is_mounted(&li, bdev) == RL_TRUE) {
		rv = rlflush(&li);
	} else {
		/*
		 * Device appears not to be mounted.
		 * We need to mount the device read only.
		 * This automatically causes the log to be rolled, then we can
		 * unmount the device again.  To do the mount, we need to
		 * create a temporary directory, and then remove it when we
		 * are done.
		 */
		rv = make_mp(&li);
		switch (rv) {
		case RL_CORRUPT:
			/* corrupt mnttab - the file sys really was mounted */
			rv = rlflush(&li);
			break;
		case RL_SUCCESS:
			rv = rlmount(&li, RLM_RO);
			if (rv == RL_SUCCESS) {
				rv = rlflush(&li);
				if (umount(li.li_blkname) == SYSERR) {
					(void) fprintf(stderr,
		"WARNING: rl_roll_log(): Can't unmount %s\n", li.li_blkname);
				}

			}
			break;
		}
	}
	cleanup(&li);
	return (rv);
}

/*
 * Static function definitions:
 */

/*
 * NAME
 *	cleanup
 *
 * SYNOPSIS
 *	cleanup(log_infop)
 *
 * DESCRIPTION
 *	Remove the temporary mount directroy and free the dynamically
 *	allocated memory that is pointed to by log_infop.
 */

static void
cleanup(log_info_t *lip)
{
	if (lip->li_blkname != (char *)NULL) {
		free(lip->li_blkname);
		lip->li_blkname = (char *)NULL;
	}
	if (lip->li_mntpoint != (char *)NULL) {
		free(lip->li_mntpoint);
		lip->li_mntpoint = (char *)NULL;
	}
	if (lip->li_tmpmp != (char *)NULL) {
		(void) rmdir(lip->li_tmpmp);
		free(lip->li_tmpmp);
		lip->li_tmpmp = (char *)NULL;
	}
	if (lip->li_tmpmp_parent != (char *)NULL) {
		(void) rmdir(lip->li_tmpmp_parent);
		free(lip->li_tmpmp_parent);
		lip->li_tmpmp_parent = (char *)NULL;
	}
}

/*
 * NAME
 *	is_mounted
 *
 * SYNOPSIS
 *	is_mounted(log_infop, dev)
 *
 * DESCRIPTION
 *	Determine if device dev is mounted, and return RL_TRUE if it is.
 *	As a side effect, li_blkname is set to point the the full path
 *	names of the block device.  Memory for this path is dynamically
 *	allocated and must be freed by the caller.
 */

extern char *getfullblkname(char *);

static rl_result_t
is_mounted(log_info_t *lip, char *dev)
{

	struct mnttab		mntbuf;
	FILE			*mnttable;
	rl_result_t		rv = RL_FALSE;

	/* Make sure that we have the full path name. */
	lip->li_blkname = getfullblkname(dev);
	if (lip->li_blkname == NULL)
		lip->li_blkname = strdup(dev);

	/* Search mnttab to see if it device is mounted. */
	if ((mnttable = fopen(MNTTAB, "r")) == NULL)
		return (rv);
	while (getmntent(mnttable, &mntbuf) == NULL) {
		if (strcmp(mntbuf.mnt_fstype, MNTTYPE_UFS) == 0) {
			/* Entry is UFS */
			if ((strcmp(mntbuf.mnt_mountp, dev) == 0) ||
			    (strcmp(mntbuf.mnt_special, lip->li_blkname)
				== 0) ||
			    (strcmp(mntbuf.mnt_special, dev) == 0)) {
				lip->li_mntpoint = strdup(mntbuf.mnt_mountp);
				rv = RL_TRUE;
				break;
			}
		}
	}
	(void) fclose(mnttable);


	return (rv);
}

/*
 * NAME
 *	make_mp
 *
 * SYNOPSIS
 *	make_mp(loginfop)
 *
 * DESCRIPTION
 *	Create a temporary directory to be used as a mount point.  li_tmpmp
 *	will be set to the path of the mount point. li_tmpmp_parent is the
 *	parent directory of the mount point.  The parent directory is
 *	created with restrictive permissions.   Memory pointed to by
 *	li_tmpmp and li_tmpmp_parent should be freed by the caller.
 */

static rl_result_t
make_mp(log_info_t *lip)
{
	size_t			i;
	rl_result_t		rv = RL_FAIL;
	/*
	 * Note tmp_dir_list[] should all be directories in the
	 * original root file system.
	 */
	static const char 	*tmp_dir_list[] = {
							"/tmp/",
							"/var/tmp/",
							"/",
						};
	char			dirname[] = RLG_TEMPLATE;
	char			tmp_dir[MAXPATHLEN + 1];
	char			mountpt_dir[MAXPATHLEN + 1];
	static size_t		list_len = sizeof (tmp_dir_list) /
						sizeof (const char *);
	int			merr = 0;

	/*
	 * Sequence of events:
	 * - Create a random name using mktemp(3C) (e.g., ".rlg.123456")
	 * - Cycle through tmp_dir_list to find a path where we can create
	 *   a temporary parent directory (e.g., /tmp/.rlg.123456) with
	 *   restrictive permissions.  This prevents any non-root processes,
	 *   such as a 'find', from wandering in where it doesn't belong.
	 * - Create the mount-point (/tmp/.rlg.123456/.rlg.123456).
	 */
	(void) mktemp(dirname);
	for (i = 0; i < list_len; i++) {
		/* Make the directory containing the mount-point */
		(void) snprintf(tmp_dir, sizeof (tmp_dir), "%s%s",
				tmp_dir_list[i], dirname);
		if (mkdir(tmp_dir, 0) == SYSERR) {
			merr = errno;
			continue;
		}

		/* Now, make the mount-point */
		(void) snprintf(mountpt_dir, sizeof (mountpt_dir), "%s/%s",
				tmp_dir, dirname);
		if (mkdir(mountpt_dir, 0) == SYSERR) {
			merr = errno;
			continue;
		}
		lip->li_tmpmp = strdup(mountpt_dir);
		lip->li_tmpmp_parent = strdup(tmp_dir);

		/* Make sure that the strdup()s both succeeded */
		if ((lip->li_tmpmp != NULL) && (lip->li_tmpmp_parent != NULL)) {
			rv = RL_SUCCESS;
		}
		break;
	}

	/* Get some help if we cannot make the directory. */
	if (rv != RL_SUCCESS) {
		/*
		 * If we get a read only filesystem failure (EROFS)
		 * to make a directory in "/", then we must be fsck'ing
		 * at boot with a incorrect mnttab.
		 *
		 * Just return RL_CORRUPT to indicate it really
		 * was mounted.
		 */
		if (merr == EROFS) {
			lip->li_mntpoint = strdup("/");
			return (RL_CORRUPT);
		}

		(void) fprintf(stderr, gettext(
			"Unable to create temporary "
			"directory in any of the directories listed "
			"below:\n"));
		for (i = 0; i < list_len; i++) {
			(void) fprintf(stderr, "\t%s\n", tmp_dir_list[i]);
		}
		(void) fprintf(stderr, gettext(
			"Please correct this problem "
			"and rerun the program.\n"));
	}

	return (rv);
}

/*
 * NAME
 *	rlflush
 *
 * SYNOPSIS
 *	rlflush(log_infop)
 *
 * DESCRIPTION
 *	Open the mount point of the file system (li_mntpoint) to get a
 *	file descriptor.  Issue the _FIOFFS ioctl to flush the file system
 *	and then close the device.
 */

static rl_result_t
rlflush(log_info_t *lip)
{
	int			fd;	/* File descriptor. */
	rl_result_t		rv = RL_SUCCESS;

	if ((fd = open((lip->li_mntpoint ? lip->li_mntpoint : lip->li_tmpmp),
		O_RDONLY)) == SYSERR) {
		return (RL_SYSERR);
	}
	if (ioctl(fd, _FIOFFS, NULL) == SYSERR) {
		rv = RL_SYSERR;
	}
	(void) close(fd);
	return (rv);
}

/*
 * NAME
 *	rlmount
 *
 * SYNOPSIS
 *	rlmount(log_infop, mntopt)
 *
 * DESCRIPTION
 *	Mount the device specified by li_blkname on li_tmpmp. mntopt specifies
 *	whether it's mounted RLM_RO or RLM_RW.
 */

static rl_result_t
rlmount(log_info_t *lip, int mntopt)
{
	struct ufs_args		args;
	rl_result_t		rv = RL_SUCCESS;
	char			opt[MAX_MNTOPT_STR];
	char			*optstr;
	int			optflg;

	args.flags = 0;	/* Initialize ufs_args */

	/*
	 * Use a minimal restrictive set of mount options.  Make sure
	 * to use "largefiles" option otherwise mount() can fail w/EFBIG.
	 * (Although "nosub" isn't a currently supported option on UFS,
	 * it would be a good one to have if it ever is implemented
	 * since submounts would prevent a umount.)
	 */
	args.flags |= UFSMNT_LARGEFILES;
	switch (mntopt) {
	case RLM_RO:
		optstr = MNTOPT_RO;
		optflg = MS_RDONLY;
		break;
	case RLM_RW:
		optstr = MNTOPT_RW;
		optflg = 0;
		break;
	default:
		return (RL_FAIL);
	}
	(void) snprintf(opt, sizeof (opt), "%s,%s,%s",
		optstr, MNTOPT_NOSUID, MNTOPT_LARGEFILES);
	if (mount(lip->li_blkname, lip->li_tmpmp,
			optflg | MS_DATA | MS_OPTIONSTR,
			MNTTYPE_UFS, &args, sizeof (args),
			opt, MAX_MNTOPT_STR) == SYSERR) {
		rv = RL_SYSERR;
	}
	return (rv);
}

/*
 * NAME
 *	rlumount
 *
 * SYNOPSIS
 *	rlumount(log_infop)
 *
 * DESCRIPTION
 *	Unmounts the device specified by li_blkname, printing an
 *	error message on failure.
 */

static rl_result_t
rlumount(log_info_t *lip)
{
	rl_result_t		rv = RL_SUCCESS;

	if (umount(lip->li_blkname) == SYSERR) {
		(void) fprintf(stderr, gettext(
		"WARNING: rlumount(): Can't unmount %s\n"),
			lip->li_blkname);
		rv = RL_SYSERR;
	}
	return (rv);
}

/*
 * NAME
 *	rl_log_control
 *
 * SYNOPSIS
 *	rl_log_control(block_dev, request)
 *
 * DESCRIPTION
 *	Enable/disable logging for the block device "block_dev".
 *	The request parameter should be set to _FIOLOGENABLE or
 *	_FIOLOGDISABLE.
 */

rl_result_t
rl_log_control(char *bdev, int request)
{
	log_info_t	li;
	rl_result_t	rv = RL_SUCCESS;
	rl_result_t	alreadymounted;
	int		fd;
	fiolog_t	fl;
	int		logenabled = 0;

	if ((request != _FIOLOGENABLE) && (request != _FIOLOGDISABLE))
		return (RL_FAIL);

	(void) memset((void *)&li, '\0', (size_t)sizeof (li));
	if ((alreadymounted = is_mounted(&li, bdev)) != RL_TRUE) {
		/*
		 * Device is not mounted. Need to mount it rw to allow
		 * the log to be enabled/disabled. To do the mount, we need
		 * to create a temporary directory, and then remove it when
		 * we are done.
		 */
		if (make_mp(&li) != RL_SUCCESS) {
			cleanup(&li);
			return (RL_FAIL);
		}
		if (rlmount(&li, RLM_RW) != RL_SUCCESS) {
			cleanup(&li);
			return (RL_FAIL);
		}
	}

	if (alreadymounted == RL_TRUE)
		fd = open(li.li_mntpoint, O_RDONLY);
	else
		fd = open(li.li_tmpmp, O_RDONLY);
	if (fd == SYSERR) {
		perror("open");
		rv = RL_SYSERR;
		goto out;
	}

	fl.nbytes_requested = 0;
	fl.nbytes_actual = 0;
	fl.error = FIOLOG_ENONE;

	if (ioctl(fd, request, &fl) == SYSERR) {
		perror("ioctl");
		(void) close(fd);
		rv = RL_SYSERR;
		goto out;
	}
	if (ioctl(fd, _FIOISLOG, &logenabled) == SYSERR) {
		perror("ioctl");
		(void) close(fd);
		rv = RL_SYSERR;
		goto out;
	}
	if (((request == _FIOLOGENABLE) && (!logenabled)) ||
	    ((request == _FIOLOGDISABLE) && logenabled))
		rv = RL_FAIL;

	(void) close(fd);
out:
	if (alreadymounted != RL_TRUE)
		(void) rlumount(&li);
	cleanup(&li);
	return (rv);
}