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>
35 #include "squashfs_fs.h"
36 #include "squashfs_fs_sb.h"
38 #include "decompressor.h"
39 #include "page_actor.h"
42 * Read the metadata block length, this is stored in the first two
43 * bytes of the metadata block.
45 static struct buffer_head
*get_block_length(struct super_block
*sb
,
46 u64
*cur_index
, int *offset
, int *length
)
48 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
49 struct buffer_head
*bh
;
51 bh
= sb_bread(sb
, *cur_index
);
55 if (msblk
->devblksize
- *offset
== 1) {
56 *length
= (unsigned char) bh
->b_data
[*offset
];
58 bh
= sb_bread(sb
, ++(*cur_index
));
61 *length
|= (unsigned char) bh
->b_data
[0] << 8;
64 *length
= (unsigned char) bh
->b_data
[*offset
] |
65 (unsigned char) bh
->b_data
[*offset
+ 1] << 8;
68 if (*offset
== msblk
->devblksize
) {
70 bh
= sb_bread(sb
, ++(*cur_index
));
82 * Read and decompress a metadata block or datablock. Length is non-zero
83 * if a datablock is being read (the size is stored elsewhere in the
84 * filesystem), otherwise the length is obtained from the first two bytes of
85 * the metadata block. A bit in the length field indicates if the block
86 * is stored uncompressed in the filesystem (usually because compression
87 * generated a larger block - this does occasionally happen with compression
90 int squashfs_read_data(struct super_block
*sb
, u64 index
, int length
,
91 u64
*next_index
, struct squashfs_page_actor
*output
)
93 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
94 struct buffer_head
**bh
;
95 int offset
= index
& ((1 << msblk
->devblksize_log2
) - 1);
96 u64 cur_index
= index
>> msblk
->devblksize_log2
;
97 int bytes
, compressed
, b
= 0, k
= 0, avail
, i
;
99 bh
= kcalloc(((output
->length
+ msblk
->devblksize
- 1)
100 >> msblk
->devblksize_log2
) + 1, sizeof(*bh
), GFP_KERNEL
);
109 compressed
= SQUASHFS_COMPRESSED_BLOCK(length
);
110 length
= SQUASHFS_COMPRESSED_SIZE_BLOCK(length
);
112 *next_index
= index
+ length
;
114 TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
115 index
, compressed
? "" : "un", length
, output
->length
);
117 if (length
< 0 || length
> output
->length
||
118 (index
+ length
) > msblk
->bytes_used
)
121 for (b
= 0; bytes
< length
; b
++, cur_index
++) {
122 bh
[b
] = sb_getblk(sb
, cur_index
);
125 bytes
+= msblk
->devblksize
;
127 ll_rw_block(READ
, b
, bh
);
132 if ((index
+ 2) > msblk
->bytes_used
)
135 bh
[0] = get_block_length(sb
, &cur_index
, &offset
, &length
);
140 bytes
= msblk
->devblksize
- offset
;
141 compressed
= SQUASHFS_COMPRESSED(length
);
142 length
= SQUASHFS_COMPRESSED_SIZE(length
);
144 *next_index
= index
+ length
+ 2;
146 TRACE("Block @ 0x%llx, %scompressed size %d\n", index
,
147 compressed
? "" : "un", length
);
149 if (length
< 0 || length
> output
->length
||
150 (index
+ length
) > msblk
->bytes_used
)
153 for (; bytes
< length
; b
++) {
154 bh
[b
] = sb_getblk(sb
, ++cur_index
);
157 bytes
+= msblk
->devblksize
;
159 ll_rw_block(READ
, b
- 1, bh
+ 1);
162 for (i
= 0; i
< b
; i
++) {
163 wait_on_buffer(bh
[i
]);
164 if (!buffer_uptodate(bh
[i
]))
169 length
= squashfs_decompress(msblk
, bh
, b
, offset
, length
,
175 * Block is uncompressed.
177 int in
, pg_offset
= 0;
178 void *data
= squashfs_first_page(output
);
180 for (bytes
= length
; k
< b
; k
++) {
181 in
= min(bytes
, msblk
->devblksize
- offset
);
184 if (pg_offset
== PAGE_CACHE_SIZE
) {
185 data
= squashfs_next_page(output
);
188 avail
= min_t(int, in
, PAGE_CACHE_SIZE
-
190 memcpy(data
+ pg_offset
, bh
[k
]->b_data
+ offset
,
199 squashfs_finish_page(output
);
210 ERROR("squashfs_read_data failed to read block 0x%llx\n",
211 (unsigned long long) index
);
This page took 0.033649 seconds and 5 git commands to generate.