1 files changed, 499 insertions, 377 deletions

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 648e0ac0f90e..6ca2795ccd9c 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -65,6 +65,9 @@ static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *)
 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry);
 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp);
+static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openflags);
+static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
+static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
 
 /* Prevent leaks of NFSv4 errors into userland */
 int nfs4_map_errors(int err)
@@ -214,27 +217,39 @@ static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
 }
 
 struct nfs4_opendata {
-        atomic_t count;
+        struct kref kref;
         struct nfs_openargs o_arg;
         struct nfs_openres o_res;
         struct nfs_open_confirmargs c_arg;
         struct nfs_open_confirmres c_res;
         struct nfs_fattr f_attr;
         struct nfs_fattr dir_attr;
-        struct dentry *dentry;
+        struct path path;
         struct dentry *dir;
         struct nfs4_state_owner *owner;
+        struct nfs4_state *state;
         struct iattr attrs;
         unsigned long timestamp;
+        unsigned int rpc_done : 1;
         int rpc_status;
         int cancelled;
 };
 
-static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
+
+static void nfs4_init_opendata_res(struct nfs4_opendata *p)
+{
+        p->o_res.f_attr = &p->f_attr;
+        p->o_res.dir_attr = &p->dir_attr;
+        p->o_res.server = p->o_arg.server;
+        nfs_fattr_init(&p->f_attr);
+        nfs_fattr_init(&p->dir_attr);
+}
+
+static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
                 struct nfs4_state_owner *sp, int flags,
                 const struct iattr *attrs)
 {
-        struct dentry *parent = dget_parent(dentry);
+        struct dentry *parent = dget_parent(path->dentry);
         struct inode *dir = parent->d_inode;
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs4_opendata *p;
@@ -245,24 +260,19 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
         if (p->o_arg.seqid == NULL)
                 goto err_free;
-        atomic_set(&p->count, 1);
-        p->dentry = dget(dentry);
+        p->path.mnt = mntget(path->mnt);
+        p->path.dentry = dget(path->dentry);
         p->dir = parent;
         p->owner = sp;
         atomic_inc(&sp->so_count);
         p->o_arg.fh = NFS_FH(dir);
         p->o_arg.open_flags = flags,
         p->o_arg.clientid = server->nfs_client->cl_clientid;
-        p->o_arg.id = sp->so_id;
-        p->o_arg.name = &dentry->d_name;
+        p->o_arg.id = sp->so_owner_id.id;
+        p->o_arg.name = &p->path.dentry->d_name;
         p->o_arg.server = server;
         p->o_arg.bitmask = server->attr_bitmask;
         p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
-        p->o_res.f_attr = &p->f_attr;
-        p->o_res.dir_attr = &p->dir_attr;
-        p->o_res.server = server;
-        nfs_fattr_init(&p->f_attr);
-        nfs_fattr_init(&p->dir_attr);
         if (flags & O_EXCL) {
                 u32 *s = (u32 *) p->o_arg.u.verifier.data;
                 s[0] = jiffies;
@@ -274,6 +284,8 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p->c_arg.fh = &p->o_res.fh;
         p->c_arg.stateid = &p->o_res.stateid;
         p->c_arg.seqid = p->o_arg.seqid;
+        nfs4_init_opendata_res(p);
+        kref_init(&p->kref);
         return p;
 err_free:
         kfree(p);
@@ -282,27 +294,25 @@ err:
         return NULL;
 }
 
-static void nfs4_opendata_free(struct nfs4_opendata *p)
+static void nfs4_opendata_free(struct kref *kref)
 {
-        if (p != NULL && atomic_dec_and_test(&p->count)) {
-                nfs_free_seqid(p->o_arg.seqid);
-                nfs4_put_state_owner(p->owner);
-                dput(p->dir);
-                dput(p->dentry);
-                kfree(p);
-        }
+        struct nfs4_opendata *p = container_of(kref,
+                        struct nfs4_opendata, kref);
+
+        nfs_free_seqid(p->o_arg.seqid);
+        if (p->state != NULL)
+                nfs4_put_open_state(p->state);
+        nfs4_put_state_owner(p->owner);
+        dput(p->dir);
+        dput(p->path.dentry);
+        mntput(p->path.mnt);
+        kfree(p);
 }
 
-/* Helper for asynchronous RPC calls */
-static int nfs4_call_async(struct rpc_clnt *clnt,
-                const struct rpc_call_ops *tk_ops, void *calldata)
+static void nfs4_opendata_put(struct nfs4_opendata *p)
 {
-        struct rpc_task *task;
-
-        if (!(task = rpc_new_task(clnt, RPC_TASK_ASYNC, tk_ops, calldata)))
-                return -ENOMEM;
-        rpc_execute(task);
-        return 0;
+        if (p != NULL)
+                kref_put(&p->kref, nfs4_opendata_free);
 }
 
 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
@@ -316,7 +326,34 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
         return ret;
 }
 
