Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/ext4/dir.c
4 : : *
5 : : * Copyright (C) 1992, 1993, 1994, 1995
6 : : * Remy Card (card@masi.ibp.fr)
7 : : * Laboratoire MASI - Institut Blaise Pascal
8 : : * Universite Pierre et Marie Curie (Paris VI)
9 : : *
10 : : * from
11 : : *
12 : : * linux/fs/minix/dir.c
13 : : *
14 : : * Copyright (C) 1991, 1992 Linus Torvalds
15 : : *
16 : : * ext4 directory handling functions
17 : : *
18 : : * Big-endian to little-endian byte-swapping/bitmaps by
19 : : * David S. Miller (davem@caip.rutgers.edu), 1995
20 : : *
21 : : * Hash Tree Directory indexing (c) 2001 Daniel Phillips
22 : : *
23 : : */
24 : :
25 : : #include <linux/fs.h>
26 : : #include <linux/buffer_head.h>
27 : : #include <linux/slab.h>
28 : : #include <linux/iversion.h>
29 : : #include <linux/unicode.h>
30 : : #include "ext4.h"
31 : : #include "xattr.h"
32 : :
33 : : static int ext4_dx_readdir(struct file *, struct dir_context *);
34 : :
35 : : /**
36 : : * is_dx_dir() - check if a directory is using htree indexing
37 : : * @inode: directory inode
38 : : *
39 : : * Check if the given dir-inode refers to an htree-indexed directory
40 : : * (or a directory which could potentially get converted to use htree
41 : : * indexing).
42 : : *
43 : : * Return 1 if it is a dx dir, 0 if not
44 : : */
45 : 5124 : static int is_dx_dir(struct inode *inode)
46 : : {
47 : 5124 : struct super_block *sb = inode->i_sb;
48 : :
49 [ + - + + ]: 10248 : if (ext4_has_feature_dir_index(inode->i_sb) &&
50 : 5068 : ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) ||
51 [ - + ]: 5068 : ((inode->i_size >> sb->s_blocksize_bits) == 1) ||
52 : : ext4_has_inline_data(inode)))
53 : 5124 : return 1;
54 : :
55 : : return 0;
56 : : }
57 : :
58 : : /*
59 : : * Return 0 if the directory entry is OK, and 1 if there is a problem
60 : : *
61 : : * Note: this is the opposite of what ext2 and ext3 historically returned...
62 : : *
63 : : * bh passed here can be an inode block or a dir data block, depending
64 : : * on the inode inline data flag.
65 : : */
66 : 471262 : int __ext4_check_dir_entry(const char *function, unsigned int line,
67 : : struct inode *dir, struct file *filp,
68 : : struct ext4_dir_entry_2 *de,
69 : : struct buffer_head *bh, char *buf, int size,
70 : : unsigned int offset)
71 : : {
72 : 471262 : const char *error_msg = NULL;
73 : 471262 : const int rlen = ext4_rec_len_from_disk(de->rec_len,
74 [ + - ]: 471262 : dir->i_sb->s_blocksize);
75 : 471262 : const int next_offset = ((char *) de - buf) + rlen;
76 : :
77 [ + - ]: 471262 : if (unlikely(rlen < EXT4_DIR_REC_LEN(1)))
78 : : error_msg = "rec_len is smaller than minimal";
79 [ + - ]: 471262 : else if (unlikely(rlen % 4 != 0))
80 : : error_msg = "rec_len % 4 != 0";
81 [ + - ]: 471262 : else if (unlikely(rlen < EXT4_DIR_REC_LEN(de->name_len)))
82 : : error_msg = "rec_len is too small for name_len";
83 [ + - ]: 471262 : else if (unlikely(next_offset > size))
84 : : error_msg = "directory entry overrun";
85 [ + + + - ]: 471262 : else if (unlikely(next_offset > size - EXT4_DIR_REC_LEN(1) &&
86 : : next_offset != size))
87 : : error_msg = "directory entry too close to block end";
88 [ - + ]: 471262 : else if (unlikely(le32_to_cpu(de->inode) >
89 : : le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count)))
90 : : error_msg = "inode out of bounds";
91 : : else
92 : : return 0;
93 : :
94 [ # # ]: 0 : if (filp)
95 : 0 : ext4_error_file(filp, function, line, bh->b_blocknr,
96 : : "bad entry in directory: %s - offset=%u, "
97 : : "inode=%u, rec_len=%d, name_len=%d, size=%d",
98 : : error_msg, offset, le32_to_cpu(de->inode),
99 : : rlen, de->name_len, size);
100 : : else
101 : 0 : ext4_error_inode(dir, function, line, bh->b_blocknr,
102 : : "bad entry in directory: %s - offset=%u, "
103 : : "inode=%u, rec_len=%d, name_len=%d, size=%d",
104 : : error_msg, offset, le32_to_cpu(de->inode),
105 : : rlen, de->name_len, size);
106 : :
107 : : return 1;
108 : : }
109 : :
110 : 5124 : static int ext4_readdir(struct file *file, struct dir_context *ctx)
111 : : {
112 : 5124 : unsigned int offset;
113 : 5124 : int i;
114 : 5124 : struct ext4_dir_entry_2 *de;
115 : 5124 : int err;
116 [ + - ]: 5124 : struct inode *inode = file_inode(file);
117 : 5124 : struct super_block *sb = inode->i_sb;
118 : 5124 : struct buffer_head *bh = NULL;
119 : 5124 : struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
120 : :
121 [ + - ]: 5124 : if (IS_ENCRYPTED(inode)) {
122 : : err = fscrypt_get_encryption_info(inode);
123 : : if (err)
124 : : return err;
125 : : }
126 : :
127 [ + - ]: 5124 : if (is_dx_dir(inode)) {
128 : 5124 : err = ext4_dx_readdir(file, ctx);
129 [ - + ]: 5124 : if (err != ERR_BAD_DX_DIR) {
130 : : return err;
131 : : }
132 : : /* Can we just clear INDEX flag to ignore htree information? */
133 [ # # ]: 0 : if (!ext4_has_metadata_csum(sb)) {
134 : : /*
135 : : * We don't set the inode dirty flag since it's not
136 : : * critical that it gets flushed back to the disk.
137 : : */
138 : 0 : ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
139 : : }
140 : : }
141 : :
142 : 0 : if (ext4_has_inline_data(inode)) {
143 : 0 : int has_inline_data = 1;
144 : 0 : err = ext4_read_inline_dir(file, ctx,
145 : : &has_inline_data);
146 [ # # ]: 0 : if (has_inline_data)
147 : 0 : return err;
148 : : }
149 : :
150 [ # # ]: 0 : if (IS_ENCRYPTED(inode)) {
151 : : err = fscrypt_fname_alloc_buffer(inode, EXT4_NAME_LEN, &fstr);
152 : : if (err < 0)
153 : : return err;
154 : : }
155 : :
156 [ # # ]: 0 : while (ctx->pos < inode->i_size) {
157 : 0 : struct ext4_map_blocks map;
158 : :
159 [ # # ]: 0 : if (fatal_signal_pending(current)) {
160 : 0 : err = -ERESTARTSYS;
161 : 0 : goto errout;
162 : : }
163 : 0 : cond_resched();
164 : 0 : offset = ctx->pos & (sb->s_blocksize - 1);
165 : 0 : map.m_lblk = ctx->pos >> EXT4_BLOCK_SIZE_BITS(sb);
166 : 0 : map.m_len = 1;
167 : 0 : err = ext4_map_blocks(NULL, inode, &map, 0);
168 [ # # ]: 0 : if (err == 0) {
169 : : /* m_len should never be zero but let's avoid
170 : : * an infinite loop if it somehow is */
171 [ # # ]: 0 : if (map.m_len == 0)
172 : 0 : map.m_len = 1;
173 : 0 : ctx->pos += map.m_len * sb->s_blocksize;
174 : 0 : continue;
175 : : }
176 [ # # ]: 0 : if (err > 0) {
177 : 0 : pgoff_t index = map.m_pblk >>
178 : 0 : (PAGE_SHIFT - inode->i_blkbits);
179 [ # # ]: 0 : if (!ra_has_index(&file->f_ra, index))
180 : 0 : page_cache_sync_readahead(
181 : 0 : sb->s_bdev->bd_inode->i_mapping,
182 : : &file->f_ra, file,
183 : : index, 1);
184 : 0 : file->f_ra.prev_pos = (loff_t)index << PAGE_SHIFT;
185 : 0 : bh = ext4_bread(NULL, inode, map.m_lblk, 0);
186 [ # # ]: 0 : if (IS_ERR(bh)) {
187 : 0 : err = PTR_ERR(bh);
188 : 0 : bh = NULL;
189 : 0 : goto errout;
190 : : }
191 : : }
192 : :
193 [ # # ]: 0 : if (!bh) {
194 : : /* corrupt size? Maybe no more blocks to read */
195 [ # # ]: 0 : if (ctx->pos > inode->i_blocks << 9)
196 : : break;
197 : 0 : ctx->pos += sb->s_blocksize - offset;
198 : 0 : continue;
199 : : }
200 : :
201 : : /* Check the checksum */
202 [ # # # # ]: 0 : if (!buffer_verified(bh) &&
203 : 0 : !ext4_dirblock_csum_verify(inode, bh)) {
204 : 0 : EXT4_ERROR_FILE(file, 0, "directory fails checksum "
205 : : "at offset %llu",
206 : : (unsigned long long)ctx->pos);
207 : 0 : ctx->pos += sb->s_blocksize - offset;
208 : 0 : brelse(bh);
209 : 0 : bh = NULL;
210 : 0 : continue;
211 : : }
212 : 0 : set_buffer_verified(bh);
213 : :
214 : : /* If the dir block has changed since the last call to
215 : : * readdir(2), then we might be pointing to an invalid
216 : : * dirent right now. Scan from the start of the block
217 : : * to make sure. */
218 [ # # ]: 0 : if (!inode_eq_iversion(inode, file->f_version)) {
219 [ # # # # ]: 0 : for (i = 0; i < sb->s_blocksize && i < offset; ) {
220 : 0 : de = (struct ext4_dir_entry_2 *)
221 : 0 : (bh->b_data + i);
222 : : /* It's too expensive to do a full
223 : : * dirent test each time round this
224 : : * loop, but we do have to test at
225 : : * least that it is non-zero. A
226 : : * failure will be detected in the
227 : : * dirent test below. */
228 [ # # ]: 0 : if (ext4_rec_len_from_disk(de->rec_len,
229 : : sb->s_blocksize) < EXT4_DIR_REC_LEN(1))
230 : : break;
231 : 0 : i += ext4_rec_len_from_disk(de->rec_len,
232 : : sb->s_blocksize);
233 : : }
234 : 0 : offset = i;
235 : 0 : ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))
236 : 0 : | offset;
237 : 0 : file->f_version = inode_query_iversion(inode);
238 : : }
239 : :
240 [ # # ]: 0 : while (ctx->pos < inode->i_size
241 [ # # ]: 0 : && offset < sb->s_blocksize) {
242 : 0 : de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);
243 [ # # ]: 0 : if (ext4_check_dir_entry(inode, file, de, bh,
244 : : bh->b_data, bh->b_size,
245 : : offset)) {
246 : : /*
247 : : * On error, skip to the next block
248 : : */
249 : 0 : ctx->pos = (ctx->pos |
250 : 0 : (sb->s_blocksize - 1)) + 1;
251 : 0 : break;
252 : : }
253 [ # # ]: 0 : offset += ext4_rec_len_from_disk(de->rec_len,
254 : : sb->s_blocksize);
255 [ # # ]: 0 : if (le32_to_cpu(de->inode)) {
256 [ # # ]: 0 : if (!IS_ENCRYPTED(inode)) {
257 [ # # ]: 0 : if (!dir_emit(ctx, de->name,
258 : 0 : de->name_len,
259 : : le32_to_cpu(de->inode),
260 [ # # ]: 0 : get_dtype(sb, de->file_type)))
261 : 0 : goto done;
262 : : } else {
263 : 0 : int save_len = fstr.len;
264 : 0 : struct fscrypt_str de_name =
265 : : FSTR_INIT(de->name,
266 : : de->name_len);
267 : :
268 : : /* Directory is encrypted */
269 : 0 : err = fscrypt_fname_disk_to_usr(inode,
270 : : 0, 0, &de_name, &fstr);
271 : 0 : de_name = fstr;
272 : 0 : fstr.len = save_len;
273 : 0 : if (err)
274 : 0 : goto errout;
275 : : if (!dir_emit(ctx,
276 : : de_name.name, de_name.len,
277 : : le32_to_cpu(de->inode),
278 : : get_dtype(sb, de->file_type)))
279 : : goto done;
280 : : }
281 : : }
282 : 0 : ctx->pos += ext4_rec_len_from_disk(de->rec_len,
283 : : sb->s_blocksize);
284 : : }
285 [ # # # # ]: 0 : if ((ctx->pos < inode->i_size) && !dir_relax_shared(inode))
286 : 0 : goto done;
287 : 0 : brelse(bh);
288 : 0 : bh = NULL;
289 : 0 : offset = 0;
290 : : }
291 : 0 : done:
292 : : err = 0;
293 : 0 : errout:
294 [ # # ]: 0 : fscrypt_fname_free_buffer(&fstr);
295 [ # # ]: 0 : brelse(bh);
296 : : return err;
297 : : }
298 : :
299 : 31360 : static inline int is_32bit_api(void)
300 : : {
301 : : #ifdef CONFIG_COMPAT
302 [ + - - - : 31360 : return in_compat_syscall();
- - - - +
- - + - +
+ - - - ]
303 : : #else
304 : : return (BITS_PER_LONG == 32);
305 : : #endif
306 : : }
307 : :
308 : : /*
309 : : * These functions convert from the major/minor hash to an f_pos
310 : : * value for dx directories
311 : : *
312 : : * Upper layer (for example NFS) should specify FMODE_32BITHASH or
313 : : * FMODE_64BITHASH explicitly. On the other hand, we allow ext4 to be mounted
314 : : * directly on both 32-bit and 64-bit nodes, under such case, neither
315 : : * FMODE_32BITHASH nor FMODE_64BITHASH is specified.
316 : : */
317 : 18424 : static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
318 : : {
319 : 36848 : if ((filp->f_mode & FMODE_32BITHASH) ||
320 [ + - ]: 18424 : (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
321 : 0 : return major >> 1;
322 : : else
323 : 18424 : return ((__u64)(major >> 1) << 32) | (__u64)minor;
324 : : }
325 : :
326 : 2604 : static inline __u32 pos2maj_hash(struct file *filp, loff_t pos)
327 : : {
328 : 5208 : if ((filp->f_mode & FMODE_32BITHASH) ||
329 [ - - + - ]: 2604 : (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
330 : 0 : return (pos << 1) & 0xffffffff;
331 : : else
332 : 2604 : return ((pos >> 32) << 1) & 0xffffffff;
333 : : }
334 : :
335 : 2604 : static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
336 : : {
337 : 5208 : if ((filp->f_mode & FMODE_32BITHASH) ||
338 [ - - + - ]: 2604 : (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
339 : : return 0;
340 : : else
341 : 2604 : return pos & 0xffffffff;
342 : : }
343 : :
344 : : /*
345 : : * Return 32- or 64-bit end-of-file for dx directories
346 : : */
347 : 7728 : static inline loff_t ext4_get_htree_eof(struct file *filp)
348 : : {
349 : 15456 : if ((filp->f_mode & FMODE_32BITHASH) ||
350 [ + - - - : 7728 : (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+ - - - ]
351 : : return EXT4_HTREE_EOF_32BIT;
352 : : else
353 : 7728 : return EXT4_HTREE_EOF_64BIT;
354 : : }
355 : :
356 : :
357 : : /*
358 : : * ext4_dir_llseek() calls generic_file_llseek_size to handle htree
359 : : * directories, where the "offset" is in terms of the filename hash
360 : : * value instead of the byte offset.
361 : : *
362 : : * Because we may return a 64-bit hash that is well beyond offset limits,
363 : : * we need to pass the max hash as the maximum allowable offset in
364 : : * the htree directory case.
365 : : *
366 : : * For non-htree, ext4_llseek already chooses the proper max offset.
367 : : */
368 : 0 : static loff_t ext4_dir_llseek(struct file *file, loff_t offset, int whence)
369 : : {
370 : 0 : struct inode *inode = file->f_mapping->host;
371 : 0 : int dx_dir = is_dx_dir(inode);
372 [ # # ]: 0 : loff_t ret, htree_max = ext4_get_htree_eof(file);
373 : :
374 [ # # ]: 0 : if (likely(dx_dir))
375 : 0 : ret = generic_file_llseek_size(file, offset, whence,
376 : : htree_max, htree_max);
377 : : else
378 : 0 : ret = ext4_llseek(file, offset, whence);
379 : 0 : file->f_version = inode_peek_iversion(inode) - 1;
380 : 0 : return ret;
381 : : }
382 : :
383 : : /*
384 : : * This structure holds the nodes of the red-black tree used to store
385 : : * the directory entry in hash order.
386 : : */
387 : : struct fname {
388 : : __u32 hash;
389 : : __u32 minor_hash;
390 : : struct rb_node rb_hash;
391 : : struct fname *next;
392 : : __u32 inode;
393 : : __u8 name_len;
394 : : __u8 file_type;
395 : : char name[0];
396 : : };
397 : :
398 : : /*
399 : : * This functoin implements a non-recursive way of freeing all of the
400 : : * nodes in the red-black tree.
401 : : */
402 : 5236 : static void free_rb_tree_fname(struct rb_root *root)
403 : : {
404 : 5236 : struct fname *fname, *next;
405 : :
406 [ + + + + : 28896 : rbtree_postorder_for_each_entry_safe(fname, next, root, rb_hash)
+ + ]
407 [ + + ]: 36848 : while (fname) {
408 : 18424 : struct fname *old = fname;
409 : 18424 : fname = fname->next;
410 : 18424 : kfree(old);
411 : : }
412 : :
413 : 5236 : *root = RB_ROOT;
414 : 5236 : }
415 : :
416 : :
417 : 2604 : static struct dir_private_info *ext4_htree_create_dir_info(struct file *filp,
418 : : loff_t pos)
419 : : {
420 : 2604 : struct dir_private_info *p;
421 : :
422 : 2604 : p = kzalloc(sizeof(*p), GFP_KERNEL);
423 [ + - ]: 2604 : if (!p)
424 : : return NULL;
425 [ + - ]: 2604 : p->curr_hash = pos2maj_hash(filp, pos);
426 [ + - ]: 2604 : p->curr_minor_hash = pos2min_hash(filp, pos);
427 : 2604 : return p;
428 : : }
429 : :
430 : 2604 : void ext4_htree_free_dir_info(struct dir_private_info *p)
431 : : {
432 : 0 : free_rb_tree_fname(&p->root);
433 : 2604 : kfree(p);
434 : 2604 : }
435 : :
436 : : /*
437 : : * Given a directory entry, enter it into the fname rb tree.
438 : : *
439 : : * When filename encryption is enabled, the dirent will hold the
440 : : * encrypted filename, while the htree will hold decrypted filename.
441 : : * The decrypted filename is passed in via ent_name. parameter.
442 : : */
443 : 18424 : int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
444 : : __u32 minor_hash,
445 : : struct ext4_dir_entry_2 *dirent,
446 : : struct fscrypt_str *ent_name)
447 : : {
448 : 18424 : struct rb_node **p, *parent = NULL;
449 : 18424 : struct fname *fname, *new_fn;
450 : 18424 : struct dir_private_info *info;
451 : 18424 : int len;
452 : :
453 : 18424 : info = dir_file->private_data;
454 : 18424 : p = &info->root.rb_node;
455 : :
456 : : /* Create and allocate the fname structure */
457 : 18424 : len = sizeof(struct fname) + ent_name->len + 1;
458 : 18424 : new_fn = kzalloc(len, GFP_KERNEL);
459 [ + - ]: 18424 : if (!new_fn)
460 : : return -ENOMEM;
461 : 18424 : new_fn->hash = hash;
462 : 18424 : new_fn->minor_hash = minor_hash;
463 : 18424 : new_fn->inode = le32_to_cpu(dirent->inode);
464 : 18424 : new_fn->name_len = ent_name->len;
465 : 18424 : new_fn->file_type = dirent->file_type;
466 : 18424 : memcpy(new_fn->name, ent_name->name, ent_name->len);
467 : :
468 [ + + ]: 80976 : while (*p) {
469 : 62552 : parent = *p;
470 : 62552 : fname = rb_entry(parent, struct fname, rb_hash);
471 : :
472 : : /*
473 : : * If the hash and minor hash match up, then we put
474 : : * them on a linked list. This rarely happens...
475 : : */
476 [ - + ]: 62552 : if ((new_fn->hash == fname->hash) &&
477 : : (new_fn->minor_hash == fname->minor_hash)) {
478 : 0 : new_fn->next = fname->next;
479 : 0 : fname->next = new_fn;
480 : 0 : return 0;
481 : : }
482 : :
483 [ + + ]: 62552 : if (new_fn->hash < fname->hash)
484 : 23828 : p = &(*p)->rb_left;
485 [ + - ]: 38724 : else if (new_fn->hash > fname->hash)
486 : 38724 : p = &(*p)->rb_right;
487 [ # # ]: 0 : else if (new_fn->minor_hash < fname->minor_hash)
488 : 0 : p = &(*p)->rb_left;
489 : : else /* if (new_fn->minor_hash > fname->minor_hash) */
490 : 0 : p = &(*p)->rb_right;
491 : : }
492 : :
493 : 18424 : rb_link_node(&new_fn->rb_hash, parent, p);
494 : 18424 : rb_insert_color(&new_fn->rb_hash, &info->root);
495 : 18424 : return 0;
496 : : }
497 : :
498 : :
499 : :
500 : : /*
501 : : * This is a helper function for ext4_dx_readdir. It calls filldir
502 : : * for all entres on the fname linked list. (Normally there is only
503 : : * one entry on the linked list, unless there are 62 bit hash collisions.)
504 : : */
505 : 18424 : static int call_filldir(struct file *file, struct dir_context *ctx,
506 : : struct fname *fname)
507 : : {
508 : 18424 : struct dir_private_info *info = file->private_data;
509 [ - + ]: 18424 : struct inode *inode = file_inode(file);
510 : 18424 : struct super_block *sb = inode->i_sb;
511 : :
512 [ - + ]: 18424 : if (!fname) {
513 : 0 : ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: "
514 : : "called with null fname?!?", __func__, __LINE__,
515 : : inode->i_ino, current->comm);
516 : 0 : return 0;
517 : : }
518 [ + - ]: 18424 : ctx->pos = hash2pos(file, fname->hash, fname->minor_hash);
519 [ + + ]: 36848 : while (fname) {
520 [ - + ]: 18424 : if (!dir_emit(ctx, fname->name,
521 : 18424 : fname->name_len,
522 : 18424 : fname->inode,
523 [ + - ]: 18424 : get_dtype(sb, fname->file_type))) {
524 : 0 : info->extra_fname = fname;
525 : 0 : return 1;
526 : : }
527 : 18424 : fname = fname->next;
528 : : }
529 : : return 0;
530 : : }
531 : :
532 : 5124 : static int ext4_dx_readdir(struct file *file, struct dir_context *ctx)
533 : : {
534 : 5124 : struct dir_private_info *info = file->private_data;
535 [ + + ]: 5124 : struct inode *inode = file_inode(file);
536 : 5124 : struct fname *fname;
537 : 5124 : int ret;
538 : :
539 [ + + ]: 5124 : if (!info) {
540 : 2604 : info = ext4_htree_create_dir_info(file, ctx->pos);
541 [ + - ]: 2604 : if (!info)
542 : : return -ENOMEM;
543 : 2604 : file->private_data = info;
544 : : }
545 : :
546 [ + - + + ]: 10248 : if (ctx->pos == ext4_get_htree_eof(file))
547 : : return 0; /* EOF */
548 : :
549 : : /* Some one has messed with f_pos; reset the world */
550 [ - + ]: 2604 : if (info->last_pos != ctx->pos) {
551 : 0 : free_rb_tree_fname(&info->root);
552 : 0 : info->curr_node = NULL;
553 : 0 : info->extra_fname = NULL;
554 [ # # ]: 0 : info->curr_hash = pos2maj_hash(file, ctx->pos);
555 [ # # ]: 0 : info->curr_minor_hash = pos2min_hash(file, ctx->pos);
556 : : }
557 : :
558 : : /*
559 : : * If there are any leftover names on the hash collision
560 : : * chain, return them first.
561 : : */
562 [ - + ]: 2604 : if (info->extra_fname) {
563 [ # # ]: 0 : if (call_filldir(file, ctx, info->extra_fname))
564 : 0 : goto finished;
565 : 0 : info->extra_fname = NULL;
566 : 0 : goto next_node;
567 [ + - ]: 2604 : } else if (!info->curr_node)
568 : 2604 : info->curr_node = rb_first(&info->root);
569 : :
570 : 18424 : while (1) {
571 : : /*
572 : : * Fill the rbtree if we have no more entries,
573 : : * or the inode has changed since we last read in the
574 : : * cached entries.
575 : : */
576 [ + + - + ]: 34216 : if ((!info->curr_node) ||
577 : 15792 : !inode_eq_iversion(inode, file->f_version)) {
578 : 2632 : info->curr_node = NULL;
579 : 2632 : free_rb_tree_fname(&info->root);
580 : 2632 : file->f_version = inode_query_iversion(inode);
581 : 2632 : ret = ext4_htree_fill_tree(file, info->curr_hash,
582 : : info->curr_minor_hash,
583 : : &info->next_hash);
584 [ + - ]: 2632 : if (ret < 0)
585 : : return ret;
586 [ - + ]: 2632 : if (ret == 0) {
587 [ # # ]: 0 : ctx->pos = ext4_get_htree_eof(file);
588 : 0 : break;
589 : : }
590 : 2632 : info->curr_node = rb_first(&info->root);
591 : : }
592 : :
593 : 18424 : fname = rb_entry(info->curr_node, struct fname, rb_hash);
594 : 18424 : info->curr_hash = fname->hash;
595 : 18424 : info->curr_minor_hash = fname->minor_hash;
596 [ + - ]: 18424 : if (call_filldir(file, ctx, fname))
597 : : break;
598 : 18424 : next_node:
599 : 18424 : info->curr_node = rb_next(info->curr_node);
600 [ + + ]: 18424 : if (info->curr_node) {
601 : 15792 : fname = rb_entry(info->curr_node, struct fname,
602 : : rb_hash);
603 : 15792 : info->curr_hash = fname->hash;
604 : 15792 : info->curr_minor_hash = fname->minor_hash;
605 : : } else {
606 [ + + ]: 2632 : if (info->next_hash == ~0) {
607 [ + - ]: 2604 : ctx->pos = ext4_get_htree_eof(file);
608 : 2604 : break;
609 : : }
610 : 28 : info->curr_hash = info->next_hash;
611 : 28 : info->curr_minor_hash = 0;
612 : : }
613 : : }
614 : 0 : finished:
615 : 2604 : info->last_pos = ctx->pos;
616 : 2604 : return 0;
617 : : }
618 : :
619 : 22064 : static int ext4_dir_open(struct inode * inode, struct file * filp)
620 : : {
621 [ - + ]: 22064 : if (IS_ENCRYPTED(inode))
622 : 0 : return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
623 : : return 0;
624 : : }
625 : :
626 : 22036 : static int ext4_release_dir(struct inode *inode, struct file *filp)
627 : : {
628 [ + + ]: 22036 : if (filp->private_data)
629 : 2604 : ext4_htree_free_dir_info(filp->private_data);
630 : :
631 : 22036 : return 0;
632 : : }
633 : :
634 : 0 : int ext4_check_all_de(struct inode *dir, struct buffer_head *bh, void *buf,
635 : : int buf_size)
636 : : {
637 : 0 : struct ext4_dir_entry_2 *de;
638 : 0 : int rlen;
639 : 0 : unsigned int offset = 0;
640 : 0 : char *top;
641 : :
642 : 0 : de = (struct ext4_dir_entry_2 *)buf;
643 : 0 : top = buf + buf_size;
644 [ # # ]: 0 : while ((char *) de < top) {
645 [ # # ]: 0 : if (ext4_check_dir_entry(dir, NULL, de, bh,
646 : : buf, buf_size, offset))
647 : : return -EFSCORRUPTED;
648 : 0 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
649 : 0 : de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
650 : 0 : offset += rlen;
651 : : }
652 [ # # ]: 0 : if ((char *) de > top)
653 : 0 : return -EFSCORRUPTED;
654 : :
655 : : return 0;
656 : : }
657 : :
658 : : const struct file_operations ext4_dir_operations = {
659 : : .llseek = ext4_dir_llseek,
660 : : .read = generic_read_dir,
661 : : .iterate_shared = ext4_readdir,
662 : : .unlocked_ioctl = ext4_ioctl,
663 : : #ifdef CONFIG_COMPAT
664 : : .compat_ioctl = ext4_compat_ioctl,
665 : : #endif
666 : : .fsync = ext4_sync_file,
667 : : .open = ext4_dir_open,
668 : : .release = ext4_release_dir,
669 : : };
670 : :
671 : : #ifdef CONFIG_UNICODE
672 : : static int ext4_d_compare(const struct dentry *dentry, unsigned int len,
673 : : const char *str, const struct qstr *name)
674 : : {
675 : : struct qstr qstr = {.name = str, .len = len };
676 : : const struct dentry *parent = READ_ONCE(dentry->d_parent);
677 : : const struct inode *inode = READ_ONCE(parent->d_inode);
678 : :
679 : : if (!inode || !IS_CASEFOLDED(inode) ||
680 : : !EXT4_SB(inode->i_sb)->s_encoding) {
681 : : if (len != name->len)
682 : : return -1;
683 : : return memcmp(str, name->name, len);
684 : : }
685 : :
686 : : return ext4_ci_compare(inode, name, &qstr, false);
687 : : }
688 : :
689 : : static int ext4_d_hash(const struct dentry *dentry, struct qstr *str)
690 : : {
691 : : const struct ext4_sb_info *sbi = EXT4_SB(dentry->d_sb);
692 : : const struct unicode_map *um = sbi->s_encoding;
693 : : const struct inode *inode = READ_ONCE(dentry->d_inode);
694 : : unsigned char *norm;
695 : : int len, ret = 0;
696 : :
697 : : if (!inode || !IS_CASEFOLDED(inode) || !um)
698 : : return 0;
699 : :
700 : : norm = kmalloc(PATH_MAX, GFP_ATOMIC);
701 : : if (!norm)
702 : : return -ENOMEM;
703 : :
704 : : len = utf8_casefold(um, str, norm, PATH_MAX);
705 : : if (len < 0) {
706 : : if (ext4_has_strict_mode(sbi))
707 : : ret = -EINVAL;
708 : : goto out;
709 : : }
710 : : str->hash = full_name_hash(dentry, norm, len);
711 : : out:
712 : : kfree(norm);
713 : : return ret;
714 : : }
715 : :
716 : : const struct dentry_operations ext4_dentry_ops = {
717 : : .d_hash = ext4_d_hash,
718 : : .d_compare = ext4_d_compare,
719 : : };
720 : : #endif
|
