tools/diskomizer/daio_fs.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
 */

#pragma ident	"@(#)daio_fs.c	1.11	09/05/26 SMI"

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

#include <diskomizer/daio.h>
#include <diskomizer/log.h>
#include "findap.h"
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <dirent.h>
#include "args.h"
#include "daio_async.h"

/* These are required so this will build, but not run, on 5.6, 5.7 and 5.8 */
#if defined(__SunOS_5_6) || defined(__SunOS_5_7) || defined(__SunOS_5_8)

extern int openat(int fildes,  const  char  *path,  int  oflag,  mode_t mode);
extern int unlinkat(int dirfd, const char *path, int flag);
extern int renameat(int fromfd, const char *old,  int  tofd,  const
	char *new);
extern DIR* fdopendir(int fd);
#define	O_XATTR 0x4000

#pragma weak openat
#pragma weak unlinkat
#pragma weak renameat
#pragma weak fdopendir

#endif


static int daio_fsrw_write(int fildes, uchar_t *bufp, int bufs, off_t
		offset, daio_result_t *resultp, struct daio_id *id);
static int daio_fsrw_read(int fildes, uchar_t *bufp, int bufs, off_t
		offset, daio_result_t *resultp, struct daio_id *id);
static ssize_t do_pwrite(int fildes, void *bufp, size_t bufs, off_t off);
static ssize_t do_unlinkat_and_pwrite(int fildes, void *bufp, size_t bufs,
	off_t off);
static ssize_t do_unlinkpath_and_pwrite(int fildes, void *bufp, size_t bufs,
	off_t off);
static ssize_t do_renameat_and_pwrite_and_unlink(int fildes, void *bufp,
	size_t bufs, off_t off);
static ssize_t do_renamepath_and_pwrite_and_unlink(int fildes, void *bufp,
	size_t bufs, off_t off);
static ssize_t (*do_pwritep)(int fildes, void *bufp, size_t bufs, off_t off);
static int fs_close(int);
static int fd_openat_blk(int fildes, int flag, off_t off);
static int fd_openpath_blk(int fildes, int flag, off_t off);
static int (*fd_open_blk)(int fildes, int flag, off_t off) = fd_openat_blk;
static int (*fd_directio_open_blk)(int fildes, int flag, off_t off);

#define	USEOPENAT (fd_open_blk == fd_openat_blk)

static struct {
	mode_t mode;
	off64_t obj_size; /* the size of the "device" */
	off64_t file_size; /* the size of each file */
	off64_t block_size; /* the daio_fs block size */
	off64_t max_block_size; /* the diskomizer block_size */
	off64_t blocks_per_file; /* number of blocks to store per file */
	uint_t wflags;
	uint_t attr;
} fs_opts;

struct fs_fds {
	char *path;
	int pathlen;
	int fd;
};

static struct fs_fds *fs_fdsp;
static int fd_nfds;

static char *
fd2pathname(int fildes, offset_t off)
{
	char *buf = malloc(fs_fdsp[fildes].pathlen + 19);
	int ret;

	if (buf == NULL) {
		return (NULL);
	}

	sprintf(buf, "%s/%llx",
	    fs_fdsp[fildes].path, off/fs_opts.file_size);
	return (buf);
}

