1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2017-2023 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <djwong@kernel.org>
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_trans_resv.h"
11#include "xfs_mount.h"
12#include "xfs_log_format.h"
13#include "xfs_inode.h"
14#include "xfs_icache.h"
15#include "xfs_dir2.h"
16#include "xfs_dir2_priv.h"
17#include "scrub/scrub.h"
18#include "scrub/common.h"
19#include "scrub/readdir.h"
20
21/* Set us up to scrub parents. */
22int
23xchk_setup_parent(
24 struct xfs_scrub *sc)
25{
26 return xchk_setup_inode_contents(sc, 0);
27}
28
29/* Parent pointers */
30
31/* Look for an entry in a parent pointing to this inode. */
32
33struct xchk_parent_ctx {
34 struct xfs_scrub *sc;
35 xfs_nlink_t nlink;
36};
37
38/* Look for a single entry in a directory pointing to an inode. */
39STATIC int
40xchk_parent_actor(
41 struct xfs_scrub *sc,
42 struct xfs_inode *dp,
43 xfs_dir2_dataptr_t dapos,
44 const struct xfs_name *name,
45 xfs_ino_t ino,
46 void *priv)
47{
48 struct xchk_parent_ctx *spc = priv;
49 int error = 0;
50
51 /* Does this name make sense? */
52 if (!xfs_dir2_namecheck(name->name, name->len))
53 error = -EFSCORRUPTED;
54 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
55 return error;
56
57 if (sc->ip->i_ino == ino)
58 spc->nlink++;
59
60 if (xchk_should_terminate(spc->sc, &error))
61 return error;
62
63 return 0;
64}
65
66/*
67 * Try to lock a parent directory for checking dirents. Returns the inode
68 * flags for the locks we now hold, or zero if we failed.
69 */
70STATIC unsigned int
71xchk_parent_ilock_dir(
72 struct xfs_inode *dp)
73{
74 if (!xfs_ilock_nowait(dp, XFS_ILOCK_SHARED))
75 return 0;
76
77 if (!xfs_need_iread_extents(&dp->i_df))
78 return XFS_ILOCK_SHARED;
79
80 xfs_iunlock(dp, XFS_ILOCK_SHARED);
81
82 if (!xfs_ilock_nowait(dp, XFS_ILOCK_EXCL))
83 return 0;
84
85 return XFS_ILOCK_EXCL;
86}
87
88/*
89 * Given the inode number of the alleged parent of the inode being scrubbed,
90 * try to validate that the parent has exactly one directory entry pointing
91 * back to the inode being scrubbed. Returns -EAGAIN if we need to revalidate
92 * the dotdot entry.
93 */
94STATIC int
95xchk_parent_validate(
96 struct xfs_scrub *sc,
97 xfs_ino_t parent_ino)
98{
99 struct xchk_parent_ctx spc = {
100 .sc = sc,
101 .nlink = 0,
102 };
103 struct xfs_mount *mp = sc->mp;
104 struct xfs_inode *dp = NULL;
105 xfs_nlink_t expected_nlink;
106 unsigned int lock_mode;
107 int error = 0;
108
109 /* Is this the root dir? Then '..' must point to itself. */
110 if (sc->ip == mp->m_rootip) {
111 if (sc->ip->i_ino != mp->m_sb.sb_rootino ||
112 sc->ip->i_ino != parent_ino)
113 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
114 return 0;
115 }
116
117 /* '..' must not point to ourselves. */
118 if (sc->ip->i_ino == parent_ino) {
119 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
120 return 0;
121 }
122
123 /*
124 * If we're an unlinked directory, the parent /won't/ have a link
125 * to us. Otherwise, it should have one link.
126 */
127 expected_nlink = VFS_I(sc->ip)->i_nlink == 0 ? 0 : 1;
128
129 /*
130 * Grab the parent directory inode. This must be released before we
131 * cancel the scrub transaction.
132 *
133 * If _iget returns -EINVAL or -ENOENT then the parent inode number is
134 * garbage and the directory is corrupt. If the _iget returns
135 * -EFSCORRUPTED or -EFSBADCRC then the parent is corrupt which is a
136 * cross referencing error. Any other error is an operational error.
137 */
138 error = xchk_iget(sc, parent_ino, &dp);
139 if (error == -EINVAL || error == -ENOENT) {
140 error = -EFSCORRUPTED;
141 xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error);
142 return error;
143 }
144 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
145 return error;
146 if (dp == sc->ip || !S_ISDIR(VFS_I(dp)->i_mode)) {
147 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
148 goto out_rele;
149 }
150
151 lock_mode = xchk_parent_ilock_dir(dp);
152 if (!lock_mode) {
153 xchk_iunlock(sc, XFS_ILOCK_EXCL);
154 xchk_ilock(sc, XFS_ILOCK_EXCL);
155 error = -EAGAIN;
156 goto out_rele;
157 }
158
159 /*
160 * We cannot yet validate this parent pointer if the directory looks as
161 * though it has been zapped by the inode record repair code.
162 */
163 if (xchk_dir_looks_zapped(dp)) {
164 error = -EBUSY;
165 xchk_set_incomplete(sc);
166 goto out_unlock;
167 }
168
169 /* Look for a directory entry in the parent pointing to the child. */
170 error = xchk_dir_walk(sc, dp, xchk_parent_actor, &spc);
171 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
172 goto out_unlock;
173
174 /*
175 * Ensure that the parent has as many links to the child as the child
176 * thinks it has to the parent.
177 */
178 if (spc.nlink != expected_nlink)
179 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
180
181out_unlock:
182 xfs_iunlock(dp, lock_mode);
183out_rele:
184 xchk_irele(sc, dp);
185 return error;
186}
187
188/* Scrub a parent pointer. */
189int
190xchk_parent(
191 struct xfs_scrub *sc)
192{
193 struct xfs_mount *mp = sc->mp;
194 xfs_ino_t parent_ino;
195 int error = 0;
196
197 /*
198 * If we're a directory, check that the '..' link points up to
199 * a directory that has one entry pointing to us.
200 */
201 if (!S_ISDIR(VFS_I(sc->ip)->i_mode))
202 return -ENOENT;
203
204 /* We're not a special inode, are we? */
205 if (!xfs_verify_dir_ino(mp, sc->ip->i_ino)) {
206 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
207 return 0;
208 }
209
210 do {
211 if (xchk_should_terminate(sc, &error))
212 break;
213
214 /* Look up '..' */
215 error = xchk_dir_lookup(sc, sc->ip, &xfs_name_dotdot,
216 &parent_ino);
217 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
218 return error;
219 if (!xfs_verify_dir_ino(mp, parent_ino)) {
220 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
221 return 0;
222 }
223
224 /*
225 * Check that the dotdot entry points to a parent directory
226 * containing a dirent pointing to this subdirectory.
227 */
228 error = xchk_parent_validate(sc, parent_ino);
229 } while (error == -EAGAIN);
230 if (error == -EBUSY) {
231 /*
232 * We could not scan a directory, so we marked the check
233 * incomplete. No further error return is necessary.
234 */
235 return 0;
236 }
237
238 return error;
239}
240

source code of linux/fs/xfs/scrub/parent.c