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 | * dir.c |
9 | */ |
10 | |
11 | /* |
12 | * This file implements code to read directories from disk. |
13 | * |
14 | * See namei.c for a description of directory organisation on disk. |
15 | */ |
16 | |
17 | #include <linux/fs.h> |
18 | #include <linux/vfs.h> |
19 | #include <linux/slab.h> |
20 | |
21 | #include "squashfs_fs.h" |
22 | #include "squashfs_fs_sb.h" |
23 | #include "squashfs_fs_i.h" |
24 | #include "squashfs.h" |
25 | |
26 | static const unsigned char squashfs_filetype_table[] = { |
27 | DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK |
28 | }; |
29 | |
30 | /* |
31 | * Lookup offset (f_pos) in the directory index, returning the |
32 | * metadata block containing it. |
33 | * |
34 | * If we get an error reading the index then return the part of the index |
35 | * (if any) we have managed to read - the index isn't essential, just |
36 | * quicker. |
37 | */ |
38 | static int get_dir_index_using_offset(struct super_block *sb, |
39 | u64 *next_block, int *next_offset, u64 index_start, int index_offset, |
40 | int i_count, u64 f_pos) |
41 | { |
42 | struct squashfs_sb_info *msblk = sb->s_fs_info; |
43 | int err, i, index, length = 0; |
44 | unsigned int size; |
45 | struct squashfs_dir_index dir_index; |
46 | |
47 | TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %lld\n" , |
48 | i_count, f_pos); |
49 | |
50 | /* |
51 | * Translate from external f_pos to the internal f_pos. This |
52 | * is offset by 3 because we invent "." and ".." entries which are |
53 | * not actually stored in the directory. |
54 | */ |
55 | if (f_pos <= 3) |
56 | return f_pos; |
57 | f_pos -= 3; |
58 | |
59 | for (i = 0; i < i_count; i++) { |
60 | err = squashfs_read_metadata(sb, &dir_index, &index_start, |
61 | &index_offset, sizeof(dir_index)); |
62 | if (err < 0) |
63 | break; |
64 | |
65 | index = le32_to_cpu(dir_index.index); |
66 | if (index > f_pos) |
67 | /* |
68 | * Found the index we're looking for. |
69 | */ |
70 | break; |
71 | |
72 | size = le32_to_cpu(dir_index.size) + 1; |
73 | |
74 | /* size should never be larger than SQUASHFS_NAME_LEN */ |
75 | if (size > SQUASHFS_NAME_LEN) |
76 | break; |
77 | |
78 | err = squashfs_read_metadata(sb, NULL, &index_start, |
79 | &index_offset, size); |
80 | if (err < 0) |
81 | break; |
82 | |
83 | length = index; |
84 | *next_block = le32_to_cpu(dir_index.start_block) + |
85 | msblk->directory_table; |
86 | } |
87 | |
88 | *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; |
89 | |
90 | /* |
91 | * Translate back from internal f_pos to external f_pos. |
92 | */ |
93 | return length + 3; |
94 | } |
95 | |
96 | |
97 | static int squashfs_readdir(struct file *file, struct dir_context *ctx) |
98 | { |
99 | struct inode *inode = file_inode(f: file); |
100 | struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; |
101 | u64 block = squashfs_i(inode)->start + msblk->directory_table; |
102 | int offset = squashfs_i(inode)->offset, length, err; |
103 | unsigned int inode_number, dir_count, size, type; |
104 | struct squashfs_dir_header dirh; |
105 | struct squashfs_dir_entry *dire; |
106 | |
107 | TRACE("Entered squashfs_readdir [%llx:%x]\n" , block, offset); |
108 | |
109 | dire = kmalloc(size: sizeof(*dire) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL); |
110 | if (dire == NULL) { |
111 | ERROR("Failed to allocate squashfs_dir_entry\n" ); |
112 | goto finish; |
113 | } |
114 | |
115 | /* |
116 | * Return "." and ".." entries as the first two filenames in the |
117 | * directory. To maximise compression these two entries are not |
118 | * stored in the directory, and so we invent them here. |
119 | * |
120 | * It also means that the external f_pos is offset by 3 from the |
121 | * on-disk directory f_pos. |
122 | */ |
123 | while (ctx->pos < 3) { |
124 | char *name; |
125 | int i_ino; |
126 | |
127 | if (ctx->pos == 0) { |
128 | name = "." ; |
129 | size = 1; |
130 | i_ino = inode->i_ino; |
131 | } else { |
132 | name = ".." ; |
133 | size = 2; |
134 | i_ino = squashfs_i(inode)->parent; |
135 | } |
136 | |
137 | if (!dir_emit(ctx, name, namelen: size, ino: i_ino, |
138 | type: squashfs_filetype_table[1])) |
139 | goto finish; |
140 | |
141 | ctx->pos += size; |
142 | } |
143 | |
144 | length = get_dir_index_using_offset(sb: inode->i_sb, next_block: &block, next_offset: &offset, |
145 | index_start: squashfs_i(inode)->dir_idx_start, |
146 | index_offset: squashfs_i(inode)->dir_idx_offset, |
147 | i_count: squashfs_i(inode)->dir_idx_cnt, |
148 | f_pos: ctx->pos); |
149 | |
150 | while (length < i_size_read(inode)) { |
151 | /* |
152 | * Read directory header |
153 | */ |
154 | err = squashfs_read_metadata(inode->i_sb, &dirh, &block, |
155 | &offset, sizeof(dirh)); |
156 | if (err < 0) |
157 | goto failed_read; |
158 | |
159 | length += sizeof(dirh); |
160 | |
161 | dir_count = le32_to_cpu(dirh.count) + 1; |
162 | |
163 | if (dir_count > SQUASHFS_DIR_COUNT) |
164 | goto failed_read; |
165 | |
166 | while (dir_count--) { |
167 | /* |
168 | * Read directory entry. |
169 | */ |
170 | err = squashfs_read_metadata(inode->i_sb, dire, &block, |
171 | &offset, sizeof(*dire)); |
172 | if (err < 0) |
173 | goto failed_read; |
174 | |
175 | size = le16_to_cpu(dire->size) + 1; |
176 | |
177 | /* size should never be larger than SQUASHFS_NAME_LEN */ |
178 | if (size > SQUASHFS_NAME_LEN) |
179 | goto failed_read; |
180 | |
181 | err = squashfs_read_metadata(inode->i_sb, dire->name, |
182 | &block, &offset, size); |
183 | if (err < 0) |
184 | goto failed_read; |
185 | |
186 | length += sizeof(*dire) + size; |
187 | |
188 | if (ctx->pos >= length) |
189 | continue; |
190 | |
191 | dire->name[size] = '\0'; |
192 | inode_number = le32_to_cpu(dirh.inode_number) + |
193 | ((short) le16_to_cpu(dire->inode_number)); |
194 | type = le16_to_cpu(dire->type); |
195 | |
196 | if (type > SQUASHFS_MAX_DIR_TYPE) |
197 | goto failed_read; |
198 | |
199 | if (!dir_emit(ctx, name: dire->name, namelen: size, |
200 | ino: inode_number, |
201 | type: squashfs_filetype_table[type])) |
202 | goto finish; |
203 | |
204 | ctx->pos = length; |
205 | } |
206 | } |
207 | |
208 | finish: |
209 | kfree(objp: dire); |
210 | return 0; |
211 | |
212 | failed_read: |
213 | ERROR("Unable to read directory block [%llx:%x]\n" , block, offset); |
214 | kfree(objp: dire); |
215 | return 0; |
216 | } |
217 | |
218 | |
219 | const struct file_operations squashfs_dir_ops = { |
220 | .read = generic_read_dir, |
221 | .iterate_shared = squashfs_readdir, |
222 | .llseek = generic_file_llseek, |
223 | }; |
224 | |