]>
Commit | Line | Data |
---|---|---|
68252eb5 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
e2780ab1 PL |
2 | /* |
3 | * Squashfs - a compressed read only filesystem for Linux | |
4 | * | |
5 | * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 | |
d7f2ff67 | 6 | * Phillip Lougher <phillip@squashfs.org.uk> |
e2780ab1 | 7 | * |
e2780ab1 PL |
8 | * block.c |
9 | */ | |
10 | ||
11 | /* | |
12 | * This file implements the low-level routines to read and decompress | |
13 | * datablocks and metadata blocks. | |
14 | */ | |
15 | ||
16 | #include <linux/fs.h> | |
17 | #include <linux/vfs.h> | |
18 | #include <linux/slab.h> | |
e2780ab1 PL |
19 | #include <linux/string.h> |
20 | #include <linux/buffer_head.h> | |
2f8b5444 | 21 | #include <linux/bio.h> |
e2780ab1 PL |
22 | |
23 | #include "squashfs_fs.h" | |
24 | #include "squashfs_fs_sb.h" | |
e2780ab1 | 25 | #include "squashfs.h" |
4c0f0bb2 | 26 | #include "decompressor.h" |
846b730e | 27 | #include "page_actor.h" |
e2780ab1 PL |
28 | |
29 | /* | |
30 | * Read the metadata block length, this is stored in the first two | |
31 | * bytes of the metadata block. | |
32 | */ | |
33 | static struct buffer_head *get_block_length(struct super_block *sb, | |
34 | u64 *cur_index, int *offset, int *length) | |
35 | { | |
36 | struct squashfs_sb_info *msblk = sb->s_fs_info; | |
37 | struct buffer_head *bh; | |
38 | ||
39 | bh = sb_bread(sb, *cur_index); | |
40 | if (bh == NULL) | |
41 | return NULL; | |
42 | ||
43 | if (msblk->devblksize - *offset == 1) { | |
44 | *length = (unsigned char) bh->b_data[*offset]; | |
45 | put_bh(bh); | |
46 | bh = sb_bread(sb, ++(*cur_index)); | |
47 | if (bh == NULL) | |
48 | return NULL; | |
49 | *length |= (unsigned char) bh->b_data[0] << 8; | |
50 | *offset = 1; | |
51 | } else { | |
52 | *length = (unsigned char) bh->b_data[*offset] | | |
53 | (unsigned char) bh->b_data[*offset + 1] << 8; | |
54 | *offset += 2; | |
3689456b PL |
55 | |
56 | if (*offset == msblk->devblksize) { | |
57 | put_bh(bh); | |
58 | bh = sb_bread(sb, ++(*cur_index)); | |
59 | if (bh == NULL) | |
60 | return NULL; | |
61 | *offset = 0; | |
62 | } | |
e2780ab1 PL |
63 | } |
64 | ||
65 | return bh; | |
66 | } | |
67 | ||
68 | ||
69 | /* | |
70 | * Read and decompress a metadata block or datablock. Length is non-zero | |
71 | * if a datablock is being read (the size is stored elsewhere in the | |
72 | * filesystem), otherwise the length is obtained from the first two bytes of | |
73 | * the metadata block. A bit in the length field indicates if the block | |
74 | * is stored uncompressed in the filesystem (usually because compression | |
ec9267b6 PL |
75 | * generated a larger block - this does occasionally happen with compression |
76 | * algorithms). | |
e2780ab1 | 77 | */ |
846b730e PL |
78 | int squashfs_read_data(struct super_block *sb, u64 index, int length, |
79 | u64 *next_index, struct squashfs_page_actor *output) | |
e2780ab1 PL |
80 | { |
81 | struct squashfs_sb_info *msblk = sb->s_fs_info; | |
82 | struct buffer_head **bh; | |
83 | int offset = index & ((1 << msblk->devblksize_log2) - 1); | |
84 | u64 cur_index = index >> msblk->devblksize_log2; | |
846b730e | 85 | int bytes, compressed, b = 0, k = 0, avail, i; |
e2780ab1 | 86 | |
846b730e | 87 | bh = kcalloc(((output->length + msblk->devblksize - 1) |
e0d1f700 | 88 | >> msblk->devblksize_log2) + 1, sizeof(*bh), GFP_KERNEL); |
e2780ab1 PL |
89 | if (bh == NULL) |
90 | return -ENOMEM; | |
91 | ||
92 | if (length) { | |
93 | /* | |
94 | * Datablock. | |
95 | */ | |
96 | bytes = -offset; | |
97 | compressed = SQUASHFS_COMPRESSED_BLOCK(length); | |
98 | length = SQUASHFS_COMPRESSED_SIZE_BLOCK(length); | |
99 | if (next_index) | |
100 | *next_index = index + length; | |
101 | ||
102 | TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n", | |
846b730e | 103 | index, compressed ? "" : "un", length, output->length); |
e2780ab1 | 104 | |
846b730e | 105 | if (length < 0 || length > output->length || |
e2780ab1 PL |
106 | (index + length) > msblk->bytes_used) |
107 | goto read_failure; | |
108 | ||
109 | for (b = 0; bytes < length; b++, cur_index++) { | |
110 | bh[b] = sb_getblk(sb, cur_index); | |
111 | if (bh[b] == NULL) | |
112 | goto block_release; | |
113 | bytes += msblk->devblksize; | |
114 | } | |
dfec8a14 | 115 | ll_rw_block(REQ_OP_READ, 0, b, bh); |
e2780ab1 PL |
116 | } else { |
117 | /* | |
118 | * Metadata block. | |
119 | */ | |
120 | if ((index + 2) > msblk->bytes_used) | |
121 | goto read_failure; | |
122 | ||
123 | bh[0] = get_block_length(sb, &cur_index, &offset, &length); | |
124 | if (bh[0] == NULL) | |
125 | goto read_failure; | |
126 | b = 1; | |
127 | ||
128 | bytes = msblk->devblksize - offset; | |
129 | compressed = SQUASHFS_COMPRESSED(length); | |
130 | length = SQUASHFS_COMPRESSED_SIZE(length); | |
131 | if (next_index) | |
132 | *next_index = index + length + 2; | |
133 | ||
134 | TRACE("Block @ 0x%llx, %scompressed size %d\n", index, | |
135 | compressed ? "" : "un", length); | |
136 | ||
846b730e | 137 | if (length < 0 || length > output->length || |
e2780ab1 PL |
138 | (index + length) > msblk->bytes_used) |
139 | goto block_release; | |
140 | ||
141 | for (; bytes < length; b++) { | |
142 | bh[b] = sb_getblk(sb, ++cur_index); | |
143 | if (bh[b] == NULL) | |
144 | goto block_release; | |
145 | bytes += msblk->devblksize; | |
146 | } | |
dfec8a14 | 147 | ll_rw_block(REQ_OP_READ, 0, b - 1, bh + 1); |
e2780ab1 PL |
148 | } |
149 | ||
9508c6b9 PL |
150 | for (i = 0; i < b; i++) { |
151 | wait_on_buffer(bh[i]); | |
152 | if (!buffer_uptodate(bh[i])) | |
153 | goto block_release; | |
154 | } | |
155 | ||
e2780ab1 | 156 | if (compressed) { |
d5125847 LT |
157 | if (!msblk->stream) |
158 | goto read_failure; | |
846b730e PL |
159 | length = squashfs_decompress(msblk, bh, b, offset, length, |
160 | output); | |
e6a6d379 PL |
161 | if (length < 0) |
162 | goto read_failure; | |
e2780ab1 PL |
163 | } else { |
164 | /* | |
165 | * Block is uncompressed. | |
166 | */ | |
e0125262 | 167 | int in, pg_offset = 0; |
846b730e | 168 | void *data = squashfs_first_page(output); |
e2780ab1 PL |
169 | |
170 | for (bytes = length; k < b; k++) { | |
171 | in = min(bytes, msblk->devblksize - offset); | |
172 | bytes -= in; | |
173 | while (in) { | |
09cbfeaf | 174 | if (pg_offset == PAGE_SIZE) { |
846b730e | 175 | data = squashfs_next_page(output); |
e2780ab1 PL |
176 | pg_offset = 0; |
177 | } | |
09cbfeaf | 178 | avail = min_t(int, in, PAGE_SIZE - |
e2780ab1 | 179 | pg_offset); |
846b730e PL |
180 | memcpy(data + pg_offset, bh[k]->b_data + offset, |
181 | avail); | |
e2780ab1 PL |
182 | in -= avail; |
183 | pg_offset += avail; | |
184 | offset += avail; | |
185 | } | |
186 | offset = 0; | |
187 | put_bh(bh[k]); | |
188 | } | |
846b730e | 189 | squashfs_finish_page(output); |
e2780ab1 PL |
190 | } |
191 | ||
192 | kfree(bh); | |
193 | return length; | |
194 | ||
e2780ab1 PL |
195 | block_release: |
196 | for (; k < b; k++) | |
197 | put_bh(bh[k]); | |
198 | ||
199 | read_failure: | |
118e1ef6 PL |
200 | ERROR("squashfs_read_data failed to read block 0x%llx\n", |
201 | (unsigned long long) index); | |
e2780ab1 PL |
202 | kfree(bh); |
203 | return -EIO; | |
204 | } |