platform_system_core/libsparse/sparse.c

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <assert.h>
#include <stdlib.h>

#include <sparse/sparse.h>

#include "defs.h"
#include "sparse_file.h"

#include "output_file.h"
#include "backed_block.h"
#include "sparse_defs.h"
#include "sparse_format.h"

struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len)
{
	struct sparse_file *s = calloc(sizeof(struct sparse_file), 1);
	if (!s) {
		return NULL;
	}

	s->backed_block_list = backed_block_list_new(block_size);
	if (!s->backed_block_list) {
		free(s);
		return NULL;
	}

	s->block_size = block_size;
	s->len = len;

	return s;
}

void sparse_file_destroy(struct sparse_file *s)
{
	backed_block_list_destroy(s->backed_block_list);
	free(s);
}

int sparse_file_add_data(struct sparse_file *s,
		void *data, unsigned int len, unsigned int block)
{
	return backed_block_add_data(s->backed_block_list, data, len, block);
}

int sparse_file_add_fill(struct sparse_file *s,
		uint32_t fill_val, unsigned int len, unsigned int block)
{
	return backed_block_add_fill(s->backed_block_list, fill_val, len, block);
}

int sparse_file_add_file(struct sparse_file *s,
		const char *filename, int64_t file_offset, unsigned int len,
		unsigned int block)
{
	return backed_block_add_file(s->backed_block_list, filename, file_offset,
			len, block);
}

int sparse_file_add_fd(struct sparse_file *s,
		int fd, int64_t file_offset, unsigned int len, unsigned int block)
{
	return backed_block_add_fd(s->backed_block_list, fd, file_offset,
			len, block);
}
unsigned int sparse_count_chunks(struct sparse_file *s)
{
	struct backed_block *bb;
	unsigned int last_block = 0;
	unsigned int chunks = 0;

	for (bb = backed_block_iter_new(s->backed_block_list); bb;
			bb = backed_block_iter_next(bb)) {
		if (backed_block_block(bb) > last_block) {
			/* If there is a gap between chunks, add a skip chunk */
			chunks++;
		}
		chunks++;
		last_block = backed_block_block(bb) +
				DIV_ROUND_UP(backed_block_len(bb), s->block_size);
	}
	if (last_block < DIV_ROUND_UP(s->len, s->block_size)) {
		chunks++;
	}

	return chunks;
}

static int sparse_file_write_block(struct output_file *out,
		struct backed_block *bb)
{
	int ret = -EINVAL;

	switch (backed_block_type(bb)) {
	case BACKED_BLOCK_DATA:
		ret = write_data_chunk(out, backed_block_len(bb), backed_block_data(bb));
		break;
	case BACKED_BLOCK_FILE:
		ret = write_file_chunk(out, backed_block_len(bb),
				       backed_block_filename(bb),
				       backed_block_file_offset(bb));
		break;
	case BACKED_BLOCK_FD:
		ret = write_fd_chunk(out, backed_block_len(bb),
				     backed_block_fd(bb),
				     backed_block_file_offset(bb));
		break;
	case BACKED_BLOCK_FILL:
		ret = write_fill_chunk(out, backed_block_len(bb),
				       backed_block_fill_val(bb));
		break;
	}

	return ret;
}

static int write_all_blocks(struct sparse_file *s, struct output_file *out)
{
	struct backed_block *bb;
	unsigned int last_block = 0;
	int64_t pad;
	int ret = 0;

	for (bb = backed_block_iter_new(s->backed_block_list); bb;
			bb = backed_block_iter_next(bb)) {
		if (backed_block_block(bb) > last_block) {
			unsigned int blocks = backed_block_block(bb) - last_block;
			write_skip_chunk(out, (int64_t)blocks * s->block_size);
		}
		ret = sparse_file_write_block(out, bb);
		if (ret)
			return ret;
		last_block = backed_block_block(bb) +
				DIV_ROUND_UP(backed_block_len(bb), s->block_size);
	}

	pad = s->len - (int64_t)last_block * s->block_size;
	assert(pad >= 0);
	if (pad > 0) {
		write_skip_chunk(out, pad);
	}

	return 0;
}

int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
		bool crc)
{
	int ret;
	int chunks;
	struct output_file *out;

	chunks = sparse_count_chunks(s);
	out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc);

	if (!out)
		return -ENOMEM;

	ret = write_all_blocks(s, out);

	output_file_close(out);

	return ret;
}

int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc,
		int (*write)(void *priv, const void *data, size_t len), void *priv)
{
	int ret;
	int chunks;
	struct output_file *out;

	chunks = sparse_count_chunks(s);
	out = output_file_open_callback(write, priv, s->block_size, s->len, false,
			sparse, chunks, crc);

	if (!out)
		return -ENOMEM;

	ret = write_all_blocks(s, out);

	output_file_close(out);

	return ret;
}

struct chunk_data {
	void		*priv;
	unsigned int	block;
	unsigned int	nr_blocks;
	int (*write)(void *priv, const void *data, size_t len,
		     unsigned int block, unsigned int nr_blocks);
};

