xref: /freebsd/tests/sys/cddl/zfs/bin/mkfile.c (revision ac00d4d59b18a76c6148ca5d7439bb446d38da5c)

/*-
 * Copyright (c) 2001-2013
 *	HATANO Tomomi.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>

#define	MKFILE_WBUF	((size_t)(1048576))	/* Is 1M a reasonable value? */

/* SunOS's mkfile(8) sets "sticky bit." */
#define	MKFILE_FLAG	(O_WRONLY | O_CREAT | O_TRUNC)
#define	MKFILE_MODE	(S_IRUSR | S_IWUSR | S_ISVTX)

static char	buf[MKFILE_WBUF];
static int	nofill = 0;
static int	verbose = 0;

static void
usage()
{
	fprintf(stderr,
	    "Usage: mkfile [-nv] <size>[e|p|t|g|m|k|b] <filename> ...\n");
}

static unsigned long long
getsize(char *s)
{
	int sh;
	unsigned long long length;
	char *suffix;

	/*
	 * NOTE: We don't handle 'Z' (zetta) or 'Y' (yotta) suffixes yet.
	 * These are too large to store in unsigned long long (64bits).
	 * In the future, we'll have to use larger type,
	 * something like uint128_t.
	 */
	length = strtoull(s, &suffix, 10);
	sh = 0;
	switch (tolower(*suffix)) {
	case 'e':	/* Exabytes. */
		sh = 60;
		break;
	case 'p':	/* Petabytes. */
		sh = 50;
		break;
	case 't':	/* Terabytes. */
		sh = 40;
		break;
	case 'g':	/* Gigabytes. */
		sh = 30;
		break;
	case 'm':	/* Megabytes. */
		sh = 20;
		break;
	case 'k':	/* Kilobytes. */
		sh = 10;
		break;
	case 'b':	/* Blocks. */
		sh = 9;
		break;
	case '\0':	/* Bytes. */
		break;
	default:	/* Unknown... */
		errno = EINVAL;
		return 0;
	}
	if (sh) {
		unsigned long long l;

		l = length;
		length <<= sh;
		/* Check overflow. */
		if ((length >> sh) != l) {
			errno = ERANGE;
			return 0;
		}
	}

	return length;
}

static int
create_file(char *f, unsigned long long s)
{
	int fd;
	size_t w;
	ssize_t ws;

	if (verbose) {
		fprintf(stdout, "%s %llu bytes\n", f, s);
		fflush(stdout);
	}

	/* Open file to create. */
	if ((fd = open(f, MKFILE_FLAG, MKFILE_MODE)) < 0) {
		return -1;
	}

	/* Seek to the end and write 1 byte. */
	if ((lseek(fd, (off_t)(s - 1LL), SEEK_SET) == (off_t)-1) ||
	    (write(fd, buf, (size_t)1) == (ssize_t)-1)) {
		/*
		 * We don't close(fd) here to avoid overwriting errno.
		 * This is fd-leak, but is not harmful
		 * because returning error causes mkfile(8) to exit.
		 */
		return -1;
	}

	/* Fill. */
	if (!nofill) {
		if (lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
			/* Same as above. */
			return -1;
		}
		while (s) {
			w = (s > MKFILE_WBUF) ? MKFILE_WBUF : s;
			if ((ws = write(fd, buf, w)) == (ssize_t)-1) {
				/* Same as above. */
				return -1;
			}
			s -= ws;
		}
	}
	close(fd);

	return 0;
}

int
main(int argc, char *argv[])
{
	unsigned long long fsize;
	int ch;

	/* We have at least 2 arguments. */
	if (argc < 3) {
		usage();
		return EXIT_FAILURE;
	}

	/* Options. */
	while ((ch = getopt(argc, argv, "nv")) != -1) {
		switch (ch) {
		case 'n':
			nofill = 1;
			break;
		case 'v':
			verbose = 1;
			break;
		default:
			usage();
			return EXIT_FAILURE;
		}
	}
	argc -= optind;
	argv += optind;

	/* File size to create. */
	if ((fsize = getsize(*argv)) == 0) {
		perror(*argv);
		return EXIT_FAILURE;
	}

	/* Filenames to create. */
	bzero(buf, MKFILE_WBUF);
	while (++argv, --argc) {
		if (create_file(*argv, fsize) == -1) {
			perror(*argv);
			return EXIT_FAILURE;
		}
	}

	return EXIT_SUCCESS;
}