Commit | Line | Data |
---|---|---|
68252eb5 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
122edd15 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> |
122edd15 | 7 | * |
122edd15 PL |
8 | * fragment.c |
9 | */ | |
10 | ||
11 | /* | |
12 | * This file implements code to handle compressed fragments (tail-end packed | |
13 | * datablocks). | |
14 | * | |
15 | * Regular files contain a fragment index which is mapped to a fragment | |
16 | * location on disk and compressed size using a fragment lookup table. | |
17 | * Like everything in Squashfs this fragment lookup table is itself stored | |
18 | * compressed into metadata blocks. A second index table is used to locate | |
19 | * these. This second index table for speed of access (and because it | |
20 | * is small) is read at mount time and cached in memory. | |
21 | */ | |
22 | ||
23 | #include <linux/fs.h> | |
24 | #include <linux/vfs.h> | |
25 | #include <linux/slab.h> | |
122edd15 PL |
26 | |
27 | #include "squashfs_fs.h" | |
28 | #include "squashfs_fs_sb.h" | |
122edd15 PL |
29 | #include "squashfs.h" |
30 | ||
31 | /* | |
32 | * Look-up fragment using the fragment index table. Return the on disk | |
33 | * location of the fragment and its compressed size | |
34 | */ | |
35 | int squashfs_frag_lookup(struct super_block *sb, unsigned int fragment, | |
36 | u64 *fragment_block) | |
37 | { | |
38 | struct squashfs_sb_info *msblk = sb->s_fs_info; | |
71755ee5 | 39 | int block, offset, size; |
122edd15 | 40 | struct squashfs_fragment_entry fragment_entry; |
71755ee5 LT |
41 | u64 start_block; |
42 | ||
43 | if (fragment >= msblk->fragments) | |
44 | return -EIO; | |
45 | block = SQUASHFS_FRAGMENT_INDEX(fragment); | |
46 | offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment); | |
47 | ||
48 | start_block = le64_to_cpu(msblk->fragment_index[block]); | |
122edd15 PL |
49 | |
50 | size = squashfs_read_metadata(sb, &fragment_entry, &start_block, | |
51 | &offset, sizeof(fragment_entry)); | |
52 | if (size < 0) | |
53 | return size; | |
54 | ||
55 | *fragment_block = le64_to_cpu(fragment_entry.start_block); | |
01cfb793 | 56 | return squashfs_block_size(fragment_entry.size); |
122edd15 PL |
57 | } |
58 | ||
59 | ||
60 | /* | |
61 | * Read the uncompressed fragment lookup table indexes off disk into memory | |
62 | */ | |
63 | __le64 *squashfs_read_fragment_index_table(struct super_block *sb, | |
1cac63cc | 64 | u64 fragment_table_start, u64 next_table, unsigned int fragments) |
122edd15 PL |
65 | { |
66 | unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(fragments); | |
1cac63cc | 67 | __le64 *table; |
122edd15 | 68 | |
1cac63cc PL |
69 | /* |
70 | * Sanity check, length bytes should not extend into the next table - | |
71 | * this check also traps instances where fragment_table_start is | |
72 | * incorrectly larger than the next table start | |
73 | */ | |
74 | if (fragment_table_start + length > next_table) | |
75 | return ERR_PTR(-EINVAL); | |
76 | ||
77 | table = squashfs_read_table(sb, fragment_table_start, length); | |
78 | ||
79 | /* | |
80 | * table[0] points to the first fragment table metadata block, this | |
81 | * should be less than fragment_table_start | |
82 | */ | |
d5b72ce1 | 83 | if (!IS_ERR(table) && le64_to_cpu(table[0]) >= fragment_table_start) { |
1cac63cc PL |
84 | kfree(table); |
85 | return ERR_PTR(-EINVAL); | |
86 | } | |
87 | ||
88 | return table; | |
122edd15 | 89 | } |