static int foreach_chunk_write(void *priv, const void *data, size_t len)
{
	struct chunk_data *chk = priv;

	return chk->write(chk->priv, data, len, chk->block, chk->nr_blocks);
}

int sparse_file_foreach_chunk(struct sparse_file *s, bool sparse, bool crc,
	int (*write)(void *priv, const void *data, size_t len, unsigned int block,
		     unsigned int nr_blocks),
	void *priv)
{
	int ret;
	int chunks;
	struct chunk_data chk;
	struct output_file *out;
	struct backed_block *bb;

	chk.priv = priv;
	chk.write = write;
	chk.block = chk.nr_blocks = 0;
	chunks = sparse_count_chunks(s);
	out = output_file_open_callback(foreach_chunk_write, &chk,
					s->block_size, s->len, false, sparse,
					chunks, crc);

	if (!out)
		return -ENOMEM;

	for (bb = backed_block_iter_new(s->backed_block_list); bb;
			bb = backed_block_iter_next(bb)) {
		chk.block = backed_block_block(bb);
		chk.nr_blocks = (backed_block_len(bb) - 1) / s->block_size + 1;
		ret = sparse_file_write_block(out, bb);
		if (ret)
			return ret;
	}

	output_file_close(out);

	return ret;
}

static int out_counter_write(void *priv, const void *data __unused, size_t len)
{
	int64_t *count = priv;
	*count += len;
	return 0;
}

int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc)
{
	int ret;
	int chunks = sparse_count_chunks(s);
	int64_t count = 0;
	struct output_file *out;

	out = output_file_open_callback(out_counter_write, &count,
			s->block_size, s->len, false, sparse, chunks, crc);
	if (!out) {
		return -1;
	}

	ret = write_all_blocks(s, out);

	output_file_close(out);

	if (ret < 0) {
		return -1;
	}

	return count;
}

unsigned int sparse_file_block_size(struct sparse_file *s)
{
	return s->block_size;
}

static struct backed_block *move_chunks_up_to_len(struct sparse_file *from,
		struct sparse_file *to, unsigned int len)
{
	int64_t count = 0;
	struct output_file *out_counter;
	struct backed_block *last_bb = NULL;
	struct backed_block *bb;
	struct backed_block *start;
	unsigned int last_block = 0;
	int64_t file_len = 0;
	int ret;

	/*
	 * overhead is sparse file header, the potential end skip
	 * chunk and crc chunk.
	 */
	int overhead = sizeof(sparse_header_t) + 2 * sizeof(chunk_header_t) +
			sizeof(uint32_t);
	len -= overhead;

	start = backed_block_iter_new(from->backed_block_list);
	out_counter = output_file_open_callback(out_counter_write, &count,
			to->block_size, to->len, false, true, 0, false);
	if (!out_counter) {
		return NULL;
	}

	for (bb = start; bb; bb = backed_block_iter_next(bb)) {
		count = 0;
		if (backed_block_block(bb) > last_block)
			count += sizeof(chunk_header_t);
		last_block = backed_block_block(bb) +
				DIV_ROUND_UP(backed_block_len(bb), to->block_size);

		/* will call out_counter_write to update count */
		ret = sparse_file_write_block(out_counter, bb);
		if (ret) {
			bb = NULL;
			goto out;
		}
		if (file_len + count > len) {
			/*
			 * If the remaining available size is more than 1/8th of the
			 * requested size, split the chunk.  Results in sparse files that
			 * are at least 7/8ths of the requested size
			 */
			file_len += sizeof(chunk_header_t);
			if (!last_bb || (len - file_len > (len / 8))) {
				backed_block_split(from->backed_block_list, bb, len - file_len);
				last_bb = bb;
			}
			goto move;
		}
		file_len += count;
		last_bb = bb;
	}

move:
	backed_block_list_move(from->backed_block_list,
		to->backed_block_list, start, last_bb);

out:
	output_file_close(out_counter);

	return bb;
}

int sparse_file_resparse(struct sparse_file *in_s, unsigned int max_len,
		struct sparse_file **out_s, int out_s_count)
{
	struct backed_block *bb;
	struct sparse_file *s;
	struct sparse_file *tmp;
	int c = 0;

	tmp = sparse_file_new(in_s->block_size, in_s->len);
	if (!tmp) {
		return -ENOMEM;
	}

	do {
		s = sparse_file_new(in_s->block_size, in_s->len);

		bb = move_chunks_up_to_len(in_s, s, max_len);

		if (c < out_s_count) {
			out_s[c] = s;
		} else {
			backed_block_list_move(s->backed_block_list, tmp->backed_block_list,
					NULL, NULL);
			sparse_file_destroy(s);
		}
		c++;
	} while (bb);

	backed_block_list_move(tmp->backed_block_list, in_s->backed_block_list,
			NULL, NULL);

	sparse_file_destroy(tmp);

	return c;
}

void sparse_file_verbose(struct sparse_file *s)
{
	s->verbose = true;
}