-static inline void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
+static int can_open_cached(struct nfs4_state *state, int mode)
+{
+        int ret = 0;
+        switch (mode & (FMODE_READ|FMODE_WRITE|O_EXCL)) {
+                case FMODE_READ:
+                        ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0;
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+                        break;
+                case FMODE_WRITE:
+                        ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0;
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+                        break;
+                case FMODE_READ|FMODE_WRITE:
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+        }
+        return ret;
+}
+
+static int can_open_delegated(struct nfs_delegation *delegation, mode_t open_flags)
+{
+        if ((delegation->type & open_flags) != open_flags)
+                return 0;
+        if (delegation->flags & NFS_DELEGATION_NEED_RECLAIM)
+                return 0;
+        return 1;
+}
+
+static void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
 {
         switch (open_flags) {
                 case FMODE_WRITE:
@@ -328,41 +365,176 @@ static inline void update_open_stateflags(struct nfs4_state *state, mode_t open_
                 case FMODE_READ|FMODE_WRITE:
                         state->n_rdwr++;
         }
+        nfs4_state_set_mode_locked(state, state->state | open_flags);
 }
 
-static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
+static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
 {
-        struct inode *inode = state->inode;
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
+                memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
+        memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
+        switch (open_flags) {
+                case FMODE_READ:
+                        set_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        break;
+                case FMODE_WRITE:
+                        set_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        break;
+                case FMODE_READ|FMODE_WRITE:
+                        set_bit(NFS_O_RDWR_STATE, &state->flags);
+        }
+}
+
+static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
+{
+        write_seqlock(&state->seqlock);
+        nfs_set_open_stateid_locked(state, stateid, open_flags);
+        write_sequnlock(&state->seqlock);
+}
 
+static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *deleg_stateid, int open_flags)
+{
         open_flags &= (FMODE_READ|FMODE_WRITE);
-        /* Protect against nfs4_find_state_byowner() */
+        /*
+         * Protect the call to nfs4_state_set_mode_locked and
+         * serialise the stateid update
+         */
+        write_seqlock(&state->seqlock);
+        if (deleg_stateid != NULL) {
+                memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
+                set_bit(NFS_DELEGATED_STATE, &state->flags);
+        }
+        if (open_stateid != NULL)
+                nfs_set_open_stateid_locked(state, open_stateid, open_flags);
+        write_sequnlock(&state->seqlock);
         spin_lock(&state->owner->so_lock);
-        spin_lock(&inode->i_lock);
-        memcpy(&state->stateid, stateid, sizeof(state->stateid));
         update_open_stateflags(state, open_flags);
-        nfs4_state_set_mode_locked(state, state->state | open_flags);
-        spin_unlock(&inode->i_lock);
         spin_unlock(&state->owner->so_lock);
 }
 
+static void nfs4_return_incompatible_delegation(struct inode *inode, mode_t open_flags)
+{
+        struct nfs_delegation *delegation;
+
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation == NULL || (delegation->type & open_flags) == open_flags) {
+                rcu_read_unlock();
+                return;
+        }
+        rcu_read_unlock();
+        nfs_inode_return_delegation(inode);
+}
+
+static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
+{
+        struct nfs4_state *state = opendata->state;
+        struct nfs_inode *nfsi = NFS_I(state->inode);
+        struct nfs_delegation *delegation;
+        int open_mode = opendata->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL);
+        nfs4_stateid stateid;
+        int ret = -EAGAIN;
+
+        rcu_read_lock();
+        delegation = rcu_dereference(nfsi->delegation);
+        for (;;) {
+                if (can_open_cached(state, open_mode)) {
+                        spin_lock(&state->owner->so_lock);
+                        if (can_open_cached(state, open_mode)) {
+                                update_open_stateflags(state, open_mode);
+                                spin_unlock(&state->owner->so_lock);
+                                rcu_read_unlock();
+                                goto out_return_state;
+                        }
+                        spin_unlock(&state->owner->so_lock);
+                }
+                if (delegation == NULL)
+                        break;
+                if (!can_open_delegated(delegation, open_mode))
+                        break;
+                /* Save the delegation */
+                memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
+                rcu_read_unlock();
+                lock_kernel();
+                ret = _nfs4_do_access(state->inode, state->owner->so_cred, open_mode);
+                unlock_kernel();
+                if (ret != 0)
+                        goto out;
+                ret = -EAGAIN;
+                rcu_read_lock();
+                delegation = rcu_dereference(nfsi->delegation);
+                /* If no delegation, try a cached open */
+                if (delegation == NULL)
+                        continue;
+                /* Is the delegation still valid? */
+                if (memcmp(stateid.data, delegation->stateid.data, sizeof(stateid.data)) != 0)
+                        continue;
+                rcu_read_unlock();
+                update_open_stateid(state, NULL, &stateid, open_mode);
+                goto out_return_state;
+        }
+        rcu_read_unlock();
+out:
+        return ERR_PTR(ret);
+out_return_state:
+        atomic_inc(&state->count);
+        return state;
+}
+
 static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 {
         struct inode *inode;
         struct nfs4_state *state = NULL;
+        struct nfs_delegation *delegation;
+        nfs4_stateid *deleg_stateid = NULL;
+        int ret;
 
-        if (!(data->f_attr.valid & NFS_ATTR_FATTR))
+        if (!data->rpc_done) {
+                state = nfs4_try_open_cached(data);
                 goto out;
+        }
+
+        ret = -EAGAIN;
+        if (!(data->f_attr.valid & NFS_ATTR_FATTR))
+                goto err;
         inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
+        ret = PTR_ERR(inode);
         if (IS_ERR(inode))
-                goto out;
+                goto err;
+        ret = -ENOMEM;
         state = nfs4_get_open_state(inode, data->owner);
         if (state == NULL)
-                goto put_inode;
-        update_open_stateid(state, &data->o_res.stateid, data->o_arg.open_flags);
-put_inode:
+                goto err_put_inode;
+        if (data->o_res.delegation_type != 0) {
+                int delegation_flags = 0;
+
+                rcu_read_lock();
+                delegation = rcu_dereference(NFS_I(inode)->delegation);
+                if (delegation)
+                        delegation_flags = delegation->flags;
+                rcu_read_unlock();
+                if (!(delegation_flags & NFS_DELEGATION_NEED_RECLAIM))
+                        nfs_inode_set_delegation(state->inode,
+                                        data->owner->so_cred,
+                                        &data->o_res);
+                else
+                        nfs_inode_reclaim_delegation(state->inode,
+                                        data->owner->so_cred,
+                                        &data->o_res);
+        }
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation != NULL)
+                deleg_stateid = &delegation->stateid;
+        update_open_stateid(state, &data->o_res.stateid, deleg_stateid, data->o_arg.open_flags);
+        rcu_read_unlock();
         iput(inode);
 out:
         return state;
+err_put_inode:
+        iput(inode);
+err:
+        return ERR_PTR(ret);
 }
 
 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
@@ -382,79 +554,78 @@ static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *
         return ERR_PTR(-ENOENT);
 }
 
