1457c8996SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * linux/fs/nfs/file.c 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (C) 1992 Rick Sladkey 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Changes Copyright (C) 1994 by Florian La Roche 81da177e4SLinus Torvalds * - Do not copy data too often around in the kernel. 91da177e4SLinus Torvalds * - In nfs_file_read the return value of kmalloc wasn't checked. 101da177e4SLinus Torvalds * - Put in a better version of read look-ahead buffering. Original idea 111da177e4SLinus Torvalds * and implementation by Wai S Kok elekokws@ee.nus.sg. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * Expire cache on write to a file by Wai S Kok (Oct 1994). 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * Total rewrite of read side for new NFS buffer cache.. Linus. 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * nfs regular file handling functions 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds 20ddda8e0aSBryan Schumaker #include <linux/module.h> 211da177e4SLinus Torvalds #include <linux/time.h> 221da177e4SLinus Torvalds #include <linux/kernel.h> 231da177e4SLinus Torvalds #include <linux/errno.h> 241da177e4SLinus Torvalds #include <linux/fcntl.h> 251da177e4SLinus Torvalds #include <linux/stat.h> 261da177e4SLinus Torvalds #include <linux/nfs_fs.h> 271da177e4SLinus Torvalds #include <linux/nfs_mount.h> 281da177e4SLinus Torvalds #include <linux/mm.h> 291da177e4SLinus Torvalds #include <linux/pagemap.h> 305a0e3ad6STejun Heo #include <linux/gfp.h> 31b608b283STrond Myklebust #include <linux/swap.h> 321da177e4SLinus Torvalds 337c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include "delegation.h" 3694387fb1STrond Myklebust #include "internal.h" 3791d5b470SChuck Lever #include "iostat.h" 38545db45fSDavid Howells #include "fscache.h" 39612aa983SChristoph Hellwig #include "pnfs.h" 401da177e4SLinus Torvalds 41f4ce1299STrond Myklebust #include "nfstrace.h" 42f4ce1299STrond Myklebust 431da177e4SLinus Torvalds #define NFSDBG_FACILITY NFSDBG_FILE 441da177e4SLinus Torvalds 45f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct nfs_file_vm_ops; 4694387fb1STrond Myklebust 47ce4ef7c0SBryan Schumaker int nfs_check_flags(int flags) 481da177e4SLinus Torvalds { 491da177e4SLinus Torvalds if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT)) 501da177e4SLinus Torvalds return -EINVAL; 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds return 0; 531da177e4SLinus Torvalds } 5489d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_check_flags); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* 571da177e4SLinus Torvalds * Open file 581da177e4SLinus Torvalds */ 591da177e4SLinus Torvalds static int 601da177e4SLinus Torvalds nfs_file_open(struct inode *inode, struct file *filp) 611da177e4SLinus Torvalds { 621da177e4SLinus Torvalds int res; 631da177e4SLinus Torvalds 646de1472fSAl Viro dprintk("NFS: open file(%pD2)\n", filp); 65cc0dd2d1SChuck Lever 66c2459dc4SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 671da177e4SLinus Torvalds res = nfs_check_flags(filp->f_flags); 681da177e4SLinus Torvalds if (res) 691da177e4SLinus Torvalds return res; 701da177e4SLinus Torvalds 7146cb650cSTrond Myklebust res = nfs_open(inode, filp); 72*a2ad63daSNeilBrown if (res == 0) 73*a2ad63daSNeilBrown filp->f_mode |= FMODE_CAN_ODIRECT; 741da177e4SLinus Torvalds return res; 751da177e4SLinus Torvalds } 761da177e4SLinus Torvalds 77ce4ef7c0SBryan Schumaker int 781da177e4SLinus Torvalds nfs_file_release(struct inode *inode, struct file *filp) 791da177e4SLinus Torvalds { 806de1472fSAl Viro dprintk("NFS: release(%pD2)\n", filp); 816da24bc9SChuck Lever 8291d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 83aff8d8dcSAnna Schumaker nfs_file_clear_open_context(filp); 84a6b5a28eSDave Wysochanski nfs_fscache_release_file(inode, filp); 85aff8d8dcSAnna Schumaker return 0; 861da177e4SLinus Torvalds } 8789d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_release); 881da177e4SLinus Torvalds 89980802e3STrond Myklebust /** 9037eaeed1STrond Myklebust * nfs_revalidate_file_size - Revalidate the file size 91302fad7bSTrond Myklebust * @inode: pointer to inode struct 92302fad7bSTrond Myklebust * @filp: pointer to struct file 93980802e3STrond Myklebust * 94980802e3STrond Myklebust * Revalidates the file length. This is basically a wrapper around 95980802e3STrond Myklebust * nfs_revalidate_inode() that takes into account the fact that we may 96980802e3STrond Myklebust * have cached writes (in which case we don't care about the server's 97980802e3STrond Myklebust * idea of what the file length is), or O_DIRECT (in which case we 98980802e3STrond Myklebust * shouldn't trust the cache). 99980802e3STrond Myklebust */ 100980802e3STrond Myklebust static int nfs_revalidate_file_size(struct inode *inode, struct file *filp) 101980802e3STrond Myklebust { 102980802e3STrond Myklebust struct nfs_server *server = NFS_SERVER(inode); 103d7cf8dd0STrond Myklebust 104980802e3STrond Myklebust if (filp->f_flags & O_DIRECT) 105980802e3STrond Myklebust goto force_reval; 10613c0b082STrond Myklebust if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_SIZE)) 107d7cf8dd0STrond Myklebust goto force_reval; 108fe51beecSTrond Myklebust return 0; 109980802e3STrond Myklebust force_reval: 110980802e3STrond Myklebust return __nfs_revalidate_inode(server, inode); 111980802e3STrond Myklebust } 112980802e3STrond Myklebust 113965c8e59SAndrew Morton loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence) 114980802e3STrond Myklebust { 1156de1472fSAl Viro dprintk("NFS: llseek file(%pD2, %lld, %d)\n", 1166de1472fSAl Viro filp, offset, whence); 117b84e06c5SChuck Lever 11806222e49SJosef Bacik /* 119965c8e59SAndrew Morton * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate 12006222e49SJosef Bacik * the cached file length 12106222e49SJosef Bacik */ 122965c8e59SAndrew Morton if (whence != SEEK_SET && whence != SEEK_CUR) { 123980802e3STrond Myklebust struct inode *inode = filp->f_mapping->host; 124d5e66348STrond Myklebust 125980802e3STrond Myklebust int retval = nfs_revalidate_file_size(inode, filp); 126980802e3STrond Myklebust if (retval < 0) 127980802e3STrond Myklebust return (loff_t)retval; 12879835a71SAndi Kleen } 129d5e66348STrond Myklebust 130965c8e59SAndrew Morton return generic_file_llseek(filp, offset, whence); 131980802e3STrond Myklebust } 13289d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_llseek); 133980802e3STrond Myklebust 1341da177e4SLinus Torvalds /* 1351da177e4SLinus Torvalds * Flush all dirty pages, and check for write errors. 1361da177e4SLinus Torvalds */ 1375445b1fbSTrond Myklebust static int 13875e1fcc0SMiklos Szeredi nfs_file_flush(struct file *file, fl_owner_t id) 1391da177e4SLinus Torvalds { 1406de1472fSAl Viro struct inode *inode = file_inode(file); 14167dd23f9SScott Mayhew errseq_t since; 1421da177e4SLinus Torvalds 1436de1472fSAl Viro dprintk("NFS: flush(%pD2)\n", file); 1441da177e4SLinus Torvalds 145c2459dc4SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 1461da177e4SLinus Torvalds if ((file->f_mode & FMODE_WRITE) == 0) 1471da177e4SLinus Torvalds return 0; 1487b159fc1STrond Myklebust 1497fe5c398STrond Myklebust /* Flush writes to the server and return any errors */ 15067dd23f9SScott Mayhew since = filemap_sample_wb_err(file->f_mapping); 15167dd23f9SScott Mayhew nfs_wb_all(inode); 15267dd23f9SScott Mayhew return filemap_check_wb_err(file->f_mapping, since); 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 155ce4ef7c0SBryan Schumaker ssize_t 1563aa2d199SAl Viro nfs_file_read(struct kiocb *iocb, struct iov_iter *to) 1571da177e4SLinus Torvalds { 1586de1472fSAl Viro struct inode *inode = file_inode(iocb->ki_filp); 1591da177e4SLinus Torvalds ssize_t result; 1601da177e4SLinus Torvalds 1612ba48ce5SAl Viro if (iocb->ki_flags & IOCB_DIRECT) 16264158668SNeilBrown return nfs_file_direct_read(iocb, to, false); 1631da177e4SLinus Torvalds 164619d30b4SAl Viro dprintk("NFS: read(%pD2, %zu@%lu)\n", 1656de1472fSAl Viro iocb->ki_filp, 1663aa2d199SAl Viro iov_iter_count(to), (unsigned long) iocb->ki_pos); 1671da177e4SLinus Torvalds 168a5864c99STrond Myklebust nfs_start_io_read(inode); 169a5864c99STrond Myklebust result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping); 1704184dcf2SChuck Lever if (!result) { 1713aa2d199SAl Viro result = generic_file_read_iter(iocb, to); 1724184dcf2SChuck Lever if (result > 0) 1734184dcf2SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result); 1744184dcf2SChuck Lever } 175a5864c99STrond Myklebust nfs_end_io_read(inode); 1761da177e4SLinus Torvalds return result; 1771da177e4SLinus Torvalds } 17889d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_read); 1791da177e4SLinus Torvalds 180ce4ef7c0SBryan Schumaker int 1811da177e4SLinus Torvalds nfs_file_mmap(struct file * file, struct vm_area_struct * vma) 1821da177e4SLinus Torvalds { 1836de1472fSAl Viro struct inode *inode = file_inode(file); 1841da177e4SLinus Torvalds int status; 1851da177e4SLinus Torvalds 1866de1472fSAl Viro dprintk("NFS: mmap(%pD2)\n", file); 1871da177e4SLinus Torvalds 188e1ebfd33STrond Myklebust /* Note: generic_file_mmap() returns ENOSYS on nommu systems 189e1ebfd33STrond Myklebust * so we call that before revalidating the mapping 190e1ebfd33STrond Myklebust */ 191e1ebfd33STrond Myklebust status = generic_file_mmap(file, vma); 19294387fb1STrond Myklebust if (!status) { 19394387fb1STrond Myklebust vma->vm_ops = &nfs_file_vm_ops; 194e1ebfd33STrond Myklebust status = nfs_revalidate_mapping(inode, file->f_mapping); 19594387fb1STrond Myklebust } 1961da177e4SLinus Torvalds return status; 1971da177e4SLinus Torvalds } 19889d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_mmap); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* 2011da177e4SLinus Torvalds * Flush any dirty pages for this process, and check for write errors. 2021da177e4SLinus Torvalds * The return status from this call provides a reliable indication of 2031da177e4SLinus Torvalds * whether any write errors occurred for this process. 2041da177e4SLinus Torvalds */ 2054ff79bc7SChristoph Hellwig static int 206bf4b4905SNeilBrown nfs_file_fsync_commit(struct file *file, int datasync) 2071da177e4SLinus Torvalds { 2086de1472fSAl Viro struct inode *inode = file_inode(file); 2092197e9b0STrond Myklebust int ret; 210af7fa165STrond Myklebust 2116de1472fSAl Viro dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync); 2121da177e4SLinus Torvalds 21391d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 2142197e9b0STrond Myklebust ret = nfs_commit_inode(inode, FLUSH_SYNC); 2152197e9b0STrond Myklebust if (ret < 0) 216a5c58892SBryan Schumaker return ret; 2172197e9b0STrond Myklebust return file_check_and_advance_wb_err(file); 218a5c58892SBryan Schumaker } 219a5c58892SBryan Schumaker 2204ff79bc7SChristoph Hellwig int 221a5c58892SBryan Schumaker nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync) 222a5c58892SBryan Schumaker { 2232197e9b0STrond Myklebust struct nfs_open_context *ctx = nfs_file_open_context(file); 224496ad9aaSAl Viro struct inode *inode = file_inode(file); 2252197e9b0STrond Myklebust int ret; 226a5c58892SBryan Schumaker 227f4ce1299STrond Myklebust trace_nfs_fsync_enter(inode); 228f4ce1299STrond Myklebust 2292197e9b0STrond Myklebust for (;;) { 2306fbda89bSTrond Myklebust ret = file_write_and_wait_range(file, start, end); 2317b281ee0STrond Myklebust if (ret != 0) 23205990d1bSTrond Myklebust break; 233bf4b4905SNeilBrown ret = nfs_file_fsync_commit(file, datasync); 2342197e9b0STrond Myklebust if (ret != 0) 2352197e9b0STrond Myklebust break; 2364ff79bc7SChristoph Hellwig ret = pnfs_sync_inode(inode, !!datasync); 2372197e9b0STrond Myklebust if (ret != 0) 2382197e9b0STrond Myklebust break; 2392197e9b0STrond Myklebust if (!test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags)) 2402197e9b0STrond Myklebust break; 241dcfc4f25STrond Myklebust /* 242dcfc4f25STrond Myklebust * If nfs_file_fsync_commit detected a server reboot, then 243dcfc4f25STrond Myklebust * resend all dirty pages that might have been covered by 244dcfc4f25STrond Myklebust * the NFS_CONTEXT_RESEND_WRITES flag 245dcfc4f25STrond Myklebust */ 246dcfc4f25STrond Myklebust start = 0; 247dcfc4f25STrond Myklebust end = LLONG_MAX; 2482197e9b0STrond Myklebust } 24905990d1bSTrond Myklebust 250f4ce1299STrond Myklebust trace_nfs_fsync_exit(inode, ret); 251af7fa165STrond Myklebust return ret; 2521da177e4SLinus Torvalds } 2534ff79bc7SChristoph Hellwig EXPORT_SYMBOL_GPL(nfs_file_fsync); 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* 25638c73044SPeter Staubach * Decide whether a read/modify/write cycle may be more efficient 25738c73044SPeter Staubach * then a modify/write/read cycle when writing to a page in the 25838c73044SPeter Staubach * page cache. 25938c73044SPeter Staubach * 2602cde04e9SKazuo Ito * Some pNFS layout drivers can only read/write at a certain block 2612cde04e9SKazuo Ito * granularity like all block devices and therefore we must perform 2622cde04e9SKazuo Ito * read/modify/write whenever a page hasn't read yet and the data 2632cde04e9SKazuo Ito * to be written there is not aligned to a block boundary and/or 2642cde04e9SKazuo Ito * smaller than the block size. 2652cde04e9SKazuo Ito * 26638c73044SPeter Staubach * The modify/write/read cycle may occur if a page is read before 26738c73044SPeter Staubach * being completely filled by the writer. In this situation, the 26838c73044SPeter Staubach * page must be completely written to stable storage on the server 26938c73044SPeter Staubach * before it can be refilled by reading in the page from the server. 27038c73044SPeter Staubach * This can lead to expensive, small, FILE_SYNC mode writes being 27138c73044SPeter Staubach * done. 27238c73044SPeter Staubach * 27338c73044SPeter Staubach * It may be more efficient to read the page first if the file is 27438c73044SPeter Staubach * open for reading in addition to writing, the page is not marked 27538c73044SPeter Staubach * as Uptodate, it is not dirty or waiting to be committed, 27638c73044SPeter Staubach * indicating that it was previously allocated and then modified, 27738c73044SPeter Staubach * that there were valid bytes of data in that range of the file, 27838c73044SPeter Staubach * and that the new data won't completely replace the old data in 27938c73044SPeter Staubach * that range of the file. 28038c73044SPeter Staubach */ 2812cde04e9SKazuo Ito static bool nfs_full_page_write(struct page *page, loff_t pos, unsigned int len) 28238c73044SPeter Staubach { 28338c73044SPeter Staubach unsigned int pglen = nfs_page_length(page); 28409cbfeafSKirill A. Shutemov unsigned int offset = pos & (PAGE_SIZE - 1); 28538c73044SPeter Staubach unsigned int end = offset + len; 28638c73044SPeter Staubach 2872cde04e9SKazuo Ito return !pglen || (end >= pglen && !offset); 288612aa983SChristoph Hellwig } 289612aa983SChristoph Hellwig 2902cde04e9SKazuo Ito static bool nfs_want_read_modify_write(struct file *file, struct page *page, 2912cde04e9SKazuo Ito loff_t pos, unsigned int len) 2922cde04e9SKazuo Ito { 2932cde04e9SKazuo Ito /* 2942cde04e9SKazuo Ito * Up-to-date pages, those with ongoing or full-page write 2952cde04e9SKazuo Ito * don't need read/modify/write 2962cde04e9SKazuo Ito */ 2972cde04e9SKazuo Ito if (PageUptodate(page) || PagePrivate(page) || 2982cde04e9SKazuo Ito nfs_full_page_write(page, pos, len)) 2992cde04e9SKazuo Ito return false; 3002cde04e9SKazuo Ito 3012cde04e9SKazuo Ito if (pnfs_ld_read_whole_page(file->f_mapping->host)) 3022cde04e9SKazuo Ito return true; 3032cde04e9SKazuo Ito /* Open for reading too? */ 3042cde04e9SKazuo Ito if (file->f_mode & FMODE_READ) 3052cde04e9SKazuo Ito return true; 3062cde04e9SKazuo Ito return false; 30738c73044SPeter Staubach } 30838c73044SPeter Staubach 30938c73044SPeter Staubach /* 3104899f9c8SNick Piggin * This does the "real" work of the write. We must allocate and lock the 3114899f9c8SNick Piggin * page to be sent back to the generic routine, which then copies the 3124899f9c8SNick Piggin * data from user space. 3131da177e4SLinus Torvalds * 3141da177e4SLinus Torvalds * If the writer ends up delaying the write, the writer needs to 3151da177e4SLinus Torvalds * increment the page use counts until he is done with the page. 3161da177e4SLinus Torvalds */ 3174899f9c8SNick Piggin static int nfs_write_begin(struct file *file, struct address_space *mapping, 3184899f9c8SNick Piggin loff_t pos, unsigned len, unsigned flags, 3194899f9c8SNick Piggin struct page **pagep, void **fsdata) 3201da177e4SLinus Torvalds { 3214899f9c8SNick Piggin int ret; 32209cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT; 3234899f9c8SNick Piggin struct page *page; 32438c73044SPeter Staubach int once_thru = 0; 3254899f9c8SNick Piggin 3261e8968c5SNiels de Vos dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n", 3276de1472fSAl Viro file, mapping->host->i_ino, len, (long long) pos); 328b7eaefaaSChuck Lever 32938c73044SPeter Staubach start: 33054566b2cSNick Piggin page = grab_cache_page_write_begin(mapping, index, flags); 3314899f9c8SNick Piggin if (!page) 3324899f9c8SNick Piggin return -ENOMEM; 3334899f9c8SNick Piggin *pagep = page; 3344899f9c8SNick Piggin 3354899f9c8SNick Piggin ret = nfs_flush_incompatible(file, page); 3364899f9c8SNick Piggin if (ret) { 3374899f9c8SNick Piggin unlock_page(page); 33809cbfeafSKirill A. Shutemov put_page(page); 33938c73044SPeter Staubach } else if (!once_thru && 34038c73044SPeter Staubach nfs_want_read_modify_write(file, page, pos, len)) { 34138c73044SPeter Staubach once_thru = 1; 34238c73044SPeter Staubach ret = nfs_readpage(file, page); 34309cbfeafSKirill A. Shutemov put_page(page); 34438c73044SPeter Staubach if (!ret) 34538c73044SPeter Staubach goto start; 3464899f9c8SNick Piggin } 3474899f9c8SNick Piggin return ret; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds 3504899f9c8SNick Piggin static int nfs_write_end(struct file *file, struct address_space *mapping, 3514899f9c8SNick Piggin loff_t pos, unsigned len, unsigned copied, 3524899f9c8SNick Piggin struct page *page, void *fsdata) 3531da177e4SLinus Torvalds { 35409cbfeafSKirill A. Shutemov unsigned offset = pos & (PAGE_SIZE - 1); 355dc24826bSAndy Adamson struct nfs_open_context *ctx = nfs_file_open_context(file); 3564899f9c8SNick Piggin int status; 3571da177e4SLinus Torvalds 3581e8968c5SNiels de Vos dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n", 3596de1472fSAl Viro file, mapping->host->i_ino, len, (long long) pos); 360b7eaefaaSChuck Lever 361efc91ed0STrond Myklebust /* 362efc91ed0STrond Myklebust * Zero any uninitialised parts of the page, and then mark the page 363efc91ed0STrond Myklebust * as up to date if it turns out that we're extending the file. 364efc91ed0STrond Myklebust */ 365efc91ed0STrond Myklebust if (!PageUptodate(page)) { 366efc91ed0STrond Myklebust unsigned pglen = nfs_page_length(page); 367c0cf3ef5SAl Viro unsigned end = offset + copied; 368efc91ed0STrond Myklebust 369efc91ed0STrond Myklebust if (pglen == 0) { 370efc91ed0STrond Myklebust zero_user_segments(page, 0, offset, 37109cbfeafSKirill A. Shutemov end, PAGE_SIZE); 372efc91ed0STrond Myklebust SetPageUptodate(page); 373efc91ed0STrond Myklebust } else if (end >= pglen) { 37409cbfeafSKirill A. Shutemov zero_user_segment(page, end, PAGE_SIZE); 375efc91ed0STrond Myklebust if (offset == 0) 376efc91ed0STrond Myklebust SetPageUptodate(page); 377efc91ed0STrond Myklebust } else 37809cbfeafSKirill A. Shutemov zero_user_segment(page, pglen, PAGE_SIZE); 379efc91ed0STrond Myklebust } 380efc91ed0STrond Myklebust 3814899f9c8SNick Piggin status = nfs_updatepage(file, page, offset, copied); 3824899f9c8SNick Piggin 3834899f9c8SNick Piggin unlock_page(page); 38409cbfeafSKirill A. Shutemov put_page(page); 3854899f9c8SNick Piggin 3863d509e54SChuck Lever if (status < 0) 3873d509e54SChuck Lever return status; 3882701d086SAndy Adamson NFS_I(mapping->host)->write_io += copied; 389dc24826bSAndy Adamson 390ce52914eSScott Mayhew if (nfs_ctx_key_to_expire(ctx, mapping->host)) { 391dc24826bSAndy Adamson status = nfs_wb_all(mapping->host); 392dc24826bSAndy Adamson if (status < 0) 393dc24826bSAndy Adamson return status; 394dc24826bSAndy Adamson } 395dc24826bSAndy Adamson 3963d509e54SChuck Lever return copied; 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds 3996b9b3514SDavid Howells /* 4006b9b3514SDavid Howells * Partially or wholly invalidate a page 4016b9b3514SDavid Howells * - Release the private state associated with a page if undergoing complete 4026b9b3514SDavid Howells * page invalidation 403545db45fSDavid Howells * - Called if either PG_private or PG_fscache is set on the page 4046b9b3514SDavid Howells * - Caller holds page lock 4056b9b3514SDavid Howells */ 4066d740c76SMatthew Wilcox (Oracle) static void nfs_invalidate_folio(struct folio *folio, size_t offset, 4076d740c76SMatthew Wilcox (Oracle) size_t length) 408cd52ed35STrond Myklebust { 4096d740c76SMatthew Wilcox (Oracle) dfprintk(PAGECACHE, "NFS: invalidate_folio(%lu, %zu, %zu)\n", 4106d740c76SMatthew Wilcox (Oracle) folio->index, offset, length); 411b7eaefaaSChuck Lever 4126d740c76SMatthew Wilcox (Oracle) if (offset != 0 || length < folio_size(folio)) 4131c75950bSTrond Myklebust return; 414d2ccddf0STrond Myklebust /* Cancel any unstarted writes on this page */ 4156d740c76SMatthew Wilcox (Oracle) nfs_wb_folio_cancel(folio->mapping->host, folio); 4166d740c76SMatthew Wilcox (Oracle) folio_wait_fscache(folio); 417cd52ed35STrond Myklebust } 418cd52ed35STrond Myklebust 4196b9b3514SDavid Howells /* 4206b9b3514SDavid Howells * Attempt to release the private state associated with a page 421545db45fSDavid Howells * - Called if either PG_private or PG_fscache is set on the page 4226b9b3514SDavid Howells * - Caller holds page lock 4236b9b3514SDavid Howells * - Return true (may release page) or false (may not) 4246b9b3514SDavid Howells */ 425cd52ed35STrond Myklebust static int nfs_release_page(struct page *page, gfp_t gfp) 426cd52ed35STrond Myklebust { 427b7eaefaaSChuck Lever dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); 428b7eaefaaSChuck Lever 429e3db7691STrond Myklebust /* If PagePrivate() is set, then the page is not freeable */ 430545db45fSDavid Howells if (PagePrivate(page)) 431ddeff520SNikita Danilov return 0; 432545db45fSDavid Howells return nfs_fscache_release_page(page, gfp); 433e3db7691STrond Myklebust } 434e3db7691STrond Myklebust 435f919b196SMel Gorman static void nfs_check_dirty_writeback(struct page *page, 436f919b196SMel Gorman bool *dirty, bool *writeback) 437f919b196SMel Gorman { 438f919b196SMel Gorman struct nfs_inode *nfsi; 439f919b196SMel Gorman struct address_space *mapping = page_file_mapping(page); 440f919b196SMel Gorman 441f919b196SMel Gorman if (!mapping || PageSwapCache(page)) 442f919b196SMel Gorman return; 443f919b196SMel Gorman 444f919b196SMel Gorman /* 445f919b196SMel Gorman * Check if an unstable page is currently being committed and 446f919b196SMel Gorman * if so, have the VM treat it as if the page is under writeback 447f919b196SMel Gorman * so it will not block due to pages that will shortly be freeable. 448f919b196SMel Gorman */ 449f919b196SMel Gorman nfsi = NFS_I(mapping->host); 450af7cf057STrond Myklebust if (atomic_read(&nfsi->commit_info.rpcs_out)) { 451f919b196SMel Gorman *writeback = true; 452f919b196SMel Gorman return; 453f919b196SMel Gorman } 454f919b196SMel Gorman 455f919b196SMel Gorman /* 456f919b196SMel Gorman * If PagePrivate() is set, then the page is not freeable and as the 457f919b196SMel Gorman * inode is not being committed, it's not going to be cleaned in the 458f919b196SMel Gorman * near future so treat it as dirty 459f919b196SMel Gorman */ 460f919b196SMel Gorman if (PagePrivate(page)) 461f919b196SMel Gorman *dirty = true; 462f919b196SMel Gorman } 463f919b196SMel Gorman 4646b9b3514SDavid Howells /* 4656b9b3514SDavid Howells * Attempt to clear the private state associated with a page when an error 4666b9b3514SDavid Howells * occurs that requires the cached contents of an inode to be written back or 4676b9b3514SDavid Howells * destroyed 468545db45fSDavid Howells * - Called if either PG_private or fscache is set on the page 4696b9b3514SDavid Howells * - Caller holds page lock 4706b9b3514SDavid Howells * - Return 0 if successful, -error otherwise 4716b9b3514SDavid Howells */ 47215a30ab2SMatthew Wilcox (Oracle) static int nfs_launder_folio(struct folio *folio) 473e3db7691STrond Myklebust { 47415a30ab2SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host; 475b7eaefaaSChuck Lever 47615a30ab2SMatthew Wilcox (Oracle) dfprintk(PAGECACHE, "NFS: launder_folio(%ld, %llu)\n", 47715a30ab2SMatthew Wilcox (Oracle) inode->i_ino, folio_pos(folio)); 478b7eaefaaSChuck Lever 47915a30ab2SMatthew Wilcox (Oracle) folio_wait_fscache(folio); 48015a30ab2SMatthew Wilcox (Oracle) return nfs_wb_page(inode, &folio->page); 481cd52ed35STrond Myklebust } 482cd52ed35STrond Myklebust 483a564b8f0SMel Gorman static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file, 484a564b8f0SMel Gorman sector_t *span) 485a564b8f0SMel Gorman { 486bd89bc67SMurphy Zhou unsigned long blocks; 487bd89bc67SMurphy Zhou long long isize; 4884b60c0ffSNeilBrown int ret; 4894dc73c67SNeilBrown struct inode *inode = file_inode(file); 4904dc73c67SNeilBrown struct rpc_clnt *clnt = NFS_CLIENT(inode); 4914dc73c67SNeilBrown struct nfs_client *cl = NFS_SERVER(inode)->nfs_client; 492bd89bc67SMurphy Zhou 493bd89bc67SMurphy Zhou spin_lock(&inode->i_lock); 494bd89bc67SMurphy Zhou blocks = inode->i_blocks; 495bd89bc67SMurphy Zhou isize = inode->i_size; 496bd89bc67SMurphy Zhou spin_unlock(&inode->i_lock); 497bd89bc67SMurphy Zhou if (blocks*512 < isize) { 498bd89bc67SMurphy Zhou pr_warn("swap activate: swapfile has holes\n"); 499bd89bc67SMurphy Zhou return -EINVAL; 500bd89bc67SMurphy Zhou } 501dad2b015SJeff Layton 5024b60c0ffSNeilBrown ret = rpc_clnt_swap_activate(clnt); 5034b60c0ffSNeilBrown if (ret) 5044b60c0ffSNeilBrown return ret; 5054b60c0ffSNeilBrown ret = add_swap_extent(sis, 0, sis->max, 0); 5064b60c0ffSNeilBrown if (ret < 0) { 5074b60c0ffSNeilBrown rpc_clnt_swap_deactivate(clnt); 5084b60c0ffSNeilBrown return ret; 5094b60c0ffSNeilBrown } 510dad2b015SJeff Layton 5114b60c0ffSNeilBrown *span = sis->pages; 5124dc73c67SNeilBrown 5134dc73c67SNeilBrown if (cl->rpc_ops->enable_swap) 5144dc73c67SNeilBrown cl->rpc_ops->enable_swap(inode); 5154dc73c67SNeilBrown 5164b60c0ffSNeilBrown sis->flags |= SWP_FS_OPS; 5174b60c0ffSNeilBrown return ret; 518a564b8f0SMel Gorman } 519a564b8f0SMel Gorman 520a564b8f0SMel Gorman static void nfs_swap_deactivate(struct file *file) 521a564b8f0SMel Gorman { 5224dc73c67SNeilBrown struct inode *inode = file_inode(file); 5234dc73c67SNeilBrown struct rpc_clnt *clnt = NFS_CLIENT(inode); 5244dc73c67SNeilBrown struct nfs_client *cl = NFS_SERVER(inode)->nfs_client; 525dad2b015SJeff Layton 5263c87ef6eSJeff Layton rpc_clnt_swap_deactivate(clnt); 5274dc73c67SNeilBrown if (cl->rpc_ops->disable_swap) 5284dc73c67SNeilBrown cl->rpc_ops->disable_swap(file_inode(file)); 529a564b8f0SMel Gorman } 530a564b8f0SMel Gorman 531f5e54d6eSChristoph Hellwig const struct address_space_operations nfs_file_aops = { 5321da177e4SLinus Torvalds .readpage = nfs_readpage, 5338786fde8SMatthew Wilcox (Oracle) .readahead = nfs_readahead, 534187c82cbSMatthew Wilcox (Oracle) .dirty_folio = filemap_dirty_folio, 5351da177e4SLinus Torvalds .writepage = nfs_writepage, 5361da177e4SLinus Torvalds .writepages = nfs_writepages, 5374899f9c8SNick Piggin .write_begin = nfs_write_begin, 5384899f9c8SNick Piggin .write_end = nfs_write_end, 5396d740c76SMatthew Wilcox (Oracle) .invalidate_folio = nfs_invalidate_folio, 540cd52ed35STrond Myklebust .releasepage = nfs_release_page, 541f844cd0dSChao Yu #ifdef CONFIG_MIGRATION 542074cc1deSTrond Myklebust .migratepage = nfs_migrate_page, 543f844cd0dSChao Yu #endif 54415a30ab2SMatthew Wilcox (Oracle) .launder_folio = nfs_launder_folio, 545f919b196SMel Gorman .is_dirty_writeback = nfs_check_dirty_writeback, 546f590f333SAndi Kleen .error_remove_page = generic_error_remove_page, 547a564b8f0SMel Gorman .swap_activate = nfs_swap_activate, 548a564b8f0SMel Gorman .swap_deactivate = nfs_swap_deactivate, 549eb79f3afSNeilBrown .swap_rw = nfs_swap_rw, 5501da177e4SLinus Torvalds }; 5511da177e4SLinus Torvalds 5526b9b3514SDavid Howells /* 5536b9b3514SDavid Howells * Notification that a PTE pointing to an NFS page is about to be made 5546b9b3514SDavid Howells * writable, implying that someone is about to modify the page through a 5556b9b3514SDavid Howells * shared-writable mapping 5566b9b3514SDavid Howells */ 55701a36844SSouptick Joarder static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf) 55894387fb1STrond Myklebust { 559c2ec175cSNick Piggin struct page *page = vmf->page; 56011bac800SDave Jiang struct file *filp = vmf->vma->vm_file; 5616de1472fSAl Viro struct inode *inode = file_inode(filp); 56294387fb1STrond Myklebust unsigned pagelen; 56301a36844SSouptick Joarder vm_fault_t ret = VM_FAULT_NOPAGE; 5644899f9c8SNick Piggin struct address_space *mapping; 56594387fb1STrond Myklebust 5661e8968c5SNiels de Vos dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n", 5676de1472fSAl Viro filp, filp->f_mapping->host->i_ino, 568b7eaefaaSChuck Lever (long long)page_offset(page)); 569b7eaefaaSChuck Lever 5709a773e7cSTrond Myklebust sb_start_pagefault(inode->i_sb); 5719a773e7cSTrond Myklebust 572545db45fSDavid Howells /* make sure the cache has finished storing the page */ 573a6b5a28eSDave Wysochanski if (PageFsCache(page) && 574a6b5a28eSDave Wysochanski wait_on_page_fscache_killable(vmf->page) < 0) { 575a6b5a28eSDave Wysochanski ret = VM_FAULT_RETRY; 576a6b5a28eSDave Wysochanski goto out; 577a6b5a28eSDave Wysochanski } 578545db45fSDavid Howells 579ef070dcbSTrond Myklebust wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING, 580ef070dcbSTrond Myklebust nfs_wait_bit_killable, TASK_KILLABLE); 581ef070dcbSTrond Myklebust 58294387fb1STrond Myklebust lock_page(page); 583d56b4ddfSMel Gorman mapping = page_file_mapping(page); 5846de1472fSAl Viro if (mapping != inode->i_mapping) 5858b1f9ee5STrond Myklebust goto out_unlock; 5868b1f9ee5STrond Myklebust 5872aeb98f4STrond Myklebust wait_on_page_writeback(page); 5882aeb98f4STrond Myklebust 5894899f9c8SNick Piggin pagelen = nfs_page_length(page); 5908b1f9ee5STrond Myklebust if (pagelen == 0) 5918b1f9ee5STrond Myklebust goto out_unlock; 5928b1f9ee5STrond Myklebust 593bc4866b6STrond Myklebust ret = VM_FAULT_LOCKED; 594bc4866b6STrond Myklebust if (nfs_flush_incompatible(filp, page) == 0 && 595bc4866b6STrond Myklebust nfs_updatepage(filp, page, 0, pagelen) == 0) 596bc4866b6STrond Myklebust goto out; 5978b1f9ee5STrond Myklebust 598bc4866b6STrond Myklebust ret = VM_FAULT_SIGBUS; 5998b1f9ee5STrond Myklebust out_unlock: 6004899f9c8SNick Piggin unlock_page(page); 601bc4866b6STrond Myklebust out: 6029a773e7cSTrond Myklebust sb_end_pagefault(inode->i_sb); 603bc4866b6STrond Myklebust return ret; 60494387fb1STrond Myklebust } 60594387fb1STrond Myklebust 606f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct nfs_file_vm_ops = { 60794387fb1STrond Myklebust .fault = filemap_fault, 608f1820361SKirill A. Shutemov .map_pages = filemap_map_pages, 60994387fb1STrond Myklebust .page_mkwrite = nfs_vm_page_mkwrite, 61094387fb1STrond Myklebust }; 61194387fb1STrond Myklebust 612ce368536SScott Mayhew static int nfs_need_check_write(struct file *filp, struct inode *inode, 613ce368536SScott Mayhew int error) 6147b159fc1STrond Myklebust { 6157b159fc1STrond Myklebust struct nfs_open_context *ctx; 6167b159fc1STrond Myklebust 617cd3758e3STrond Myklebust ctx = nfs_file_open_context(filp); 618ce368536SScott Mayhew if (nfs_error_is_fatal_on_server(error) || 619ce368536SScott Mayhew nfs_ctx_key_to_expire(ctx, inode)) 6207b159fc1STrond Myklebust return 1; 6217b159fc1STrond Myklebust return 0; 6227b159fc1STrond Myklebust } 6237b159fc1STrond Myklebust 624edaf4369SAl Viro ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from) 6251da177e4SLinus Torvalds { 6266de1472fSAl Viro struct file *file = iocb->ki_filp; 6276de1472fSAl Viro struct inode *inode = file_inode(file); 628ed7bcdb3STrond Myklebust unsigned int mntflags = NFS_SERVER(inode)->flags; 629ed7bcdb3STrond Myklebust ssize_t result, written; 630ce368536SScott Mayhew errseq_t since; 631ce368536SScott Mayhew int error; 6321da177e4SLinus Torvalds 6336de1472fSAl Viro result = nfs_key_timeout_notify(file, inode); 634dc24826bSAndy Adamson if (result) 635dc24826bSAndy Adamson return result; 636dc24826bSAndy Adamson 63789698b24STrond Myklebust if (iocb->ki_flags & IOCB_DIRECT) 63864158668SNeilBrown return nfs_file_direct_write(iocb, from, false); 6391da177e4SLinus Torvalds 640619d30b4SAl Viro dprintk("NFS: write(%pD2, %zu@%Ld)\n", 64118290650STrond Myklebust file, iov_iter_count(from), (long long) iocb->ki_pos); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds if (IS_SWAPFILE(inode)) 6441da177e4SLinus Torvalds goto out_swapfile; 6457d52e862STrond Myklebust /* 6467d52e862STrond Myklebust * O_APPEND implies that we must revalidate the file length. 6477d52e862STrond Myklebust */ 648fc9dc401STrond Myklebust if (iocb->ki_flags & IOCB_APPEND || iocb->ki_pos > i_size_read(inode)) { 6496de1472fSAl Viro result = nfs_revalidate_file_size(inode, file); 6501da177e4SLinus Torvalds if (result) 6511da177e4SLinus Torvalds goto out; 652fe51beecSTrond Myklebust } 6531da177e4SLinus Torvalds 65428aa2f9eSTrond Myklebust nfs_clear_invalid_mapping(file->f_mapping); 65528aa2f9eSTrond Myklebust 656ce368536SScott Mayhew since = filemap_sample_wb_err(file->f_mapping); 657a5864c99STrond Myklebust nfs_start_io_write(inode); 65818290650STrond Myklebust result = generic_write_checks(iocb, from); 65918290650STrond Myklebust if (result > 0) { 66018290650STrond Myklebust current->backing_dev_info = inode_to_bdi(inode); 661800ba295SMatthew Wilcox (Oracle) result = generic_perform_write(iocb, from); 66218290650STrond Myklebust current->backing_dev_info = NULL; 66318290650STrond Myklebust } 664a5864c99STrond Myklebust nfs_end_io_write(inode); 66518290650STrond Myklebust if (result <= 0) 6661da177e4SLinus Torvalds goto out; 6671da177e4SLinus Torvalds 668c49edecdSTrond Myklebust written = result; 66918290650STrond Myklebust iocb->ki_pos += written; 670ed7bcdb3STrond Myklebust 671ed7bcdb3STrond Myklebust if (mntflags & NFS_MOUNT_WRITE_EAGER) { 672ed7bcdb3STrond Myklebust result = filemap_fdatawrite_range(file->f_mapping, 673ed7bcdb3STrond Myklebust iocb->ki_pos - written, 674ed7bcdb3STrond Myklebust iocb->ki_pos - 1); 675ed7bcdb3STrond Myklebust if (result < 0) 676ed7bcdb3STrond Myklebust goto out; 677ed7bcdb3STrond Myklebust } 678ed7bcdb3STrond Myklebust if (mntflags & NFS_MOUNT_WRITE_WAIT) { 679ed7bcdb3STrond Myklebust result = filemap_fdatawait_range(file->f_mapping, 680ed7bcdb3STrond Myklebust iocb->ki_pos - written, 681ed7bcdb3STrond Myklebust iocb->ki_pos - 1); 682ed7bcdb3STrond Myklebust if (result < 0) 683ed7bcdb3STrond Myklebust goto out; 684ed7bcdb3STrond Myklebust } 685e973b1a5Starangg@amazon.com result = generic_write_sync(iocb, written); 686e973b1a5Starangg@amazon.com if (result < 0) 687e973b1a5Starangg@amazon.com goto out; 6887e381172SChuck Lever 6897e94d6c4STrond Myklebust /* Return error values */ 690ce368536SScott Mayhew error = filemap_check_wb_err(file->f_mapping, since); 691ce368536SScott Mayhew if (nfs_need_check_write(file, inode, error)) { 692aded8d7bSTrond Myklebust int err = nfs_wb_all(inode); 693200baa21STrond Myklebust if (err < 0) 694200baa21STrond Myklebust result = err; 695200baa21STrond Myklebust } 6967e381172SChuck Lever nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written); 6971da177e4SLinus Torvalds out: 6981da177e4SLinus Torvalds return result; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds out_swapfile: 7011da177e4SLinus Torvalds printk(KERN_INFO "NFS: attempt to write to active swap file!\n"); 70289658c4dSAnna Schumaker return -ETXTBSY; 7031da177e4SLinus Torvalds } 70489d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_write); 7051da177e4SLinus Torvalds 7065eebde23SSuresh Jayaraman static int 7075eebde23SSuresh Jayaraman do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 7081da177e4SLinus Torvalds { 7091da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 7101da177e4SLinus Torvalds int status = 0; 71121ac19d4SSergey Vlasov unsigned int saved_type = fl->fl_type; 7121da177e4SLinus Torvalds 713039c4d7aSTrond Myklebust /* Try local locking first */ 7146d34ac19SJ. Bruce Fields posix_test_lock(filp, fl); 7156d34ac19SJ. Bruce Fields if (fl->fl_type != F_UNLCK) { 7166d34ac19SJ. Bruce Fields /* found a conflict */ 717039c4d7aSTrond Myklebust goto out; 7181da177e4SLinus Torvalds } 71921ac19d4SSergey Vlasov fl->fl_type = saved_type; 720039c4d7aSTrond Myklebust 721011e2a7fSBryan Schumaker if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 722039c4d7aSTrond Myklebust goto out_noconflict; 723039c4d7aSTrond Myklebust 7245eebde23SSuresh Jayaraman if (is_local) 725039c4d7aSTrond Myklebust goto out_noconflict; 726039c4d7aSTrond Myklebust 727039c4d7aSTrond Myklebust status = NFS_PROTO(inode)->lock(filp, cmd, fl); 728039c4d7aSTrond Myklebust out: 7291da177e4SLinus Torvalds return status; 730039c4d7aSTrond Myklebust out_noconflict: 731039c4d7aSTrond Myklebust fl->fl_type = F_UNLCK; 732039c4d7aSTrond Myklebust goto out; 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; 7397a8203d8STrond Myklebust struct nfs_lock_context *l_ctx; 7401da177e4SLinus Torvalds int status; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds /* 7431da177e4SLinus Torvalds * Flush all pending writes before doing anything 7441da177e4SLinus Torvalds * with locks.. 7451da177e4SLinus Torvalds */ 746aded8d7bSTrond Myklebust nfs_wb_all(inode); 7471da177e4SLinus Torvalds 7487a8203d8STrond Myklebust l_ctx = nfs_get_lock_context(nfs_file_open_context(filp)); 7497a8203d8STrond Myklebust if (!IS_ERR(l_ctx)) { 750210c7c17SBenjamin Coddington status = nfs_iocounter_wait(l_ctx); 7517a8203d8STrond Myklebust nfs_put_lock_context(l_ctx); 7521da177e4SLinus Torvalds /* NOTE: special case 7531da177e4SLinus Torvalds * If we're signalled while cleaning up locks on process exit, we 7541da177e4SLinus Torvalds * still need to complete the unlock. 7551da177e4SLinus Torvalds */ 756f30cb757SBenjamin Coddington if (status < 0 && !(fl->fl_flags & FL_CLOSE)) 757f30cb757SBenjamin Coddington return status; 758f30cb757SBenjamin Coddington } 759f30cb757SBenjamin Coddington 7605eebde23SSuresh Jayaraman /* 7615eebde23SSuresh Jayaraman * Use local locking if mounted with "-onolock" or with appropriate 7625eebde23SSuresh Jayaraman * "-olocal_lock=" 7635eebde23SSuresh Jayaraman */ 7645eebde23SSuresh Jayaraman if (!is_local) 7651da177e4SLinus Torvalds status = NFS_PROTO(inode)->lock(filp, cmd, fl); 7661da177e4SLinus Torvalds else 76775575ddfSJeff Layton status = locks_lock_file_wait(filp, fl); 7681da177e4SLinus Torvalds return status; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds 7715eebde23SSuresh Jayaraman static int 7725eebde23SSuresh Jayaraman do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) 7731da177e4SLinus Torvalds { 7741da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 7751da177e4SLinus Torvalds int status; 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds /* 7781da177e4SLinus Torvalds * Flush all pending writes before doing anything 7791da177e4SLinus Torvalds * with locks.. 7801da177e4SLinus Torvalds */ 78129884df0STrond Myklebust status = nfs_sync_mapping(filp->f_mapping); 78229884df0STrond Myklebust if (status != 0) 7831da177e4SLinus Torvalds goto out; 7841da177e4SLinus Torvalds 7855eebde23SSuresh Jayaraman /* 7865eebde23SSuresh Jayaraman * Use local locking if mounted with "-onolock" or with appropriate 7875eebde23SSuresh Jayaraman * "-olocal_lock=" 7885eebde23SSuresh Jayaraman */ 7895eebde23SSuresh Jayaraman if (!is_local) 7901da177e4SLinus Torvalds status = NFS_PROTO(inode)->lock(filp, cmd, fl); 791c4d7c402STrond Myklebust else 79275575ddfSJeff Layton status = locks_lock_file_wait(filp, fl); 7931da177e4SLinus Torvalds if (status < 0) 7941da177e4SLinus Torvalds goto out; 7956b96724eSRicardo Labiaga 7961da177e4SLinus Torvalds /* 797779eafabSNeilBrown * Invalidate cache to prevent missing any changes. If 798779eafabSNeilBrown * the file is mapped, clear the page cache as well so 799779eafabSNeilBrown * those mappings will be loaded. 8006b96724eSRicardo Labiaga * 8011da177e4SLinus Torvalds * This makes locking act as a cache coherency point. 8021da177e4SLinus Torvalds */ 80329884df0STrond Myklebust nfs_sync_mapping(filp->f_mapping); 804779eafabSNeilBrown if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) { 805442ce049SNeilBrown nfs_zap_caches(inode); 806779eafabSNeilBrown if (mapping_mapped(filp->f_mapping)) 807779eafabSNeilBrown nfs_revalidate_mapping(inode, filp->f_mapping); 808779eafabSNeilBrown } 8091da177e4SLinus Torvalds out: 8101da177e4SLinus Torvalds return status; 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds /* 8141da177e4SLinus Torvalds * Lock a (portion of) a file 8151da177e4SLinus Torvalds */ 816ce4ef7c0SBryan Schumaker int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 8171da177e4SLinus Torvalds { 8181da177e4SLinus Torvalds struct inode *inode = filp->f_mapping->host; 8192116271aSTrond Myklebust int ret = -ENOLCK; 8205eebde23SSuresh Jayaraman int is_local = 0; 8211da177e4SLinus Torvalds 8226de1472fSAl Viro dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n", 8236de1472fSAl Viro filp, fl->fl_type, fl->fl_flags, 8241da177e4SLinus Torvalds (long long)fl->fl_start, (long long)fl->fl_end); 8256da24bc9SChuck Lever 82691d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSLOCK); 8271da177e4SLinus Torvalds 828bb0a55bbSJ. Bruce Fields if (fl->fl_flags & FL_RECLAIM) 829bb0a55bbSJ. Bruce Fields return -ENOGRACE; 830bb0a55bbSJ. Bruce Fields 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 } 84989d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_lock); 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds /* 8521da177e4SLinus Torvalds * Lock a (portion of) a file 8531da177e4SLinus Torvalds */ 854ce4ef7c0SBryan Schumaker int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 8551da177e4SLinus Torvalds { 8565eebde23SSuresh Jayaraman struct inode *inode = filp->f_mapping->host; 8575eebde23SSuresh Jayaraman int is_local = 0; 8585eebde23SSuresh Jayaraman 8596de1472fSAl Viro dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", 8606de1472fSAl Viro filp, fl->fl_type, fl->fl_flags); 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds if (!(fl->fl_flags & FL_FLOCK)) 8631da177e4SLinus Torvalds return -ENOLCK; 8641da177e4SLinus Torvalds 8655eebde23SSuresh Jayaraman if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK) 8665eebde23SSuresh Jayaraman is_local = 1; 8675eebde23SSuresh Jayaraman 868fcfa4470SBenjamin Coddington /* We're simulating flock() locks using posix locks on the server */ 869fcfa4470SBenjamin Coddington if (fl->fl_type == F_UNLCK) 8705eebde23SSuresh Jayaraman return do_unlk(filp, cmd, fl, is_local); 8715eebde23SSuresh Jayaraman return do_setlk(filp, cmd, fl, is_local); 8721da177e4SLinus Torvalds } 87389d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_flock); 874370f6599SJ. Bruce Fields 8750486958fSJeff Layton const struct file_operations nfs_file_operations = { 8760486958fSJeff Layton .llseek = nfs_file_llseek, 8773aa2d199SAl Viro .read_iter = nfs_file_read, 878edaf4369SAl Viro .write_iter = nfs_file_write, 8790486958fSJeff Layton .mmap = nfs_file_mmap, 8800486958fSJeff Layton .open = nfs_file_open, 8810486958fSJeff Layton .flush = nfs_file_flush, 8820486958fSJeff Layton .release = nfs_file_release, 8830486958fSJeff Layton .fsync = nfs_file_fsync, 8840486958fSJeff Layton .lock = nfs_lock, 8850486958fSJeff Layton .flock = nfs_flock, 88682c156f8SAl Viro .splice_read = generic_file_splice_read, 8874da54c21SAl Viro .splice_write = iter_file_splice_write, 8880486958fSJeff Layton .check_flags = nfs_check_flags, 8891c994a09SJeff Layton .setlease = simple_nosetlease, 8900486958fSJeff Layton }; 891ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_file_operations); 892