LU-10934 llite: integrate statx() API with Lustre

[fs/lustre-release.git] / lustre / llite / dcache.c

diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c
index cc03462..a02055f 100644 (file)
--- a/lustre/llite/dcache.c
+++ b/lustre/llite/dcache.c
@@ -66,6 +66,55 @@ static void ll_release(struct dentry *de)
        EXIT;
 }
 
+/* Compare if two dentries are the same.  Don't match if the existing dentry
+ * is marked invalid.  Returns 1 if different, 0 if the same.
+ *
+ * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
+ * an AST before calling d_revalidate_it().  The dentry still exists (marked
+ * INVALID) so d_lookup() matches it, but we have no lock on it (so
+ * lock_match() fails) and we spin around real_lookup().
+ *
+ * This race doesn't apply to lookups in d_alloc_parallel(), and for
+ * those we want to ensure that only one dentry with a given name is
+ * in ll_lookup_nd() at a time.  So allow invalid dentries to match
+ * while d_in_lookup().  We will be called again when the lookup
+ * completes, and can give a different answer then.
+ */
+#if defined(HAVE_D_COMPARE_5ARGS)
+static int ll_dcompare(const struct dentry *parent, const struct dentry *dentry,
+                      unsigned int len, const char *str,
+                      const struct qstr *name)
+#elif defined(HAVE_D_COMPARE_4ARGS)
+static int ll_dcompare(const struct dentry *dentry, unsigned int len,
+                      const char *str, const struct qstr *name)
+#endif
+{
+       ENTRY;
+
+       if (len != name->len)
+               RETURN(1);
+
+       if (memcmp(str, name->name, len))
+               RETURN(1);
+
+       CDEBUG(D_DENTRY, "found name %.*s(%p) flags %#x refc %d\n",
+              name->len, name->name, dentry, dentry->d_flags,
+              ll_d_count(dentry));
+
+       /* mountpoint is always valid */
+       if (d_mountpoint((struct dentry *)dentry))
+               RETURN(0);
+
+       /* ensure exclusion against parallel lookup of the same name */
+       if (d_in_lookup((struct dentry *)dentry))
+               return 0;
+
+       if (d_lustre_invalid(dentry))
+               RETURN(1);
+
+       RETURN(0);
+}
+
 /**
  * Called when last reference to a dentry is dropped and dcache wants to know
  * whether or not it should cache it:
@@ -78,9 +127,9 @@ static int ll_ddelete(const struct dentry *de)
        ENTRY;
        LASSERT(de);
 
-       CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
+       CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
               d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
-              de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
+              de, de, de->d_parent, de->d_inode,
               d_unhashed((struct dentry *)de) ? "" : "hashed,",
               list_empty(&de->d_subdirs) ? "" : "subdirs");
 
@@ -97,9 +146,9 @@ int ll_d_init(struct dentry *de)
        ENTRY;
        LASSERT(de != NULL);
 
-       CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
-               de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
-               ll_d_count(de));
+       CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
+              de, de, de->d_parent, de->d_inode,
+              ll_d_count(de));
 
        if (de->d_fsdata == NULL) {
                struct ll_dentry_data *lld;
@@ -180,9 +229,9 @@ void ll_invalidate_aliases(struct inode *inode)
 
        spin_lock(&inode->i_lock);
        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
-               CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
-                      "inode %p flags %d\n", dentry->d_name.len,
-                      dentry->d_name.name, dentry, dentry->d_parent,
+               CDEBUG(D_DENTRY,
+                      "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
+                      dentry, dentry, dentry->d_parent,
                       dentry->d_inode, dentry->d_flags);
 
                d_lustre_invalidate(dentry, 0);
@@ -241,14 +290,6 @@ static int ll_revalidate_dentry(struct dentry *dentry,
        CDEBUG(D_VFSTRACE, "VFS Op:name=%s, flags=%u\n",
               dentry->d_name.name, lookup_flags);
 
-       /* mountpoint is always valid */
-       if (d_mountpoint((struct dentry *)dentry))
-               return 1;
-
-       /* No lock -> invalid dentry */
-       if (d_lustre_invalid(dentry))
-               return 0;
-
        /* If this is intermediate component path lookup and we were able to get
         * to this dentry, then its lock has not been revoked and the
         * path component is valid. */
@@ -276,7 +317,7 @@ static int ll_revalidate_dentry(struct dentry *dentry,
                return -ECHILD;
 
        if (dentry_may_statahead(dir, dentry))
-               ll_statahead(dir, &dentry, dentry->d_inode == NULL);
+               ll_revalidate_statahead(dir, &dentry, dentry->d_inode == NULL);
 
        return 1;
 }
@@ -285,4 +326,5 @@ const struct dentry_operations ll_d_ops = {
        .d_revalidate   = ll_revalidate_dentry,
         .d_release = ll_release,
         .d_delete  = ll_ddelete,
+        .d_compare = ll_dcompare,
 };