OpenSolaris_b135/cmd/boot/fiocompress/fiocompress.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * fiocompress - a utility to compress files with a filesystem.
 * Used to build compressed boot archives to reduce memory
 * requirements for booting.
 */

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <utility.h>
#include <zlib.h>

#include <sys/filio.h>
#include <sys/fs/decomp.h>

#include "message.h"

static void	setup_infile(char *);
static void	setup_outfile(char *);
static void	do_comp(size_t);
static void	do_decomp(void);

static caddr_t	srcaddr;
static size_t	srclen;

static int	dstfd;

static char	*srcfile;
static char	*dstfile;


int
main(int argc, char **argv)
{
	int compress = 0;
	int decompress = 0;
	int doioc = 0;
	size_t	blksize = 8192;
	char c;

	while ((c = getopt(argc, argv, "mcdb:")) != -1) {
		switch (c) {
		case 'm':
			doioc++;
			break;
		case 'c':
			if (decompress) {
				(void) fprintf(stderr, OPT_DC_EXCL);
				exit(-1);
			}
			compress = 1;
			break;
		case 'd':
			if (compress) {
				(void) fprintf(stderr, OPT_DC_EXCL);
				exit(-1);
			}
			decompress = 1;
			break;
		case 'b':
			blksize = atoi(optarg);
			if (blksize == 0 || (blksize & (blksize-1))) {
				(void) fprintf(stderr, INVALID_BLKSZ);
				exit(-1);
			}
			break;
		case '?':
			(void) fprintf(stderr, UNKNOWN_OPTION, optopt);
			exit(-1);
		}
	}
	if (argc - optind != 2) {
		(void) fprintf(stderr, MISS_FILES);
		exit(-1);
	}

	setup_infile(argv[optind]);
	setup_outfile(argv[optind + 1]);

	if (decompress)
		do_decomp();
	else {
		do_comp(blksize);
		if (doioc) {
			if (ioctl(dstfd, _FIO_COMPRESSED, 0) == -1) {
				(void) fprintf(stderr, FIO_COMP_FAIL,
				    dstfile, strerror(errno));
				exit(-1);
			}
		}
	}
	return (0);
}

static void
setup_infile(char *file)
{
	int fd;
	void *addr;
	struct stat stbuf;

	srcfile = file;

	fd = open(srcfile, O_RDONLY, 0);
	if (fd == -1) {
		(void) fprintf(stderr, CANT_OPEN,
		    srcfile, strerror(errno));
		exit(-1);
	}

	if (fstat(fd, &stbuf) == -1) {
		(void) fprintf(stderr, STAT_FAIL,
		    srcfile, strerror(errno));
		exit(-1);
	}
	srclen = stbuf.st_size;

	addr = mmap(0, srclen, PROT_READ, MAP_SHARED, fd, 0);
	if (addr == MAP_FAILED) {
		(void) fprintf(stderr, MMAP_FAIL, srcfile, strerror(errno));
		exit(-1);
	}
	srcaddr = addr;
}

