void nfs_commitdata_release(void *data) { struct nfs_write_data *wdata = data; put_nfs_open_context(wdata->args.context); nfs_commit_free(wdata); }
/** * nfs_release_request - Release the count on an NFS read/write request * @req: request to release * * Note: Should never be called with the spinlock held! */ static void nfs_free_request(struct kref *kref) { struct nfs_page *req = container_of(kref, struct nfs_page, wb_kref); /* Release struct file or cached credential */ nfs_clear_request(req); put_nfs_open_context(req->wb_context); nfs_page_free(req); }
static void nfs3_nlm_release_call(void *data) { struct nfs_lock_context *l_ctx = data; struct nfs_open_context *ctx; if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { ctx = l_ctx->open_context; nfs_put_lock_context(l_ctx); put_nfs_open_context(ctx); } }
static int nfs42_set_rw_stateid(nfs4_stateid *dst, struct file *file, fmode_t fmode) { struct nfs_open_context *open; struct nfs_lock_context *lock; int ret; open = get_nfs_open_context(nfs_file_open_context(file)); lock = nfs_get_lock_context(open); if (IS_ERR(lock)) { put_nfs_open_context(open); return PTR_ERR(lock); } ret = nfs4_set_rw_stateid(dst, open, lock, fmode); nfs_put_lock_context(lock); put_nfs_open_context(open); return ret; }
/** * nfs_clear_request - Free up all resources allocated to the request * @req: * * Release page and open context resources associated with a read/write * request after it has completed. */ void nfs_clear_request(struct nfs_page *req) { struct page *page = req->wb_page; struct nfs_open_context *ctx = req->wb_context; if (page != NULL) { page_cache_release(page); req->wb_page = NULL; } if (ctx != NULL) { put_nfs_open_context(ctx); req->wb_context = NULL; } }
/** * nfs_release_request - Release the count on an NFS read/write request * @req: request to release * * Note: Should never be called with the spinlock held! */ void nfs_release_request(struct nfs_page *req) { if (!atomic_dec_and_test(&req->wb_count)) return; #ifdef NFS_PARANOIA BUG_ON (!list_empty(&req->wb_list)); BUG_ON (NFS_WBACK_BUSY(req)); #endif /* Release struct file or cached credential */ nfs_clear_request(req); put_nfs_open_context(req->wb_context); nfs_page_free(req); }
/* * nfs_clear_request - Free up all resources allocated to the request * @req: * * Release page and open context resources associated with a read/write * request after it has completed. */ static void nfs_clear_request(struct nfs_page *req) { struct page *page = req->wb_page; struct nfs_open_context *ctx = req->wb_context; struct nfs_lock_context *l_ctx = req->wb_lock_context; if (page != NULL) { page_cache_release(page); req->wb_page = NULL; } if (l_ctx != NULL) { nfs_iocounter_dec(&l_ctx->io_count); nfs_put_lock_context(l_ctx); req->wb_lock_context = NULL; } if (ctx != NULL) { put_nfs_open_context(ctx); req->wb_context = NULL; } }
static int nfs4_file_open(struct inode *inode, struct file *filp) { struct nfs_open_context *ctx; struct dentry *dentry = filp->f_path.dentry; struct dentry *parent = NULL; struct inode *dir; unsigned openflags = filp->f_flags; struct iattr attr; int opened = 0; int err; /* * If no cached dentry exists or if it's negative, NFSv4 handled the * opens in ->lookup() or ->create(). * * We only get this far for a cached positive dentry. We skipped * revalidation, so handle it here by dropping the dentry and returning * -EOPENSTALE. The VFS will retry the lookup/create/open. */ dprintk("NFS: open file(%s/%s)\n", dentry->d_parent->d_name.name, dentry->d_name.name); if ((openflags & O_ACCMODE) == 3) openflags--; /* We can't create new files here */ openflags &= ~(O_CREAT|O_EXCL); parent = dget_parent(dentry); dir = parent->d_inode; ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode); err = PTR_ERR(ctx); if (IS_ERR(ctx)) goto out; attr.ia_valid = ATTR_OPEN; if (openflags & O_TRUNC) { attr.ia_valid |= ATTR_SIZE; attr.ia_size = 0; nfs_wb_all(inode); } inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr, &opened); if (IS_ERR(inode)) { err = PTR_ERR(inode); switch (err) { case -EPERM: case -EACCES: case -EDQUOT: case -ENOSPC: case -EROFS: goto out_put_ctx; default: goto out_drop; } } if (inode != dentry->d_inode) goto out_drop; nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); nfs_file_set_open_context(filp, ctx); nfs_fscache_open_file(inode, filp); err = 0; out_put_ctx: put_nfs_open_context(ctx); out: dput(parent); return err; out_drop: d_drop(dentry); err = -EOPENSTALE; goto out_put_ctx; }
static void nfs_writedata_release(struct nfs_write_data *wdata) { put_nfs_open_context(wdata->args.context); nfs_writedata_free(wdata); }
/* * Release an extra reference on a read context. * - This function can be absent if the completion function doesn't require a * context. */ static void nfs_fh_put_context(void *cookie_netfs_data, void *context) { if (context) put_nfs_open_context(context); }
/** * nfs_pgio_data_destroy - make @hdr suitable for reuse * * Frees memory and releases refs from nfs_generic_pgio, so that it may * be called again. * * @hdr: A header that has had nfs_generic_pgio called */ void nfs_pgio_data_destroy(struct nfs_pgio_header *hdr) { put_nfs_open_context(hdr->args.context); if (hdr->page_array.pagevec != hdr->page_array.page_array) kfree(hdr->page_array.pagevec); }