1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * dentry cache handling code
7 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
11 #include <linux/types.h>
12 #include <linux/slab.h>
13 #include <linux/namei.h>
15 #include <cluster/masklog.h>
24 #include "ocfs2_trace.h"
26 void ocfs2_dentry_attach_gen(struct dentry
*dentry
)
29 OCFS2_I(d_inode(dentry
->d_parent
))->ip_dir_lock_gen
;
30 BUG_ON(d_inode(dentry
));
31 dentry
->d_fsdata
= (void *)gen
;
35 static int ocfs2_dentry_revalidate(struct dentry
*dentry
, unsigned int flags
)
38 int ret
= 0; /* if all else fails, just return false */
39 struct ocfs2_super
*osb
;
41 if (flags
& LOOKUP_RCU
)
44 inode
= d_inode(dentry
);
45 osb
= OCFS2_SB(dentry
->d_sb
);
47 trace_ocfs2_dentry_revalidate(dentry
, dentry
->d_name
.len
,
50 /* For a negative dentry -
51 * check the generation number of the parent and compare with the
52 * one stored in the inode.
55 unsigned long gen
= (unsigned long) dentry
->d_fsdata
;
57 spin_lock(&dentry
->d_lock
);
58 pgen
= OCFS2_I(d_inode(dentry
->d_parent
))->ip_dir_lock_gen
;
59 spin_unlock(&dentry
->d_lock
);
60 trace_ocfs2_dentry_revalidate_negative(dentry
->d_name
.len
,
70 if (inode
== osb
->root_inode
|| is_bad_inode(inode
))
73 spin_lock(&OCFS2_I(inode
)->ip_lock
);
74 /* did we or someone else delete this inode? */
75 if (OCFS2_I(inode
)->ip_flags
& OCFS2_INODE_DELETED
) {
76 spin_unlock(&OCFS2_I(inode
)->ip_lock
);
77 trace_ocfs2_dentry_revalidate_delete(
78 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
81 spin_unlock(&OCFS2_I(inode
)->ip_lock
);
84 * We don't need a cluster lock to test this because once an
85 * inode nlink hits zero, it never goes back.
87 if (inode
->i_nlink
== 0) {
88 trace_ocfs2_dentry_revalidate_orphaned(
89 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
90 S_ISDIR(inode
->i_mode
));
95 * If the last lookup failed to create dentry lock, let us
98 if (!dentry
->d_fsdata
) {
99 trace_ocfs2_dentry_revalidate_nofsdata(
100 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
108 trace_ocfs2_dentry_revalidate_ret(ret
);
112 static int ocfs2_match_dentry(struct dentry
*dentry
,
116 struct inode
*parent
;
119 * ocfs2_lookup() does a d_splice_alias() _before_ attaching
120 * to the lock data, so we skip those here, otherwise
121 * ocfs2_dentry_attach_lock() will get its original dentry
124 if (!dentry
->d_fsdata
)
127 if (!dentry
->d_parent
)
130 if (skip_unhashed
&& d_unhashed(dentry
))
133 parent
= d_inode(dentry
->d_parent
);
134 /* Negative parent dentry? */
138 /* Name is in a different directory. */
139 if (OCFS2_I(parent
)->ip_blkno
!= parent_blkno
)
146 * Walk the inode alias list, and find a dentry which has a given
147 * parent. ocfs2_dentry_attach_lock() wants to find _any_ alias as it
148 * is looking for a dentry_lock reference. The downconvert thread is
149 * looking to unhash aliases, so we allow it to skip any that already
150 * have that property.
152 struct dentry
*ocfs2_find_local_alias(struct inode
*inode
,
156 struct dentry
*dentry
;
158 spin_lock(&inode
->i_lock
);
159 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_u
.d_alias
) {
160 spin_lock(&dentry
->d_lock
);
161 if (ocfs2_match_dentry(dentry
, parent_blkno
, skip_unhashed
)) {
162 trace_ocfs2_find_local_alias(dentry
->d_name
.len
,
163 dentry
->d_name
.name
);
166 spin_unlock(&dentry
->d_lock
);
167 spin_unlock(&inode
->i_lock
);
170 spin_unlock(&dentry
->d_lock
);
172 spin_unlock(&inode
->i_lock
);
176 DEFINE_SPINLOCK(dentry_attach_lock
);
179 * Attach this dentry to a cluster lock.
181 * Dentry locks cover all links in a given directory to a particular
182 * inode. We do this so that ocfs2 can build a lock name which all
183 * nodes in the cluster can agree on at all times. Shoving full names
184 * in the cluster lock won't work due to size restrictions. Covering
185 * links inside of a directory is a good compromise because it still
186 * allows us to use the parent directory lock to synchronize
189 * Call this function with the parent dir semaphore and the parent dir
192 * The dir semaphore will protect us from having to worry about
193 * concurrent processes on our node trying to attach a lock at the
196 * The dir cluster lock (held at either PR or EX mode) protects us
197 * from unlink and rename on other nodes.
199 * A dput() can happen asynchronously due to pruning, so we cover
200 * attaching and detaching the dentry lock with a
201 * dentry_attach_lock.
203 * A node which has done lookup on a name retains a protected read
204 * lock until final dput. If the user requests and unlink or rename,
205 * the protected read is upgraded to an exclusive lock. Other nodes
206 * who have seen the dentry will then be informed that they need to
207 * downgrade their lock, which will involve d_delete on the
208 * dentry. This happens in ocfs2_dentry_convert_worker().
210 int ocfs2_dentry_attach_lock(struct dentry
*dentry
,
215 struct dentry
*alias
;
216 struct ocfs2_dentry_lock
*dl
= dentry
->d_fsdata
;
218 trace_ocfs2_dentry_attach_lock(dentry
->d_name
.len
, dentry
->d_name
.name
,
219 (unsigned long long)parent_blkno
, dl
);
222 * Negative dentry. We ignore these for now.
224 * XXX: Could we can improve ocfs2_dentry_revalidate() by
230 if (d_really_is_negative(dentry
) && dentry
->d_fsdata
) {
231 /* Converting a negative dentry to positive
232 Clear dentry->d_fsdata */
233 dentry
->d_fsdata
= dl
= NULL
;
237 mlog_bug_on_msg(dl
->dl_parent_blkno
!= parent_blkno
,
238 " \"%pd\": old parent: %llu, new: %llu\n",
240 (unsigned long long)parent_blkno
,
241 (unsigned long long)dl
->dl_parent_blkno
);
245 alias
= ocfs2_find_local_alias(inode
, parent_blkno
, 0);
248 * Great, an alias exists, which means we must have a
249 * dentry lock already. We can just grab the lock off
250 * the alias and add it to the list.
252 * We're depending here on the fact that this dentry
253 * was found and exists in the dcache and so must have
254 * a reference to the dentry_lock because we can't
255 * race creates. Final dput() cannot happen on it
256 * since we have it pinned, so our reference is safe.
258 dl
= alias
->d_fsdata
;
259 mlog_bug_on_msg(!dl
, "parent %llu, ino %llu\n",
260 (unsigned long long)parent_blkno
,
261 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
263 mlog_bug_on_msg(dl
->dl_parent_blkno
!= parent_blkno
,
264 " \"%pd\": old parent: %llu, new: %llu\n",
266 (unsigned long long)parent_blkno
,
267 (unsigned long long)dl
->dl_parent_blkno
);
269 trace_ocfs2_dentry_attach_lock_found(dl
->dl_lockres
.l_name
,
270 (unsigned long long)parent_blkno
,
271 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
277 * There are no other aliases
279 dl
= kmalloc(sizeof(*dl
), GFP_NOFS
);
288 * Does this have to happen below, for all attaches, in case
289 * the struct inode gets blown away by the downconvert thread?
291 dl
->dl_inode
= igrab(inode
);
292 dl
->dl_parent_blkno
= parent_blkno
;
293 ocfs2_dentry_lock_res_init(dl
, parent_blkno
, inode
);
296 spin_lock(&dentry_attach_lock
);
297 if (unlikely(dentry
->d_fsdata
&& !alias
)) {
298 /* d_fsdata is set by a racing thread which is doing
299 * the same thing as this thread is doing. Leave the racing
300 * thread going ahead and we return here.
302 spin_unlock(&dentry_attach_lock
);
304 ocfs2_lock_res_free(&dl
->dl_lockres
);
309 dentry
->d_fsdata
= dl
;
311 spin_unlock(&dentry_attach_lock
);
314 * This actually gets us our PRMODE level lock. From now on,
315 * we'll have a notification if one of these names is
316 * destroyed on another node.
318 ret
= ocfs2_dentry_lock(dentry
, 0);
320 ocfs2_dentry_unlock(dentry
, 0);
325 * In case of error, manually free the allocation and do the iput().
326 * We need to do this because error here means no d_instantiate(),
327 * which means iput() will not be called during dput(dentry).
329 if (ret
< 0 && !alias
) {
330 ocfs2_lock_res_free(&dl
->dl_lockres
);
331 BUG_ON(dl
->dl_count
!= 1);
332 spin_lock(&dentry_attach_lock
);
333 dentry
->d_fsdata
= NULL
;
334 spin_unlock(&dentry_attach_lock
);
345 * ocfs2_dentry_iput() and friends.
347 * At this point, our particular dentry is detached from the inodes
348 * alias list, so there's no way that the locking code can find it.
350 * The interesting stuff happens when we determine that our lock needs
351 * to go away because this is the last subdir alias in the
352 * system. This function needs to handle a couple things:
354 * 1) Synchronizing lock shutdown with the downconvert threads. This
355 * is already handled for us via the lockres release drop function
356 * called in ocfs2_release_dentry_lock()
358 * 2) A race may occur when we're doing our lock shutdown and
359 * another process wants to create a new dentry lock. Right now we
360 * let them race, which means that for a very short while, this
361 * node might have two locks on a lock resource. This should be a
362 * problem though because one of them is in the process of being
365 static void ocfs2_drop_dentry_lock(struct ocfs2_super
*osb
,
366 struct ocfs2_dentry_lock
*dl
)
369 ocfs2_simple_drop_lockres(osb
, &dl
->dl_lockres
);
370 ocfs2_lock_res_free(&dl
->dl_lockres
);
374 void ocfs2_dentry_lock_put(struct ocfs2_super
*osb
,
375 struct ocfs2_dentry_lock
*dl
)
379 BUG_ON(dl
->dl_count
== 0);
381 spin_lock(&dentry_attach_lock
);
383 unlock
= !dl
->dl_count
;
384 spin_unlock(&dentry_attach_lock
);
387 ocfs2_drop_dentry_lock(osb
, dl
);
390 static void ocfs2_dentry_iput(struct dentry
*dentry
, struct inode
*inode
)
392 struct ocfs2_dentry_lock
*dl
= dentry
->d_fsdata
;
396 * No dentry lock is ok if we're disconnected or
399 if (!(dentry
->d_flags
& DCACHE_DISCONNECTED
) &&
400 !d_unhashed(dentry
)) {
401 unsigned long long ino
= 0ULL;
403 ino
= (unsigned long long)OCFS2_I(inode
)->ip_blkno
;
404 mlog(ML_ERROR
, "Dentry is missing cluster lock. "
405 "inode: %llu, d_flags: 0x%x, d_name: %pd\n",
406 ino
, dentry
->d_flags
, dentry
);
412 mlog_bug_on_msg(dl
->dl_count
== 0, "dentry: %pd, count: %u\n",
413 dentry
, dl
->dl_count
);
415 ocfs2_dentry_lock_put(OCFS2_SB(dentry
->d_sb
), dl
);
422 * d_move(), but keep the locks in sync.
424 * When we are done, "dentry" will have the parent dir and name of
425 * "target", which will be thrown away.
427 * We manually update the lock of "dentry" if need be.
429 * "target" doesn't have it's dentry lock touched - we allow the later
430 * dput() to handle this for us.
432 * This is called during ocfs2_rename(), while holding parent
433 * directory locks. The dentries have already been deleted on other
434 * nodes via ocfs2_remote_dentry_delete().
436 * Normally, the VFS handles the d_move() for the file system, after
437 * the ->rename() callback. OCFS2 wants to handle this internally, so
438 * the new lock can be created atomically with respect to the cluster.
440 void ocfs2_dentry_move(struct dentry
*dentry
, struct dentry
*target
,
441 struct inode
*old_dir
, struct inode
*new_dir
)
444 struct ocfs2_super
*osb
= OCFS2_SB(old_dir
->i_sb
);
445 struct inode
*inode
= d_inode(dentry
);
448 * Move within the same directory, so the actual lock info won't
451 * XXX: Is there any advantage to dropping the lock here?
453 if (old_dir
== new_dir
)
456 ocfs2_dentry_lock_put(osb
, dentry
->d_fsdata
);
458 dentry
->d_fsdata
= NULL
;
459 ret
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(new_dir
)->ip_blkno
);
464 d_move(dentry
, target
);
467 const struct dentry_operations ocfs2_dentry_ops
= {
468 .d_revalidate
= ocfs2_dentry_revalidate
,
469 .d_iput
= ocfs2_dentry_iput
,