-static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, nfs4_stateid *stateid)
+static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
+        struct nfs4_opendata *opendata;
+
+        opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL);
+        if (opendata == NULL)
+                return ERR_PTR(-ENOMEM);
+        opendata->state = state;
+        atomic_inc(&state->count);
+        return opendata;
+}
+
+static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, struct nfs4_state **res)
+{
+        struct nfs4_state *newstate;
         int ret;
 
         opendata->o_arg.open_flags = openflags;
+        memset(&opendata->o_res, 0, sizeof(opendata->o_res));
+        memset(&opendata->c_res, 0, sizeof(opendata->c_res));
+        nfs4_init_opendata_res(opendata);
         ret = _nfs4_proc_open(opendata);
         if (ret != 0)
                 return ret; 
-        memcpy(stateid->data, opendata->o_res.stateid.data,
-                        sizeof(stateid->data));
+        newstate = nfs4_opendata_to_nfs4_state(opendata);
+        if (IS_ERR(newstate))
+                return PTR_ERR(newstate);
+        nfs4_close_state(&opendata->path, newstate, openflags);
+        *res = newstate;
         return 0;
 }
 
 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
 {
-        nfs4_stateid stateid;
         struct nfs4_state *newstate;
-        int mode = 0;
-        int delegation = 0;
         int ret;
 
         /* memory barrier prior to reading state->n_* */
+        clear_bit(NFS_DELEGATED_STATE, &state->flags);
         smp_rmb();
         if (state->n_rdwr != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_READ|FMODE_WRITE;
-                if (opendata->o_res.delegation_type != 0)
-                        delegation = opendata->o_res.delegation_type;
-                smp_rmb();
+                if (newstate != state)
+                        return -ESTALE;
         }
         if (state->n_wronly != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_WRITE;
-                if (opendata->o_res.delegation_type != 0)
-                        delegation = opendata->o_res.delegation_type;
-                smp_rmb();
+                if (newstate != state)
+                        return -ESTALE;
         }
         if (state->n_rdonly != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_READ, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_READ;
+                if (newstate != state)
+                        return -ESTALE;
         }
-        clear_bit(NFS_DELEGATED_STATE, &state->flags);
-        if (mode == 0)
-                return 0;
-        if (opendata->o_res.delegation_type == 0)
-                opendata->o_res.delegation_type = delegation;
-        opendata->o_arg.open_flags |= mode;
-        newstate = nfs4_opendata_to_nfs4_state(opendata);
-        if (newstate != NULL) {
-                if (opendata->o_res.delegation_type != 0) {
-                        struct nfs_inode *nfsi = NFS_I(newstate->inode);
-                        int delegation_flags = 0;
-                        if (nfsi->delegation)
-                                delegation_flags = nfsi->delegation->flags;
-                        if (!(delegation_flags & NFS_DELEGATION_NEED_RECLAIM))
-                                nfs_inode_set_delegation(newstate->inode,
-                                                opendata->owner->so_cred,
-                                                &opendata->o_res);
-                        else
-                                nfs_inode_reclaim_delegation(newstate->inode,
-                                                opendata->owner->so_cred,
-                                                &opendata->o_res);
-                }
-                nfs4_close_state(newstate, opendata->o_arg.open_flags);
+        /*
+         * We may have performed cached opens for all three recoveries.
+         * Check if we need to update the current stateid.
+         */
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
+            memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
+                write_seqlock(&state->seqlock);
+                if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
+                        memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
+                write_sequnlock(&state->seqlock);
         }
-        if (newstate != state)
-                return -ESTALE;
         return 0;
 }
 
@@ -462,41 +633,36 @@ static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *
  * OPEN_RECLAIM:
  *      reclaim state on the server after a reboot.
  */
-static int _nfs4_do_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct nfs_delegation *delegation = NFS_I(state->inode)->delegation;
+        struct nfs_delegation *delegation;
         struct nfs4_opendata *opendata;
         int delegation_type = 0;
         int status;
 
-        if (delegation != NULL) {
-                if (!(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
-                        memcpy(&state->stateid, &delegation->stateid,
-                                        sizeof(state->stateid));
-                        set_bit(NFS_DELEGATED_STATE, &state->flags);
-                        return 0;
-                }
-                delegation_type = delegation->type;
-        }
-        opendata = nfs4_opendata_alloc(dentry, sp, 0, NULL);
-        if (opendata == NULL)
-                return -ENOMEM;
+        opendata = nfs4_open_recoverdata_alloc(ctx, state);
+        if (IS_ERR(opendata))
+                return PTR_ERR(opendata);
         opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;
         opendata->o_arg.fh = NFS_FH(state->inode);
-        nfs_copy_fh(&opendata->o_res.fh, opendata->o_arg.fh);
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(state->inode)->delegation);
+        if (delegation != NULL && (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) != 0)
+                delegation_type = delegation->flags;
+        rcu_read_unlock();
         opendata->o_arg.u.delegation_type = delegation_type;
         status = nfs4_open_recover(opendata, state);
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return status;
 }
 
-static int nfs4_do_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = _nfs4_do_open_reclaim(sp, state, dentry);
+                err = _nfs4_do_open_reclaim(ctx, state);
                 if (err != -NFS4ERR_DELAY)
                         break;
                 nfs4_handle_exception(server, err, &exception);
@@ -512,37 +678,34 @@ static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *sta
         ctx = nfs4_state_find_open_context(state);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
-        ret = nfs4_do_open_reclaim(sp, state, ctx->dentry);
+        ret = nfs4_do_open_reclaim(ctx, state);
         put_nfs_open_context(ctx);
         return ret;
 }
 
