| blob | a38a22785a1a28e6a7a50b533c1103f5caf2ebd0 |
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2017 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 */
32 /* Set us up to scrub directories. */
33 int
37 {
39 }
41 /* Directories */
43 /* Scrub a directory entry. */
46 /* VFS fill-directory iterator */
50 };
52 /* Check that an inode's mode matches a given DT_ type. */
53 STATIC int
56 xfs_fileoff_t offset,
57 xfs_ino_t inum,
59 {
68 offset);
70 }
72 /*
73 * Grab the inode pointed to by the dirent. We release the
74 * inode before we cancel the scrub transaction. Since we're
75 * don't know a priori that releasing the inode won't trigger
76 * eofblocks cleanup (which allocates what would be a nested
77 * transaction), we can't use DONTCACHE here because DONTCACHE
78 * inodes can trigger immediate inactive cleanup of the inode.
79 */
85 /* Convert mode to the DT_* values that dir_emit uses. */
91 out:
93 }
95 /*
96 * Scrub a single directory entry.
97 *
98 * We use the VFS directory iterator (i.e. readdir) to call this
99 * function for every directory entry in a directory. Once we're here,
100 * we check the inode number to make sure it's sane, then we check that
101 * we can look up this filename. Finally, we check the ftype.
102 */
103 STATIC int
108 loff_t pos,
109 u64 ino,
111 {
116 xfs_ino_t lookup_ino;
117 xfs_dablk_t offset;
126 /* Does this inode number make sense? */
130 }
132 /* Does this name make sense? */
136 }
139 /* If this is "." then check that the inum matches the dir. */
142 offset);
145 offset);
147 /*
148 * If this is ".." in the root inode, check that the inum
149 * matches this dir.
150 */
153 offset);
156 offset);
157 }
159 /* Verify that we can look up this name by hash. */
171 }
173 /* Verify the file type. This function absorbs error codes. */
177 out:
178 /*
179 * A negative error code returned here is supposed to cause the
180 * dir_emit caller (xfs_readdir) to abort the directory iteration
181 * and return zero to xchk_directory.
182 */
186 }
188 /* Scrub a directory btree record. */
189 STATIC int
194 {
201 xfs_ino_t ino;
202 xfs_dablk_t rec_bno;
203 xfs_dir2_db_t db;
204 xfs_dir2_data_aoff_t off;
205 xfs_dir2_dataptr_t ptr;
206 xfs_dahash_t calc_hash;
207 xfs_dahash_t hash;
211 /* Check the hash of the entry. */
216 /* Valid hash pointer? */
221 /* Find the directory entry's location. */
229 }
237 }
245 /* Make sure we got a real directory entry. */
251 }
260 }
265 }
269 }
271 /* Retrieve the entry, sanity check it, and compare hashes. */
280 }
285 out_relse:
287 out:
289 }
291 /*
292 * Is this unused entry either in the bestfree or smaller than all of
293 * them? We've already checked that the bestfrees are sorted longest to
294 * shortest, and that there aren't any bogus entries.
295 */
296 STATIC void
299 xfs_dablk_t lblk,
302 {
308 /* Unused entry is shorter than any of the bestfrees */
316 /* Unused entry should be in the bestfrees but wasn't found. */
318 }
320 /* Check free space info in a directory data block. */
321 STATIC int
324 xfs_dablk_t lblk,
326 {
335 u16 tag;
346 /* dir block format */
351 /* dir data format */
353 }
358 /* XXX: Check xfs_dir3_data_hdr.pad is zero once we start setting it. */
363 /* Do the bestfrees correspond to actual free space? */
373 }
377 /* bestfree doesn't match the entry it points at? */
383 }
385 /* bestfree records should be ordered largest to smallest */
389 }
392 nr_bestfrees++;
393 }
395 /* Make sure the bestfrees are actually the best free spaces. */
399 /* Iterate the entries, stopping when we hit or go past the end. */
402 /* Skip real entries */
410 lblk);
412 }
415 }
417 /* Spot check this free entry */
422 }
424 /*
425 * Either this entry is a bestfree or it's smaller than
426 * any of the bestfrees.
427 */
432 /* Move on. */
437 }
440 nr_frees++;
441 }
443 /* We're required to fill all the space. */
447 /* Did we see at least as many free slots as there are bestfrees? */
450 out_buf:
452 out:
454 }
456 /*
457 * Does the free space length in the free space index block ($len) match
458 * the longest length in the directory data block's bestfree array?
459 * Assume that we've already checked that the data block's bestfree
460 * array is in order.
461 */
462 STATIC void
465 xfs_dablk_t lblk,
468 {
478 }
480 /* Check free space info in a directory leaf1 block. */
481 STATIC int
485 xfs_dablk_t lblk)
486 {
496 __u16 best;
497 __u32 hash;
499 __u32 bestcount;
504 /* Read the free space block. */
522 }
524 /*
525 * There should be as many bestfree slots as there are dir data
526 * blocks that can fit under i_size.
527 */
531 }
533 /* Is the leaf count even remotely sane? */
537 }
539 /* Leaves and bests don't overlap in leaf format. */
543 }
545 /* Check hash value order, count stale entries. */
552 stale++;
553 }
559 /* Check all the bestfree entries. */
573 }
574 out:
576 }
578 /* Check free space info in a directory freespace block. */
579 STATIC int
583 xfs_dablk_t lblk)
584 {
589 __u16 best;
594 /* Read the free space block */
605 }
607 /* Check all the entries. */
613 stale++;
615 }
624 }
628 out:
630 }
632 /* Check free space information in directories. */
633 STATIC int
636 {
641 xfs_fileoff_t leaf_lblk;
642 xfs_fileoff_t free_lblk;
643 xfs_fileoff_t lblk;
645 xfs_dablk_t dabno;
650 /* Ignore local format directories. */
660 /* Is this a block dir? */
668 /* Iterate all the data extents in the directory... */
671 /* Block directories only have a single block at offset 0. */
678 }
680 /* No more data blocks... */
684 /*
685 * Check each data block's bestfree data.
686 *
687 * Iterate all the fsbcount-aligned block offsets in
688 * this directory. The directory block reading code is
689 * smart enough to do its own bmap lookups to handle
690 * discontiguous directory blocks. When we're done
691 * with the extent record, re-query the bmap at the
692 * next fsbcount-aligned offset to avoid redundant
693 * block checks.
694 */
700 is_block);
703 }
707 }
712 /* Look for a leaf1 block, which has free info. */
720 }
722 leaf_lblk);
725 }
730 /* Scan for free blocks */
734 /*
735 * Dirs can't have blocks mapped above 2^32.
736 * Single-block dirs shouldn't even be here.
737 */
742 }
746 }
748 /*
749 * Check each dir free block's bestfree data.
750 *
751 * Iterate all the fsbcount-aligned block offsets in
752 * this directory. The directory block reading code is
753 * smart enough to do its own bmap lookups to handle
754 * discontiguous directory blocks. When we're done
755 * with the extent record, re-query the bmap at the
756 * next fsbcount-aligned offset to avoid redundant
757 * block checks.
758 */
764 lblk);
767 }
771 }
772 out:
774 }
776 /* Scrub a whole directory. */
777 int
780 {
785 };
787 loff_t oldpos;
793 /* Plausible size? */
797 }
799 /* Check directory tree structure */
807 /* Check the freespace. */
815 /*
816 * Check that every dirent we see can also be looked up by hash.
817 * Userspace usually asks for a 32k buffer, so we will too.
818 */
822 /*
823 * Look up every name in this directory by hash.
824 *
825 * Use the xfs_readdir function to call xchk_dir_actor on
826 * every directory entry in this directory. In _actor, we check
827 * the name, inode number, and ftype (if applicable) of the
828 * entry. xfs_readdir uses the VFS filldir functions to provide
829 * iteration context.
830 *
831 * The VFS grabs a read or write lock via i_rwsem before it reads
832 * or writes to a directory. If we've gotten this far we've
833 * already obtained IOLOCK_EXCL, which (since 4.10) is the same as
834 * getting a write lock on i_rwsem. Therefore, it is safe for us
835 * to drop the ILOCK here in order to reuse the _readdir and
836 * _dir_lookup routines, which do their own ILOCK locking.
837 */
849 }
851 out:
853 }