aboutsummaryrefslogtreecommitdiff
path: root/lib/sqfs/blk_proc/process_block.c
blob: 2951406dacf6fbfd22d59e1b4d75c6c380dba04e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/* SPDX-License-Identifier: LGPL-3.0-or-later */
/*
 * process_block.c
 *
 * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
 */
#define SQFS_BUILDING_DLL
#include "internal.h"

#include <string.h>

static int allign_file(sqfs_block_processor_t *proc, sqfs_block_t *blk)
{
	if (!(blk->flags & SQFS_BLK_ALLIGN))
		return 0;

	return padd_sqfs(proc->file, proc->file->get_size(proc->file),
			 proc->devblksz);
}

int process_completed_block(sqfs_block_processor_t *proc, sqfs_block_t *blk)
{
	size_t start, count;
	uint64_t offset;
	uint32_t out;
	int err;

	if (blk->flags & SQFS_BLK_FIRST_BLOCK) {
		proc->start = proc->file->get_size(proc->file);
		proc->file_start = proc->num_blocks;

		err = allign_file(proc, blk);
		if (err)
			return err;
	}

	if (blk->size != 0) {
		out = blk->size;
		if (!(blk->flags & SQFS_BLK_IS_COMPRESSED))
			out |= 1 << 24;

		offset = proc->file->get_size(proc->file);

		if (blk->flags & SQFS_BLK_FRAGMENT_BLOCK) {
			offset = htole64(offset);
			proc->fragments[blk->index].start_offset = offset;
			proc->fragments[blk->index].pad0 = 0;
			proc->fragments[blk->index].size = htole32(out);
		} else {
			blk->inode->block_sizes[blk->index] = out;
		}

		err = store_block_location(proc, offset, out, blk->checksum);
		if (err)
			return err;

		err = proc->file->write_at(proc->file, offset,
					   blk->data, blk->size);
		if (err)
			return err;
	}

	if (blk->flags & SQFS_BLK_LAST_BLOCK) {
		err = allign_file(proc, blk);
		if (err)
			return err;

		count = proc->num_blocks - proc->file_start;
		start = deduplicate_blocks(proc, count);
		offset = proc->blocks[start].offset;

		sqfs_inode_set_file_block_start(blk->inode, offset);

		if (start < proc->file_start) {
			offset = start + count;

			if (offset >= proc->file_start) {
				proc->num_blocks = offset;
			} else {
				proc->num_blocks = proc->file_start;
			}

			err = proc->file->truncate(proc->file, proc->start);
			if (err)
				return err;
		}
	}

	return 0;
}