1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <assert.h>
18#include <stdlib.h>
19
20#include <sparse/sparse.h>
21
22#include "defs.h"
23#include "sparse_file.h"
24
25#include "output_file.h"
26#include "backed_block.h"
27#include "sparse_defs.h"
28#include "sparse_format.h"
29
30struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len)
31{
32	struct sparse_file *s = calloc(sizeof(struct sparse_file), 1);
33	if (!s) {
34		return NULL;
35	}
36
37	s->backed_block_list = backed_block_list_new(block_size);
38	if (!s->backed_block_list) {
39		free(s);
40		return NULL;
41	}
42
43	s->block_size = block_size;
44	s->len = len;
45
46	return s;
47}
48
49void sparse_file_destroy(struct sparse_file *s)
50{
51	backed_block_list_destroy(s->backed_block_list);
52	free(s);
53}
54
55int sparse_file_add_data(struct sparse_file *s,
56		void *data, unsigned int len, unsigned int block)
57{
58	return backed_block_add_data(s->backed_block_list, data, len, block);
59}
60
61int sparse_file_add_fill(struct sparse_file *s,
62		uint32_t fill_val, unsigned int len, unsigned int block)
63{
64	return backed_block_add_fill(s->backed_block_list, fill_val, len, block);
65}
66
67int sparse_file_add_file(struct sparse_file *s,
68		const char *filename, int64_t file_offset, unsigned int len,
69		unsigned int block)
70{
71	return backed_block_add_file(s->backed_block_list, filename, file_offset,
72			len, block);
73}
74
75int sparse_file_add_fd(struct sparse_file *s,
76		int fd, int64_t file_offset, unsigned int len, unsigned int block)
77{
78	return backed_block_add_fd(s->backed_block_list, fd, file_offset,
79			len, block);
80}
81unsigned int sparse_count_chunks(struct sparse_file *s)
82{
83	struct backed_block *bb;
84	unsigned int last_block = 0;
85	unsigned int chunks = 0;
86
87	for (bb = backed_block_iter_new(s->backed_block_list); bb;
88			bb = backed_block_iter_next(bb)) {
89		if (backed_block_block(bb) > last_block) {
90			/* If there is a gap between chunks, add a skip chunk */
91			chunks++;
92		}
93		chunks++;
94		last_block = backed_block_block(bb) +
95				DIV_ROUND_UP(backed_block_len(bb), s->block_size);
96	}
97	if (last_block < DIV_ROUND_UP(s->len, s->block_size)) {
98		chunks++;
99	}
100
101	return chunks;
102}
103
104static void sparse_file_write_block(struct output_file *out,
105		struct backed_block *bb)
106{
107	switch (backed_block_type(bb)) {
108	case BACKED_BLOCK_DATA:
109		write_data_chunk(out, backed_block_len(bb), backed_block_data(bb));
110		break;
111	case BACKED_BLOCK_FILE:
112		write_file_chunk(out, backed_block_len(bb),
113				backed_block_filename(bb), backed_block_file_offset(bb));
114		break;
115	case BACKED_BLOCK_FD:
116		write_fd_chunk(out, backed_block_len(bb),
117				backed_block_fd(bb), backed_block_file_offset(bb));
118		break;
119	case BACKED_BLOCK_FILL:
120		write_fill_chunk(out, backed_block_len(bb),
121				backed_block_fill_val(bb));
122		break;
123	}
124}
125
126static int write_all_blocks(struct sparse_file *s, struct output_file *out)
127{
128	struct backed_block *bb;
129	unsigned int last_block = 0;
130	int64_t pad;
131
132	for (bb = backed_block_iter_new(s->backed_block_list); bb;
133			bb = backed_block_iter_next(bb)) {
134		if (backed_block_block(bb) > last_block) {
135			unsigned int blocks = backed_block_block(bb) - last_block;
136			write_skip_chunk(out, (int64_t)blocks * s->block_size);
137		}
138		sparse_file_write_block(out, bb);
139		last_block = backed_block_block(bb) +
140				DIV_ROUND_UP(backed_block_len(bb), s->block_size);
141	}
142
143	pad = s->len - (int64_t)last_block * s->block_size;
144	assert(pad >= 0);
145	if (pad > 0) {
146		write_skip_chunk(out, pad);
147	}
148
149	return 0;
150}
151
152int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse,
153		bool crc)
154{
155	int ret;
156	int chunks;
157	struct output_file *out;
158
159	chunks = sparse_count_chunks(s);
160	out = output_file_open_fd(fd, s->block_size, s->len, gz, sparse, chunks, crc);
161
162	if (!out)
163		return -ENOMEM;
164
165	ret = write_all_blocks(s, out);
166
167	output_file_close(out);
168
169	return ret;
170}
171
172int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc,
173		int (*write)(void *priv, const void *data, int len), void *priv)
174{
175	int ret;
176	int chunks;
177	struct output_file *out;
178
179	chunks = sparse_count_chunks(s);
180	out = output_file_open_callback(write, priv, s->block_size, s->len, false,
181			sparse, chunks, crc);
182
183	if (!out)
184		return -ENOMEM;
185
186	ret = write_all_blocks(s, out);
187
188	output_file_close(out);
189
190	return ret;
191}
192
193static int out_counter_write(void *priv, const void *data __unused, int len)
194{
195	int64_t *count = priv;
196	*count += len;
197	return 0;
198}
199
200int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc)
201{
202	int ret;
203	int chunks = sparse_count_chunks(s);
204	int64_t count = 0;
205	struct output_file *out;
206
207	out = output_file_open_callback(out_counter_write, &count,
208			s->block_size, s->len, false, sparse, chunks, crc);
209	if (!out) {
210		return -1;
211	}
212
213	ret = write_all_blocks(s, out);
214
215	output_file_close(out);
216
217	if (ret < 0) {
218		return -1;
219	}
220
221	return count;
222}
223
224static struct backed_block *move_chunks_up_to_len(struct sparse_file *from,
225		struct sparse_file *to, unsigned int len)
226{
227	int64_t count = 0;
228	struct output_file *out_counter;
229	struct backed_block *last_bb = NULL;
230	struct backed_block *bb;
231	struct backed_block *start;
232	int64_t file_len = 0;
233
234	/*
235	 * overhead is sparse file header, initial skip chunk, split chunk, end
236	 * skip chunk, and crc chunk.
237	 */
238	int overhead = sizeof(sparse_header_t) + 4 * sizeof(chunk_header_t) +
239			sizeof(uint32_t);
240	len -= overhead;
241
242	start = backed_block_iter_new(from->backed_block_list);
243	out_counter = output_file_open_callback(out_counter_write, &count,
244			to->block_size, to->len, false, true, 0, false);
245	if (!out_counter) {
246		return NULL;
247	}
248
249	for (bb = start; bb; bb = backed_block_iter_next(bb)) {
250		count = 0;
251		/* will call out_counter_write to update count */
252		sparse_file_write_block(out_counter, bb);
253		if (file_len + count > len) {
254			/*
255			 * If the remaining available size is more than 1/8th of the
256			 * requested size, split the chunk.  Results in sparse files that
257			 * are at least 7/8ths of the requested size
258			 */
259			if (!last_bb || (len - file_len > (len / 8))) {
260				backed_block_split(from->backed_block_list, bb, len - file_len);
261				last_bb = bb;
262			}
263			goto out;
264		}
265		file_len += count;
266		last_bb = bb;
267	}
268
269out:
270	backed_block_list_move(from->backed_block_list,
271		to->backed_block_list, start, last_bb);
272
273	output_file_close(out_counter);
274
275	return bb;
276}
277
278int sparse_file_resparse(struct sparse_file *in_s, unsigned int max_len,
279		struct sparse_file **out_s, int out_s_count)
280{
281	struct backed_block *bb;
282	struct sparse_file *s;
283	struct sparse_file *tmp;
284	int c = 0;
285
286	tmp = sparse_file_new(in_s->block_size, in_s->len);
287	if (!tmp) {
288		return -ENOMEM;
289	}
290
291	do {
292		s = sparse_file_new(in_s->block_size, in_s->len);
293
294		bb = move_chunks_up_to_len(in_s, s, max_len);
295
296		if (c < out_s_count) {
297			out_s[c] = s;
298		} else {
299			backed_block_list_move(s->backed_block_list, tmp->backed_block_list,
300					NULL, NULL);
301			sparse_file_destroy(s);
302		}
303		c++;
304	} while (bb);
305
306	backed_block_list_move(tmp->backed_block_list, in_s->backed_block_list,
307			NULL, NULL);
308
309	sparse_file_destroy(tmp);
310
311	return c;
312}
313
314void sparse_file_verbose(struct sparse_file *s)
315{
316	s->verbose = true;
317}
318