/*
* Copyright (c) 2010, 2011, 2012, 2013
* Phillip Lougher <phillip@squashfs.org.uk>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2,
* or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* xz_wrapper.c
*
* Support for XZ (LZMA2) compression using XZ Utils liblzma
* http://tukaani.org/xz/
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <lzma.h>
#include "squashfs_fs.h"
#include "xz_wrapper.h"
#include "compressor.h"
static struct bcj bcj[] = {
{ "x86", LZMA_FILTER_X86, 0 },
{ "powerpc", LZMA_FILTER_POWERPC, 0 },
{ "ia64", LZMA_FILTER_IA64, 0 },
{ "arm", LZMA_FILTER_ARM, 0 },
{ "armthumb", LZMA_FILTER_ARMTHUMB, 0 },
{ "sparc", LZMA_FILTER_SPARC, 0 },
{ NULL, LZMA_VLI_UNKNOWN, 0 }
};
static int filter_count = 1;
static int dictionary_size = 0;
static float dictionary_percent = 0;
/*
* This function is called by the options parsing code in mksquashfs.c
* to parse any -X compressor option.
*
* Two specific options are supported:
* -Xbcj
* -Xdict-size
*
* This function returns:
* >=0 (number of additional args parsed) on success
* -1 if the option was unrecognised, or
* -2 if the option was recognised, but otherwise bad in
* some way (e.g. invalid parameter)
*
* Note: this function sets internal compressor state, but does not
* pass back the results of the parsing other than success/failure.
* The xz_dump_options() function is called later to get the options in
* a format suitable for writing to the filesystem.
*/
static int xz_options(char *argv[], int argc)
{
int i;
char *name;
if(strcmp(argv[0], "-Xbcj") == 0) {
if(argc < 2) {
fprintf(stderr, "xz: -Xbcj missing filter\n");
goto failed;
}
name = argv[1];
while(name[0] != '\0') {
for(i = 0; bcj[i].name; i++) {
int n = strlen(bcj[i].name);
if((strncmp(name, bcj[i].name, n) == 0) &&
(name[n] == '\0' ||
name[n] == ',')) {
if(bcj[i].selected == 0) {
bcj[i].selected = 1;
filter_count++;
}
name += name[n] == ',' ? n + 1 : n;
break;
}
}
if(bcj[i].name == NULL) {
fprintf(stderr, "xz: -Xbcj unrecognised "
"filter\n");
goto failed;
}
}
return 1;
} else if(strcmp(argv[0], "-Xdict-size") == 0) {
char *b;
float size;
if(argc < 2) {
fprintf(stderr, "xz: -Xdict-size missing dict-size\n");
goto failed;
}
size = strtof(argv[1], &b);
if(*b == '%') {
if(size <= 0 || size > 100) {
fprintf(stderr, "xz: -Xdict-size percentage "
"should be 0 < dict-size <= 100\n");
goto failed;
}
dictionary_percent = size;
dictionary_size = 0;
} else {
if((float) ((int) size) != size) {
fprintf(stderr, "xz: -Xdict-size can't be "
"fractional unless a percentage of the"
" block size\n");
goto failed;
}
dictionary_percent = 0;
dictionary_size = (int) size;
if(*b == 'k' || *b == 'K')
dictionary_size *= 1024;
else if(*b == 'm' || *b == 'M')
dictionary_size *= 1024 * 1024;
else if(*b != '\0') {
fprintf(stderr, "xz: -Xdict-size invalid "
"dict-size\n");
goto failed;
}
}
return 1;
}
return -1;
failed:
return -2;
}
/*
* This function is called after all options have been parsed.
* It is used to do post-processing on the compressor options using
* values that were not expected to be known at option parse time.
*
* In this case block_size may not be known until after -Xdict-size has
* been processed (in the case where -b is specified after -Xdict-size)
*
* This function returns 0 on successful post processing, or
* -1 on error
*/
static int xz_options_post(int block_size)
{
/*
* if -Xdict-size has been specified use this to compute the datablock
* dictionary size
*/
if(dictionary_size || dictionary_percent) {
int n;
if(dictionary_size) {
if(dictionary_size > block_size) {
fprintf(stderr, "xz: -Xdict-size is larger than"
" block_size\n");
goto failed;
}
} else
dictionary_size = block_size * dictionary_percent / 100;
if(dictionary_size < 8192) {
fprintf(stderr, "xz: -Xdict-size should be 8192 bytes "
"or larger\n");
goto failed;
}
/*
* dictionary_size must be storable in xz header as either
* 2^n or as 2^n+2^(n+1)
*/
n = ffs(dictionary_size) - 1;
if(dictionary_size != (1 << n) &&
dictionary_size != ((1 << n) + (1 << (n + 1)))) {
fprintf(stderr, "xz: -Xdict-size is an unsupported "
"value, dict-size must be storable in xz "
"header\n");
fprintf(stderr, "as either 2^n or as 2^n+2^(n+1). "
"Example dict-sizes are 75%%, 50%%, 37.5%%, "
"25%%,\n");
fprintf(stderr, "or 32K, 16K, 8K etc.\n");
goto failed;
}
} else
/* No -Xdict-size specified, use defaults */
dictionary_size = block_size;
return 0;
failed:
return -1;
}
/*
* This function is called by mksquashfs to dump the parsed
* compressor options in a format suitable for writing to the
* compressor options field in the filesystem (stored immediately
* after the superblock).
*
* This function returns a pointer to the compression options structure
* to be stored (and the size), or NULL if there are no compression
* options
*/
static void *xz_dump_options(int block_size, int *size)
{
static struct comp_opts comp_opts;
int flags = 0, i;
/*
* don't store compressor specific options in file system if the
* default options are being used - no compressor options in the
* file system means the default options are always assumed
*
* Defaults are:
* metadata dictionary size: SQUASHFS_METADATA_SIZE
* datablock dictionary size: block_size
* 1 filter
*/
if(dictionary_size == block_size && filter_count == 1)
return NULL;
for(i = 0; bcj[i].name; i++)
flags |= bcj[i].selected << i;
comp_opts.dictionary_size = dictionary_size;
comp_opts.flags = flags;
SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
*size = sizeof(comp_opts);
return &comp_opts;
}
/*
* This function is a helper specifically for the append mode of
* mksquashfs. Its purpose is to set the internal compressor state
* to the stored compressor options in the passed compressor options
* structure.
*
* In effect this function sets up the compressor options
* to the same state they were when the filesystem was originally
* generated, this is to ensure on appending, the compressor uses
* the same compression options that were used to generate the
* original filesystem.
*
* Note, even if there are no compressor options, this function is still
* called with an empty compressor structure (size == 0), to explicitly
* set the default options, this is to ensure any user supplied
* -X options on the appending mksquashfs command line are over-ridden
*
* This function returns 0 on sucessful extraction of options, and
* -1 on error
*/
static int xz_extract_options(int block_size, void *buffer, int size)
{
struct comp_opts *comp_opts = buffer;
int flags, i, n;
if(size == 0) {
/* set defaults */
dictionary_size = block_size;
flags = 0;
} else {
/* check passed comp opts struct is of the correct length */
if(size != sizeof(struct comp_opts))
goto failed;
SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
dictionary_size = comp_opts->dictionary_size;
flags = comp_opts->flags;
/*
* check that the dictionary size seems correct - the dictionary
* size should 2^n or 2^n+2^(n+1)
*/
n = ffs(dictionary_size) - 1;
if(dictionary_size != (1 << n) &&
dictionary_size != ((1 << n) + (1 << (n + 1))))
goto failed;
}
filter_count = 1;
for(i = 0; bcj[i].name; i++) {
if((flags >> i) & 1) {
bcj[i].selected = 1;
filter_count ++;
} else
bcj[i].selected = 0;
}
return 0;
failed:
fprintf(stderr, "xz: error reading stored compressor options from "
"filesystem!\n");
return -1;
}
void xz_display_options(void *buffer, int size)
{
struct comp_opts *comp_opts = buffer;
int dictionary_size, flags, printed;
int i, n;
/* check passed comp opts struct is of the correct length */
if(size != sizeof(struct comp_opts))
goto failed;
SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
dictionary_size = comp_opts->dictionary_size;
flags = comp_opts->flags;
/*
* check that the dictionary size seems correct - the dictionary
* size should 2^n or 2^n+2^(n+1)
*/
n = ffs(dictionary_size) - 1;
if(dictionary_size != (1 << n) &&
dictionary_size != ((1 << n) + (1 << (n + 1))))
goto failed;
printf("\tDictionary size %d\n", dictionary_size);
printed = 0;
for(i = 0; bcj[i].name; i++) {
if((flags >> i) & 1) {
if(printed)
printf(", ");
else
printf("\tFilters selected: ");
printf("%s", bcj[i].name);
printed = 1;
}
}
if(!printed)
printf("\tNo filters specified\n");
else
printf("\n");
return;
failed:
fprintf(stderr, "xz: error reading stored compressor options from "
"filesystem!\n");
}
/*
* This function is called by mksquashfs to initialise the
* compressor, before compress() is called.
*
* This function returns 0 on success, and
* -1 on error
*/
static int xz_init(void **strm, int block_size, int datablock)
{
int i, j, filters = datablock ? filter_count : 1;
struct filter *filter = malloc(filters * sizeof(struct filter));
struct xz_stream *stream;
if(filter == NULL)
goto failed;
stream = *strm = malloc(sizeof(struct xz_stream));
if(stream == NULL)
goto failed2;
stream->filter = filter;
stream->filters = filters;
memset(filter, 0, filters * sizeof(struct filter));
stream->dictionary_size = datablock ? dictionary_size :
SQUASHFS_METADATA_SIZE;
filter[0].filter[0].id = LZMA_FILTER_LZMA2;
filter[0].filter[0].options = &stream->opt;
filter[0].filter[1].id = LZMA_VLI_UNKNOWN;
for(i = 0, j = 1; datablock && bcj[i].name; i++) {
if(bcj[i].selected) {
filter[j].buffer = malloc(block_size);
if(filter[j].buffer == NULL)
goto failed3;
filter[j].filter[0].id = bcj[i].id;
filter[j].filter[1].id = LZMA_FILTER_LZMA2;
filter[j].filter[1].options = &stream->opt;
filter[j].filter[2].id = LZMA_VLI_UNKNOWN;
j++;
}
}
return 0;
failed3:
for(i = 1; i < filters; i++)
free(filter[i].buffer);
free(stream);
failed2:
free(filter);
failed:
return -1;
}
static int xz_compress(void *strm, void *dest, void *src, int size,
int block_size, int *error)
{
int i;
lzma_ret res = 0;
struct xz_stream *stream = strm;
struct filter *selected = NULL;
stream->filter[0].buffer = dest;
for(i = 0; i < stream->filters; i++) {
struct filter *filter = &stream->filter[i];
if(lzma_lzma_preset(&stream->opt, LZMA_PRESET_DEFAULT))
goto failed;
stream->opt.dict_size = stream->dictionary_size;
filter->length = 0;
res = lzma_stream_buffer_encode(filter->filter,
LZMA_CHECK_CRC32, NULL, src, size, filter->buffer,
&filter->length, block_size);
if(res == LZMA_OK) {
if(!selected || selected->length > filter->length)
selected = filter;
} else if(res != LZMA_BUF_ERROR)
goto failed;
}
if(!selected)
/*
* Output buffer overflow. Return out of buffer space
*/
return 0;
if(selected->buffer != dest)
memcpy(dest, selected->buffer, selected->length);
return (int) selected->length;
failed:
/*
* All other errors return failure, with the compressor
* specific error code in *error
*/
*error = res;
return -1;
}
static int xz_uncompress(void *dest, void *src, int size, int outsize,
int *error)
{
size_t src_pos = 0;
size_t dest_pos = 0;
uint64_t memlimit = MEMLIMIT;
lzma_ret res = lzma_stream_buffer_decode(&memlimit, 0, NULL,
src, &src_pos, size, dest, &dest_pos, outsize);
if(res == LZMA_OK && size == (int) src_pos)
return (int) dest_pos;
else {
*error = res;
return -1;
}
}
void xz_usage()
{
fprintf(stderr, "\t -Xbcj filter1,filter2,...,filterN\n");
fprintf(stderr, "\t\tCompress using filter1,filter2,...,filterN in");
fprintf(stderr, " turn\n\t\t(in addition to no filter), and choose");
fprintf(stderr, " the best compression.\n");
fprintf(stderr, "\t\tAvailable filters: x86, arm, armthumb,");
fprintf(stderr, " powerpc, sparc, ia64\n");
fprintf(stderr, "\t -Xdict-size <dict-size>\n");
fprintf(stderr, "\t\tUse <dict-size> as the XZ dictionary size. The");
fprintf(stderr, " dictionary size\n\t\tcan be specified as a");
fprintf(stderr, " percentage of the block size, or as an\n\t\t");
fprintf(stderr, "absolute value. The dictionary size must be less");
fprintf(stderr, " than or equal\n\t\tto the block size and 8192 bytes");
fprintf(stderr, " or larger. It must also be\n\t\tstorable in the xz");
fprintf(stderr, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
fprintf(stderr, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
fprintf(stderr, " 32K, 16K, 8K\n\t\tetc.\n");
}
struct compressor xz_comp_ops = {
.init = xz_init,
.compress = xz_compress,
.uncompress = xz_uncompress,
.options = xz_options,
.options_post = xz_options_post,
.dump_options = xz_dump_options,
.extract_options = xz_extract_options,
.display_options = xz_display_options,
.usage = xz_usage,
.id = XZ_COMPRESSION,
.name = "xz",
.supported = 1
};