static void
fs_init(const char *checker, off64_t max_block_size)
{
	const struct option_ops *ops;
	uint64_t ll;
	long i;
	char c;

	ops = opts_init();

	fs_opts.max_block_size = max_block_size;

	if (ops->opt_long_long("FILE_SIZE", (long long *)&ll) != OPT_OK ||
	    ll == 0) {
		plog(LOG_ERR, "DAIO_FS requires FILE_SIZE to be set\n");
		exit(-1);
	}
	fs_opts.obj_size = ll;
	if (ops->opt_long("DAIO_FS_BLOCKS_PER_FILE", &i) != OPT_OK || i == 0) {
		i = 1;
	}
	fs_opts.blocks_per_file = i;
	if (ops->opt_long_long("DAIO_FS_BLOCK_SIZE",
	    (long long *)&fs_opts.block_size) != OPT_OK ||
	    fs_opts.block_size == 0) {
		fs_opts.block_size = fs_opts.max_block_size;
	}
	if (fs_opts.block_size < fs_opts.max_block_size) {
		plog(LOG_WARNING, "DAIO_FS_BLOCK_SIZE must be greater than or "
		    "equal to the maximum block size\n");
		exit(-1);
	}

	if (ops->opt_int("DAIO_FS_MODE", (int *)&fs_opts.mode) != OPT_OK) {
		fs_opts.mode = 0600;
	}
	fs_opts.file_size = i * fs_opts.max_block_size;
	if ((ops->opt_bool("DAIO_FS_NOT_XXXAT", &c)  == OPT_OK && c == 1) ||
	    openat == NULL) {
		fd_open_blk = fd_openpath_blk;
	}

	if (ops->opt_bool("DAIO_FS_O_XATTR", &c) == OPT_OK && c == 1) {
		if (!USEOPENAT) {
			if (openat == NULL) {
				plog(LOG_ERR, "DAIO_FS_O_XATTR not available "
				    "on this OS");
			} else {
				plog(LOG_ERR, "DAIO_FS_O_XATTR and "
				    "DAIO_FS_NOT_XXXAT are mutually exclusive");
			}
			exit(-1);
		}
		fs_opts.attr = O_XATTR;
	}
	if (ops->opt_bool("DAIO_FS_TRUNC", &c) == OPT_OK && c == 1 && i == 1) {
		fs_opts.wflags = O_TRUNC;
	}

	if (ops->opt_bool("DAIO_FS_UNLINK", &c) == OPT_OK && c == 1 && i == 1) {
		if (!USEOPENAT) {
			do_pwritep = do_unlinkpath_and_pwrite;
		} else {
			do_pwritep = do_unlinkat_and_pwrite;
		}
	} else {
		do_pwritep = do_pwrite;
	}
	if (ops->opt_bool("DAIO_FS_RENAME_AND_UNLINK", &c) == OPT_OK &&
	    c == 1 && i == 1) {
		if (do_pwritep != do_pwrite) {
			plog(LOG_WARNING, "DAIO_FS_UNLINK and "
			    "DAIO_FS_RENAME_AND_UNLINK are mutually exclusive, "
			    "using DAIO_FS_UNLINK");
		} else {
			if (!USEOPENAT) {
				do_pwritep =
				    do_renamepath_and_pwrite_and_unlink;
			} else {
				do_pwritep = do_renameat_and_pwrite_and_unlink;
			}
		}
	}

	opts_fini();
	daio_async_init_checker(checker, max_block_size);
}

static off_t
fd_off2real_off(int fildes, off_t off)
{
	off_t x = fs_opts.block_size *
	    ((off % fs_opts.file_size)/fs_opts.max_block_size);
	return (x);
}

static int
fd_openpath_blk(int fildes, int flag, off_t off)
{
	char *buf = fd2pathname(fildes, off);
	int ret;

	if (buf == NULL) {
		return (-1);
	}

	ret = open(buf, flag, fs_opts.mode);
	free(buf);
	return (ret);
}

static int
fd_openat_blk(int fildes, int flag, off_t off)
{
	char buf[17]; /* big enough to hold the largest 64 bit quantity */

	if (snprintf(buf, sizeof (buf), "%llx", off/fs_opts.file_size) >
	    sizeof (buf) - 1) {
		return (-1);
	}

	return (openat(fs_fdsp[fildes].fd, buf, flag, fs_opts.mode));
}

static int
fs_ioctl(int fdes, int a, void *b)
{
	errno = EINVAL;
	return (-1);
}

static int
do_open(const char *path, int flag, mode_t mode)
{
	int fd;

	if ((fd = open(path, O_RDONLY|(O_EXCL & flag), mode)) == -1) {
		return (-1);
	}
	if (fs_opts.attr) {
		int fd2;
		if (!USEOPENAT ||
		    (fd2 = openat(fd, ".", fs_opts.attr, 0)) == -1) {
			close(fd);
			return (-1);
		}
		(void) close(fd);
		fd = fd2;
	}
	return (fd);
}

