1 /*
2  * Squashfs - a compressed read only filesystem for Linux
3  *
4  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
5  * Phillip Lougher <phillip@squashfs.org.uk>
6  *
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.
11  *
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.
16  *
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.
20  *
21  * file.c
22  */
23 
24 /*
25  * This file contains code for handling regular files.  A regular file
26  * consists of a sequence of contiguous compressed blocks, and/or a
27  * compressed fragment block (tail-end packed block).   The compressed size
28  * of each datablock is stored in a block list contained within the
29  * file inode (itself stored in one or more compressed metadata blocks).
30  *
31  * To speed up access to datablocks when reading 'large' files (256 Mbytes or
32  * larger), the code implements an index cache that caches the mapping from
33  * block index to datablock location on disk.
34  *
35  * The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
36  * retaining a simple and space-efficient block list on disk.  The cache
37  * is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
38  * Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
39  * The index cache is designed to be memory efficient, and by default uses
40  * 16 KiB.
41  */
42 
43 #include <linux/fs.h>
44 #include <linux/vfs.h>
45 #include <linux/kernel.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/pagemap.h>
49 #include <linux/mutex.h>
50 
51 #include "squashfs_fs.h"
52 #include "squashfs_fs_sb.h"
53 #include "squashfs_fs_i.h"
54 #include "squashfs.h"
55 
56 /*
57  * Locate cache slot in range [offset, index] for specified inode.  If
58  * there's more than one return the slot closest to index.
59  */
locate_meta_index(struct inode * inode,int offset,int index)60 static struct meta_index *locate_meta_index(struct inode *inode, int offset,
61 				int index)
62 {
63 	struct meta_index *meta = NULL;
64 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
65 	int i;
66 
67 	mutex_lock(&msblk->meta_index_mutex);
68 
69 	TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
70 
71 	if (msblk->meta_index == NULL)
72 		goto not_allocated;
73 
74 	for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
75 		if (msblk->meta_index[i].inode_number == inode->i_ino &&
76 				msblk->meta_index[i].offset >= offset &&
77 				msblk->meta_index[i].offset <= index &&
78 				msblk->meta_index[i].locked == 0) {
79 			TRACE("locate_meta_index: entry %d, offset %d\n", i,
80 					msblk->meta_index[i].offset);
81 			meta = &msblk->meta_index[i];
82 			offset = meta->offset;
83 		}
84 	}
85 
86 	if (meta)
87 		meta->locked = 1;
88 
89 not_allocated:
90 	mutex_unlock(&msblk->meta_index_mutex);
91 
92 	return meta;
93 }
94 
95 
96 /*
97  * Find and initialise an empty cache slot for index offset.
98  */
empty_meta_index(struct inode * inode,int offset,int skip)99 static struct meta_index *empty_meta_index(struct inode *inode, int offset,
100 				int skip)
101 {
102 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
103 	struct meta_index *meta = NULL;
104 	int i;
105 
106 	mutex_lock(&msblk->meta_index_mutex);
107 
108 	TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
109 
110 	if (msblk->meta_index == NULL) {
111 		/*
112 		 * First time cache index has been used, allocate and
113 		 * initialise.  The cache index could be allocated at
114 		 * mount time but doing it here means it is allocated only
115 		 * if a 'large' file is read.
116 		 */
117 		msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS,
118 			sizeof(*(msblk->meta_index)), GFP_KERNEL);
119 		if (msblk->meta_index == NULL) {
120 			ERROR("Failed to allocate meta_index\n");
121 			goto failed;
122 		}
123 		for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
124 			msblk->meta_index[i].inode_number = 0;
125 			msblk->meta_index[i].locked = 0;
126 		}
127 		msblk->next_meta_index = 0;
128 	}
129 
130 	for (i = SQUASHFS_META_SLOTS; i &&
131 			msblk->meta_index[msblk->next_meta_index].locked; i--)
132 		msblk->next_meta_index = (msblk->next_meta_index + 1) %
133 			SQUASHFS_META_SLOTS;
134 
135 	if (i == 0) {
136 		TRACE("empty_meta_index: failed!\n");
137 		goto failed;
138 	}
139 
140 	TRACE("empty_meta_index: returned meta entry %d, %p\n",
141 			msblk->next_meta_index,
142 			&msblk->meta_index[msblk->next_meta_index]);
143 
144 	meta = &msblk->meta_index[msblk->next_meta_index];
145 	msblk->next_meta_index = (msblk->next_meta_index + 1) %
146 			SQUASHFS_META_SLOTS;
147 
148 	meta->inode_number = inode->i_ino;
149 	meta->offset = offset;
150 	meta->skip = skip;
151 	meta->entries = 0;
152 	meta->locked = 1;
153 
154 failed:
155 	mutex_unlock(&msblk->meta_index_mutex);
156 	return meta;
157 }
158 
159 
release_meta_index(struct inode * inode,struct meta_index * meta)160 static void release_meta_index(struct inode *inode, struct meta_index *meta)
161 {
162 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
163 	mutex_lock(&msblk->meta_index_mutex);
164 	meta->locked = 0;
165 	mutex_unlock(&msblk->meta_index_mutex);
166 }
167 
168 
169 /*
170  * Read the next n blocks from the block list, starting from
171  * metadata block <start_block, offset>.
172  */
read_indexes(struct super_block * sb,int n,u64 * start_block,int * offset)173 static long long read_indexes(struct super_block *sb, int n,
174 				u64 *start_block, int *offset)
175 {
176 	int err, i;
177 	long long block = 0;
178 	__le32 *blist = kmalloc(PAGE_SIZE, GFP_KERNEL);
179 
180 	if (blist == NULL) {
181 		ERROR("read_indexes: Failed to allocate block_list\n");
182 		return -ENOMEM;
183 	}
184 
185 	while (n) {
186 		int blocks = min_t(int, n, PAGE_SIZE >> 2);
187 
188 		err = squashfs_read_metadata(sb, blist, start_block,
189 				offset, blocks << 2);
190 		if (err < 0) {
191 			ERROR("read_indexes: reading block [%llx:%x]\n",
192 				*start_block, *offset);
193 			goto failure;
194 		}
195 
196 		for (i = 0; i < blocks; i++) {
197 			int size = squashfs_block_size(blist[i]);
198 			if (size < 0) {
199 				err = size;
200 				goto failure;
201 			}
202 			block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
203 		}
204 		n -= blocks;
205 	}
206 
207 	kfree(blist);
208 	return block;
209 
210 failure:
211 	kfree(blist);
212 	return err;
213 }
214 
215 
216 /*
217  * Each cache index slot has SQUASHFS_META_ENTRIES, each of which
218  * can cache one index -> datablock/blocklist-block mapping.  We wish
219  * to distribute these over the length of the file, entry[0] maps index x,
220  * entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on.
221  * The larger the file, the greater the skip factor.  The skip factor is
222  * limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure
223  * the number of metadata blocks that need to be read fits into the cache.
224  * If the skip factor is limited in this way then the file will use multiple
225  * slots.
226  */
calculate_skip(u64 blocks)227 static inline int calculate_skip(u64 blocks)
228 {
229 	u64 skip = blocks / ((SQUASHFS_META_ENTRIES + 1)
230 		 * SQUASHFS_META_INDEXES);
231 	return min((u64) SQUASHFS_CACHED_BLKS - 1, skip + 1);
232 }
233 
234 
235 /*
236  * Search and grow the index cache for the specified inode, returning the
237  * on-disk locations of the datablock and block list metadata block
238  * <index_block, index_offset> for index (scaled to nearest cache index).
239  */
fill_meta_index(struct inode * inode,int index,u64 * index_block,int * index_offset,u64 * data_block)240 static int fill_meta_index(struct inode *inode, int index,
241 		u64 *index_block, int *index_offset, u64 *data_block)
242 {
243 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
244 	int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);
245 	int offset = 0;
246 	struct meta_index *meta;
247 	struct meta_entry *meta_entry;
248 	u64 cur_index_block = squashfs_i(inode)->block_list_start;
249 	int cur_offset = squashfs_i(inode)->offset;
250 	u64 cur_data_block = squashfs_i(inode)->start;
251 	int err, i;
252 
253 	/*
254 	 * Scale index to cache index (cache slot entry)
255 	 */
256 	index /= SQUASHFS_META_INDEXES * skip;
257 
258 	while (offset < index) {
259 		meta = locate_meta_index(inode, offset + 1, index);
260 
261 		if (meta == NULL) {
262 			meta = empty_meta_index(inode, offset + 1, skip);
263 			if (meta == NULL)
264 				goto all_done;
265 		} else {
266 			offset = index < meta->offset + meta->entries ? index :
267 				meta->offset + meta->entries - 1;
268 			meta_entry = &meta->meta_entry[offset - meta->offset];
269 			cur_index_block = meta_entry->index_block +
270 				msblk->inode_table;
271 			cur_offset = meta_entry->offset;
272 			cur_data_block = meta_entry->data_block;
273 			TRACE("get_meta_index: offset %d, meta->offset %d, "
274 				"meta->entries %d\n", offset, meta->offset,
275 				meta->entries);
276 			TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
277 				" data_block 0x%llx\n", cur_index_block,
278 				cur_offset, cur_data_block);
279 		}
280 
281 		/*
282 		 * If necessary grow cache slot by reading block list.  Cache
283 		 * slot is extended up to index or to the end of the slot, in
284 		 * which case further slots will be used.
285 		 */
286 		for (i = meta->offset + meta->entries; i <= index &&
287 				i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
288 			int blocks = skip * SQUASHFS_META_INDEXES;
289 			long long res = read_indexes(inode->i_sb, blocks,
290 					&cur_index_block, &cur_offset);
291 
292 			if (res < 0) {
293 				if (meta->entries == 0)
294 					/*
295 					 * Don't leave an empty slot on read
296 					 * error allocated to this inode...
297 					 */
298 					meta->inode_number = 0;
299 				err = res;
300 				goto failed;
301 			}
302 
303 			cur_data_block += res;
304 			meta_entry = &meta->meta_entry[i - meta->offset];
305 			meta_entry->index_block = cur_index_block -
306 				msblk->inode_table;
307 			meta_entry->offset = cur_offset;
308 			meta_entry->data_block = cur_data_block;
309 			meta->entries++;
310 			offset++;
311 		}
312 
313 		TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
314 				meta->offset, meta->entries);
315 
316 		release_meta_index(inode, meta);
317 	}
318 
319 all_done:
320 	*index_block = cur_index_block;
321 	*index_offset = cur_offset;
322 	*data_block = cur_data_block;
323 
324 	/*
325 	 * Scale cache index (cache slot entry) to index
326 	 */
327 	return offset * SQUASHFS_META_INDEXES * skip;
328 
329 failed:
330 	release_meta_index(inode, meta);
331 	return err;
332 }
333 
334 
335 /*
336  * Get the on-disk location and compressed size of the datablock
337  * specified by index.  Fill_meta_index() does most of the work.
338  */
read_blocklist(struct inode * inode,int index,u64 * block)339 static int read_blocklist(struct inode *inode, int index, u64 *block)
340 {
341 	u64 start;
342 	long long blks;
343 	int offset;
344 	__le32 size;
345 	int res = fill_meta_index(inode, index, &start, &offset, block);
346 
347 	TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset"
348 		       " 0x%x, block 0x%llx\n", res, index, start, offset,
349 			*block);
350 
351 	if (res < 0)
352 		return res;
353 
354 	/*
355 	 * res contains the index of the mapping returned by fill_meta_index(),
356 	 * this will likely be less than the desired index (because the
357 	 * meta_index cache works at a higher granularity).  Read any
358 	 * extra block indexes needed.
359 	 */
360 	if (res < index) {
361 		blks = read_indexes(inode->i_sb, index - res, &start, &offset);
362 		if (blks < 0)
363 			return (int) blks;
364 		*block += blks;
365 	}
366 
367 	/*
368 	 * Read length of block specified by index.
369 	 */
370 	res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset,
371 			sizeof(size));
372 	if (res < 0)
373 		return res;
374 	return squashfs_block_size(size);
375 }
376 
squashfs_fill_page(struct page * page,struct squashfs_cache_entry * buffer,int offset,int avail)377 void squashfs_fill_page(struct page *page, struct squashfs_cache_entry *buffer, int offset, int avail)
378 {
379 	int copied;
380 	void *pageaddr;
381 
382 	pageaddr = kmap_atomic(page);
383 	copied = squashfs_copy_data(pageaddr, buffer, offset, avail);
384 	memset(pageaddr + copied, 0, PAGE_SIZE - copied);
385 	kunmap_atomic(pageaddr);
386 
387 	flush_dcache_page(page);
388 	if (copied == avail)
389 		SetPageUptodate(page);
390 	else
391 		SetPageError(page);
392 }
393 
394 /* Copy data into page cache  */
squashfs_copy_cache(struct page * page,struct squashfs_cache_entry * buffer,int bytes,int offset)395 void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
396 	int bytes, int offset)
397 {
398 	struct inode *inode = page->mapping->host;
399 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
400 	int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
401 	int start_index = page->index & ~mask, end_index = start_index | mask;
402 
403 	/*
404 	 * Loop copying datablock into pages.  As the datablock likely covers
405 	 * many PAGE_SIZE pages (default block size is 128 KiB) explicitly
406 	 * grab the pages from the page cache, except for the page that we've
407 	 * been called to fill.
408 	 */
409 	for (i = start_index; i <= end_index && bytes > 0; i++,
410 			bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
411 		struct page *push_page;
412 		int avail = buffer ? min_t(int, bytes, PAGE_SIZE) : 0;
413 
414 		TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
415 
416 		push_page = (i == page->index) ? page :
417 			grab_cache_page_nowait(page->mapping, i);
418 
419 		if (!push_page)
420 			continue;
421 
422 		if (PageUptodate(push_page))
423 			goto skip_page;
424 
425 		squashfs_fill_page(push_page, buffer, offset, avail);
426 skip_page:
427 		unlock_page(push_page);
428 		if (i != page->index)
429 			put_page(push_page);
430 	}
431 }
432 
433 /* Read datablock stored packed inside a fragment (tail-end packed block) */
squashfs_readpage_fragment(struct page * page,int expected)434 static int squashfs_readpage_fragment(struct page *page, int expected)
435 {
436 	struct inode *inode = page->mapping->host;
437 	struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb,
438 		squashfs_i(inode)->fragment_block,
439 		squashfs_i(inode)->fragment_size);
440 	int res = buffer->error;
441 
442 	if (res)
443 		ERROR("Unable to read page, block %llx, size %x\n",
444 			squashfs_i(inode)->fragment_block,
445 			squashfs_i(inode)->fragment_size);
446 	else
447 		squashfs_copy_cache(page, buffer, expected,
448 			squashfs_i(inode)->fragment_offset);
449 
450 	squashfs_cache_put(buffer);
451 	return res;
452 }
453 
squashfs_readpage_sparse(struct page * page,int expected)454 static int squashfs_readpage_sparse(struct page *page, int expected)
455 {
456 	squashfs_copy_cache(page, NULL, expected, 0);
457 	return 0;
458 }
459 
squashfs_readpage(struct file * file,struct page * page)460 static int squashfs_readpage(struct file *file, struct page *page)
461 {
462 	struct inode *inode = page->mapping->host;
463 	struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
464 	int index = page->index >> (msblk->block_log - PAGE_SHIFT);
465 	int file_end = i_size_read(inode) >> msblk->block_log;
466 	int expected = index == file_end ?
467 			(i_size_read(inode) & (msblk->block_size - 1)) :
468 			 msblk->block_size;
469 	int res;
470 	void *pageaddr;
471 
472 	TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
473 				page->index, squashfs_i(inode)->start);
474 
475 	if (page->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>
476 					PAGE_SHIFT))
477 		goto out;
478 
479 	if (index < file_end || squashfs_i(inode)->fragment_block ==
480 					SQUASHFS_INVALID_BLK) {
481 		u64 block = 0;
482 		int bsize = read_blocklist(inode, index, &block);
483 		if (bsize < 0)
484 			goto error_out;
485 
486 		if (bsize == 0)
487 			res = squashfs_readpage_sparse(page, expected);
488 		else
489 			res = squashfs_readpage_block(page, block, bsize, expected);
490 	} else
491 		res = squashfs_readpage_fragment(page, expected);
492 
493 	if (!res)
494 		return 0;
495 
496 error_out:
497 	SetPageError(page);
498 out:
499 	pageaddr = kmap_atomic(page);
500 	memset(pageaddr, 0, PAGE_SIZE);
501 	kunmap_atomic(pageaddr);
502 	flush_dcache_page(page);
503 	if (!PageError(page))
504 		SetPageUptodate(page);
505 	unlock_page(page);
506 
507 	return 0;
508 }
509 
510 
511 const struct address_space_operations squashfs_aops = {
512 	.readpage = squashfs_readpage
513 };
514