1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Squashfs - a compressed read only filesystem for Linux |
4 | * |
5 | * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 |
6 | * Phillip Lougher <phillip@squashfs.org.uk> |
7 | * |
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> |
26 | |
27 | #include "squashfs_fs.h" |
28 | #include "squashfs_fs_sb.h" |
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; |
39 | int block, offset, size; |
40 | struct squashfs_fragment_entry fragment_entry; |
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]); |
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); |
56 | return squashfs_block_size(raw: fragment_entry.size); |
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, |
64 | u64 fragment_table_start, u64 next_table, unsigned int fragments) |
65 | { |
66 | unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(fragments); |
67 | __le64 *table; |
68 | |
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(error: -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 | */ |
83 | if (!IS_ERR(ptr: table) && le64_to_cpu(table[0]) >= fragment_table_start) { |
84 | kfree(objp: table); |
85 | return ERR_PTR(error: -EINVAL); |
86 | } |
87 | |
88 | return table; |
89 | } |
90 | |