static int do_getlk(struct file *filp, int cmd, struct file_lock *fl) { struct inode *inode = filp->f_mapping->host; int status = 0; /* Try local locking first */ posix_test_lock(filp, fl); if (fl->fl_type != F_UNLCK) { /* found a conflict */ goto out; } if (nfs_have_delegation(inode, FMODE_READ)) goto out_noconflict; if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM) goto out_noconflict; status = NFS_PROTO(inode)->lock(filp, cmd, fl); out: return status; out_noconflict: fl->fl_type = F_UNLCK; goto out; }
static int do_setlk(struct file *filp, int cmd, struct file_lock *fl) { struct inode *inode = filp->f_mapping->host; int status; /* * Flush all pending writes before doing anything * with locks.. */ status = nfs_sync_mapping(filp->f_mapping); if (status != 0) goto out; /* Use local locking if mounted with "-onolock" */ if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) status = NFS_PROTO(inode)->lock(filp, cmd, fl); else status = do_vfs_lock(filp, fl); if (status < 0) goto out; /* * Make sure we clear the cache whenever we try to get the lock. * This makes locking act as a cache coherency point. */ nfs_sync_mapping(filp->f_mapping); if (!nfs_have_delegation(inode, FMODE_READ)) nfs_zap_caches(inode); out: return status; }
/* * Insert a write request into an inode */ static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req) { struct nfs_inode *nfsi = NFS_I(inode); int error; error = radix_tree_preload(GFP_NOFS); if (error != 0) goto out; /* Lock the request! */ nfs_lock_request_dontget(req); spin_lock(&inode->i_lock); error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req); BUG_ON(error); if (!nfsi->npages) { igrab(inode); if (nfs_have_delegation(inode, FMODE_WRITE)) nfsi->change_attr++; } SetPagePrivate(req->wb_page); set_page_private(req->wb_page, (unsigned long)req); nfsi->npages++; kref_get(&req->wb_kref); radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED); spin_unlock(&inode->i_lock); radix_tree_preload_end(); out: return error; }
static int do_getlk(struct file *filp, int cmd, struct file_lock *fl) { struct file_lock *cfl; struct inode *inode = filp->f_mapping->host; int status = 0; lock_kernel(); /* Try local locking first */ cfl = posix_test_lock(filp, fl); if (cfl != NULL) { locks_copy_lock(fl, cfl); goto out; } if (nfs_have_delegation(inode, FMODE_READ)) goto out_noconflict; if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM) goto out_noconflict; status = NFS_PROTO(inode)->lock(filp, cmd, fl); out: unlock_kernel(); return status; out_noconflict: fl->fl_type = F_UNLCK; goto out; }
static int do_getlk(struct file *filp, int cmd, struct file_lock *fl) { struct file_lock cfl; struct inode *inode = filp->f_mapping->host; int status = 0; lock_kernel(); /* Try local locking first */ if (posix_test_lock(filp, fl, &cfl)) { fl->fl_start = cfl.fl_start; fl->fl_end = cfl.fl_end; fl->fl_type = cfl.fl_type; fl->fl_pid = cfl.fl_pid; goto out; } if (nfs_have_delegation(inode, FMODE_READ)) goto out_noconflict; if (NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM) goto out_noconflict; status = NFS_PROTO(inode)->lock(filp, cmd, fl); out: unlock_kernel(); return status; out_noconflict: fl->fl_type = F_UNLCK; goto out; }
static int do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) { struct inode *inode = filp->f_mapping->host; int status; /* * Flush all pending writes before doing anything * with locks.. */ status = nfs_sync_mapping(filp->f_mapping); if (status != 0) goto out; /* * Use local locking if mounted with "-onolock" or with appropriate * "-olocal_lock=" */ if (!is_local) status = NFS_PROTO(inode)->lock(filp, cmd, fl); else status = do_vfs_lock(filp, fl); if (status < 0) goto out; /* * Revalidate the cache if the server has time stamps granular * enough to detect subsecond changes. Otherwise, clear the * cache to prevent missing any changes. * * This makes locking act as a cache coherency point. */ nfs_sync_mapping(filp->f_mapping); if (!nfs_have_delegation(inode, FMODE_READ)) { if (is_time_granular(&NFS_SERVER(inode)->time_delta)) __nfs_revalidate_inode(NFS_SERVER(inode), inode); else nfs_zap_caches(inode); } out: return status; }
/* * Flush all dirty pages, and check for write errors. * */ static int nfs_file_flush(struct file *file) { struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data; struct inode *inode = file->f_dentry->d_inode; int status; dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); if ((file->f_mode & FMODE_WRITE) == 0) return 0; lock_kernel(); /* Ensure that data+attribute caches are up to date after close() */ status = nfs_wb_all(inode); if (!status) { status = ctx->error; ctx->error = 0; if (!status && !nfs_have_delegation(inode, FMODE_READ)) __nfs_revalidate_inode(NFS_SERVER(inode), inode); } unlock_kernel(); return status; }