-static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
+static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 {
-        struct nfs4_state_owner  *sp  = state->owner;
         struct nfs4_opendata *opendata;
         int ret;
 
-        if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
-                return 0;
-        opendata = nfs4_opendata_alloc(dentry, sp, 0, NULL);
-        if (opendata == NULL)
-                return -ENOMEM;
+        opendata = nfs4_open_recoverdata_alloc(ctx, state);
+        if (IS_ERR(opendata))
+                return PTR_ERR(opendata);
         opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
-        memcpy(opendata->o_arg.u.delegation.data, state->stateid.data,
+        memcpy(opendata->o_arg.u.delegation.data, stateid->data,
                         sizeof(opendata->o_arg.u.delegation.data));
         ret = nfs4_open_recover(opendata, state);
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return ret;
 }
 
-int nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
+int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 {
         struct nfs4_exception exception = { };
-        struct nfs_server *server = NFS_SERVER(dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         int err;
         do {
-                err = _nfs4_open_delegation_recall(dentry, state);
+                err = _nfs4_open_delegation_recall(ctx, state, stateid);
                 switch (err) {
                         case 0:
                                 return err;
@@ -582,9 +745,10 @@ static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
                 memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
                                 sizeof(data->o_res.stateid.data));
                 renew_lease(data->o_res.server, data->timestamp);
+                data->rpc_done = 1;
         }
-        nfs_increment_open_seqid(data->rpc_status, data->c_arg.seqid);
         nfs_confirm_seqid(&data->owner->so_seqid, data->rpc_status);
+        nfs_increment_open_seqid(data->rpc_status, data->c_arg.seqid);
 }
 
 static void nfs4_open_confirm_release(void *calldata)
@@ -596,14 +760,14 @@ static void nfs4_open_confirm_release(void *calldata)
         if (data->cancelled == 0)
                 goto out_free;
         /* In case of error, no cleanup! */
-        if (data->rpc_status != 0)
+        if (!data->rpc_done)
                 goto out_free;
         nfs_confirm_seqid(&data->owner->so_seqid, 0);
         state = nfs4_opendata_to_nfs4_state(data);
-        if (state != NULL)
-                nfs4_close_state(state, data->o_arg.open_flags);
+        if (!IS_ERR(state))
+                nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 out_free:
-        nfs4_opendata_free(data);
+        nfs4_opendata_put(data);
 }
 
 static const struct rpc_call_ops nfs4_open_confirm_ops = {
@@ -621,12 +785,9 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
         struct rpc_task *task;
         int status;
 
-        atomic_inc(&data->count);
-        /*
-         * If rpc_run_task() ends up calling ->rpc_release(), we
-         * want to ensure that it takes the 'error' code path.
-         */
-        data->rpc_status = -ENOMEM;
+        kref_get(&data->kref);
+        data->rpc_done = 0;
+        data->rpc_status = 0;
         task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_confirm_ops, data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
@@ -653,13 +814,37 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
         
         if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
                 return;
+        /*
+         * Check if we still need to send an OPEN call, or if we can use
+         * a delegation instead.
+         */
+        if (data->state != NULL) {
+                struct nfs_delegation *delegation;
+
+                if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL)))
+                        goto out_no_action;
+                rcu_read_lock();
+                delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
+                if (delegation != NULL &&
+                   (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) == 0) {
+                        rcu_read_unlock();
+                        goto out_no_action;
+                }
+                rcu_read_unlock();
+        }
         /* Update sequence id. */
-        data->o_arg.id = sp->so_id;
+        data->o_arg.id = sp->so_owner_id.id;
         data->o_arg.clientid = sp->so_client->cl_clientid;
-        if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
+        if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
                 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
+                nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
+        }
         data->timestamp = jiffies;
         rpc_call_setup(task, &msg, 0);
+        return;
+out_no_action:
+        task->tk_action = NULL;
+
 }
 
 static void nfs4_open_done(struct rpc_task *task, void *calldata)
@@ -683,8 +868,11 @@ static void nfs4_open_done(struct rpc_task *task, void *calldata)
                                 data->rpc_status = -ENOTDIR;
                 }
                 renew_lease(data->o_res.server, data->timestamp);
+                if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
+                        nfs_confirm_seqid(&data->owner->so_seqid, 0);
         }
         nfs_increment_open_seqid(data->rpc_status, data->o_arg.seqid);
+        data->rpc_done = 1;
 }
 
 static void nfs4_open_release(void *calldata)
@@ -696,17 +884,17 @@ static void nfs4_open_release(void *calldata)
         if (data->cancelled == 0)
                 goto out_free;
         /* In case of error, no cleanup! */
-        if (data->rpc_status != 0)
+        if (data->rpc_status != 0 || !data->rpc_done)
                 goto out_free;
         /* In case we need an open_confirm, no cleanup! */
         if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
                 goto out_free;
         nfs_confirm_seqid(&data->owner->so_seqid, 0);
         state = nfs4_opendata_to_nfs4_state(data);
-        if (state != NULL)
-                nfs4_close_state(state, data->o_arg.open_flags);
+        if (!IS_ERR(state))
+                nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 out_free:
-        nfs4_opendata_free(data);
+        nfs4_opendata_put(data);
 }
 
 static const struct rpc_call_ops nfs4_open_ops = {
@@ -727,12 +915,10 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
         struct rpc_task *task;
         int status;
 
-        atomic_inc(&data->count);
-        /*
-         * If rpc_run_task() ends up calling ->rpc_release(), we
-         * want to ensure that it takes the 'error' code path.
-         */
-        data->rpc_status = -ENOMEM;
+        kref_get(&data->kref);
+        data->rpc_done = 0;
+        data->rpc_status = 0;
+        data->cancelled = 0;
         task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_ops, data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
@@ -743,9 +929,12 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
         } else
                 status = data->rpc_status;
         rpc_put_task(task);
-        if (status != 0)
+        if (status != 0 || !data->rpc_done)
                 return status;
 
+        if (o_res->fh.size == 0)
+                _nfs4_proc_lookup(dir, o_arg->name, &o_res->fh, o_res->f_attr);
+
         if (o_arg->open_flags & O_CREAT) {
                 update_changeattr(dir, &o_res->cinfo);
                 nfs_post_op_update_inode(dir, o_res->dir_attr);
@@ -756,9 +945,8 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
                 if (status != 0)
                         return status;
         }
-        nfs_confirm_seqid(&data->owner->so_seqid, 0);
         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
-                return server->nfs_client->rpc_ops->getattr(server, &o_res->fh, o_res->f_attr);
+                _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
         return 0;
 }
 
@@ -772,6 +960,8 @@ static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openf
                 mask |= MAY_READ;
         if (openflags & FMODE_WRITE)
                 mask |= MAY_WRITE;
+        if (openflags & FMODE_EXEC)
+                mask |= MAY_EXEC;
         status = nfs_access_get_cached(inode, cred, &cache);
         if (status == 0)
                 goto out;
