xref: /openbmc/linux/fs/squashfs/dir.c (revision 68252eb5)
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  */
get_dir_index_using_offset(struct super_block * sb,u64 * next_block,int * next_offset,u64 index_start,int index_offset,int i_count,u64 f_pos)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 
squashfs_readdir(struct file * file,struct dir_context * ctx)97 static int squashfs_readdir(struct file *file, struct dir_context *ctx)
98 {
99 	struct inode *inode = file_inode(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(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, size, i_ino,
138 				squashfs_filetype_table[1]))
139 			goto finish;
140 
141 		ctx->pos += size;
142 	}
143 
144 	length = get_dir_index_using_offset(inode->i_sb, &block, &offset,
145 				squashfs_i(inode)->dir_idx_start,
146 				squashfs_i(inode)->dir_idx_offset,
147 				squashfs_i(inode)->dir_idx_cnt,
148 				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, dire->name, size,
200 					inode_number,
201 					squashfs_filetype_table[type]))
202 				goto finish;
203 
204 			ctx->pos = length;
205 		}
206 	}
207 
208 finish:
209 	kfree(dire);
210 	return 0;
211 
212 failed_read:
213 	ERROR("Unable to read directory block [%llx:%x]\n", block, offset);
214 	kfree(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