]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/squashfs/block.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Squashfs - a compressed read only filesystem for Linux
5 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
6 * Phillip Lougher <phillip@squashfs.org.uk>
12 * This file implements the low-level routines to read and decompress
13 * datablocks and metadata blocks.
16 #include <linux/blkdev.h>
18 #include <linux/vfs.h>
19 #include <linux/slab.h>
20 #include <linux/string.h>
21 #include <linux/buffer_head.h>
22 #include <linux/bio.h>
24 #include "squashfs_fs.h"
25 #include "squashfs_fs_sb.h"
27 #include "decompressor.h"
28 #include "page_actor.h"
31 * Returns the amount of bytes copied to the page actor.
33 static int copy_bio_to_actor(struct bio
*bio
,
34 struct squashfs_page_actor
*actor
,
35 int offset
, int req_length
)
37 void *actor_addr
= squashfs_first_page(actor
);
38 struct bvec_iter_all iter_all
= {};
39 struct bio_vec
*bvec
= bvec_init_iter_all(&iter_all
);
43 if (WARN_ON_ONCE(!bio_next_segment(bio
, &iter_all
)))
46 while (copied_bytes
< req_length
) {
47 int bytes_to_copy
= min_t(int, bvec
->bv_len
- offset
,
48 PAGE_SIZE
- actor_offset
);
50 bytes_to_copy
= min_t(int, bytes_to_copy
,
51 req_length
- copied_bytes
);
52 memcpy(actor_addr
+ actor_offset
, bvec_virt(bvec
) + offset
,
55 actor_offset
+= bytes_to_copy
;
56 copied_bytes
+= bytes_to_copy
;
57 offset
+= bytes_to_copy
;
59 if (actor_offset
>= PAGE_SIZE
) {
60 actor_addr
= squashfs_next_page(actor
);
65 if (offset
>= bvec
->bv_len
) {
66 if (!bio_next_segment(bio
, &iter_all
))
71 squashfs_finish_page(actor
);
75 static int squashfs_bio_read(struct super_block
*sb
, u64 index
, int length
,
76 struct bio
**biop
, int *block_offset
)
78 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
79 const u64 read_start
= round_down(index
, msblk
->devblksize
);
80 const sector_t block
= read_start
>> msblk
->devblksize_log2
;
81 const u64 read_end
= round_up(index
+ length
, msblk
->devblksize
);
82 const sector_t block_end
= read_end
>> msblk
->devblksize_log2
;
83 int offset
= read_start
- round_down(index
, PAGE_SIZE
);
84 int total_len
= (block_end
- block
) << msblk
->devblksize_log2
;
85 const int page_count
= DIV_ROUND_UP(total_len
+ offset
, PAGE_SIZE
);
89 if (page_count
<= BIO_MAX_VECS
)
90 bio
= bio_alloc(GFP_NOIO
, page_count
);
92 bio
= bio_kmalloc(GFP_NOIO
, page_count
);
97 bio_set_dev(bio
, sb
->s_bdev
);
99 bio
->bi_iter
.bi_sector
= block
* (msblk
->devblksize
>> SECTOR_SHIFT
);
101 for (i
= 0; i
< page_count
; ++i
) {
103 min_t(unsigned int, PAGE_SIZE
- offset
, total_len
);
104 struct page
*page
= alloc_page(GFP_NOIO
);
110 if (!bio_add_page(bio
, page
, len
, offset
)) {
118 error
= submit_bio_wait(bio
);
123 *block_offset
= index
& ((1 << msblk
->devblksize_log2
) - 1);
133 * Read and decompress a metadata block or datablock. Length is non-zero
134 * if a datablock is being read (the size is stored elsewhere in the
135 * filesystem), otherwise the length is obtained from the first two bytes of
136 * the metadata block. A bit in the length field indicates if the block
137 * is stored uncompressed in the filesystem (usually because compression
138 * generated a larger block - this does occasionally happen with compression
141 int squashfs_read_data(struct super_block
*sb
, u64 index
, int length
,
142 u64
*next_index
, struct squashfs_page_actor
*output
)
144 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
145 struct bio
*bio
= NULL
;
154 compressed
= SQUASHFS_COMPRESSED_BLOCK(length
);
155 length
= SQUASHFS_COMPRESSED_SIZE_BLOCK(length
);
156 TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
157 index
, compressed
? "" : "un", length
, output
->length
);
163 struct bvec_iter_all iter_all
= {};
164 struct bio_vec
*bvec
= bvec_init_iter_all(&iter_all
);
166 if (index
+ 2 > msblk
->bytes_used
) {
170 res
= squashfs_bio_read(sb
, index
, 2, &bio
, &offset
);
174 if (WARN_ON_ONCE(!bio_next_segment(bio
, &iter_all
))) {
178 /* Extract the length of the metadata block */
179 data
= bvec_virt(bvec
);
180 length
= data
[offset
];
181 if (offset
< bvec
->bv_len
- 1) {
182 length
|= data
[offset
+ 1] << 8;
184 if (WARN_ON_ONCE(!bio_next_segment(bio
, &iter_all
))) {
188 data
= bvec_virt(bvec
);
189 length
|= data
[0] << 8;
194 compressed
= SQUASHFS_COMPRESSED(length
);
195 length
= SQUASHFS_COMPRESSED_SIZE(length
);
198 TRACE("Block @ 0x%llx, %scompressed size %d\n", index
- 2,
199 compressed
? "" : "un", length
);
201 if (length
< 0 || length
> output
->length
||
202 (index
+ length
) > msblk
->bytes_used
) {
208 *next_index
= index
+ length
;
210 res
= squashfs_bio_read(sb
, index
, length
, &bio
, &offset
);
215 if (!msblk
->stream
) {
219 res
= squashfs_decompress(msblk
, bio
, offset
, length
, output
);
221 res
= copy_bio_to_actor(bio
, output
, offset
, length
);
229 ERROR("Failed to read block 0x%llx: %d\n", index
, res
);
230 if (msblk
->panic_on_errors
)
231 panic("squashfs read failed");