@@ -811,43 +1001,32 @@ static int nfs4_recover_expired_lease(struct nfs_server *server)
  *      reclaim state on the server after a network partition.
  *      Assumes caller holds the appropriate lock
  */
-static int _nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct inode *inode = state->inode;
-        struct nfs_delegation *delegation = NFS_I(inode)->delegation;
         struct nfs4_opendata *opendata;
-        int openflags = state->state & (FMODE_READ|FMODE_WRITE);
         int ret;
 
-        if (delegation != NULL && !(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
-                ret = _nfs4_do_access(inode, sp->so_cred, openflags);
-                if (ret < 0)
-                        return ret;
-                memcpy(&state->stateid, &delegation->stateid, sizeof(state->stateid));
-                set_bit(NFS_DELEGATED_STATE, &state->flags);
-                return 0;
-        }
-        opendata = nfs4_opendata_alloc(dentry, sp, openflags, NULL);
-        if (opendata == NULL)
-                return -ENOMEM;
+        opendata = nfs4_open_recoverdata_alloc(ctx, state);
+        if (IS_ERR(opendata))
+                return PTR_ERR(opendata);
         ret = nfs4_open_recover(opendata, state);
         if (ret == -ESTALE) {
                 /* Invalidate the state owner so we don't ever use it again */
-                nfs4_drop_state_owner(sp);
-                d_drop(dentry);
+                nfs4_drop_state_owner(state->owner);
+                d_drop(ctx->path.dentry);
         }
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return ret;
 }
 
-static inline int nfs4_do_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static inline int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct nfs_server *server = NFS_SERVER(dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_exception exception = { };
         int err;
 
         do {
-                err = _nfs4_open_expired(sp, state, dentry);
+                err = _nfs4_open_expired(ctx, state);
                 if (err == -NFS4ERR_DELAY)
                         nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
@@ -862,107 +1041,38 @@ static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *sta
         ctx = nfs4_state_find_open_context(state);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
-        ret = nfs4_do_open_expired(sp, state, ctx->dentry);
+        ret = nfs4_do_open_expired(ctx, state);
         put_nfs_open_context(ctx);
         return ret;
 }
 
 /*
- * Returns a referenced nfs4_state if there is an open delegation on the file
+ * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
+ * fields corresponding to attributes that were used to store the verifier.
+ * Make sure we clobber those fields in the later setattr call
  */
-static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred, struct nfs4_state **res)
+static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
 {
-        struct nfs_delegation *delegation;
-        struct nfs_server *server = NFS_SERVER(inode);
-        struct nfs_client *clp = server->nfs_client;
-        struct nfs_inode *nfsi = NFS_I(inode);
-        struct nfs4_state_owner *sp = NULL;
-        struct nfs4_state *state = NULL;
-        int open_flags = flags & (FMODE_READ|FMODE_WRITE);
-        int err;
+        if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
+            !(sattr->ia_valid & ATTR_ATIME_SET))
+                sattr->ia_valid |= ATTR_ATIME;
 
-        err = -ENOMEM;
-        if (!(sp = nfs4_get_state_owner(server, cred))) {
-                dprintk("%s: nfs4_get_state_owner failed!\n", __FUNCTION__);
-                return err;
-        }
-        err = nfs4_recover_expired_lease(server);
-        if (err != 0)
-                goto out_put_state_owner;
-        /* Protect against reboot recovery - NOTE ORDER! */
-        down_read(&clp->cl_sem);
-        /* Protect against delegation recall */
-        down_read(&nfsi->rwsem);
-        delegation = NFS_I(inode)->delegation;
-        err = -ENOENT;
-        if (delegation == NULL || (delegation->type & open_flags) != open_flags)
-                goto out_err;
-        err = -ENOMEM;
-        state = nfs4_get_open_state(inode, sp);
-        if (state == NULL)
-                goto out_err;
-
-        err = -ENOENT;
-        if ((state->state & open_flags) == open_flags) {
-                spin_lock(&inode->i_lock);
-                update_open_stateflags(state, open_flags);
-                spin_unlock(&inode->i_lock);
-                goto out_ok;
-        } else if (state->state != 0)
-                goto out_put_open_state;
-
-        lock_kernel();
-        err = _nfs4_do_access(inode, cred, open_flags);
-        unlock_kernel();
-        if (err != 0)
-                goto out_put_open_state;
-        set_bit(NFS_DELEGATED_STATE, &state->flags);
-        update_open_stateid(state, &delegation->stateid, open_flags);
-out_ok:
-        nfs4_put_state_owner(sp);
-        up_read(&nfsi->rwsem);
-        up_read(&clp->cl_sem);
-        *res = state;
-        return 0;
-out_put_open_state:
-        nfs4_put_open_state(state);
-out_err:
-        up_read(&nfsi->rwsem);
-        up_read(&clp->cl_sem);
-        if (err != -EACCES)
-                nfs_inode_return_delegation(inode);
-out_put_state_owner:
-        nfs4_put_state_owner(sp);
-        return err;
-}
-
-static struct nfs4_state *nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred)
-{
-        struct nfs4_exception exception = { };
-        struct nfs4_state *res = ERR_PTR(-EIO);
-        int err;
-
-        do {
-                err = _nfs4_open_delegated(inode, flags, cred, &res);
-                if (err == 0)
-                        break;
-                res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(inode),
-                                        err, &exception));
-        } while (exception.retry);
-        return res;
+        if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
+            !(sattr->ia_valid & ATTR_MTIME_SET))
+                sattr->ia_valid |= ATTR_MTIME;
 }
 
 /*
  * Returns a referenced nfs4_state
  */
-static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
+static int _nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
 {
         struct nfs4_state_owner  *sp;
         struct nfs4_state     *state = NULL;
         struct nfs_server       *server = NFS_SERVER(dir);
         struct nfs_client *clp = server->nfs_client;
         struct nfs4_opendata *opendata;
-        int                     status;
+        int status;
 
         /* Protect against reboot recovery conflicts */
         status = -ENOMEM;
@@ -973,29 +1083,35 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         status = nfs4_recover_expired_lease(server);
         if (status != 0)
                 goto err_put_state_owner;
+        if (path->dentry->d_inode != NULL)
+                nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ|FMODE_WRITE));
         down_read(&clp->cl_sem);
         status = -ENOMEM;
