| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * Copyright (C) 2017-2023 Oracle. All Rights Reserved. | |
| * Author: Darrick J. Wong <djwong@kernel.org> | |
| */ | |
| #include "xfs_platform.h" | |
| #include "xfs_fs.h" | |
| #include "xfs_shared.h" | |
| #include "xfs_format.h" | |
| #include "xfs_trans_resv.h" | |
| #include "xfs_mount.h" | |
| #include "xfs_log_format.h" | |
| #include "xfs_trans.h" | |
| #include "xfs_inode.h" | |
| #include "xfs_icache.h" | |
| #include "xfs_dir2.h" | |
| #include "xfs_dir2_priv.h" | |
| #include "xfs_attr.h" | |
| #include "xfs_parent.h" | |
| #include "scrub/scrub.h" | |
| #include "scrub/common.h" | |
| #include "scrub/readdir.h" | |
| #include "scrub/tempfile.h" | |
| #include "scrub/repair.h" | |
| #include "scrub/listxattr.h" | |
| #include "scrub/xfile.h" | |
| #include "scrub/xfarray.h" | |
| #include "scrub/xfblob.h" | |
| #include "scrub/trace.h" | |
| /* Set us up to scrub parents. */ | |
| int | |
| xchk_setup_parent( | |
| struct xfs_scrub *sc) | |
| { | |
| int error; | |
| if (xchk_could_repair(sc)) { | |
| error = xrep_setup_parent(sc); | |
| if (error) | |
| return error; | |
| } | |
| return xchk_setup_inode_contents(sc, 0); | |
| } | |
| /* Parent pointers */ | |
| /* Look for an entry in a parent pointing to this inode. */ | |
| struct xchk_parent_ctx { | |
| struct xfs_scrub *sc; | |
| xfs_nlink_t nlink; | |
| }; | |
| /* Look for a single entry in a directory pointing to an inode. */ | |
| STATIC int | |
| xchk_parent_actor( | |
| struct xfs_scrub *sc, | |
| struct xfs_inode *dp, | |
| xfs_dir2_dataptr_t dapos, | |
| const struct xfs_name *name, | |
| xfs_ino_t ino, | |
| void *priv) | |
| { | |
| struct xchk_parent_ctx *spc = priv; | |
| int error = 0; | |
| /* Does this name make sense? */ | |
| if (!xfs_dir2_namecheck(name->name, name->len)) | |
| error = -EFSCORRUPTED; | |
| if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) | |
| return error; | |
| if (I_INO(sc->ip) == ino) | |
| spc->nlink++; | |
| if (xchk_should_terminate(spc->sc, &error)) | |
| return error; | |
| return 0; | |
| } | |
| /* | |
| * Try to lock a parent directory for checking dirents. Returns the inode | |
| * flags for the locks we now hold, or zero if we failed. | |
| */ | |
| STATIC unsigned int | |
| xchk_parent_ilock_dir( | |
| struct xfs_inode *dp) | |
| { | |
| if (!xfs_ilock_nowait(dp, XFS_ILOCK_SHARED)) | |
| return 0; | |
| if (!xfs_need_iread_extents(&dp->i_df)) | |
| return XFS_ILOCK_SHARED; | |
| xfs_iunlock(dp, XFS_ILOCK_SHARED); | |
| if (!xfs_ilock_nowait(dp, XFS_ILOCK_EXCL)) | |
| return 0; | |
| return XFS_ILOCK_EXCL; | |
| } | |
| /* | |
| * Given the inode number of the alleged parent of the inode being scrubbed, | |
| * try to validate that the parent has exactly one directory entry pointing | |
| * back to the inode being scrubbed. Returns -EAGAIN if we need to revalidate | |
| * the dotdot entry. | |
| */ | |
| STATIC int | |
| xchk_parent_validate( | |
| struct xfs_scrub *sc, | |
| xfs_ino_t parent_ino) | |
| { | |
| struct xchk_parent_ctx spc = { | |
| .sc = sc, | |
| .nlink = 0, | |
| }; | |
| struct xfs_mount *mp = sc->mp; | |
| xfs_ino_t ino = I_INO(sc->ip); | |
| struct xfs_inode *dp = NULL; | |
| xfs_nlink_t expected_nlink; | |
| unsigned int lock_mode; | |
| int error = 0; | |
| /* Is this the root dir? Then '..' must point to itself. */ | |
| if (sc->ip == mp->m_rootip) { | |
| if (ino != mp->m_sb.sb_rootino || ino != parent_ino) | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* Is this the metadata root dir? Then '..' must point to itself. */ | |
| if (sc->ip == mp->m_metadirip) { | |
| if (ino != mp->m_sb.sb_metadirino || ino != parent_ino) | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* '..' must not point to ourselves. */ | |
| if (ino == parent_ino) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* | |
| * If we're an unlinked directory, the parent /won't/ have a link | |
| * to us. Otherwise, it should have one link. | |
| */ | |
| expected_nlink = VFS_I(sc->ip)->i_nlink == 0 ? 0 : 1; | |
| /* | |
| * Grab the parent directory inode. This must be released before we | |
| * cancel the scrub transaction. | |
| * | |
| * If _iget returns -EINVAL or -ENOENT then the parent inode number is | |
| * garbage and the directory is corrupt. If the _iget returns | |
| * -EFSCORRUPTED or -EFSBADCRC then the parent is corrupt which is a | |
| * cross referencing error. Any other error is an operational error. | |
| */ | |
| error = xchk_iget(sc, parent_ino, &dp); | |
| if (error == -EINVAL || error == -ENOENT) { | |
| error = -EFSCORRUPTED; | |
| xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error); | |
| return error; | |
| } | |
| if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) | |
| return error; | |
| if (dp == sc->ip || xrep_is_tempfile(dp) || | |
| !S_ISDIR(VFS_I(dp)->i_mode)) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| goto out_rele; | |
| } | |
| lock_mode = xchk_parent_ilock_dir(dp); | |
| if (!lock_mode) { | |
| xchk_iunlock(sc, XFS_ILOCK_EXCL); | |
| xchk_ilock(sc, XFS_ILOCK_EXCL); | |
| error = -EAGAIN; | |
| goto out_rele; | |
| } | |
| /* | |
| * We cannot yet validate this parent pointer if the directory looks as | |
| * though it has been zapped by the inode record repair code. | |
| */ | |
| if (xchk_dir_looks_zapped(dp)) { | |
| error = -EBUSY; | |
| xchk_set_incomplete(sc); | |
| goto out_unlock; | |
| } | |
| /* Metadata and regular inodes cannot cross trees. */ | |
| if (xfs_is_metadir_inode(dp) != xfs_is_metadir_inode(sc->ip)) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| goto out_unlock; | |
| } | |
| /* Look for a directory entry in the parent pointing to the child. */ | |
| error = xchk_dir_walk(sc, dp, xchk_parent_actor, &spc); | |
| if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) | |
| goto out_unlock; | |
| /* | |
| * Ensure that the parent has as many links to the child as the child | |
| * thinks it has to the parent. | |
| */ | |
| if (spc.nlink != expected_nlink) | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| out_unlock: | |
| xfs_iunlock(dp, lock_mode); | |
| out_rele: | |
| xchk_irele(sc, dp); | |
| return error; | |
| } | |
| /* | |
| * Checking of Parent Pointers | |
| * =========================== | |
| * | |
| * On filesystems with directory parent pointers, we check the referential | |
| * integrity by visiting each parent pointer of a child file and checking that | |
| * the directory referenced by the pointer actually has a dirent pointing | |
| * forward to the child file. | |
| */ | |
| /* Deferred parent pointer entry that we saved for later. */ | |
| struct xchk_pptr { | |
| /* Cookie for retrieval of the pptr name. */ | |
| xfblob_cookie name_cookie; | |
| /* Parent pointer record. */ | |
| struct xfs_parent_rec pptr_rec; | |
| /* Length of the pptr name. */ | |
| uint8_t namelen; | |
| }; | |
| struct xchk_pptrs { | |
| struct xfs_scrub *sc; | |
| /* How many parent pointers did we find at the end? */ | |
| unsigned long long pptrs_found; | |
| /* Parent of this directory. */ | |
| xfs_ino_t parent_ino; | |
| /* Fixed-size array of xchk_pptr structures. */ | |
| struct xfarray *pptr_entries; | |
| /* Blobs containing parent pointer names. */ | |
| struct xfblob *pptr_names; | |
| /* Scratch buffer for scanning pptr xattrs */ | |
| struct xfs_da_args pptr_args; | |
| /* If we've cycled the ILOCK, we must revalidate all deferred pptrs. */ | |
| bool need_revalidate; | |
| /* Name buffer */ | |
| struct xfs_name xname; | |
| char namebuf[MAXNAMELEN]; | |
| }; | |
| /* Does this parent pointer match the dotdot entry? */ | |
| STATIC int | |
| xchk_parent_scan_dotdot( | |
| struct xfs_scrub *sc, | |
| struct xfs_inode *ip, | |
| unsigned int attr_flags, | |
| const unsigned char *name, | |
| unsigned int namelen, | |
| const void *value, | |
| unsigned int valuelen, | |
| void *priv) | |
| { | |
| struct xchk_pptrs *pp = priv; | |
| xfs_ino_t parent_ino; | |
| int error; | |
| if (!(attr_flags & XFS_ATTR_PARENT)) | |
| return 0; | |
| error = xfs_parent_from_attr(sc->mp, attr_flags, name, namelen, value, | |
| valuelen, &parent_ino, NULL); | |
| if (error) | |
| return error; | |
| if (pp->parent_ino == parent_ino) | |
| return -ECANCELED; | |
| return 0; | |
| } | |
| /* Look up the dotdot entry so that we can check it as we walk the pptrs. */ | |
| STATIC int | |
| xchk_parent_pptr_and_dotdot( | |
| struct xchk_pptrs *pp) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| int error; | |
| /* Look up '..' */ | |
| error = xchk_dir_lookup(sc, sc->ip, &xfs_name_dotdot, &pp->parent_ino); | |
| if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error)) | |
| return error; | |
| if (!xfs_verify_dir_ino(sc->mp, pp->parent_ino)) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* Is this the root dir? Then '..' must point to itself. */ | |
| if (xchk_inode_is_dirtree_root(sc->ip)) { | |
| if (I_INO(sc->ip) != pp->parent_ino) | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* | |
| * If this is now an unlinked directory, the dotdot value is | |
| * meaningless as long as it points to a valid inode. | |
| */ | |
| if (VFS_I(sc->ip)->i_nlink == 0) | |
| return 0; | |
| if (pp->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) | |
| return 0; | |
| /* Otherwise, walk the pptrs again, and check. */ | |
| error = xchk_xattr_walk(sc, sc->ip, xchk_parent_scan_dotdot, NULL, pp); | |
| if (error == -ECANCELED) { | |
| /* Found a parent pointer that matches dotdot. */ | |
| return 0; | |
| } | |
| if (!error || error == -EFSCORRUPTED) { | |
| /* Found a broken parent pointer or no match. */ | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return 0; | |
| } | |
| return error; | |
| } | |
| /* | |
| * Try to lock a parent directory for checking dirents. Returns the inode | |
| * flags for the locks we now hold, or zero if we failed. | |
| */ | |
| STATIC unsigned int | |
| xchk_parent_lock_dir( | |
| struct xfs_scrub *sc, | |
| struct xfs_inode *dp) | |
| { | |
| if (!xfs_ilock_nowait(dp, XFS_IOLOCK_SHARED)) | |
| return 0; | |
| if (!xfs_ilock_nowait(dp, XFS_ILOCK_SHARED)) { | |
| xfs_iunlock(dp, XFS_IOLOCK_SHARED); | |
| return 0; | |
| } | |
| if (!xfs_need_iread_extents(&dp->i_df)) | |
| return XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED; | |
| xfs_iunlock(dp, XFS_ILOCK_SHARED); | |
| if (!xfs_ilock_nowait(dp, XFS_ILOCK_EXCL)) { | |
| xfs_iunlock(dp, XFS_IOLOCK_SHARED); | |
| return 0; | |
| } | |
| return XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL; | |
| } | |
| /* Check the forward link (dirent) associated with this parent pointer. */ | |
| STATIC int | |
| xchk_parent_dirent( | |
| struct xchk_pptrs *pp, | |
| const struct xfs_name *xname, | |
| struct xfs_inode *dp) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| xfs_ino_t child_ino; | |
| int error; | |
| /* | |
| * Use the name attached to this parent pointer to look up the | |
| * directory entry in the alleged parent. | |
| */ | |
| error = xchk_dir_lookup(sc, dp, xname, &child_ino); | |
| if (error == -ENOENT) { | |
| xchk_fblock_xref_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return 0; | |
| } | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, &error)) | |
| return error; | |
| /* Does the inode number match? */ | |
| if (child_ino != I_INO(sc->ip)) { | |
| xchk_fblock_xref_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return 0; | |
| } | |
| return 0; | |
| } | |
| /* Try to grab a parent directory. */ | |
| STATIC int | |
| xchk_parent_iget( | |
| struct xchk_pptrs *pp, | |
| const struct xfs_parent_rec *pptr, | |
| struct xfs_inode **dpp) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| struct xfs_inode *ip; | |
| xfs_ino_t parent_ino = be64_to_cpu(pptr->p_ino); | |
| int error; | |
| /* Validate inode number. */ | |
| error = xfs_dir_ino_validate(sc->mp, parent_ino); | |
| if (error) { | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return -ECANCELED; | |
| } | |
| error = xchk_iget(sc, parent_ino, &ip); | |
| if (error == -EINVAL || error == -ENOENT) { | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return -ECANCELED; | |
| } | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, &error)) | |
| return error; | |
| /* The parent must be a directory. */ | |
| if (!S_ISDIR(VFS_I(ip)->i_mode)) { | |
| xchk_fblock_xref_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| goto out_rele; | |
| } | |
| /* Validate generation number. */ | |
| if (VFS_I(ip)->i_generation != be32_to_cpu(pptr->p_gen)) { | |
| xchk_fblock_xref_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| goto out_rele; | |
| } | |
| *dpp = ip; | |
| return 0; | |
| out_rele: | |
| xchk_irele(sc, ip); | |
| return 0; | |
| } | |
| /* | |
| * Walk an xattr of a file. If this xattr is a parent pointer, follow it up | |
| * to a parent directory and check that the parent has a dirent pointing back | |
| * to us. | |
| */ | |
| STATIC int | |
| xchk_parent_scan_attr( | |
| struct xfs_scrub *sc, | |
| struct xfs_inode *ip, | |
| unsigned int attr_flags, | |
| const unsigned char *name, | |
| unsigned int namelen, | |
| const void *value, | |
| unsigned int valuelen, | |
| void *priv) | |
| { | |
| struct xfs_name xname = { | |
| .name = name, | |
| .len = namelen, | |
| }; | |
| struct xchk_pptrs *pp = priv; | |
| struct xfs_inode *dp = NULL; | |
| const struct xfs_parent_rec *pptr_rec = value; | |
| xfs_ino_t parent_ino; | |
| unsigned int lockmode; | |
| int error; | |
| if (!(attr_flags & XFS_ATTR_PARENT)) | |
| return 0; | |
| error = xfs_parent_from_attr(sc->mp, attr_flags, name, namelen, value, | |
| valuelen, &parent_ino, NULL); | |
| if (error) { | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return -ECANCELED; | |
| } | |
| /* No self-referential parent pointers. */ | |
| if (parent_ino == I_INO(sc->ip)) { | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return -ECANCELED; | |
| } | |
| pp->pptrs_found++; | |
| error = xchk_parent_iget(pp, pptr_rec, &dp); | |
| if (error) | |
| return error; | |
| if (!dp) | |
| return 0; | |
| /* Try to lock the inode. */ | |
| lockmode = xchk_parent_lock_dir(sc, dp); | |
| if (!lockmode) { | |
| struct xchk_pptr save_pp = { | |
| .pptr_rec = *pptr_rec, /* struct copy */ | |
| .namelen = namelen, | |
| }; | |
| /* Couldn't lock the inode, so save the pptr for later. */ | |
| trace_xchk_parent_defer(sc->ip, &xname, I_INO(dp)); | |
| error = xfblob_storename(pp->pptr_names, &save_pp.name_cookie, | |
| &xname); | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, | |
| &error)) | |
| goto out_rele; | |
| error = xfarray_append(pp->pptr_entries, &save_pp); | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, | |
| &error)) | |
| goto out_rele; | |
| goto out_rele; | |
| } | |
| error = xchk_parent_dirent(pp, &xname, dp); | |
| if (error) | |
| goto out_unlock; | |
| out_unlock: | |
| xfs_iunlock(dp, lockmode); | |
| out_rele: | |
| xchk_irele(sc, dp); | |
| return error; | |
| } | |
| /* | |
| * Revalidate a parent pointer that we collected in the past but couldn't check | |
| * because of lock contention. Returns 0 if the parent pointer is still valid, | |
| * -ENOENT if it has gone away on us, or a negative errno. | |
| */ | |
| STATIC int | |
| xchk_parent_revalidate_pptr( | |
| struct xchk_pptrs *pp, | |
| const struct xfs_name *xname, | |
| struct xfs_parent_rec *pptr) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| int error; | |
| error = xfs_parent_lookup(sc->tp, sc->ip, xname, pptr, &pp->pptr_args); | |
| if (error == -ENOATTR) { | |
| /* Parent pointer went away, nothing to revalidate. */ | |
| return -ENOENT; | |
| } | |
| return error; | |
| } | |
| /* | |
| * Check a parent pointer the slow way, which means we cycle locks a bunch | |
| * and put up with revalidation until we get it done. | |
| */ | |
| STATIC int | |
| xchk_parent_slow_pptr( | |
| struct xchk_pptrs *pp, | |
| const struct xfs_name *xname, | |
| struct xfs_parent_rec *pptr) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| struct xfs_inode *dp = NULL; | |
| unsigned int lockmode; | |
| int error; | |
| /* Check that the deferred parent pointer still exists. */ | |
| if (pp->need_revalidate) { | |
| error = xchk_parent_revalidate_pptr(pp, xname, pptr); | |
| if (error == -ENOENT) | |
| return 0; | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, | |
| &error)) | |
| return error; | |
| } | |
| error = xchk_parent_iget(pp, pptr, &dp); | |
| if (error) | |
| return error; | |
| if (!dp) | |
| return 0; | |
| /* | |
| * If we can grab both IOLOCK and ILOCK of the alleged parent, we | |
| * can proceed with the validation. | |
| */ | |
| lockmode = xchk_parent_lock_dir(sc, dp); | |
| if (lockmode) { | |
| trace_xchk_parent_slowpath(sc->ip, xname, I_INO(dp)); | |
| goto check_dirent; | |
| } | |
| /* | |
| * We couldn't lock the parent dir. Drop all the locks and try to | |
| * get them again, one at a time. | |
| */ | |
| xchk_iunlock(sc, sc->ilock_flags); | |
| pp->need_revalidate = true; | |
| trace_xchk_parent_ultraslowpath(sc->ip, xname, I_INO(dp)); | |
| error = xchk_dir_trylock_for_pptrs(sc, dp, &lockmode); | |
| if (error) | |
| goto out_rele; | |
| /* Revalidate the parent pointer now that we cycled locks. */ | |
| error = xchk_parent_revalidate_pptr(pp, xname, pptr); | |
| if (error == -ENOENT) { | |
| error = 0; | |
| goto out_unlock; | |
| } | |
| if (!xchk_fblock_xref_process_error(sc, XFS_ATTR_FORK, 0, &error)) | |
| goto out_unlock; | |
| check_dirent: | |
| error = xchk_parent_dirent(pp, xname, dp); | |
| out_unlock: | |
| xfs_iunlock(dp, lockmode); | |
| out_rele: | |
| xchk_irele(sc, dp); | |
| return error; | |
| } | |
| /* Check all the parent pointers that we deferred the first time around. */ | |
| STATIC int | |
| xchk_parent_finish_slow_pptrs( | |
| struct xchk_pptrs *pp) | |
| { | |
| xfarray_idx_t array_cur; | |
| int error; | |
| foreach_xfarray_idx(pp->pptr_entries, array_cur) { | |
| struct xchk_pptr pptr; | |
| if (pp->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) | |
| return 0; | |
| error = xfarray_load(pp->pptr_entries, array_cur, &pptr); | |
| if (error) | |
| return error; | |
| error = xfblob_loadname(pp->pptr_names, pptr.name_cookie, | |
| &pp->xname, pptr.namelen); | |
| if (error) | |
| return error; | |
| error = xchk_parent_slow_pptr(pp, &pp->xname, &pptr.pptr_rec); | |
| if (error) | |
| return error; | |
| } | |
| /* Empty out both xfiles now that we've checked everything. */ | |
| xfarray_truncate(pp->pptr_entries); | |
| xfblob_truncate(pp->pptr_names); | |
| return 0; | |
| } | |
| /* Count the number of parent pointers. */ | |
| STATIC int | |
| xchk_parent_count_pptr( | |
| struct xfs_scrub *sc, | |
| struct xfs_inode *ip, | |
| unsigned int attr_flags, | |
| const unsigned char *name, | |
| unsigned int namelen, | |
| const void *value, | |
| unsigned int valuelen, | |
| void *priv) | |
| { | |
| struct xchk_pptrs *pp = priv; | |
| int error; | |
| if (!(attr_flags & XFS_ATTR_PARENT)) | |
| return 0; | |
| error = xfs_parent_from_attr(sc->mp, attr_flags, name, namelen, value, | |
| valuelen, NULL, NULL); | |
| if (error) | |
| return error; | |
| pp->pptrs_found++; | |
| return 0; | |
| } | |
| /* | |
| * Compare the number of parent pointers to the link count. For | |
| * non-directories these should be the same. For unlinked directories the | |
| * count should be zero; for linked directories, it should be nonzero. | |
| */ | |
| STATIC int | |
| xchk_parent_count_pptrs( | |
| struct xchk_pptrs *pp) | |
| { | |
| struct xfs_scrub *sc = pp->sc; | |
| int error; | |
| /* | |
| * If we cycled the ILOCK while cross-checking parent pointers with | |
| * dirents, then we need to recalculate the number of parent pointers. | |
| */ | |
| if (pp->need_revalidate) { | |
| pp->pptrs_found = 0; | |
| error = xchk_xattr_walk(sc, sc->ip, xchk_parent_count_pptr, | |
| NULL, pp); | |
| if (error == -EFSCORRUPTED) { | |
| /* Found a bad parent pointer */ | |
| xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0); | |
| return 0; | |
| } | |
| if (error) | |
| return error; | |
| } | |
| if (S_ISDIR(VFS_I(sc->ip)->i_mode)) { | |
| if (xchk_inode_is_dirtree_root(sc->ip)) | |
| pp->pptrs_found++; | |
| if (VFS_I(sc->ip)->i_nlink == 0 && pp->pptrs_found > 0) | |
| xchk_ip_set_corrupt(sc, sc->ip); | |
| else if (VFS_I(sc->ip)->i_nlink > 0 && | |
| pp->pptrs_found == 0) | |
| xchk_ip_set_corrupt(sc, sc->ip); | |
| } else { | |
| /* | |
| * Starting with metadir, we allow checking of parent pointers | |
| * of non-directory files that are children of the superblock. | |
| * Pretend that we found a parent pointer attr. | |
| */ | |
| if (xfs_has_metadir(sc->mp) && xchk_inode_is_sb_rooted(sc->ip)) | |
| pp->pptrs_found++; | |
| if (VFS_I(sc->ip)->i_nlink != pp->pptrs_found) | |
| xchk_ip_set_corrupt(sc, sc->ip); | |
| } | |
| return 0; | |
| } | |
| /* Check parent pointers of a file. */ | |
| STATIC int | |
| xchk_parent_pptr( | |
| struct xfs_scrub *sc) | |
| { | |
| struct xchk_pptrs *pp; | |
| int error; | |
| pp = kvzalloc_obj(struct xchk_pptrs, XCHK_GFP_FLAGS); | |
| if (!pp) | |
| return -ENOMEM; | |
| pp->sc = sc; | |
| pp->xname.name = pp->namebuf; | |
| /* | |
| * Set up some staging memory for parent pointers that we can't check | |
| * due to locking contention. | |
| */ | |
| error = xfarray_create("slow parent pointer entries", 0, | |
| sizeof(struct xchk_pptr), &pp->pptr_entries); | |
| if (error) | |
| goto out_pp; | |
| error = xfblob_create("slow parent pointer names", &pp->pptr_names); | |
| if (error) | |
| goto out_entries; | |
| error = xchk_xattr_walk(sc, sc->ip, xchk_parent_scan_attr, NULL, pp); | |
| if (error == -ECANCELED) { | |
| error = 0; | |
| goto out_names; | |
| } | |
| if (error) | |
| goto out_names; | |
| error = xchk_parent_finish_slow_pptrs(pp); | |
| if (error == -ETIMEDOUT) { | |
| /* Couldn't grab a lock, scrub was marked incomplete */ | |
| error = 0; | |
| goto out_names; | |
| } | |
| if (error) | |
| goto out_names; | |
| if (pp->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) | |
| goto out_names; | |
| /* | |
| * For subdirectories, make sure the dotdot entry references the same | |
| * inode as the parent pointers. | |
| * | |
| * If we're scanning a /consistent/ directory, there should only be | |
| * one parent pointer, and it should point to the same directory as | |
| * the dotdot entry. | |
| * | |
| * However, a corrupt directory tree might feature a subdirectory with | |
| * multiple parents. The directory loop scanner is responsible for | |
| * correcting that kind of problem, so for now we only validate that | |
| * the dotdot entry matches /one/ of the parents. | |
| */ | |
| if (S_ISDIR(VFS_I(sc->ip)->i_mode)) { | |
| error = xchk_parent_pptr_and_dotdot(pp); | |
| if (error) | |
| goto out_names; | |
| } | |
| if (pp->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) | |
| goto out_names; | |
| /* | |
| * Complain if the number of parent pointers doesn't match the link | |
| * count. This could be a sign of missing parent pointers (or an | |
| * incorrect link count). | |
| */ | |
| error = xchk_parent_count_pptrs(pp); | |
| if (error) | |
| goto out_names; | |
| out_names: | |
| xfblob_destroy(pp->pptr_names); | |
| out_entries: | |
| xfarray_destroy(pp->pptr_entries); | |
| out_pp: | |
| kvfree(pp); | |
| return error; | |
| } | |
| /* Scrub a parent pointer. */ | |
| int | |
| xchk_parent( | |
| struct xfs_scrub *sc) | |
| { | |
| struct xfs_mount *mp = sc->mp; | |
| xfs_ino_t parent_ino; | |
| int error = 0; | |
| if (xfs_has_parent(mp)) | |
| return xchk_parent_pptr(sc); | |
| /* | |
| * If we're a directory, check that the '..' link points up to | |
| * a directory that has one entry pointing to us. | |
| */ | |
| if (!S_ISDIR(VFS_I(sc->ip)->i_mode)) | |
| return -ENOENT; | |
| /* We're not a special inode, are we? */ | |
| if (!xfs_verify_dir_ino(mp, I_INO(sc->ip))) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| do { | |
| if (xchk_should_terminate(sc, &error)) | |
| break; | |
| /* Look up '..' */ | |
| error = xchk_dir_lookup(sc, sc->ip, &xfs_name_dotdot, | |
| &parent_ino); | |
| if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error)) | |
| return error; | |
| if (!xfs_verify_dir_ino(mp, parent_ino)) { | |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); | |
| return 0; | |
| } | |
| /* | |
| * Check that the dotdot entry points to a parent directory | |
| * containing a dirent pointing to this subdirectory. | |
| */ | |
| error = xchk_parent_validate(sc, parent_ino); | |
| } while (error == -EAGAIN); | |
| if (error == -EBUSY) { | |
| /* | |
| * We could not scan a directory, so we marked the check | |
| * incomplete. No further error return is necessary. | |
| */ | |
| return 0; | |
| } | |
| return error; | |
| } | |
| /* | |
| * Decide if this file's extended attributes (and therefore its parent | |
| * pointers) have been zapped to satisfy the inode and ifork verifiers. | |
| * Checking and repairing should be postponed until the extended attribute | |
| * structure is fixed. | |
| */ | |
| bool | |
| xchk_pptr_looks_zapped( | |
| struct xfs_inode *ip) | |
| { | |
| struct inode *inode = VFS_I(ip); | |
| ASSERT(xfs_has_parent(ip->i_mount)); | |
| /* | |
| * Temporary files that cannot be linked into the directory tree do not | |
| * have attr forks because they cannot ever have parents. | |
| */ | |
| if (inode->i_nlink == 0 && !(inode_state_read_once(inode) & I_LINKABLE)) | |
| return false; | |
| /* | |
| * Directory tree roots do not have parents, so the expected outcome | |
| * of a parent pointer scan is always the empty set. It's safe to scan | |
| * them even if the attr fork was zapped. | |
| */ | |
| if (xchk_inode_is_dirtree_root(ip)) | |
| return false; | |
| /* | |
| * Metadata inodes that are rooted in the superblock do not have any | |
| * parents. Hence the attr fork will not be initialized, but there are | |
| * no parent pointers that might have been zapped. | |
| */ | |
| if (xchk_inode_is_sb_rooted(ip)) | |
| return false; | |
| /* | |
| * Linked and linkable non-rootdir files should always have an | |
| * attribute fork because that is where parent pointers are | |
| * stored. If the fork is absent, something is amiss. | |
| */ | |
| if (!xfs_inode_has_attr_fork(ip)) | |
| return true; | |
| /* Repair zapped this file's attr fork a short time ago */ | |
| if (xfs_ifork_zapped(ip, XFS_ATTR_FORK)) | |
| return true; | |
| /* | |
| * If the dinode repair found a bad attr fork, it will reset the fork | |
| * to extents format with zero records and wait for the bmapbta | |
| * scrubber to reconstruct the block mappings. The extended attribute | |
| * structure always contain some content when parent pointers are | |
| * enabled, so this is a clear sign of a zapped attr fork. | |
| */ | |
| return ip->i_af.if_format == XFS_DINODE_FMT_EXTENTS && | |
| ip->i_af.if_nextents == 0; | |
| } |