static int
fs_open(const char *path, int flag, mode_t mode)
{
	struct stat buf;
	struct fs_fds *tmp;
	int fd;

	if (stat(path, &buf) == -1) {
		if ((mode & O_RDONLY) != 0) {
			errno = EACCES;
			return (-1);
		} else if (mkdir(path, fs_opts.mode | S_IXUSR) == -1) {
			return (-1);
		}
	}

	if ((fd = do_open(path, flag, mode)) == -1) {
		return (-1);
	}

	tmp = realloc(fs_fdsp, (fd_nfds + 1) * sizeof (struct fs_fds));

	if (tmp == NULL) {
		return (-1);
	}
	fs_fdsp = tmp;
	if (path[0] != '/') {
		char *b = getcwd(NULL, PATH_MAX);

		if (b == NULL) {
			fs_close(fd);
			return (-1);
		}
		fs_fdsp[fd_nfds].path = malloc(strlen(b) + strlen(path) + 2);
		if (fs_fdsp[fd_nfds].path == NULL) {
			free(b);
			fs_close(fd);
			return (-1);
		}

		sprintf(fs_fdsp[fd_nfds].path, "%s/%s", b, path);
		free(b);
	} else {
		fs_fdsp[fd_nfds].path = strdup(path);
	}
	fs_fdsp[fd_nfds].pathlen = strlen(fs_fdsp[fd_nfds].path);
	fs_fdsp[fd_nfds++].fd = fd;

	return (fd_nfds - 1);
}

static int
fs_close(int fildes)
{
	int ret;

	if (fildes >= fd_nfds) {
		errno = EINVAL;
		return (-1);
	}
	if ((ret = close(fs_fdsp[fildes].fd)) == 0) {
		fs_fdsp[fildes].fd = -1;
		free(fs_fdsp[fildes].path);
		fs_fdsp[fildes].path = NULL;
	}
	return (ret);
}

static int
fs_ftruncate64(int fildes, off64_t len)
{
	fs_opts.obj_size = len;
	return (0); /* this is a lie */
}

static int
fd_do_open_and_directio(int fildes, int flag, off_t off)
{
	int fd;
	if ((fd = fd_directio_open_blk(fildes, flag, off)) != -1) {
		(void) directio(fd, DIRECTIO_ON);
	}
	return (fd);
}
static int
fs_directio(int fildes, int advice)
{
	if (ftruncate == NULL) {
		return (-1);
	} else {
		if (advice) {
			fd_directio_open_blk = fd_open_blk;
			fd_open_blk = fd_do_open_and_directio;
		}
	}
	return (0);
}

static int
fs_stat64(const char *path, struct stat64 *bp)
{
	int ret;

	ret = stat64(path, bp);
	return (ret);
}

static int
fs_fstat64(int fildes, struct stat64 *bp)
{
	int ret;
	ret  = fstat64(fs_fdsp[fildes].fd, bp);
	bp->st_mode &= ~S_IFMT;
	bp->st_mode |= S_IFREG; /* pretend to be an ordinary file */
	bp->st_size = fs_opts.obj_size;
	return (ret);
}
#if defined(__SunOS_5_6) || defined(__SunOS_5_7) || defined(__SunOS_5_8)
static DIR *
do_opendir(int fd, const char *path)
{
	if (fdopendir != NULL) {
		return (fdopendir(fd));
	} else {
		return (opendir(path));
	}
}
#else
#define	do_opendir(FD, PATH) fdopendir(FD)
#endif