-        opendata = nfs4_opendata_alloc(dentry, sp, flags, sattr);
+        opendata = nfs4_opendata_alloc(path, sp, flags, sattr);
         if (opendata == NULL)
                 goto err_release_rwsem;
 
+        if (path->dentry->d_inode != NULL)
+                opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);
+
         status = _nfs4_proc_open(opendata);
         if (status != 0)
-                goto err_opendata_free;
+                goto err_opendata_put;
+
+        if (opendata->o_arg.open_flags & O_EXCL)
+                nfs4_exclusive_attrset(opendata, sattr);
 
-        status = -ENOMEM;
         state = nfs4_opendata_to_nfs4_state(opendata);
-        if (state == NULL)
-                goto err_opendata_free;
-        if (opendata->o_res.delegation_type != 0)
-                nfs_inode_set_delegation(state->inode, cred, &opendata->o_res);
-        nfs4_opendata_free(opendata);
+        status = PTR_ERR(state);
+        if (IS_ERR(state))
+                goto err_opendata_put;
+        nfs4_opendata_put(opendata);
         nfs4_put_state_owner(sp);
         up_read(&clp->cl_sem);
         *res = state;
         return 0;
-err_opendata_free:
-        nfs4_opendata_free(opendata);
+err_opendata_put:
+        nfs4_opendata_put(opendata);
 err_release_rwsem:
         up_read(&clp->cl_sem);
 err_put_state_owner:
@@ -1006,14 +1122,14 @@ out_err:
 }
 
 
-static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred)
+static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         struct nfs4_state *res;
         int status;
 
         do {
-                status = _nfs4_do_open(dir, dentry, flags, sattr, cred, &res);
+                status = _nfs4_do_open(dir, path, flags, sattr, cred, &res);
                 if (status == 0)
                         break;
                 /* NOTE: BAD_SEQID means the server and client disagree about the
@@ -1028,7 +1144,9 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry,
                  * the user though...
                  */
                 if (status == -NFS4ERR_BAD_SEQID) {
-                        printk(KERN_WARNING "NFS: v4 server returned a bad sequence-id error!\n");
+                        printk(KERN_WARNING "NFS: v4 server %s "
+                                        " returned a bad sequence-id error!\n",
+                                        NFS_SERVER(dir)->nfs_client->cl_hostname);
                         exception.retry = 1;
                         continue;
                 }
@@ -1042,6 +1160,11 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry,
                         exception.retry = 1;
                         continue;
                 }
+                if (status == -EAGAIN) {
+                        /* We must have found a delegation */
+                        exception.retry = 1;
+                        continue;
+                }
                 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
                                         status, &exception));
         } while (exception.retry);
@@ -1101,6 +1224,7 @@ static int nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
 }
 
 struct nfs4_closedata {
+        struct path path;
         struct inode *inode;
         struct nfs4_state *state;
         struct nfs_closeargs arg;
@@ -1117,6 +1241,8 @@ static void nfs4_free_closedata(void *data)
         nfs4_put_open_state(calldata->state);
         nfs_free_seqid(calldata->arg.seqid);
         nfs4_put_state_owner(sp);
+        dput(calldata->path.dentry);
+        mntput(calldata->path.mnt);
         kfree(calldata);
 }
 
@@ -1134,8 +1260,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)
         nfs_increment_open_seqid(task->tk_status, calldata->arg.seqid);
         switch (task->tk_status) {
                 case 0:
-                        memcpy(&state->stateid, &calldata->res.stateid,
-                                        sizeof(state->stateid));
+                        nfs_set_open_stateid(state, &calldata->res.stateid, calldata->arg.open_flags);
                         renew_lease(server, calldata->timestamp);
                         break;
                 case -NFS4ERR_STALE_STATEID:
@@ -1160,26 +1285,30 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
                 .rpc_resp = &calldata->res,
                 .rpc_cred = state->owner->so_cred,
         };
-        int mode = 0, old_mode;
+        int clear_rd, clear_wr, clear_rdwr;
+        int mode;
 
         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
                 return;
-        /* Recalculate the new open mode in case someone reopened the file
-         * while we were waiting in line to be scheduled.
-         */
+
+        mode = FMODE_READ|FMODE_WRITE;
+        clear_rd = clear_wr = clear_rdwr = 0;
         spin_lock(&state->owner->so_lock);
