11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/nfs/file.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1992 Rick Sladkey 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Changes Copyright (C) 1994 by Florian La Roche 71da177e4SLinus Torvalds * - Do not copy data too often around in the kernel. 81da177e4SLinus Torvalds * - In nfs_file_read the return value of kmalloc wasn't checked. 91da177e4SLinus Torvalds * - Put in a better version of read look-ahead buffering. Original idea 101da177e4SLinus Torvalds * and implementation by Wai S Kok elekokws@ee.nus.sg. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Expire cache on write to a file by Wai S Kok (Oct 1994). 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * Total rewrite of read side for new NFS buffer cache.. Linus. 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * nfs regular file handling functions 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds #include <linux/time.h> 201da177e4SLinus Torvalds #include <linux/kernel.h> 211da177e4SLinus Torvalds #include <linux/errno.h> 221da177e4SLinus Torvalds #include <linux/fcntl.h> 231da177e4SLinus Torvalds #include <linux/stat.h> 241da177e4SLinus Torvalds #include <linux/nfs_fs.h> 251da177e4SLinus Torvalds #include <linux/nfs_mount.h> 261da177e4SLinus Torvalds #include <linux/mm.h> 271da177e4SLinus Torvalds #include <linux/pagemap.h> 28e8edc6e0SAlexey Dobriyan #include <linux/aio.h> 295a0e3ad6STejun Heo #include <linux/gfp.h> 30b608b283STrond Myklebust #include <linux/swap.h> 311da177e4SLinus Torvalds 321da177e4SLinus Torvalds #include <asm/uaccess.h> 331da177e4SLinus Torvalds #include <asm/system.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include "delegation.h" 3694387fb1STrond Myklebust #include "internal.h" 3791d5b470SChuck Lever #include "iostat.h" 38545db45fSDavid Howells #include "fscache.h" 39e5e94017SBenny Halevy #include "pnfs.h" 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds #define NFSDBG_FACILITY NFSDBG_FILE 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds static int nfs_file_open(struct inode *, struct file *); 441da177e4SLinus Torvalds static int nfs_file_release(struct inode *, struct file *); 45980802e3STrond Myklebust static loff_t nfs_file_llseek(struct file *file, loff_t offset, int origin); 461da177e4SLinus Torvalds static int nfs_file_mmap(struct file *, struct vm_area_struct *); 47f0930fffSJens Axboe static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos, 48f0930fffSJens Axboe struct pipe_inode_info *pipe, 49f0930fffSJens Axboe size_t count, unsigned int flags); 50027445c3SBadari Pulavarty static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov, 51027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 52bf40d343SSuresh Jayaraman static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe, 53bf40d343SSuresh Jayaraman struct file *filp, loff_t *ppos, 54bf40d343SSuresh Jayaraman size_t count, unsigned int flags); 55027445c3SBadari Pulavarty static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov, 56027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 5775e1fcc0SMiklos Szeredi static int nfs_file_flush(struct file *, fl_owner_t id); 587ea80859SChristoph Hellwig static int nfs_file_fsync(struct file *, int datasync); 591da177e4SLinus Torvalds static int nfs_check_flags(int flags); 601da177e4SLinus Torvalds static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl); 611da177e4SLinus Torvalds static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl); 62370f6599SJ. Bruce Fields static int nfs_setlease(struct file *file, long arg, struct file_lock **fl); 631da177e4SLinus Torvalds 64f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct nfs_file_vm_ops; 6594387fb1STrond Myklebust 664b6f5d20SArjan van de Ven const struct file_operations nfs_file_operations = { 67980802e3STrond Myklebust .llseek = nfs_file_llseek, 681da177e4SLinus Torvalds .read = do_sync_read, 691da177e4SLinus Torvalds .write = do_sync_write, 701da177e4SLinus Torvalds .aio_read = nfs_file_read, 711da177e4SLinus Torvalds .aio_write = nfs_file_write, 721da177e4SLinus Torvalds .mmap = nfs_file_mmap, 731da177e4SLinus Torvalds .open = nfs_file_open, 741da177e4SLinus Torvalds .flush = nfs_file_flush, 751da177e4SLinus Torvalds .release = nfs_file_release, 7654917786SChuck Lever .fsync = nfs_file_fsync, 771da177e4SLinus Torvalds .lock = nfs_lock, 781da177e4SLinus Torvalds .flock = nfs_flock, 79f0930fffSJens Axboe .splice_read = nfs_file_splice_read, 80bf40d343SSuresh Jayaraman .splice_write = nfs_file_splice_write, 811da177e4SLinus Torvalds .check_flags = nfs_check_flags, 82370f6599SJ. Bruce Fields .setlease = nfs_setlease, 831da177e4SLinus Torvalds }; 841da177e4SLinus Torvalds 8592e1d5beSArjan van de Ven const struct inode_operations nfs_file_inode_operations = { 861da177e4SLinus Torvalds .permission = nfs_permission, 871da177e4SLinus Torvalds .getattr = nfs_getattr, 881da177e4SLinus Torvalds .setattr = nfs_setattr, 891da177e4SLinus Torvalds }; 901da177e4SLinus Torvalds 91b7fa0554SAndreas Gruenbacher #ifdef CONFIG_NFS_V3 9292e1d5beSArjan van de Ven const struct inode_operations nfs3_file_inode_operations = { 93b7fa0554SAndreas Gruenbacher .permission = nfs_permission, 94b7fa0554SAndreas Gruenbacher .getattr = nfs_getattr, 95b7fa0554SAndreas Gruenbacher .setattr = nfs_setattr, 96b7fa0554SAndreas Gruenbacher .listxattr = nfs3_listxattr, 97b7fa0554SAndreas Gruenbacher .getxattr = nfs3_getxattr, 98b7fa0554SAndreas Gruenbacher .setxattr = nfs3_setxattr, 99b7fa0554SAndreas Gruenbacher .removexattr = nfs3_removexattr, 100b7fa0554SAndreas Gruenbacher }; 101b7fa0554SAndreas Gruenbacher #endif /* CONFIG_NFS_v3 */ 102b7fa0554SAndreas Gruenbacher 1031da177e4SLinus Torvalds /* Hack for future NFS swap support */ 1041da177e4SLinus Torvalds #ifndef IS_SWAPFILE 1051da177e4SLinus Torvalds # define IS_SWAPFILE(inode) (0) 1061da177e4SLinus Torvalds #endif 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static int nfs_check_flags(int flags) 1091da177e4SLinus Torvalds { 1101da177e4SLinus Torvalds if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 1111da177e4SLinus Torvalds return -EINVAL; 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds return 0; 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds /* 1171da177e4SLinus Torvalds * Open file 1181da177e4SLinus Torvalds */ 1191da177e4SLinus Torvalds static int 1201da177e4SLinus Torvalds nfs_file_open(struct inode *inode, struct file *filp) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds int res; 1231da177e4SLinus Torvalds 1246da24bc9SChuck Lever dprintk("NFS: open file(%s/%s)\n", 125cc0dd2d1SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 126cc0dd2d1SChuck Lever filp->f_path.dentry->d_name.name); 127cc0dd2d1SChuck Lever 128c2459dc4SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 1291da177e4SLinus Torvalds res = nfs_check_flags(filp->f_flags); 1301da177e4SLinus Torvalds if (res) 1311da177e4SLinus Torvalds return res; 1321da177e4SLinus Torvalds 13346cb650cSTrond Myklebust res = nfs_open(inode, filp); 1341da177e4SLinus Torvalds return res; 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds static int 1381da177e4SLinus Torvalds nfs_file_release(struct inode *inode, struct file *filp) 1391da177e4SLinus Torvalds { 1406da24bc9SChuck Lever struct dentry *dentry = filp->f_path.dentry; 1416da24bc9SChuck Lever 1426da24bc9SChuck Lever dprintk("NFS: release(%s/%s)\n", 1436da24bc9SChuck Lever dentry->d_parent->d_name.name, 1446da24bc9SChuck Lever dentry->d_name.name); 1456da24bc9SChuck Lever 14691d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 14746cb650cSTrond Myklebust return nfs_release(inode, filp); 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 150980802e3STrond Myklebust /** 151980802e3STrond Myklebust * nfs_revalidate_size - Revalidate the file size 152980802e3STrond Myklebust * @inode - pointer to inode struct 153980802e3STrond Myklebust * @file - pointer to struct file 154980802e3STrond Myklebust * 155980802e3STrond Myklebust * Revalidates the file length. This is basically a wrapper around 156980802e3STrond Myklebust * nfs_revalidate_inode() that takes into account the fact that we may 157980802e3STrond Myklebust * have cached writes (in which case we don't care about the server's 158980802e3STrond Myklebust * idea of what the file length is), or O_DIRECT (in which case we 159980802e3STrond Myklebust * shouldn't trust the cache). 160980802e3STrond Myklebust */ 161980802e3STrond Myklebust static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 162980802e3STrond Myklebust { 163980802e3STrond Myklebust struct nfs_server *server = NFS_SERVER(inode); 164980802e3STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 165980802e3STrond Myklebust 166d7cf8dd0STrond Myklebust if (nfs_have_delegated_attributes(inode)) 167d7cf8dd0STrond Myklebust goto out_noreval; 168d7cf8dd0STrond Myklebust 169980802e3STrond Myklebust if (filp->f_flags & O_DIRECT) 170980802e3STrond Myklebust goto force_reval; 171d7cf8dd0STrond Myklebust if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) 172d7cf8dd0STrond Myklebust goto force_reval; 173d7cf8dd0STrond Myklebust if (nfs_attribute_timeout(inode)) 174d7cf8dd0STrond Myklebust goto force_reval; 175d7cf8dd0STrond Myklebust out_noreval: 176fe51beecSTrond Myklebust return 0; 177980802e3STrond Myklebust force_reval: 178980802e3STrond Myklebust return __nfs_revalidate_inode(server, inode); 179980802e3STrond Myklebust } 180980802e3STrond Myklebust 181980802e3STrond Myklebust static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin) 182980802e3STrond Myklebust { 1839465efc9SAndi Kleen loff_t loff; 184e89e896dSTrond Myklebust 1856da24bc9SChuck Lever dprintk("NFS: llseek file(%s/%s, %lld, %d)\n", 186b84e06c5SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 187b84e06c5SChuck Lever filp->f_path.dentry->d_name.name, 188b84e06c5SChuck Lever offset, origin); 189b84e06c5SChuck Lever 190980802e3STrond Myklebust /* origin == SEEK_END => we must revalidate the cached file length */ 191aec5e175SJosef 'Jeff' Sipek if (origin == SEEK_END) { 192980802e3STrond Myklebust struct inode *inode = filp->f_mapping->host; 193d5e66348STrond Myklebust 194980802e3STrond Myklebust int retval = nfs_revalidate_file_size(inode, filp); 195980802e3STrond Myklebust if (retval < 0) 196980802e3STrond Myklebust return (loff_t)retval; 197d5e66348STrond Myklebust 198d5e66348STrond Myklebust spin_lock(&inode->i_lock); 1999465efc9SAndi Kleen loff = generic_file_llseek_unlocked(filp, offset, origin); 200d5e66348STrond Myklebust spin_unlock(&inode->i_lock); 201d5e66348STrond Myklebust } else 202d5e66348STrond Myklebust loff = generic_file_llseek_unlocked(filp, offset, origin); 2039465efc9SAndi Kleen return loff; 204980802e3STrond Myklebust } 205980802e3STrond Myklebust 2061da177e4SLinus Torvalds /* 2071da177e4SLinus Torvalds * Flush all dirty pages, and check for write errors. 2081da177e4SLinus Torvalds */ 2091da177e4SLinus Torvalds static int 21075e1fcc0SMiklos Szeredi nfs_file_flush(struct file *file, fl_owner_t id) 2111da177e4SLinus Torvalds { 2126da24bc9SChuck Lever struct dentry *dentry = file->f_path.dentry; 2136da24bc9SChuck Lever struct inode *inode = dentry->d_inode; 2141da177e4SLinus Torvalds 2156da24bc9SChuck Lever dprintk("NFS: flush(%s/%s)\n", 2166da24bc9SChuck Lever dentry->d_parent->d_name.name, 2176da24bc9SChuck Lever dentry->d_name.name); 2181da177e4SLinus Torvalds 219c2459dc4SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 2201da177e4SLinus Torvalds if ((file->f_mode & FMODE_WRITE) == 0) 2211da177e4SLinus Torvalds return 0; 2227b159fc1STrond Myklebust 2237fe5c398STrond Myklebust /* Flush writes to the server and return any errors */ 224af7fa165STrond Myklebust return vfs_fsync(file, 0); 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds static ssize_t 228027445c3SBadari Pulavarty nfs_file_read(struct kiocb *iocb, const struct iovec *iov, 229027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 2301da177e4SLinus Torvalds { 23101cce933SJosef "Jeff" Sipek struct dentry * dentry = iocb->ki_filp->f_path.dentry; 2321da177e4SLinus Torvalds struct inode * inode = dentry->d_inode; 2331da177e4SLinus Torvalds ssize_t result; 234027445c3SBadari Pulavarty size_t count = iov_length(iov, nr_segs); 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds if (iocb->ki_filp->f_flags & O_DIRECT) 237027445c3SBadari Pulavarty return nfs_file_direct_read(iocb, iov, nr_segs, pos); 2381da177e4SLinus Torvalds 2396da24bc9SChuck Lever dprintk("NFS: read(%s/%s, %lu@%lu)\n", 2401da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 2411da177e4SLinus Torvalds (unsigned long) count, (unsigned long) pos); 2421da177e4SLinus Torvalds 24344b11874STrond Myklebust result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 2444184dcf2SChuck Lever if (!result) { 245027445c3SBadari Pulavarty result = generic_file_aio_read(iocb, iov, nr_segs, pos); 2464184dcf2SChuck Lever if (result > 0) 2474184dcf2SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result); 2484184dcf2SChuck Lever } 2491da177e4SLinus Torvalds return result; 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds static ssize_t 253f0930fffSJens Axboe nfs_file_splice_read(struct file *filp, loff_t *ppos, 254f0930fffSJens Axboe struct pipe_inode_info *pipe, size_t count, 255f0930fffSJens Axboe unsigned int flags) 2561da177e4SLinus Torvalds { 25701cce933SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 2581da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 2591da177e4SLinus Torvalds ssize_t res; 2601da177e4SLinus Torvalds 2616da24bc9SChuck Lever dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n", 2621da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 2631da177e4SLinus Torvalds (unsigned long) count, (unsigned long long) *ppos); 2641da177e4SLinus Torvalds 26544b11874STrond Myklebust res = nfs_revalidate_mapping(inode, filp->f_mapping); 266aa2f1ef1SChuck Lever if (!res) { 267f0930fffSJens Axboe res = generic_file_splice_read(filp, ppos, pipe, count, flags); 268aa2f1ef1SChuck Lever if (res > 0) 269aa2f1ef1SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res); 270aa2f1ef1SChuck Lever } 2711da177e4SLinus Torvalds return res; 2721da177e4SLinus Torvalds } 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds static int 2751da177e4SLinus Torvalds nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 2761da177e4SLinus Torvalds { 27701cce933SJosef "Jeff" Sipek struct dentry *dentry = file->f_path.dentry; 2781da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 2791da177e4SLinus Torvalds int status; 2801da177e4SLinus Torvalds 2816da24bc9SChuck Lever dprintk("NFS: mmap(%s/%s)\n", 2821da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 2831da177e4SLinus Torvalds 284e1ebfd33STrond Myklebust /* Note: generic_file_mmap() returns ENOSYS on nommu systems 285e1ebfd33STrond Myklebust * so we call that before revalidating the mapping 286e1ebfd33STrond Myklebust */ 287e1ebfd33STrond Myklebust status = generic_file_mmap(file, vma); 28894387fb1STrond Myklebust if (!status) { 28994387fb1STrond Myklebust vma->vm_ops = &nfs_file_vm_ops; 290e1ebfd33STrond Myklebust status = nfs_revalidate_mapping(inode, file->f_mapping); 29194387fb1STrond Myklebust } 2921da177e4SLinus Torvalds return status; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds /* 2961da177e4SLinus Torvalds * Flush any dirty pages for this process, and check for write errors. 2971da177e4SLinus Torvalds * The return status from this call provides a reliable indication of 2981da177e4SLinus Torvalds * whether any write errors occurred for this process. 299af7fa165STrond Myklebust * 300af7fa165STrond Myklebust * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to 301af7fa165STrond Myklebust * disk, but it retrieves and clears ctx->error after synching, despite 302af7fa165STrond Myklebust * the two being set at the same time in nfs_context_set_write_error(). 303af7fa165STrond Myklebust * This is because the former is used to notify the _next_ call to 304af7fa165STrond Myklebust * nfs_file_write() that a write error occured, and hence cause it to 305af7fa165STrond Myklebust * fall back to doing a synchronous write. 3061da177e4SLinus Torvalds */ 3071da177e4SLinus Torvalds static int 3087ea80859SChristoph Hellwig nfs_file_fsync(struct file *file, int datasync) 3091da177e4SLinus Torvalds { 3107ea80859SChristoph Hellwig struct dentry *dentry = file->f_path.dentry; 311cd3758e3STrond Myklebust struct nfs_open_context *ctx = nfs_file_open_context(file); 3121da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 313af7fa165STrond Myklebust int have_error, status; 314af7fa165STrond Myklebust int ret = 0; 315af7fa165STrond Myklebust 3161da177e4SLinus Torvalds 3176da24bc9SChuck Lever dprintk("NFS: fsync file(%s/%s) datasync %d\n", 31854917786SChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 31954917786SChuck Lever datasync); 3201da177e4SLinus Torvalds 32191d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 322af7fa165STrond Myklebust have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 323af7fa165STrond Myklebust status = nfs_commit_inode(inode, FLUSH_SYNC); 324af7fa165STrond Myklebust have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags); 325af7fa165STrond Myklebust if (have_error) 326af7fa165STrond Myklebust ret = xchg(&ctx->error, 0); 3270702099bSJ. R. Okajima if (!ret && status < 0) 328af7fa165STrond Myklebust ret = status; 329863a3c6cSAndy Adamson if (!ret && !datasync) 330863a3c6cSAndy Adamson /* application has asked for meta-data sync */ 331863a3c6cSAndy Adamson ret = pnfs_layoutcommit_inode(inode, 1); 332af7fa165STrond Myklebust return ret; 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds /* 33638c73044SPeter Staubach * Decide whether a read/modify/write cycle may be more efficient 33738c73044SPeter Staubach * then a modify/write/read cycle when writing to a page in the 33838c73044SPeter Staubach * page cache. 33938c73044SPeter Staubach * 34038c73044SPeter Staubach * The modify/write/read cycle may occur if a page is read before 34138c73044SPeter Staubach * being completely filled by the writer. In this situation, the 34238c73044SPeter Staubach * page must be completely written to stable storage on the server 34338c73044SPeter Staubach * before it can be refilled by reading in the page from the server. 34438c73044SPeter Staubach * This can lead to expensive, small, FILE_SYNC mode writes being 34538c73044SPeter Staubach * done. 34638c73044SPeter Staubach * 34738c73044SPeter Staubach * It may be more efficient to read the page first if the file is 34838c73044SPeter Staubach * open for reading in addition to writing, the page is not marked 34938c73044SPeter Staubach * as Uptodate, it is not dirty or waiting to be committed, 35038c73044SPeter Staubach * indicating that it was previously allocated and then modified, 35138c73044SPeter Staubach * that there were valid bytes of data in that range of the file, 35238c73044SPeter Staubach * and that the new data won't completely replace the old data in 35338c73044SPeter Staubach * that range of the file. 35438c73044SPeter Staubach */ 35538c73044SPeter Staubach static int nfs_want_read_modify_write(struct file *file, struct page *page, 35638c73044SPeter Staubach loff_t pos, unsigned len) 35738c73044SPeter Staubach { 35838c73044SPeter Staubach unsigned int pglen = nfs_page_length(page); 35938c73044SPeter Staubach unsigned int offset = pos & (PAGE_CACHE_SIZE - 1); 36038c73044SPeter Staubach unsigned int end = offset + len; 36138c73044SPeter Staubach 36238c73044SPeter Staubach if ((file->f_mode & FMODE_READ) && /* open for read? */ 36338c73044SPeter Staubach !PageUptodate(page) && /* Uptodate? */ 36438c73044SPeter Staubach !PagePrivate(page) && /* i/o request already? */ 36538c73044SPeter Staubach pglen && /* valid bytes of file? */ 36638c73044SPeter Staubach (end < pglen || offset)) /* replace all valid bytes? */ 36738c73044SPeter Staubach return 1; 36838c73044SPeter Staubach return 0; 36938c73044SPeter Staubach } 37038c73044SPeter Staubach 37138c73044SPeter Staubach /* 3724899f9c8SNick Piggin * This does the "real" work of the write. We must allocate and lock the 3734899f9c8SNick Piggin * page to be sent back to the generic routine, which then copies the 3744899f9c8SNick Piggin * data from user space. 3751da177e4SLinus Torvalds * 3761da177e4SLinus Torvalds * If the writer ends up delaying the write, the writer needs to 3771da177e4SLinus Torvalds * increment the page use counts until he is done with the page. 3781da177e4SLinus Torvalds */ 3794899f9c8SNick Piggin static int nfs_write_begin(struct file *file, struct address_space *mapping, 3804899f9c8SNick Piggin loff_t pos, unsigned len, unsigned flags, 3814899f9c8SNick Piggin struct page **pagep, void **fsdata) 3821da177e4SLinus Torvalds { 3834899f9c8SNick Piggin int ret; 38438c73044SPeter Staubach pgoff_t index = pos >> PAGE_CACHE_SHIFT; 3854899f9c8SNick Piggin struct page *page; 38638c73044SPeter Staubach int once_thru = 0; 3874899f9c8SNick Piggin 388b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n", 389b7eaefaaSChuck Lever file->f_path.dentry->d_parent->d_name.name, 390b7eaefaaSChuck Lever file->f_path.dentry->d_name.name, 391b7eaefaaSChuck Lever mapping->host->i_ino, len, (long long) pos); 392b7eaefaaSChuck Lever 39338c73044SPeter Staubach start: 39472cb77f4STrond Myklebust /* 39572cb77f4STrond Myklebust * Prevent starvation issues if someone is doing a consistency 39672cb77f4STrond Myklebust * sync-to-disk 39772cb77f4STrond Myklebust */ 39872cb77f4STrond Myklebust ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING, 39972cb77f4STrond Myklebust nfs_wait_bit_killable, TASK_KILLABLE); 40072cb77f4STrond Myklebust if (ret) 40172cb77f4STrond Myklebust return ret; 40272cb77f4STrond Myklebust 40354566b2cSNick Piggin page = grab_cache_page_write_begin(mapping, index, flags); 4044899f9c8SNick Piggin if (!page) 4054899f9c8SNick Piggin return -ENOMEM; 4064899f9c8SNick Piggin *pagep = page; 4074899f9c8SNick Piggin 4084899f9c8SNick Piggin ret = nfs_flush_incompatible(file, page); 4094899f9c8SNick Piggin if (ret) { 4104899f9c8SNick Piggin unlock_page(page); 4114899f9c8SNick Piggin page_cache_release(page); 41238c73044SPeter Staubach } else if (!once_thru && 41338c73044SPeter Staubach nfs_want_read_modify_write(file, page, pos, len)) { 41438c73044SPeter Staubach once_thru = 1; 41538c73044SPeter Staubach ret = nfs_readpage(file, page); 41638c73044SPeter Staubach page_cache_release(page); 41738c73044SPeter Staubach if (!ret) 41838c73044SPeter Staubach goto start; 4194899f9c8SNick Piggin } 4204899f9c8SNick Piggin return ret; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4234899f9c8SNick Piggin static int nfs_write_end(struct file *file, struct address_space *mapping, 4244899f9c8SNick Piggin loff_t pos, unsigned len, unsigned copied, 4254899f9c8SNick Piggin struct page *page, void *fsdata) 4261da177e4SLinus Torvalds { 4274899f9c8SNick Piggin unsigned offset = pos & (PAGE_CACHE_SIZE - 1); 4284899f9c8SNick Piggin int status; 4291da177e4SLinus Torvalds 430b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n", 431b7eaefaaSChuck Lever file->f_path.dentry->d_parent->d_name.name, 432b7eaefaaSChuck Lever file->f_path.dentry->d_name.name, 433b7eaefaaSChuck Lever mapping->host->i_ino, len, (long long) pos); 434b7eaefaaSChuck Lever 435efc91ed0STrond Myklebust /* 436efc91ed0STrond Myklebust * Zero any uninitialised parts of the page, and then mark the page 437efc91ed0STrond Myklebust * as up to date if it turns out that we're extending the file. 438efc91ed0STrond Myklebust */ 439efc91ed0STrond Myklebust if (!PageUptodate(page)) { 440efc91ed0STrond Myklebust unsigned pglen = nfs_page_length(page); 441efc91ed0STrond Myklebust unsigned end = offset + len; 442efc91ed0STrond Myklebust 443efc91ed0STrond Myklebust if (pglen == 0) { 444efc91ed0STrond Myklebust zero_user_segments(page, 0, offset, 445efc91ed0STrond Myklebust end, PAGE_CACHE_SIZE); 446efc91ed0STrond Myklebust SetPageUptodate(page); 447efc91ed0STrond Myklebust } else if (end >= pglen) { 448efc91ed0STrond Myklebust zero_user_segment(page, end, PAGE_CACHE_SIZE); 449efc91ed0STrond Myklebust if (offset == 0) 450efc91ed0STrond Myklebust SetPageUptodate(page); 451efc91ed0STrond Myklebust } else 452efc91ed0STrond Myklebust zero_user_segment(page, pglen, PAGE_CACHE_SIZE); 453efc91ed0STrond Myklebust } 454efc91ed0STrond Myklebust 4554899f9c8SNick Piggin status = nfs_updatepage(file, page, offset, copied); 4564899f9c8SNick Piggin 4574899f9c8SNick Piggin unlock_page(page); 4584899f9c8SNick Piggin page_cache_release(page); 4594899f9c8SNick Piggin 4603d509e54SChuck Lever if (status < 0) 4613d509e54SChuck Lever return status; 4623d509e54SChuck Lever return copied; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds 4656b9b3514SDavid Howells /* 4666b9b3514SDavid Howells * Partially or wholly invalidate a page 4676b9b3514SDavid Howells * - Release the private state associated with a page if undergoing complete 4686b9b3514SDavid Howells * page invalidation 469545db45fSDavid Howells * - Called if either PG_private or PG_fscache is set on the page 4706b9b3514SDavid Howells * - Caller holds page lock 4716b9b3514SDavid Howells */ 4722ff28e22SNeilBrown static void nfs_invalidate_page(struct page *page, unsigned long offset) 473cd52ed35STrond Myklebust { 474b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset); 475b7eaefaaSChuck Lever 4761c75950bSTrond Myklebust if (offset != 0) 4771c75950bSTrond Myklebust return; 478d2ccddf0STrond Myklebust /* Cancel any unstarted writes on this page */ 4791b3b4a1aSTrond Myklebust nfs_wb_page_cancel(page->mapping->host, page); 480545db45fSDavid Howells 481545db45fSDavid Howells nfs_fscache_invalidate_page(page, page->mapping->host); 482cd52ed35STrond Myklebust } 483cd52ed35STrond Myklebust 4846b9b3514SDavid Howells /* 4856b9b3514SDavid Howells * Attempt to release the private state associated with a page 486545db45fSDavid Howells * - Called if either PG_private or PG_fscache is set on the page 4876b9b3514SDavid Howells * - Caller holds page lock 4886b9b3514SDavid Howells * - Return true (may release page) or false (may not) 4896b9b3514SDavid Howells */ 490cd52ed35STrond Myklebust static int nfs_release_page(struct page *page, gfp_t gfp) 491cd52ed35STrond Myklebust { 492b608b283STrond Myklebust struct address_space *mapping = page->mapping; 493b608b283STrond Myklebust 494b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); 495b7eaefaaSChuck Lever 496d812e575STrond Myklebust /* Only do I/O if gfp is a superset of GFP_KERNEL */ 497b608b283STrond Myklebust if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL) { 498b608b283STrond Myklebust int how = FLUSH_SYNC; 499b608b283STrond Myklebust 500b608b283STrond Myklebust /* Don't let kswapd deadlock waiting for OOM RPC calls */ 501b608b283STrond Myklebust if (current_is_kswapd()) 502b608b283STrond Myklebust how = 0; 503b608b283STrond Myklebust nfs_commit_inode(mapping->host, how); 504b608b283STrond Myklebust } 505e3db7691STrond Myklebust /* If PagePrivate() is set, then the page is not freeable */ 506545db45fSDavid Howells if (PagePrivate(page)) 507ddeff520SNikita Danilov return 0; 508545db45fSDavid Howells return nfs_fscache_release_page(page, gfp); 509e3db7691STrond Myklebust } 510e3db7691STrond Myklebust 5116b9b3514SDavid Howells /* 5126b9b3514SDavid Howells * Attempt to clear the private state associated with a page when an error 5136b9b3514SDavid Howells * occurs that requires the cached contents of an inode to be written back or 5146b9b3514SDavid Howells * destroyed 515545db45fSDavid Howells * - Called if either PG_private or fscache is set on the page 5166b9b3514SDavid Howells * - Caller holds page lock 5176b9b3514SDavid Howells * - Return 0 if successful, -error otherwise 5186b9b3514SDavid Howells */ 519e3db7691STrond Myklebust static int nfs_launder_page(struct page *page) 520e3db7691STrond Myklebust { 521b7eaefaaSChuck Lever struct inode *inode = page->mapping->host; 522545db45fSDavid Howells struct nfs_inode *nfsi = NFS_I(inode); 523b7eaefaaSChuck Lever 524b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n", 525b7eaefaaSChuck Lever inode->i_ino, (long long)page_offset(page)); 526b7eaefaaSChuck Lever 527545db45fSDavid Howells nfs_fscache_wait_on_page_write(nfsi, page); 528b7eaefaaSChuck Lever return nfs_wb_page(inode, page); 529cd52ed35STrond Myklebust } 530cd52ed35STrond Myklebust 531f5e54d6eSChristoph Hellwig const struct address_space_operations nfs_file_aops = { 5321da177e4SLinus Torvalds .readpage = nfs_readpage, 5331da177e4SLinus Torvalds .readpages = nfs_readpages, 5349cccef95STrond Myklebust .set_page_dirty = __set_page_dirty_nobuffers, 5351da177e4SLinus Torvalds .writepage = nfs_writepage, 5361da177e4SLinus Torvalds .writepages = nfs_writepages, 5374899f9c8SNick Piggin .write_begin = nfs_write_begin, 5384899f9c8SNick Piggin .write_end = nfs_write_end, 539cd52ed35STrond Myklebust .invalidatepage = nfs_invalidate_page, 540cd52ed35STrond Myklebust .releasepage = nfs_release_page, 5411da177e4SLinus Torvalds .direct_IO = nfs_direct_IO, 542074cc1deSTrond Myklebust .migratepage = nfs_migrate_page, 543e3db7691STrond Myklebust .launder_page = nfs_launder_page, 544f590f333SAndi Kleen .error_remove_page = generic_error_remove_page, 5451da177e4SLinus Torvalds }; 5461da177e4SLinus Torvalds 5476b9b3514SDavid Howells /* 5486b9b3514SDavid Howells * Notification that a PTE pointing to an NFS page is about to be made 5496b9b3514SDavid Howells * writable, implying that someone is about to modify the page through a 5506b9b3514SDavid Howells * shared-writable mapping 5516b9b3514SDavid Howells */ 552c2ec175cSNick Piggin static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 55394387fb1STrond Myklebust { 554c2ec175cSNick Piggin struct page *page = vmf->page; 55594387fb1STrond Myklebust struct file *filp = vma->vm_file; 556b7eaefaaSChuck Lever struct dentry *dentry = filp->f_path.dentry; 55794387fb1STrond Myklebust unsigned pagelen; 558bc4866b6STrond Myklebust int ret = VM_FAULT_NOPAGE; 5594899f9c8SNick Piggin struct address_space *mapping; 56094387fb1STrond Myklebust 561b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n", 562b7eaefaaSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 563b7eaefaaSChuck Lever filp->f_mapping->host->i_ino, 564b7eaefaaSChuck Lever (long long)page_offset(page)); 565b7eaefaaSChuck Lever 566545db45fSDavid Howells /* make sure the cache has finished storing the page */ 567545db45fSDavid Howells nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page); 568545db45fSDavid Howells 56994387fb1STrond Myklebust lock_page(page); 5704899f9c8SNick Piggin mapping = page->mapping; 571b7eaefaaSChuck Lever if (mapping != dentry->d_inode->i_mapping) 5728b1f9ee5STrond Myklebust goto out_unlock; 5738b1f9ee5STrond Myklebust 5744899f9c8SNick Piggin pagelen = nfs_page_length(page); 5758b1f9ee5STrond Myklebust if (pagelen == 0) 5768b1f9ee5STrond Myklebust goto out_unlock; 5778b1f9ee5STrond Myklebust 578bc4866b6STrond Myklebust ret = VM_FAULT_LOCKED; 579bc4866b6STrond Myklebust if (nfs_flush_incompatible(filp, page) == 0 && 580bc4866b6STrond Myklebust nfs_updatepage(filp, page, 0, pagelen) == 0) 581bc4866b6STrond Myklebust goto out; 5828b1f9ee5STrond Myklebust 583bc4866b6STrond Myklebust ret = VM_FAULT_SIGBUS; 5848b1f9ee5STrond Myklebust out_unlock: 5854899f9c8SNick Piggin unlock_page(page); 586bc4866b6STrond Myklebust out: 587bc4866b6STrond Myklebust return ret; 58894387fb1STrond Myklebust } 58994387fb1STrond Myklebust 590f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct nfs_file_vm_ops = { 59194387fb1STrond Myklebust .fault = filemap_fault, 59294387fb1STrond Myklebust .page_mkwrite = nfs_vm_page_mkwrite, 59394387fb1STrond Myklebust }; 59494387fb1STrond Myklebust 5957b159fc1STrond Myklebust static int nfs_need_sync_write(struct file *filp, struct inode *inode) 5967b159fc1STrond Myklebust { 5977b159fc1STrond Myklebust struct nfs_open_context *ctx; 5987b159fc1STrond Myklebust 5996b2f3d1fSChristoph Hellwig if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC)) 6007b159fc1STrond Myklebust return 1; 601cd3758e3STrond Myklebust ctx = nfs_file_open_context(filp); 6027b159fc1STrond Myklebust if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags)) 6037b159fc1STrond Myklebust return 1; 6047b159fc1STrond Myklebust return 0; 6057b159fc1STrond Myklebust } 6067b159fc1STrond Myklebust 607027445c3SBadari Pulavarty static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov, 608027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 6091da177e4SLinus Torvalds { 61001cce933SJosef "Jeff" Sipek struct dentry * dentry = iocb->ki_filp->f_path.dentry; 6111da177e4SLinus Torvalds struct inode * inode = dentry->d_inode; 6127e381172SChuck Lever unsigned long written = 0; 6131da177e4SLinus Torvalds ssize_t result; 614027445c3SBadari Pulavarty size_t count = iov_length(iov, nr_segs); 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds if (iocb->ki_filp->f_flags & O_DIRECT) 617027445c3SBadari Pulavarty return nfs_file_direct_write(iocb, iov, nr_segs, pos); 6181da177e4SLinus Torvalds 6196da24bc9SChuck Lever dprintk("NFS: write(%s/%s, %lu@%Ld)\n", 6201da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 6216da24bc9SChuck Lever (unsigned long) count, (long long) pos); 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds result = -EBUSY; 6241da177e4SLinus Torvalds if (IS_SWAPFILE(inode)) 6251da177e4SLinus Torvalds goto out_swapfile; 6267d52e862STrond Myklebust /* 6277d52e862STrond Myklebust * O_APPEND implies that we must revalidate the file length. 6287d52e862STrond Myklebust */ 6297d52e862STrond Myklebust if (iocb->ki_filp->f_flags & O_APPEND) { 6307d52e862STrond Myklebust result = nfs_revalidate_file_size(inode, iocb->ki_filp); 6311da177e4SLinus Torvalds if (result) 6321da177e4SLinus Torvalds goto out; 633fe51beecSTrond Myklebust } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds result = count; 6361da177e4SLinus Torvalds if (!count) 6371da177e4SLinus Torvalds goto out; 6381da177e4SLinus Torvalds 639027445c3SBadari Pulavarty result = generic_file_aio_write(iocb, iov, nr_segs, pos); 6407e381172SChuck Lever if (result > 0) 6417e381172SChuck Lever written = result; 6427e381172SChuck Lever 6436b2f3d1fSChristoph Hellwig /* Return error values for O_DSYNC and IS_SYNC() */ 6447b159fc1STrond Myklebust if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) { 645af7fa165STrond Myklebust int err = vfs_fsync(iocb->ki_filp, 0); 646200baa21STrond Myklebust if (err < 0) 647200baa21STrond Myklebust result = err; 648200baa21STrond Myklebust } 6497e381172SChuck Lever if (result > 0) 6507e381172SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written); 6511da177e4SLinus Torvalds out: 6521da177e4SLinus Torvalds return result; 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds out_swapfile: 6551da177e4SLinus Torvalds printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 6561da177e4SLinus Torvalds goto out; 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 659bf40d343SSuresh Jayaraman static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe, 660bf40d343SSuresh Jayaraman struct file *filp, loff_t *ppos, 661bf40d343SSuresh Jayaraman size_t count, unsigned int flags) 662bf40d343SSuresh Jayaraman { 663bf40d343SSuresh Jayaraman struct dentry *dentry = filp->f_path.dentry; 664bf40d343SSuresh Jayaraman struct inode *inode = dentry->d_inode; 6657e381172SChuck Lever unsigned long written = 0; 666bf40d343SSuresh Jayaraman ssize_t ret; 667bf40d343SSuresh Jayaraman 668bf40d343SSuresh Jayaraman dprintk("NFS splice_write(%s/%s, %lu@%llu)\n", 669bf40d343SSuresh Jayaraman dentry->d_parent->d_name.name, dentry->d_name.name, 670bf40d343SSuresh Jayaraman (unsigned long) count, (unsigned long long) *ppos); 671bf40d343SSuresh Jayaraman 672bf40d343SSuresh Jayaraman /* 673bf40d343SSuresh Jayaraman * The combination of splice and an O_APPEND destination is disallowed. 674bf40d343SSuresh Jayaraman */ 675bf40d343SSuresh Jayaraman 676bf40d343SSuresh Jayaraman ret = generic_file_splice_write(pipe, filp, ppos, count, flags); 6777e381172SChuck Lever if (ret > 0) 6787e381172SChuck Lever written = ret; 6797e381172SChuck Lever 680bf40d343SSuresh Jayaraman if (ret >= 0 && nfs_need_sync_write(filp, inode)) { 681af7fa165STrond Myklebust int err = vfs_fsync(filp, 0); 682bf40d343SSuresh Jayaraman if (err < 0) 683bf40d343SSuresh Jayaraman ret = err; 684bf40d343SSuresh Jayaraman } 6857e381172SChuck Lever if (ret > 0) 6867e381172SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written); 687bf40d343SSuresh Jayaraman return ret; 688bf40d343SSuresh Jayaraman } 689bf40d343SSuresh Jayaraman 6905eebde23SSuresh Jayaraman static int 6915eebde23SSuresh Jayaraman do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 6921da177e4SLinus Torvalds { 6931da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 6941da177e4SLinus Torvalds int status = 0; 69521ac19d4SSergey Vlasov unsigned int saved_type = fl->fl_type; 6961da177e4SLinus Torvalds 697039c4d7aSTrond Myklebust /* Try local locking first */ 6986d34ac19SJ. Bruce Fields posix_test_lock(filp, fl); 6996d34ac19SJ. Bruce Fields if (fl->fl_type != F_UNLCK) { 7006d34ac19SJ. Bruce Fields /* found a conflict */ 701039c4d7aSTrond Myklebust goto out; 7021da177e4SLinus Torvalds } 70321ac19d4SSergey Vlasov fl->fl_type = saved_type; 704039c4d7aSTrond Myklebust 705039c4d7aSTrond Myklebust if (nfs_have_delegation(inode, FMODE_READ)) 706039c4d7aSTrond Myklebust goto out_noconflict; 707039c4d7aSTrond Myklebust 7085eebde23SSuresh Jayaraman if (is_local) 709039c4d7aSTrond Myklebust goto out_noconflict; 710039c4d7aSTrond Myklebust 711039c4d7aSTrond Myklebust status = NFS_PROTO(inode)->lock(filp, cmd, fl); 712039c4d7aSTrond Myklebust out: 7131da177e4SLinus Torvalds return status; 714039c4d7aSTrond Myklebust out_noconflict: 715039c4d7aSTrond Myklebust fl->fl_type = F_UNLCK; 716039c4d7aSTrond Myklebust goto out; 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds static int do_vfs_lock(struct file *file, struct file_lock *fl) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds int res = 0; 7221da177e4SLinus Torvalds switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 7231da177e4SLinus Torvalds case FL_POSIX: 7241da177e4SLinus Torvalds res = posix_lock_file_wait(file, fl); 7251da177e4SLinus Torvalds break; 7261da177e4SLinus Torvalds case FL_FLOCK: 7271da177e4SLinus Torvalds res = flock_lock_file_wait(file, fl); 7281da177e4SLinus Torvalds break; 7291da177e4SLinus Torvalds default: 7301da177e4SLinus Torvalds BUG(); 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds return res; 7331da177e4SLinus Torvalds } 7341da177e4SLinus Torvalds 7355eebde23SSuresh Jayaraman static int 7365eebde23SSuresh Jayaraman do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 7371da177e4SLinus Torvalds { 7381da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 7391da177e4SLinus Torvalds int status; 7401da177e4SLinus Torvalds 7411da177e4SLinus Torvalds /* 7421da177e4SLinus Torvalds * Flush all pending writes before doing anything 7431da177e4SLinus Torvalds * with locks.. 7441da177e4SLinus Torvalds */ 74529884df0STrond Myklebust nfs_sync_mapping(filp->f_mapping); 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds /* NOTE: special case 7481da177e4SLinus Torvalds * If we're signalled while cleaning up locks on process exit, we 7491da177e4SLinus Torvalds * still need to complete the unlock. 7501da177e4SLinus Torvalds */ 7515eebde23SSuresh Jayaraman /* 7525eebde23SSuresh Jayaraman * Use local locking if mounted with "-onolock" or with appropriate 7535eebde23SSuresh Jayaraman * "-olocal_lock=" 7545eebde23SSuresh Jayaraman */ 7555eebde23SSuresh Jayaraman if (!is_local) 7561da177e4SLinus Torvalds status = NFS_PROTO(inode)->lock(filp, cmd, fl); 7571da177e4SLinus Torvalds else 7581da177e4SLinus Torvalds status = do_vfs_lock(filp, fl); 7591da177e4SLinus Torvalds return status; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7625eebde23SSuresh Jayaraman static int 7636b96724eSRicardo Labiaga is_time_granular(struct timespec *ts) { 7646b96724eSRicardo Labiaga return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000)); 7656b96724eSRicardo Labiaga } 7666b96724eSRicardo Labiaga 7676b96724eSRicardo Labiaga static int 7685eebde23SSuresh Jayaraman do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 7691da177e4SLinus Torvalds { 7701da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 7711da177e4SLinus Torvalds int status; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds /* 7741da177e4SLinus Torvalds * Flush all pending writes before doing anything 7751da177e4SLinus Torvalds * with locks.. 7761da177e4SLinus Torvalds */ 77729884df0STrond Myklebust status = nfs_sync_mapping(filp->f_mapping); 77829884df0STrond Myklebust if (status != 0) 7791da177e4SLinus Torvalds goto out; 7801da177e4SLinus Torvalds 7815eebde23SSuresh Jayaraman /* 7825eebde23SSuresh Jayaraman * Use local locking if mounted with "-onolock" or with appropriate 7835eebde23SSuresh Jayaraman * "-olocal_lock=" 7845eebde23SSuresh Jayaraman */ 7855eebde23SSuresh Jayaraman if (!is_local) 7861da177e4SLinus Torvalds status = NFS_PROTO(inode)->lock(filp, cmd, fl); 787c4d7c402STrond Myklebust else 7881da177e4SLinus Torvalds status = do_vfs_lock(filp, fl); 7891da177e4SLinus Torvalds if (status < 0) 7901da177e4SLinus Torvalds goto out; 7916b96724eSRicardo Labiaga 7921da177e4SLinus Torvalds /* 7936b96724eSRicardo Labiaga * Revalidate the cache if the server has time stamps granular 7946b96724eSRicardo Labiaga * enough to detect subsecond changes. Otherwise, clear the 7956b96724eSRicardo Labiaga * cache to prevent missing any changes. 7966b96724eSRicardo Labiaga * 7971da177e4SLinus Torvalds * This makes locking act as a cache coherency point. 7981da177e4SLinus Torvalds */ 79929884df0STrond Myklebust nfs_sync_mapping(filp->f_mapping); 8006b96724eSRicardo Labiaga if (!nfs_have_delegation(inode, FMODE_READ)) { 8016b96724eSRicardo Labiaga if (is_time_granular(&NFS_SERVER(inode)->time_delta)) 8026b96724eSRicardo Labiaga __nfs_revalidate_inode(NFS_SERVER(inode), inode); 8036b96724eSRicardo Labiaga else 8041da177e4SLinus Torvalds nfs_zap_caches(inode); 8056b96724eSRicardo Labiaga } 8061da177e4SLinus Torvalds out: 8071da177e4SLinus Torvalds return status; 8081da177e4SLinus Torvalds } 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds /* 8111da177e4SLinus Torvalds * Lock a (portion of) a file 8121da177e4SLinus Torvalds */ 8131da177e4SLinus Torvalds static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 8141da177e4SLinus Torvalds { 8151da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 8162116271aSTrond Myklebust int ret = -ENOLCK; 8175eebde23SSuresh Jayaraman int is_local = 0; 8181da177e4SLinus Torvalds 8196da24bc9SChuck Lever dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n", 8206da24bc9SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 8216da24bc9SChuck Lever filp->f_path.dentry->d_name.name, 8221da177e4SLinus Torvalds fl->fl_type, fl->fl_flags, 8231da177e4SLinus Torvalds (long long)fl->fl_start, (long long)fl->fl_end); 8246da24bc9SChuck Lever 82591d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSLOCK); 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds /* No mandatory locks over NFS */ 828dfad9441SPavel Emelyanov if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 8292116271aSTrond Myklebust goto out_err; 8302116271aSTrond Myklebust 8315eebde23SSuresh Jayaraman if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL) 8325eebde23SSuresh Jayaraman is_local = 1; 8335eebde23SSuresh Jayaraman 8342116271aSTrond Myklebust if (NFS_PROTO(inode)->lock_check_bounds != NULL) { 8352116271aSTrond Myklebust ret = NFS_PROTO(inode)->lock_check_bounds(fl); 8362116271aSTrond Myklebust if (ret < 0) 8372116271aSTrond Myklebust goto out_err; 8382116271aSTrond Myklebust } 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds if (IS_GETLK(cmd)) 8415eebde23SSuresh Jayaraman ret = do_getlk(filp, cmd, fl, is_local); 8422116271aSTrond Myklebust else if (fl->fl_type == F_UNLCK) 8435eebde23SSuresh Jayaraman ret = do_unlk(filp, cmd, fl, is_local); 8442116271aSTrond Myklebust else 8455eebde23SSuresh Jayaraman ret = do_setlk(filp, cmd, fl, is_local); 8462116271aSTrond Myklebust out_err: 8472116271aSTrond Myklebust return ret; 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds /* 8511da177e4SLinus Torvalds * Lock a (portion of) a file 8521da177e4SLinus Torvalds */ 8531da177e4SLinus Torvalds static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 8541da177e4SLinus Torvalds { 8555eebde23SSuresh Jayaraman struct inode *inode = filp->f_mapping->host; 8565eebde23SSuresh Jayaraman int is_local = 0; 8575eebde23SSuresh Jayaraman 8586da24bc9SChuck Lever dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n", 8596da24bc9SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 8606da24bc9SChuck Lever filp->f_path.dentry->d_name.name, 8611da177e4SLinus Torvalds fl->fl_type, fl->fl_flags); 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds if (!(fl->fl_flags & FL_FLOCK)) 8641da177e4SLinus Torvalds return -ENOLCK; 8651da177e4SLinus Torvalds 8665eebde23SSuresh Jayaraman if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) 8675eebde23SSuresh Jayaraman is_local = 1; 8685eebde23SSuresh Jayaraman 8691da177e4SLinus Torvalds /* We're simulating flock() locks using posix locks on the server */ 8701da177e4SLinus Torvalds fl->fl_owner = (fl_owner_t)filp; 8711da177e4SLinus Torvalds fl->fl_start = 0; 8721da177e4SLinus Torvalds fl->fl_end = OFFSET_MAX; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds if (fl->fl_type == F_UNLCK) 8755eebde23SSuresh Jayaraman return do_unlk(filp, cmd, fl, is_local); 8765eebde23SSuresh Jayaraman return do_setlk(filp, cmd, fl, is_local); 8771da177e4SLinus Torvalds } 878370f6599SJ. Bruce Fields 8796da24bc9SChuck Lever /* 8806da24bc9SChuck Lever * There is no protocol support for leases, so we have no way to implement 8816da24bc9SChuck Lever * them correctly in the face of opens by other clients. 8826da24bc9SChuck Lever */ 883370f6599SJ. Bruce Fields static int nfs_setlease(struct file *file, long arg, struct file_lock **fl) 884370f6599SJ. Bruce Fields { 8856da24bc9SChuck Lever dprintk("NFS: setlease(%s/%s, arg=%ld)\n", 8866da24bc9SChuck Lever file->f_path.dentry->d_parent->d_name.name, 8876da24bc9SChuck Lever file->f_path.dentry->d_name.name, arg); 888370f6599SJ. Bruce Fields return -EINVAL; 889370f6599SJ. Bruce Fields } 890