static int
fs_unlink(const char *path)
{
	int fd;
	if (rmdir(path) == 0) {
		return (0);
	}

	if (errno != EEXIST) {
		return (-1);
	}

	if (!USEOPENAT) {
		off64_t off;
		off64_t end = fs_opts.obj_size/fs_opts.file_size;
		DIR *dirp;
		void *scratch;
		int len = strlen(path);
		char *buf;

		if ((buf = malloc(len + 18)) == NULL) {
			return (-1);
		}

		strcpy(buf, path);

		if ((scratch = malloc(sizeof (struct dirent) +
		    pathconf(path, PATH_MAX) + 1)) != NULL &&
		    (dirp = opendir(path)) != NULL) {
			struct dirent *dep;

			while (readdir_r(dirp, scratch, &dep) == 0 &&
			    dep != NULL) {
				off64_t off;

				if (dep->d_name[0] == '.') {
					continue;
				}
				off = strtoll(dep->d_name, NULL, 16);

				if (off >= 0 && off < end) {
					sprintf(&buf[len], "/%s", dep->d_name);
					unlink(buf);
				}
			}
			closedir(dirp);
		}
		free(scratch);
		free(buf);
	} else {
		if ((fd = do_open(path, O_RDONLY, 0)) != -1) {
			DIR *dirp;
			void *scratch;
			off64_t end = fs_opts.obj_size/fs_opts.file_size;

			if ((scratch = malloc(sizeof (struct dirent) +
			    fpathconf(fd, PATH_MAX) + 1)) != NULL &&
			    (dirp = do_opendir(fd, path)) != NULL) {
				struct dirent *dep;

				while (readdir_r(dirp, scratch, &dep) == 0 &&
				    dep != NULL) {
					off64_t off;

					if (dep->d_name[0] == '.') {
						continue;
					}
					off = strtoll(dep->d_name, NULL, 16);

					if (off >= 0 && off < end) {
						unlinkat(fd, dep->d_name, 0);
					}
				}
				closedir(dirp);
			}
			free(scratch);
			close(fd);
		}
	}
	return (rmdir(path));
}

static ssize_t
do_pwrite(int fildes, void *bufp, size_t bufs, off_t off)
{
	int fd;
	ssize_t ret;
	int err;

	if ((fd = fd_open_blk(fildes, O_WRONLY|O_CREAT|fs_opts.wflags, off)) ==
	    -1) {
		return (-1);
	}
	ret = pwrite(fd, (char *)bufp, bufs, fd_off2real_off(fildes, off));
	err = errno;
	if (close(fd) < 0) {
		ret = -1;
	} else {
		errno = err;
	}
	return (ret);
}

static ssize_t
do_renameat_and_pwrite_and_unlink(
    int fildes, void *bufp, size_t bufs, off_t off)
{
	int ret;
	char buf[6 + 17];

	snprintf(buf, sizeof (buf), "To_go.%llx", off/fs_opts.file_size);
	if (renameat(fs_fdsp[fildes].fd, &buf[6], fs_fdsp[fildes].fd, buf) ==
	    -1) {
		if (errno != ENOENT) {
			return (-1);
		} else {
			ret = do_pwrite(fildes, bufp, bufs, off);
		}
	} else {
		ret = do_pwrite(fildes, bufp, bufs, off);
		unlinkat(fs_fdsp[fildes].fd, buf, 0);
	}
	return (ret);
}

static ssize_t
do_renamepath_and_pwrite_and_unlink(
    int fildes, void *bufp, size_t bufs, off_t off)
{
	int ret;
	char *bufo;
	char *bufn;

	if ((bufo = fd2pathname(fildes, off)) == NULL) {
		return (-1);
	}

	bufn = malloc(fs_fdsp[fildes].pathlen + 16 + 6 + 2);
	if (bufn != NULL) {
		sprintf(bufn, "%s/To_go.%llx",
		    fs_fdsp[fildes].path, off/fs_opts.file_size);

		if (rename(bufo, bufn) == -1) {
			if (errno != ENOENT) {
				ret = -1;
			} else {
				ret = do_pwrite(fildes, bufp, bufs, off);
			}
		} else {
			ret = do_pwrite(fildes, bufp, bufs, off);
			unlink(bufn);
		}
		free(bufn);
	} else {
		ret = -1;
	}
	free(bufo);
	return (ret);
}

