]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/squashfs/block.c
2 * Squashfs - a compressed read only filesystem for Linux
4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 * Phillip Lougher <phillip@squashfs.org.uk>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2,
10 * or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
25 * This file implements the low-level routines to read and decompress
26 * datablocks and metadata blocks.
30 #include <linux/vfs.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/buffer_head.h>
34 #include <linux/bio.h>
36 #include "squashfs_fs.h"
37 #include "squashfs_fs_sb.h"
39 #include "decompressor.h"
40 #include "page_actor.h"
43 * Read the metadata block length, this is stored in the first two
44 * bytes of the metadata block.
46 static struct buffer_head
*get_block_length(struct super_block
*sb
,
47 u64
*cur_index
, int *offset
, int *length
)
49 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
50 struct buffer_head
*bh
;
52 bh
= sb_bread(sb
, *cur_index
);
56 if (msblk
->devblksize
- *offset
== 1) {
57 *length
= (unsigned char) bh
->b_data
[*offset
];
59 bh
= sb_bread(sb
, ++(*cur_index
));
62 *length
|= (unsigned char) bh
->b_data
[0] << 8;
65 *length
= (unsigned char) bh
->b_data
[*offset
] |
66 (unsigned char) bh
->b_data
[*offset
+ 1] << 8;
69 if (*offset
== msblk
->devblksize
) {
71 bh
= sb_bread(sb
, ++(*cur_index
));
83 * Read and decompress a metadata block or datablock. Length is non-zero
84 * if a datablock is being read (the size is stored elsewhere in the
85 * filesystem), otherwise the length is obtained from the first two bytes of
86 * the metadata block. A bit in the length field indicates if the block
87 * is stored uncompressed in the filesystem (usually because compression
88 * generated a larger block - this does occasionally happen with compression
91 int squashfs_read_data(struct super_block
*sb
, u64 index
, int length
,
92 u64
*next_index
, struct squashfs_page_actor
*output
)
94 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
95 struct buffer_head
**bh
;
96 int offset
= index
& ((1 << msblk
->devblksize_log2
) - 1);
97 u64 cur_index
= index
>> msblk
->devblksize_log2
;
98 int bytes
, compressed
, b
= 0, k
= 0, avail
, i
;
100 bh
= kcalloc(((output
->length
+ msblk
->devblksize
- 1)
101 >> msblk
->devblksize_log2
) + 1, sizeof(*bh
), GFP_KERNEL
);
110 compressed
= SQUASHFS_COMPRESSED_BLOCK(length
);
111 length
= SQUASHFS_COMPRESSED_SIZE_BLOCK(length
);
113 *next_index
= index
+ length
;
115 TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
116 index
, compressed
? "" : "un", length
, output
->length
);
118 if (length
< 0 || length
> output
->length
||
119 (index
+ length
) > msblk
->bytes_used
)
122 for (b
= 0; bytes
< length
; b
++, cur_index
++) {
123 bh
[b
] = sb_getblk(sb
, cur_index
);
126 bytes
+= msblk
->devblksize
;
128 ll_rw_block(REQ_OP_READ
, 0, b
, bh
);
133 if ((index
+ 2) > msblk
->bytes_used
)
136 bh
[0] = get_block_length(sb
, &cur_index
, &offset
, &length
);
141 bytes
= msblk
->devblksize
- offset
;
142 compressed
= SQUASHFS_COMPRESSED(length
);
143 length
= SQUASHFS_COMPRESSED_SIZE(length
);
145 *next_index
= index
+ length
+ 2;
147 TRACE("Block @ 0x%llx, %scompressed size %d\n", index
,
148 compressed
? "" : "un", length
);
150 if (length
< 0 || length
> output
->length
||
151 (index
+ length
) > msblk
->bytes_used
)
154 for (; bytes
< length
; b
++) {
155 bh
[b
] = sb_getblk(sb
, ++cur_index
);
158 bytes
+= msblk
->devblksize
;
160 ll_rw_block(REQ_OP_READ
, 0, b
- 1, bh
+ 1);
163 for (i
= 0; i
< b
; i
++) {
164 wait_on_buffer(bh
[i
]);
165 if (!buffer_uptodate(bh
[i
]))
170 length
= squashfs_decompress(msblk
, bh
, b
, offset
, length
,
176 * Block is uncompressed.
178 int in
, pg_offset
= 0;
179 void *data
= squashfs_first_page(output
);
181 for (bytes
= length
; k
< b
; k
++) {
182 in
= min(bytes
, msblk
->devblksize
- offset
);
185 if (pg_offset
== PAGE_SIZE
) {
186 data
= squashfs_next_page(output
);
189 avail
= min_t(int, in
, PAGE_SIZE
-
191 memcpy(data
+ pg_offset
, bh
[k
]->b_data
+ offset
,
200 squashfs_finish_page(output
);
211 ERROR("squashfs_read_data failed to read block 0x%llx\n",
212 (unsigned long long) index
);