static void
setup_outfile(char *file)
{
	int fd;

	dstfile = file;

	fd = open(dstfile, O_WRONLY | O_CREAT | O_TRUNC,
	    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
	if (fd == -1) {
		(void) fprintf(stderr, OPEN_FAIL, dstfile, strerror(errno));
		exit(-1);
	}
	dstfd = fd;
}

static void
do_comp(size_t blksize)
{
	struct comphdr *hdr;
	off_t offset;
	size_t blks, dstlen, hlen;
	void *dstbuf;
	int i;

	blks = ((srclen - 1) / blksize) + 1;
	hlen = offset = sizeof (struct comphdr) + blks * sizeof (uint64_t);
	hdr = malloc(hlen);
	if (hdr == NULL) {
		(void) fprintf(stderr, HDR_ALLOC, hlen);
		exit(-1);
	}

	hdr->ch_magic = CH_MAGIC_ZLIB;
	hdr->ch_version = CH_VERSION;
	hdr->ch_algorithm = CH_ALG_ZLIB;
	hdr->ch_fsize = srclen;
	hdr->ch_blksize = blksize;

	dstlen = ZMAXBUF(blksize);
	dstbuf = malloc(dstlen);
	if (dstbuf == NULL) {
		(void) fprintf(stderr, BUF_ALLOC, dstlen);
		exit(-1);
	}

	if (lseek(dstfd, offset, SEEK_SET) == (off_t)-1) {
		(void) fprintf(stderr, SEEK_ERR,
		    offset, dstfile, strerror(errno));
		exit(-1);
	}

	for (i = 0; i < blks; i++) {
		ulong_t slen, dlen;
		int ret;

		hdr->ch_blkmap[i] = offset;
		slen = MIN(srclen, blksize);
		dlen = dstlen;
		ret = compress2(dstbuf, &dlen, (Bytef *)srcaddr, slen, 9);
		if (ret != Z_OK) {
			(void) fprintf(stderr, COMP_ERR, srcfile, ret);
			exit(-1);
		}

		if (write(dstfd, dstbuf, dlen) != dlen) {
			(void) fprintf(stderr, WRITE_ERR,
			    dlen, dstfile, strerror(errno));
			exit(-1);
		}

		offset += dlen;
		srclen -= slen;
		srcaddr += slen;
	}

	if (lseek(dstfd, 0, SEEK_SET) == (off_t)-1) {
		(void) fprintf(stderr, SEEK_ERR,
		    0, dstfile, strerror(errno));
		exit(-1);
	}

	if (write(dstfd, hdr, hlen) != hlen) {
		(void) fprintf(stderr, WRITE_ERR,
		    hlen, dstfile, strerror(errno));
		exit(-1);
	}
}

static void
do_decomp()
{
	struct comphdr *hdr;
	size_t blks, blksize;
	void *dstbuf;
	int i;
	ulong_t slen, dlen;
	int ret;

	hdr = (struct comphdr *)(void *)srcaddr;
	if (hdr->ch_magic != CH_MAGIC_ZLIB) {
		(void) fprintf(stderr, BAD_MAGIC,
		    srcfile, (uint64_t)hdr->ch_magic, CH_MAGIC_ZLIB);
		exit(-1);
	}
	if (hdr->ch_version != CH_VERSION) {
		(void) fprintf(stderr, BAD_VERS,
		    srcfile, (uint64_t)hdr->ch_version, CH_VERSION);
		exit(-1);
	}
	if (hdr->ch_algorithm != CH_ALG_ZLIB) {
		(void) fprintf(stderr, BAD_ALG,
		    srcfile, (uint64_t)hdr->ch_algorithm, CH_ALG_ZLIB);
		exit(-1);
	}

	blksize = hdr->ch_blksize;
	dstbuf = malloc(blksize);
	if (dstbuf == NULL) {
		(void) fprintf(stderr, HDR_ALLOC, blksize);
		exit(-1);
	}

	blks = (hdr->ch_fsize - 1) / blksize;
	srcaddr += hdr->ch_blkmap[0];
	for (i = 0; i < blks; i++) {
		dlen = blksize;
		slen = hdr->ch_blkmap[i + 1] - hdr->ch_blkmap[i];
		ret = uncompress(dstbuf, &dlen, (Bytef *)srcaddr, slen);
		if (ret != Z_OK) {
			(void) fprintf(stderr, DECOMP_ERR, srcfile, ret);
			exit(-1);
		}

		if (dlen != blksize) {
			(void) fprintf(stderr, CORRUPT, srcfile);
			exit(-1);
		}
		if (write(dstfd, dstbuf, dlen) != dlen) {
			(void) fprintf(stderr, WRITE_ERR,
			    dlen, dstfile, strerror(errno));
			exit(-1);
		}
		srcaddr += slen;
	}

	dlen = blksize;
	slen = hdr->ch_fsize - hdr->ch_blkmap[i];
	if ((ret = uncompress(dstbuf, &dlen, (Bytef *)srcaddr, slen)) != Z_OK) {
		(void) fprintf(stderr, DECOMP_ERR, dstfile, ret);
		exit(-1);
	}

	if (write(dstfd, dstbuf, dlen) != dlen) {
		(void) fprintf(stderr, WRITE_ERR,
		    dlen, dstfile, strerror(errno));
		exit(-1);
	}
}