-        spin_lock(&calldata->inode->i_lock);
-        mode = old_mode = state->state;
+        /* Calculate the change in open mode */
         if (state->n_rdwr == 0) {
-                if (state->n_rdonly == 0)
+                if (state->n_rdonly == 0) {
                         mode &= ~FMODE_READ;
-                if (state->n_wronly == 0)
+                        clear_rd |= test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
+                if (state->n_wronly == 0) {
                         mode &= ~FMODE_WRITE;
+                        clear_wr |= test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
         }
-        nfs4_state_set_mode_locked(state, mode);
-        spin_unlock(&calldata->inode->i_lock);
         spin_unlock(&state->owner->so_lock);
-        if (mode == old_mode || test_bit(NFS_DELEGATED_STATE, &state->flags)) {
+        if (!clear_rd && !clear_wr && !clear_rdwr) {
                 /* Note: exit _without_ calling nfs4_close_done */
                 task->tk_action = NULL;
                 return;
@@ -1209,19 +1338,21 @@ static const struct rpc_call_ops nfs4_close_ops = {
  *
  * NOTE: Caller must be holding the sp->so_owner semaphore!
  */
-int nfs4_do_close(struct inode *inode, struct nfs4_state *state) 
+int nfs4_do_close(struct path *path, struct nfs4_state *state)
 {
-        struct nfs_server *server = NFS_SERVER(inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_closedata *calldata;
+        struct nfs4_state_owner *sp = state->owner;
+        struct rpc_task *task;
         int status = -ENOMEM;
 
         calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
         if (calldata == NULL)
                 goto out;
-        calldata->inode = inode;
+        calldata->inode = state->inode;
         calldata->state = state;
-        calldata->arg.fh = NFS_FH(inode);
-        calldata->arg.stateid = &state->stateid;
+        calldata->arg.fh = NFS_FH(state->inode);
+        calldata->arg.stateid = &state->open_stateid;
         /* Serialization for the sequence id */
         calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
         if (calldata->arg.seqid == NULL)
@@ -1229,36 +1360,55 @@ int nfs4_do_close(struct inode *inode, struct nfs4_state *state)
         calldata->arg.bitmask = server->attr_bitmask;
         calldata->res.fattr = &calldata->fattr;
         calldata->res.server = server;
+        calldata->path.mnt = mntget(path->mnt);
+        calldata->path.dentry = dget(path->dentry);
 
-        status = nfs4_call_async(server->client, &nfs4_close_ops, calldata);
-        if (status == 0)
-                goto out;
-
-        nfs_free_seqid(calldata->arg.seqid);
+        task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_close_ops, calldata);
+        if (IS_ERR(task))
+                return PTR_ERR(task);
+        rpc_put_task(task);
+        return 0;
 out_free_calldata:
         kfree(calldata);
 out:
+        nfs4_put_open_state(state);
+        nfs4_put_state_owner(sp);
         return status;
 }
 
-static int nfs4_intent_set_file(struct nameidata *nd, struct dentry *dentry, struct nfs4_state *state)
+static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state)
 {
         struct file *filp;
+        int ret;
 
-        filp = lookup_instantiate_filp(nd, dentry, NULL);
+        /* If the open_intent is for execute, we have an extra check to make */
+        if (nd->intent.open.flags & FMODE_EXEC) {
+                ret = _nfs4_do_access(state->inode,
+                                state->owner->so_cred,
+                                nd->intent.open.flags);
+                if (ret < 0)
+                        goto out_close;
+        }
+        filp = lookup_instantiate_filp(nd, path->dentry, NULL);
         if (!IS_ERR(filp)) {
                 struct nfs_open_context *ctx;
                 ctx = (struct nfs_open_context *)filp->private_data;
                 ctx->state = state;
                 return 0;
         }
-        nfs4_close_state(state, nd->intent.open.flags);
-        return PTR_ERR(filp);
+        ret = PTR_ERR(filp);
+out_close:
+        nfs4_close_state(path, state, nd->intent.open.flags);
+        return ret;
 }
 
 struct dentry *
 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct iattr attr;
         struct rpc_cred *cred;
         struct nfs4_state *state;
@@ -1277,7 +1427,7 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
         if (IS_ERR(cred))
                 return (struct dentry *)cred;
-        state = nfs4_do_open(dir, dentry, nd->intent.open.flags, &attr, cred);
+        state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 if (PTR_ERR(state) == -ENOENT)
@@ -1287,22 +1437,24 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         res = d_add_unique(dentry, igrab(state->inode));
         if (res != NULL)
                 dentry = res;
-        nfs4_intent_set_file(nd, dentry, state);
+        nfs4_intent_set_file(nd, &path, state);
         return res;
 }
 
 int
 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct rpc_cred *cred;
         struct nfs4_state *state;
 
         cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
         if (IS_ERR(cred))
                 return PTR_ERR(cred);
-        state = nfs4_open_delegated(dentry->d_inode, openflags, cred);
-        if (IS_ERR(state))
-                state = nfs4_do_open(dir, dentry, openflags, NULL, cred);
+        state = nfs4_do_open(dir, &path, openflags, NULL, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 switch (PTR_ERR(state)) {
@@ -1318,10 +1470,10 @@ nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, st
                 }
         }
         if (state->inode == dentry->d_inode) {
-                nfs4_intent_set_file(nd, dentry, state);
+                nfs4_intent_set_file(nd, &path, state);
                 return 1;
         }
-        nfs4_close_state(state, openflags);
+        nfs4_close_state(&path, state, openflags);
 out_drop:
         d_drop(dentry);
         return 0;
@@ -1418,7 +1570,7 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  * Note that we'll actually follow the referral later when
  * we detect fsid mismatch in inode revalidation
  */
-static int nfs4_get_referral(struct inode *dir, struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle)
+static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle)
 {
         int status = -ENOMEM;
         struct page *page = NULL;
@@ -1533,8 +1685,8 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
         return status;
 }
 
-static int _nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
-                struct qstr *name, struct nfs_fh *fhandle,
+static int _nfs4_proc_lookupfh(struct nfs_server *server, const struct nfs_fh *dirfh,
+                const struct qstr *name, struct nfs_fh *fhandle,
                 struct nfs_fattr *fattr)
 {
         int                    status;
@@ -1559,8 +1711,6 @@ static int _nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
         dprintk("NFS call  lookupfh %s\n", name->name);
         status = rpc_call_sync(server->client, &msg, 0);
         dprintk("NFS reply lookupfh: %d\n", status);
-        if (status == -NFS4ERR_MOVED)
-                status = -EREMOTE;
         return status;
 }
 
@@ -1571,39 +1721,24 @@ static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = nfs4_handle_exception(server,
-                                _nfs4_proc_lookupfh(server, dirfh, name,
-                                                    fhandle, fattr),
-                                &exception);
+                err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr);
+                /* FIXME: !!!! */
+                if (err == -NFS4ERR_MOVED) {
+                        err = -EREMOTE;
+                        break;
+                }
+                err = nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
         return err;
 }
 
-static int _nfs4_proc_lookup(struct inode *dir, struct qstr *name,
+static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 {
-        int                    status;
-        struct nfs_server *server = NFS_SERVER(dir);
-        struct nfs4_lookup_arg args = {
-                .bitmask = server->attr_bitmask,
-                .dir_fh = NFS_FH(dir),
-                .name = name,
-        };
-        struct nfs4_lookup_res res = {
-                .server = server,
-                .fattr = fattr,
-                .fh = fhandle,
-        };
-        struct rpc_message msg = {
-                .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
-                .rpc_argp = &args,
-                .rpc_resp = &res,
-        };
-        
-        nfs_fattr_init(fattr);
+        int status;
         
         dprintk("NFS call  lookup %s\n", name->name);
-        status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
+        status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);
         if (status == -NFS4ERR_MOVED)
                 status = nfs4_get_referral(dir, name, fattr, fhandle);
         dprintk("NFS reply lookup: %d\n", status);
@@ -1752,6 +1887,10 @@ static int
 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                  int flags, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct nfs4_state *state;
         struct rpc_cred *cred;
         int status = 0;
@@ -1761,7 +1900,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 status = PTR_ERR(cred);
                 goto out;
         }
