LU-1994 llite: atomic_open support

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

diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c
index cad36a4..6ce32f7 100644 (file)
--- a/lustre/llite/dcache.c
+++ b/lustre/llite/dcache.c
@@ -262,7 +262,20 @@ void ll_intent_drop_lock(struct lookup_intent *it)
         struct lustre_handle *handle;
 
         if (it->it_op && it->d.lustre.it_lock_mode) {
-                handle = (struct lustre_handle *)&it->d.lustre.it_lock_handle;
+               struct ldlm_lock *lock;
+
+               handle = (struct lustre_handle *)&it->d.lustre.it_lock_handle;
+               lock = ldlm_handle2lock(handle);
+               if (lock != NULL) {
+                       /* it can only be allowed to match after layout is
+                        * applied to inode otherwise false layout would be
+                        * seen. Applying layout shoud happen before dropping
+                        * the intent lock. */
+                       if (it->d.lustre.it_lock_bits & MDS_INODELOCK_LAYOUT)
+                               ldlm_lock_allow_match(lock);
+                       LDLM_LOCK_PUT(lock);
+               }
+
                 CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
                        " from it %p\n", handle->cookie, it);
                 ldlm_lock_decref(handle, it->d.lustre.it_lock_mode);
@@ -296,6 +309,7 @@ void ll_intent_release(struct lookup_intent *it)
 void ll_invalidate_aliases(struct inode *inode)
 {
        struct dentry *dentry;
+       struct ll_d_hlist_node *p;
        ENTRY;
 
        LASSERT(inode != NULL);
@@ -304,11 +318,11 @@ void ll_invalidate_aliases(struct inode *inode)
               inode->i_ino, inode->i_generation, inode);
 
        ll_lock_dcache(inode);
-       cfs_list_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,
-                       dentry->d_inode, dentry->d_flags);
+       ll_d_hlist_for_each_entry(dentry, p, &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,
+                      dentry->d_inode, dentry->d_flags);
 
                 if (dentry->d_name.len == 1 && dentry->d_name.name[0] == '/') {
                         CERROR("called on root (?) dentry=%p, inode=%p "
@@ -461,7 +475,7 @@ int ll_revalidate_it(struct dentry *de, int lookup_flags,
                 ibits = MDS_INODELOCK_LOOKUP;
                 if (!ll_have_md_lock(inode, &ibits, LCK_MINMODE))
                         goto do_lock;
-                cfs_mutex_lock(&lli->lli_och_mutex);
+               mutex_lock(&lli->lli_och_mutex);
                 if (*och_p) { /* Everything is open already, do nothing */
                         /*(*och_usecount)++;  Do not let them steal our open
                           handle from under us */
@@ -473,10 +487,10 @@ int ll_revalidate_it(struct dentry *de, int lookup_flags,
                            hope the lock won't be invalidated in between. But
                            if it would be, we'll reopen the open request to
                            MDS later during file open path */
-                        cfs_mutex_unlock(&lli->lli_och_mutex);
+                       mutex_unlock(&lli->lli_och_mutex);
                         RETURN(1);
                 } else {
-                        cfs_mutex_unlock(&lli->lli_och_mutex);
+                       mutex_unlock(&lli->lli_och_mutex);
                 }
         }
 
@@ -495,7 +509,8 @@ do_lock:
         if (IS_ERR(op_data))
                 RETURN(PTR_ERR(op_data));
 
-        it->it_create_mode &= ~cfs_curproc_umask();
+        if (!IS_POSIXACL(parent) || !exp_connect_umask(exp))
+                it->it_create_mode &= ~cfs_curproc_umask();
         it->it_create_mode |= M_CHECK_STALE;
         rc = md_intent_lock(exp, op_data, NULL, 0, it,
                             lookup_flags,
@@ -542,6 +557,9 @@ out:
         if (req != NULL && !it_disposition(it, DISP_ENQ_COMPLETE))
                 ptlrpc_req_finished(req);
         if (rc == 0) {
+               /* mdt may grant layout lock for the newly created file, so
+                * release the lock to avoid leaking */
+               ll_intent_drop_lock(it);
                ll_invalidate_aliases(de->d_inode);
        } else {
                __u64 bits = 0;
@@ -624,6 +642,34 @@ out_sa:
         goto mark;
 }
 
+#ifdef HAVE_IOP_ATOMIC_OPEN
+/*
+ * Always trust cached dentries. Update statahead window if necessary.
+ */
+int ll_revalidate_nd(struct dentry *dentry, unsigned int flags)
+{
+       struct inode *parent = dentry->d_parent->d_inode;
+       int unplug = 0;
+
+       ENTRY;
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%s,flags=%u\n",
+              dentry->d_name.name, flags);
+
+       if (!(flags & (LOOKUP_PARENT|LOOKUP_OPEN|LOOKUP_CREATE)) &&
+           ll_need_statahead(parent, dentry) > 0) {
+               if (flags & LOOKUP_RCU)
+                       RETURN(-ECHILD);
+
+               if (dentry->d_inode == NULL)
+                       unplug = 1;
+               do_statahead_enter(parent, &dentry, unplug);
+               ll_statahead_mark(parent, dentry);
+       }
+
+       RETURN(1);
+}
+
+#else /* !HAVE_IOP_ATOMIC_OPEN */
 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
 {
         int rc;
@@ -691,6 +737,7 @@ out_it:
 
         RETURN(rc);
 }
+#endif /* HAVE_IOP_ATOMIC_OPEN */
 
 void ll_d_iput(struct dentry *de, struct inode *inode)
 {