static ssize_t
do_unlinkat_and_pwrite(int fildes, void *bufp, size_t bufs, off_t off)
{
	char buf[17];

	snprintf(buf, sizeof (buf), "%llx", off/fs_opts.file_size);
	unlinkat(fs_fdsp[fildes].fd, buf, 0);
	return (do_pwrite(fildes, bufp, bufs, off));
}

static ssize_t
do_unlinkpath_and_pwrite(int fildes, void *bufp, size_t bufs, off_t off)
{
	char *buf = fd2pathname(fildes, off);

	if (buf == NULL) {
		return (-1);
	}
	unlink(buf);
	free(buf);

	return (do_pwrite(fildes, bufp, bufs, off));
}

ssize_t
fs_pwrite(int fildes, const uchar_t *bufp, size_t bufs, off_t off,
		struct daio_id *id)
{
	return (do_pwritep(fildes, (void *)bufp, bufs, off));
}

ssize_t
do_pread(int fildes, void *bufp, size_t bufs, off_t off)
{
	int fd;
	int ret;
	int err;

	if ((fd = fd_open_blk(fildes, O_RDONLY, off)) == -1) {
		return (-1);
	}
	ret = pread64(fd, bufp, bufs, fd_off2real_off(fildes, off));
	err = errno;
	close(fd);
	errno = err;
	return (ret);
}

ssize_t
fs_pread(int fildes, void *bufp, size_t bufs, off_t off,
		struct daio_id *id)
{
	return (do_pread(fildes, bufp, bufs, off));
}

ssize_t
fs_pread_and_check(int fildes, uchar_t *bufp, size_t bufs, off_t off,
		struct daio_id *id)
{
	int ret;

	ret = do_pread(fildes, bufp, bufs, off);
	if (id != NULL && ret >= 0) {
		if ((daio_async_get_checker())(bufp, ret, id) != 0) {
			ret = DAIO_CORRUPT;
		}
	}
	return (ret);
}

static int
daio_fsrw_read(int fildes, uchar_t *bufp, int bufs, off_t offset,
		daio_result_t *resultp, struct daio_id *id)
{
	return (daio_async_rw(fildes, bufp, bufs, offset, resultp, id,
	    do_pread, IS_READ));
}

static int
daio_fsrw_write(int fildes, uchar_t *bufp, int bufs, off_t offset,
		daio_result_t *resultp, struct daio_id *id)
{
	return (daio_async_rw(fildes, bufp, bufs, offset, resultp, id,
	    do_pwritep, IS_WRITE));
}

static void *
fs_read_disko_vtoc(int filedes)
{
	return (NULL);
}

struct paths *
fs_findap(const char *inpath, const char *devices)
{
	return (NULL);
}

static void
fs_dd(int pri, int fd, size_t len, size_t bs, off_t off)
{
	if (USEOPENAT) {
		plog(pri, "runat %s dd if=%llx bs=%d iseek=%d\n",
		    fs_fdsp[fd].path, off/fs_opts.file_size,
		    len, fd_off2real_off(fd, off)/bs);
	} else {
		plog(pri, "dd if=%s/%llx bs=%d iseek=%d\n",
		    fs_fdsp[fd].path, off/fs_opts.file_size,
		    len, fd_off2real_off(fd, off)/bs);
	}
}

struct daio_ops DAIO_OPS = {
	daio_async_init,
	fs_init,
	daio_async_get_checker,
	fs_findap,
	(int (*)(const char *, int, ...))fs_open,
	fs_close,
	fs_unlink,
	fs_stat64,
	fs_fstat64,
	(int (*)(int, int, ...))fs_ioctl,
	fs_ftruncate64,
	fs_directio,
	fs_read_disko_vtoc,
	fs_pwrite,
	fs_pread_and_check,
	daio_fsrw_write,
	daio_fsrw_read,
	daio_async_status,
	daio_async_start_time,
	daio_async_end_time,
	daio_async_wait,
	daio_async_cancel,
	daio_async_fini,
	fs_dd
};