-        state = nfs4_do_open(dir, dentry, flags, sattr, cred);
+        state = nfs4_do_open(dir, &path, flags, sattr, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
@@ -1773,11 +1912,12 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 status = nfs4_do_setattr(state->inode, &fattr, sattr, state);
                 if (status == 0)
                         nfs_setattr_update_inode(state->inode, sattr);
+                nfs_post_op_update_inode(state->inode, &fattr);
         }
-        if (status == 0 && nd != NULL && (nd->flags & LOOKUP_OPEN))
-                status = nfs4_intent_set_file(nd, dentry, state);
+        if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0)
+                status = nfs4_intent_set_file(nd, &path, state);
         else
-                nfs4_close_state(state, flags);
+                nfs4_close_state(&path, state, flags);
 out:
         return status;
 }
@@ -1785,28 +1925,27 @@ out:
 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
 {
         struct nfs_server *server = NFS_SERVER(dir);
-        struct nfs4_remove_arg args = {
+        struct nfs_removeargs args = {
                 .fh = NFS_FH(dir),
-                .name = name,
+                .name.len = name->len,
+                .name.name = name->name,
                 .bitmask = server->attr_bitmask,
         };
-        struct nfs_fattr dir_attr;
-        struct nfs4_remove_res  res = {
+        struct nfs_removeres res = {
                 .server = server,
-                .dir_attr = &dir_attr,
         };
         struct rpc_message msg = {
-                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
-                .rpc_argp       = &args,
-                .rpc_resp       = &res,
+                .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
+                .rpc_argp = &args,
+                .rpc_resp = &res,
         };
         int                     status;
 
-        nfs_fattr_init(res.dir_attr);
+        nfs_fattr_init(&res.dir_attr);
         status = rpc_call_sync(server->client, &msg, 0);
         if (status == 0) {
                 update_changeattr(dir, &res.cinfo);
-                nfs_post_op_update_inode(dir, res.dir_attr);
+                nfs_post_op_update_inode(dir, &res.dir_attr);
         }
         return status;
 }
@@ -1823,48 +1962,26 @@ static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
         return err;
 }
 
-struct unlink_desc {
-        struct nfs4_remove_arg  args;
-        struct nfs4_remove_res  res;
-        struct nfs_fattr dir_attr;
-};
-
-static int nfs4_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir,
-                struct qstr *name)
+static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
 {
-        struct nfs_server *server = NFS_SERVER(dir->d_inode);
-        struct unlink_desc *up;
+        struct nfs_server *server = NFS_SERVER(dir);
+        struct nfs_removeargs *args = msg->rpc_argp;
+        struct nfs_removeres *res = msg->rpc_resp;
 
-        up = kmalloc(sizeof(*up), GFP_KERNEL);
-        if (!up)
-                return -ENOMEM;
-        
-        up->args.fh = NFS_FH(dir->d_inode);
-        up->args.name = name;
-        up->args.bitmask = server->attr_bitmask;
-        up->res.server = server;
-        up->res.dir_attr = &up->dir_attr;
-        
+        args->bitmask = server->attr_bitmask;
+        res->server = server;
         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
-        msg->rpc_argp = &up->args;
-        msg->rpc_resp = &up->res;
-        return 0;
 }
 
-static int nfs4_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
+static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 {
-        struct rpc_message *msg = &task->tk_msg;
-        struct unlink_desc *up;
-        
-        if (msg->rpc_resp != NULL) {
-                up = container_of(msg->rpc_resp, struct unlink_desc, res);
-                update_changeattr(dir->d_inode, &up->res.cinfo);
-                nfs_post_op_update_inode(dir->d_inode, up->res.dir_attr);
-                kfree(up);
-                msg->rpc_resp = NULL;
-                msg->rpc_argp = NULL;
-        }
-        return 0;
+        struct nfs_removeres *res = task->tk_msg.rpc_resp;
+
+        if (nfs4_async_handle_error(task, res->server) == -EAGAIN)
+                return 0;
+        update_changeattr(dir, &res->cinfo);
+        nfs_post_op_update_inode(dir, &res->dir_attr);
+        return 1;
 }
 
 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
@@ -3008,7 +3125,7 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
         if (status != 0)
                 goto out;
         lsp = request->fl_u.nfs4_fl.owner;
-        arg.lock_owner.id = lsp->ls_id; 
+        arg.lock_owner.id = lsp->ls_id.id;
         status = rpc_call_sync(server->client, &msg, 0);
         switch (status) {
                 case 0:
@@ -3152,6 +3269,11 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
 {
         struct nfs4_unlockdata *data;
 
+        /* Ensure this is an unlock - when canceling a lock, the
+         * canceled lock is passed in, and it won't be an unlock.
+         */
+        fl->fl_type = F_UNLCK;
+
         data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
         if (data == NULL) {
                 nfs_free_seqid(seqid);
@@ -3222,7 +3344,7 @@ static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
                 goto out_free;
         p->arg.lock_stateid = &lsp->ls_stateid;
         p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
-        p->arg.lock_owner.id = lsp->ls_id;
+        p->arg.lock_owner.id = lsp->ls_id.id;
         p->lsp = lsp;
         atomic_inc(&lsp->ls_count);
         p->ctx = get_nfs_open_context(ctx);
@@ -3285,7 +3407,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
                 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
                                         sizeof(data->lsp->ls_stateid.data));
                 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
-                renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
+                renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
         }
         nfs_increment_lock_seqid(data->rpc_status, data->arg.lock_seqid);
 out:
@@ -3544,7 +3666,7 @@ ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen)
         return len;
 }
 
-int nfs4_proc_fs_locations(struct inode *dir, struct qstr *name,
+int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
                 struct nfs4_fs_locations *fs_locations, struct page *page)
 {
         struct nfs_server *server = NFS_SERVER(dir);