nfs_open_context doesn't need struct path either

just dentry, please...

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index a86acd6..a0693f3 100644 (file)
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1345,10 +1345,6 @@ static int is_atomic_open(struct nameidata *nd)
 
 static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd)
 {
-       struct path path = {
-               .mnt = nd->path.mnt,
-               .dentry = dentry,
-       };
        struct nfs_open_context *ctx;
        struct rpc_cred *cred;
        fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
@@ -1356,7 +1352,7 @@ static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *den
        cred = rpc_lookup_cred();
        if (IS_ERR(cred))
                return ERR_CAST(cred);
-       ctx = alloc_nfs_open_context(&path, cred, fmode);
+       ctx = alloc_nfs_open_context(dentry, cred, fmode);
        put_rpccred(cred);
        if (ctx == NULL)
                return ERR_PTR(-ENOMEM);
@@ -1376,13 +1372,13 @@ static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ct
 
        /* If the open_intent is for execute, we have an extra check to make */
        if (ctx->mode & FMODE_EXEC) {
-               ret = nfs_may_open(ctx->path.dentry->d_inode,
+               ret = nfs_may_open(ctx->dentry->d_inode,
                                ctx->cred,
                                nd->intent.open.flags);
                if (ret < 0)
                        goto out;
        }
-       filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open);
+       filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
        if (IS_ERR(filp))
                ret = PTR_ERR(filp);
        else
@@ -1463,8 +1459,8 @@ static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry
        res = d_add_unique(dentry, inode);
        nfs_unblock_sillyrename(dentry->d_parent);
        if (res != NULL) {
-               dput(ctx->path.dentry);
-               ctx->path.dentry = dget(res);
+               dput(ctx->dentry);
+               ctx->dentry = dget(res);
                dentry = res;
        }
        err = nfs_intent_set_file(nd, ctx);

diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 8eea253..b35d25b 100644 (file)
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -284,7 +284,7 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
                                                loff_t pos)
 {
        struct nfs_open_context *ctx = dreq->ctx;
-       struct inode *inode = ctx->path.dentry->d_inode;
+       struct inode *inode = ctx->dentry->d_inode;
        unsigned long user_addr = (unsigned long)iov->iov_base;
        size_t count = iov->iov_len;
        size_t rsize = NFS_SERVER(inode)->rsize;
@@ -715,7 +715,7 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
                                                 loff_t pos, int sync)
 {
        struct nfs_open_context *ctx = dreq->ctx;
-       struct inode *inode = ctx->path.dentry->d_inode;
+       struct inode *inode = ctx->dentry->d_inode;
        unsigned long user_addr = (unsigned long)iov->iov_base;
        size_t count = iov->iov_len;
        struct rpc_task *task;

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 6f4850d..fe12037 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -567,7 +567,7 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 {
        struct nfs_lock_context *res, *new = NULL;
-       struct inode *inode = ctx->path.dentry->d_inode;
+       struct inode *inode = ctx->dentry->d_inode;
 
        spin_lock(&inode->i_lock);
        res = __nfs_find_lock_context(ctx);
@@ -594,7 +594,7 @@ struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
 {
        struct nfs_open_context *ctx = l_ctx->open_context;
-       struct inode *inode = ctx->path.dentry->d_inode;
+       struct inode *inode = ctx->dentry->d_inode;
 
        if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
                return;
@@ -620,7 +620,7 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
                return;
        if (!is_sync)
                return;
-       inode = ctx->path.dentry->d_inode;
+       inode = ctx->dentry->d_inode;
        if (!list_empty(&NFS_I(inode)->open_files))
                return;
        server = NFS_SERVER(inode);
@@ -629,14 +629,14 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
        nfs_revalidate_inode(server, inode);
 }
 
-struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode)
+struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode)
 {
        struct nfs_open_context *ctx;
 
        ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
        if (ctx != NULL) {
-               ctx->path = *path;
-               path_get(&ctx->path);
+               nfs_sb_active(dentry->d_sb);
+               ctx->dentry = dget(dentry);
                ctx->cred = get_rpccred(cred);
                ctx->state = NULL;
                ctx->mode = f_mode;
@@ -658,7 +658,8 @@ struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
 
 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 {
-       struct inode *inode = ctx->path.dentry->d_inode;
+       struct inode *inode = ctx->dentry->d_inode;
+       struct super_block *sb = ctx->dentry->d_sb;
 
        if (!list_empty(&ctx->list)) {
                if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
@@ -671,7 +672,8 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
                NFS_PROTO(inode)->close_context(ctx, is_sync);
        if (ctx->cred != NULL)
                put_rpccred(ctx->cred);
-       path_put(&ctx->path);
+       dput(ctx->dentry);
+       nfs_sb_deactive(sb);
        kfree(ctx);
 }
 
@@ -741,7 +743,7 @@ int nfs_open(struct inode *inode, struct file *filp)
        cred = rpc_lookup_cred();
        if (IS_ERR(cred))
                return PTR_ERR(cred);
-       ctx = alloc_nfs_open_context(&filp->f_path, cred, filp->f_mode);
+       ctx = alloc_nfs_open_context(filp->f_path.dentry, cred, filp->f_mode);
        put_rpccred(cred);
        if (ctx == NULL)
                return -ENOMEM;

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index aef22fa..26bece8 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1132,7 +1132,7 @@ static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context
 {
        struct nfs4_opendata *opendata;
 
-       opendata = nfs4_opendata_alloc(ctx->path.dentry, state->owner, 0, 0, NULL, GFP_NOFS);
+       opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, GFP_NOFS);
        if (opendata == NULL)
                return ERR_PTR(-ENOMEM);
        opendata->state = state;
@@ -1650,7 +1650,7 @@ static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *s
                return PTR_ERR(opendata);
        ret = nfs4_open_recover(opendata, state);
        if (ret == -ESTALE)
-               d_drop(ctx->path.dentry);
+               d_drop(ctx->dentry);
        nfs4_opendata_put(opendata);
        return ret;
 }
@@ -2081,7 +2081,7 @@ nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags
        struct nfs4_state *state;
 
        /* Protect against concurrent sillydeletes */
-       state = nfs4_do_open(dir, ctx->path.dentry, ctx->mode, open_flags, attr, ctx->cred);
+       state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, ctx->cred);
        if (IS_ERR(state))
                return ERR_CAST(state);
        ctx->state = state;
@@ -2625,7 +2625,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 
        if (ctx != NULL) {
                cred = ctx->cred;
-               de = ctx->path.dentry;
+               de = ctx->dentry;
                fmode = ctx->mode;
        }
        sattr->ia_mode &= ~current_umask();
@@ -4292,7 +4292,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->path.dentry->d_inode), data->timestamp);
+               renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
        }
 out:
        dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);

diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 0098557..18449f4 100644 (file)
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -114,7 +114,7 @@ int nfs_set_page_tag_locked(struct nfs_page *req)
        if (!nfs_lock_request_dontget(req))
                return 0;
        if (test_bit(PG_MAPPED, &req->wb_flags))
-               radix_tree_tag_set(&NFS_I(req->wb_context->path.dentry->d_inode)->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
+               radix_tree_tag_set(&NFS_I(req->wb_context->dentry->d_inode)->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
        return 1;
 }
 
@@ -124,7 +124,7 @@ int nfs_set_page_tag_locked(struct nfs_page *req)
 void nfs_clear_page_tag_locked(struct nfs_page *req)
 {
        if (test_bit(PG_MAPPED, &req->wb_flags)) {
-               struct inode *inode = req->wb_context->path.dentry->d_inode;
+               struct inode *inode = req->wb_context->dentry->d_inode;
                struct nfs_inode *nfsi = NFS_I(inode);
 
                spin_lock(&inode->i_lock);

diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 20a7f95..a68679f 100644 (file)
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -144,7 +144,7 @@ int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
 
 static void nfs_readpage_release(struct nfs_page *req)
 {
-       struct inode *d_inode = req->wb_context->path.dentry->d_inode;
+       struct inode *d_inode = req->wb_context->dentry->d_inode;
 
        if (PageUptodate(req->wb_page))
                nfs_readpage_to_fscache(d_inode, req->wb_page, 0);
@@ -152,8 +152,8 @@ static void nfs_readpage_release(struct nfs_page *req)
        unlock_page(req->wb_page);
 
        dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
-                       req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                       (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                       req->wb_context->dentry->d_inode->i_sb->s_id,
+                       (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                        req->wb_bytes,
                        (long long)req_offset(req));
        nfs_release_request(req);
@@ -207,7 +207,7 @@ static int nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
                unsigned int count, unsigned int offset,
                struct pnfs_layout_segment *lseg)
 {
-       struct inode *inode = req->wb_context->path.dentry->d_inode;
+       struct inode *inode = req->wb_context->dentry->d_inode;
 
        data->req         = req;
        data->inode       = inode;

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 7271680..0857931 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -409,7 +409,7 @@ out:
  */
 static void nfs_inode_remove_request(struct nfs_page *req)
 {
-       struct inode *inode = req->wb_context->path.dentry->d_inode;
+       struct inode *inode = req->wb_context->dentry->d_inode;
        struct nfs_inode *nfsi = NFS_I(inode);
 
        BUG_ON (!NFS_WBACK_BUSY(req));
@@ -438,7 +438,7 @@ nfs_mark_request_dirty(struct nfs_page *req)
 static void
 nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
 {
-       struct inode *inode = req->wb_context->path.dentry->d_inode;
+       struct inode *inode = req->wb_context->dentry->d_inode;
        struct nfs_inode *nfsi = NFS_I(inode);
 
        spin_lock(&inode->i_lock);
@@ -852,13 +852,13 @@ static int nfs_write_rpcsetup(struct nfs_page *req,
                struct pnfs_layout_segment *lseg,
                int how)
 {
-       struct inode *inode = req->wb_context->path.dentry->d_inode;
+       struct inode *inode = req->wb_context->dentry->d_inode;
 
        /* Set up the RPC argument and reply structs
         * NB: take care not to mess about with data->commit et al. */
 
        data->req = req;
-       data->inode = inode = req->wb_context->path.dentry->d_inode;
+       data->inode = inode = req->wb_context->dentry->d_inode;
        data->cred = req->wb_context->cred;
        data->lseg = get_lseg(lseg);
 
@@ -1053,9 +1053,9 @@ static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
 
        dprintk("NFS: %5u write(%s/%lld %d@%lld)",
                task->tk_pid,
-               data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
+               data->req->wb_context->dentry->d_inode->i_sb->s_id,
                (long long)
-                 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
+                 NFS_FILEID(data->req->wb_context->dentry->d_inode),
                data->req->wb_bytes, (long long)req_offset(data->req));
 
        nfs_writeback_done(task, data);
@@ -1148,8 +1148,8 @@ static void nfs_writeback_release_full(void *calldata)
 
                dprintk("NFS: %5u write (%s/%lld %d@%lld)",
                        data->task.tk_pid,
-                       req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                       (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                       req->wb_context->dentry->d_inode->i_sb->s_id,
+                       (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                        req->wb_bytes,
                        (long long)req_offset(req));
 
@@ -1347,7 +1347,7 @@ void nfs_init_commit(struct nfs_write_data *data,
                            struct pnfs_layout_segment *lseg)
 {
        struct nfs_page *first = nfs_list_entry(head->next);
-       struct inode *inode = first->wb_context->path.dentry->d_inode;
+       struct inode *inode = first->wb_context->dentry->d_inode;
 
        /* Set up the RPC argument and reply structs
         * NB: take care not to mess about with data->commit et al. */
@@ -1435,8 +1435,8 @@ void nfs_commit_release_pages(struct nfs_write_data *data)
                nfs_clear_request_commit(req);
 
                dprintk("NFS:       commit (%s/%lld %d@%lld)",
-                       req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                       (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                       req->wb_context->dentry->d_sb->s_id,
+                       (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                        req->wb_bytes,
                        (long long)req_offset(req));
                if (status < 0) {

diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 8601481..8b579be 100644 (file)
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -85,7 +85,7 @@ struct nfs_lock_context {
 struct nfs4_state;
 struct nfs_open_context {
        struct nfs_lock_context lock_context;
-       struct path path;
+       struct dentry *dentry;
        struct rpc_cred *cred;
        struct nfs4_state *state;
        fmode_t mode;
@@ -372,7 +372,7 @@ extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
-extern struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode);
+extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode);
 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);