linux/fs/nfs/file.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/nfs/file.c
   3 *
   4 *  Copyright (C) 1992  Rick Sladkey
   5 *
   6 *  Changes Copyright (C) 1994 by Florian La Roche
   7 *   - Do not copy data too often around in the kernel.
   8 *   - In nfs_file_read the return value of kmalloc wasn't checked.
   9 *   - Put in a better version of read look-ahead buffering. Original idea
  10 *     and implementation by Wai S Kok elekokws@ee.nus.sg.
  11 *
  12 *  Expire cache on write to a file by Wai S Kok (Oct 1994).
  13 *
  14 *  Total rewrite of read side for new NFS buffer cache.. Linus.
  15 *
  16 *  nfs regular file handling functions
  17 */
  18
  19#include <linux/module.h>
  20#include <linux/time.h>
  21#include <linux/kernel.h>
  22#include <linux/errno.h>
  23#include <linux/fcntl.h>
  24#include <linux/stat.h>
  25#include <linux/nfs_fs.h>
  26#include <linux/nfs_mount.h>
  27#include <linux/mm.h>
  28#include <linux/pagemap.h>
  29#include <linux/gfp.h>
  30#include <linux/swap.h>
  31
  32#include <linux/uaccess.h>
  33
  34#include "delegation.h"
  35#include "internal.h"
  36#include "iostat.h"
  37#include "fscache.h"
  38#include "pnfs.h"
  39
  40#include "nfstrace.h"
  41
  42#define NFSDBG_FACILITY         NFSDBG_FILE
  43
  44static const struct vm_operations_struct nfs_file_vm_ops;
  45
  46/* Hack for future NFS swap support */
  47#ifndef IS_SWAPFILE
  48# define IS_SWAPFILE(inode)     (0)
  49#endif
  50
  51int nfs_check_flags(int flags)
  52{
  53        if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
  54                return -EINVAL;
  55
  56        return 0;
  57}
  58EXPORT_SYMBOL_GPL(nfs_check_flags);
  59
  60/*
  61 * Open file
  62 */
  63static int
  64nfs_file_open(struct inode *inode, struct file *filp)
  65{
  66        int res;
  67
  68        dprintk("NFS: open file(%pD2)\n", filp);
  69
  70        nfs_inc_stats(inode, NFSIOS_VFSOPEN);
  71        res = nfs_check_flags(filp->f_flags);
  72        if (res)
  73                return res;
  74
  75        res = nfs_open(inode, filp);
  76        return res;
  77}
  78
  79int
  80nfs_file_release(struct inode *inode, struct file *filp)
  81{
  82        dprintk("NFS: release(%pD2)\n", filp);
  83
  84        nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
  85        nfs_file_clear_open_context(filp);
  86        return 0;
  87}
  88EXPORT_SYMBOL_GPL(nfs_file_release);
  89
  90/**
  91 * nfs_revalidate_size - Revalidate the file size
  92 * @inode - pointer to inode struct
  93 * @file - pointer to struct file
  94 *
  95 * Revalidates the file length. This is basically a wrapper around
  96 * nfs_revalidate_inode() that takes into account the fact that we may
  97 * have cached writes (in which case we don't care about the server's
  98 * idea of what the file length is), or O_DIRECT (in which case we
  99 * shouldn't trust the cache).
 100 */
 101static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
 102{
 103        struct nfs_server *server = NFS_SERVER(inode);
 104
 105        if (filp->f_flags & O_DIRECT)
 106                goto force_reval;
 107        if (nfs_check_cache_invalid(inode, NFS_INO_REVAL_PAGECACHE))
 108                goto force_reval;
 109        return 0;
 110force_reval:
 111        return __nfs_revalidate_inode(server, inode);
 112}
 113
 114loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
 115{
 116        dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
 117                        filp, offset, whence);
 118
 119        /*
 120         * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 121         * the cached file length
 122         */
 123        if (whence != SEEK_SET && whence != SEEK_CUR) {
 124                struct inode *inode = filp->f_mapping->host;
 125
 126                int retval = nfs_revalidate_file_size(inode, filp);
 127                if (retval < 0)
 128                        return (loff_t)retval;
 129        }
 130
 131        return generic_file_llseek(filp, offset, whence);
 132}
 133EXPORT_SYMBOL_GPL(nfs_file_llseek);
 134
 135/*
 136 * Flush all dirty pages, and check for write errors.
 137 */
 138static int
 139nfs_file_flush(struct file *file, fl_owner_t id)
 140{
 141        struct inode    *inode = file_inode(file);
 142
 143        dprintk("NFS: flush(%pD2)\n", file);
 144
 145        nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
 146        if ((file->f_mode & FMODE_WRITE) == 0)
 147                return 0;
 148
 149        /* Flush writes to the server and return any errors */
 150        return vfs_fsync(file, 0);
 151}
 152
 153ssize_t
 154nfs_file_read(struct kiocb *iocb, struct iov_iter *to)
 155{
 156        struct inode *inode = file_inode(iocb->ki_filp);
 157        ssize_t result;
 158
 159        if (iocb->ki_flags & IOCB_DIRECT)
 160                return nfs_file_direct_read(iocb, to);
 161
 162        dprintk("NFS: read(%pD2, %zu@%lu)\n",
 163                iocb->ki_filp,
 164                iov_iter_count(to), (unsigned long) iocb->ki_pos);
 165
 166        nfs_start_io_read(inode);
 167        result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
 168        if (!result) {
 169                result = generic_file_read_iter(iocb, to);
 170                if (result > 0)
 171                        nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
 172        }
 173        nfs_end_io_read(inode);
 174        return result;
 175}
 176EXPORT_SYMBOL_GPL(nfs_file_read);
 177
 178int
 179nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
 180{
 181        struct inode *inode = file_inode(file);
 182        int     status;
 183
 184        dprintk("NFS: mmap(%pD2)\n", file);
 185
 186        /* Note: generic_file_mmap() returns ENOSYS on nommu systems
 187         *       so we call that before revalidating the mapping
 188         */
 189        status = generic_file_mmap(file, vma);
 190        if (!status) {
 191                vma->vm_ops = &nfs_file_vm_ops;
 192                status = nfs_revalidate_mapping(inode, file->f_mapping);
 193        }
 194        return status;
 195}
 196EXPORT_SYMBOL_GPL(nfs_file_mmap);
 197
 198/*
 199 * Flush any dirty pages for this process, and check for write errors.
 200 * The return status from this call provides a reliable indication of
 201 * whether any write errors occurred for this process.
 202 *
 203 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
 204 * disk, but it retrieves and clears ctx->error after synching, despite
 205 * the two being set at the same time in nfs_context_set_write_error().
 206 * This is because the former is used to notify the _next_ call to
 207 * nfs_file_write() that a write error occurred, and hence cause it to
 208 * fall back to doing a synchronous write.
 209 */
 210static int
 211nfs_file_fsync_commit(struct file *file, int datasync)
 212{
 213        struct nfs_open_context *ctx = nfs_file_open_context(file);
 214        struct inode *inode = file_inode(file);
 215        int do_resend, status;
 216        int ret = 0;
 217
 218        dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync);
 219
 220        nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
 221        do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
 222        status = nfs_commit_inode(inode, FLUSH_SYNC);
 223        if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags)) {
 224                ret = xchg(&ctx->error, 0);
 225                if (ret)
 226                        goto out;
 227        }
 228        if (status < 0) {
 229                ret = status;
 230                goto out;
 231        }
 232        do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
 233        if (do_resend)
 234                ret = -EAGAIN;
 235out:
 236        return ret;
 237}
 238
 239int
 240nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 241{
 242        int ret;
 243        struct inode *inode = file_inode(file);
 244
 245        trace_nfs_fsync_enter(inode);
 246
 247        do {
 248                struct nfs_open_context *ctx = nfs_file_open_context(file);
 249                ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
 250                if (test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags)) {
 251                        int ret2 = xchg(&ctx->error, 0);
 252                        if (ret2)
 253                                ret = ret2;
 254                }
 255                if (ret != 0)
 256                        break;
 257                ret = nfs_file_fsync_commit(file, datasync);
 258                if (!ret)
 259                        ret = pnfs_sync_inode(inode, !!datasync);
 260                /*
 261                 * If nfs_file_fsync_commit detected a server reboot, then
 262                 * resend all dirty pages that might have been covered by
 263                 * the NFS_CONTEXT_RESEND_WRITES flag
 264                 */
 265                start = 0;
 266                end = LLONG_MAX;
 267        } while (ret == -EAGAIN);
 268
 269        trace_nfs_fsync_exit(inode, ret);
 270        return ret;
 271}
 272EXPORT_SYMBOL_GPL(nfs_file_fsync);
 273
 274/*
 275 * Decide whether a read/modify/write cycle may be more efficient
 276 * then a modify/write/read cycle when writing to a page in the
 277 * page cache.
 278 *
 279 * The modify/write/read cycle may occur if a page is read before
 280 * being completely filled by the writer.  In this situation, the
 281 * page must be completely written to stable storage on the server
 282 * before it can be refilled by reading in the page from the server.
 283 * This can lead to expensive, small, FILE_SYNC mode writes being
 284 * done.
 285 *
 286 * It may be more efficient to read the page first if the file is
 287 * open for reading in addition to writing, the page is not marked
 288 * as Uptodate, it is not dirty or waiting to be committed,
 289 * indicating that it was previously allocated and then modified,
 290 * that there were valid bytes of data in that range of the file,
 291 * and that the new data won't completely replace the old data in
 292 * that range of the file.
 293 */
 294static int nfs_want_read_modify_write(struct file *file, struct page *page,
 295                        loff_t pos, unsigned len)
 296{
 297        unsigned int pglen = nfs_page_length(page);
 298        unsigned int offset = pos & (PAGE_SIZE - 1);
 299        unsigned int end = offset + len;
 300
 301        if (pnfs_ld_read_whole_page(file->f_mapping->host)) {
 302                if (!PageUptodate(page))
 303                        return 1;
 304                return 0;
 305        }
 306
 307        if ((file->f_mode & FMODE_READ) &&      /* open for read? */
 308            !PageUptodate(page) &&              /* Uptodate? */
 309            !PagePrivate(page) &&               /* i/o request already? */
 310            pglen &&                            /* valid bytes of file? */
 311            (end < pglen || offset))            /* replace all valid bytes? */
 312                return 1;
 313        return 0;
 314}
 315
 316/*
 317 * This does the "real" work of the write. We must allocate and lock the
 318 * page to be sent back to the generic routine, which then copies the
 319 * data from user space.
 320 *
 321 * If the writer ends up delaying the write, the writer needs to
 322 * increment the page use counts until he is done with the page.
 323 */
 324static int nfs_write_begin(struct file *file, struct address_space *mapping,
 325                        loff_t pos, unsigned len, unsigned flags,
 326                        struct page **pagep, void **fsdata)
 327{
 328        int ret;
 329        pgoff_t index = pos >> PAGE_SHIFT;
 330        struct page *page;
 331        int once_thru = 0;
 332
 333        dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
 334                file, mapping->host->i_ino, len, (long long) pos);
 335
 336start:
 337        page = grab_cache_page_write_begin(mapping, index, flags);
 338        if (!page)
 339                return -ENOMEM;
 340        *pagep = page;
 341
 342        ret = nfs_flush_incompatible(file, page);
 343        if (ret) {
 344                unlock_page(page);
 345                put_page(page);
 346        } else if (!once_thru &&
 347                   nfs_want_read_modify_write(file, page, pos, len)) {
 348                once_thru = 1;
 349                ret = nfs_readpage(file, page);
 350                put_page(page);
 351                if (!ret)
 352                        goto start;
 353        }
 354        return ret;
 355}
 356
 357static int nfs_write_end(struct file *file, struct address_space *mapping,
 358                        loff_t pos, unsigned len, unsigned copied,
 359                        struct page *page, void *fsdata)
 360{
 361        unsigned offset = pos & (PAGE_SIZE - 1);
 362        struct nfs_open_context *ctx = nfs_file_open_context(file);
 363        int status;
 364
 365        dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
 366                file, mapping->host->i_ino, len, (long long) pos);
 367
 368        /*
 369         * Zero any uninitialised parts of the page, and then mark the page
 370         * as up to date if it turns out that we're extending the file.
 371         */
 372        if (!PageUptodate(page)) {
 373                unsigned pglen = nfs_page_length(page);
 374                unsigned end = offset + copied;
 375
 376                if (pglen == 0) {
 377                        zero_user_segments(page, 0, offset,
 378                                        end, PAGE_SIZE);
 379                        SetPageUptodate(page);
 380                } else if (end >= pglen) {
 381                        zero_user_segment(page, end, PAGE_SIZE);
 382                        if (offset == 0)
 383                                SetPageUptodate(page);
 384                } else
 385                        zero_user_segment(page, pglen, PAGE_SIZE);
 386        }
 387
 388        status = nfs_updatepage(file, page, offset, copied);
 389
 390        unlock_page(page);
 391        put_page(page);
 392
 393        if (status < 0)
 394                return status;
 395        NFS_I(mapping->host)->write_io += copied;
 396
 397        if (nfs_ctx_key_to_expire(ctx, mapping->host)) {
 398                status = nfs_wb_all(mapping->host);
 399                if (status < 0)
 400                        return status;
 401        }
 402
 403        return copied;
 404}
 405
 406/*
 407 * Partially or wholly invalidate a page
 408 * - Release the private state associated with a page if undergoing complete
 409 *   page invalidation
 410 * - Called if either PG_private or PG_fscache is set on the page
 411 * - Caller holds page lock
 412 */
 413static void nfs_invalidate_page(struct page *page, unsigned int offset,
 414                                unsigned int length)
 415{
 416        dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
 417                 page, offset, length);
 418
 419        if (offset != 0 || length < PAGE_SIZE)
 420                return;
 421        /* Cancel any unstarted writes on this page */
 422        nfs_wb_page_cancel(page_file_mapping(page)->host, page);
 423
 424        nfs_fscache_invalidate_page(page, page->mapping->host);
 425}
 426
 427/*
 428 * Attempt to release the private state associated with a page
 429 * - Called if either PG_private or PG_fscache is set on the page
 430 * - Caller holds page lock
 431 * - Return true (may release page) or false (may not)
 432 */
 433static int nfs_release_page(struct page *page, gfp_t gfp)
 434{
 435        dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
 436
 437        /* If PagePrivate() is set, then the page is not freeable */
 438        if (PagePrivate(page))
 439                return 0;
 440        return nfs_fscache_release_page(page, gfp);
 441}
 442
 443static void nfs_check_dirty_writeback(struct page *page,
 444                                bool *dirty, bool *writeback)
 445{
 446        struct nfs_inode *nfsi;
 447        struct address_space *mapping = page_file_mapping(page);
 448
 449        if (!mapping || PageSwapCache(page))
 450                return;
 451
 452        /*
 453         * Check if an unstable page is currently being committed and
 454         * if so, have the VM treat it as if the page is under writeback
 455         * so it will not block due to pages that will shortly be freeable.
 456         */
 457        nfsi = NFS_I(mapping->host);
 458        if (atomic_read(&nfsi->commit_info.rpcs_out)) {
 459                *writeback = true;
 460                return;
 461        }
 462
 463        /*
 464         * If PagePrivate() is set, then the page is not freeable and as the
 465         * inode is not being committed, it's not going to be cleaned in the
 466         * near future so treat it as dirty
 467         */
 468        if (PagePrivate(page))
 469                *dirty = true;
 470}
 471
 472/*
 473 * Attempt to clear the private state associated with a page when an error
 474 * occurs that requires the cached contents of an inode to be written back or
 475 * destroyed
 476 * - Called if either PG_private or fscache is set on the page
 477 * - Caller holds page lock
 478 * - Return 0 if successful, -error otherwise
 479 */
 480static int nfs_launder_page(struct page *page)
 481{
 482        struct inode *inode = page_file_mapping(page)->host;
 483        struct nfs_inode *nfsi = NFS_I(inode);
 484
 485        dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
 486                inode->i_ino, (long long)page_offset(page));
 487
 488        nfs_fscache_wait_on_page_write(nfsi, page);
 489        return nfs_wb_page(inode, page);
 490}
 491
 492static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
 493                                                sector_t *span)
 494{
 495        struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
 496
 497        *span = sis->pages;
 498
 499        return rpc_clnt_swap_activate(clnt);
 500}
 501
 502static void nfs_swap_deactivate(struct file *file)
 503{
 504        struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
 505
 506        rpc_clnt_swap_deactivate(clnt);
 507}
 508
 509const struct address_space_operations nfs_file_aops = {
 510        .readpage = nfs_readpage,
 511        .readpages = nfs_readpages,
 512        .set_page_dirty = __set_page_dirty_nobuffers,
 513        .writepage = nfs_writepage,
 514        .writepages = nfs_writepages,
 515        .write_begin = nfs_write_begin,
 516        .write_end = nfs_write_end,
 517        .invalidatepage = nfs_invalidate_page,
 518        .releasepage = nfs_release_page,
 519        .direct_IO = nfs_direct_IO,
 520#ifdef CONFIG_MIGRATION
 521        .migratepage = nfs_migrate_page,
 522#endif
 523        .launder_page = nfs_launder_page,
 524        .is_dirty_writeback = nfs_check_dirty_writeback,
 525        .error_remove_page = generic_error_remove_page,
 526        .swap_activate = nfs_swap_activate,
 527        .swap_deactivate = nfs_swap_deactivate,
 528};
 529
 530/*
 531 * Notification that a PTE pointing to an NFS page is about to be made
 532 * writable, implying that someone is about to modify the page through a
 533 * shared-writable mapping
 534 */
 535static int nfs_vm_page_mkwrite(struct vm_fault *vmf)
 536{
 537        struct page *page = vmf->page;
 538        struct file *filp = vmf->vma->vm_file;
 539        struct inode *inode = file_inode(filp);
 540        unsigned pagelen;
 541        int ret = VM_FAULT_NOPAGE;
 542        struct address_space *mapping;
 543
 544        dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
 545                filp, filp->f_mapping->host->i_ino,
 546                (long long)page_offset(page));
 547
 548        sb_start_pagefault(inode->i_sb);
 549
 550        /* make sure the cache has finished storing the page */
 551        nfs_fscache_wait_on_page_write(NFS_I(inode), page);
 552
 553        wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING,
 554                        nfs_wait_bit_killable, TASK_KILLABLE);
 555
 556        lock_page(page);
 557        mapping = page_file_mapping(page);
 558        if (mapping != inode->i_mapping)
 559                goto out_unlock;
 560
 561        wait_on_page_writeback(page);
 562
 563        pagelen = nfs_page_length(page);
 564        if (pagelen == 0)
 565                goto out_unlock;
 566
 567        ret = VM_FAULT_LOCKED;
 568        if (nfs_flush_incompatible(filp, page) == 0 &&
 569            nfs_updatepage(filp, page, 0, pagelen) == 0)
 570                goto out;
 571
 572        ret = VM_FAULT_SIGBUS;
 573out_unlock:
 574        unlock_page(page);
 575out:
 576        sb_end_pagefault(inode->i_sb);
 577        return ret;
 578}
 579
 580static const struct vm_operations_struct nfs_file_vm_ops = {
 581        .fault = filemap_fault,
 582        .map_pages = filemap_map_pages,
 583        .page_mkwrite = nfs_vm_page_mkwrite,
 584};
 585
 586static int nfs_need_check_write(struct file *filp, struct inode *inode)
 587{
 588        struct nfs_open_context *ctx;
 589
 590        ctx = nfs_file_open_context(filp);
 591        if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
 592            nfs_ctx_key_to_expire(ctx, inode))
 593                return 1;
 594        return 0;
 595}
 596
 597ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
 598{
 599        struct file *file = iocb->ki_filp;
 600        struct inode *inode = file_inode(file);
 601        unsigned long written = 0;
 602        ssize_t result;
 603
 604        result = nfs_key_timeout_notify(file, inode);
 605        if (result)
 606                return result;
 607
 608        if (iocb->ki_flags & IOCB_DIRECT)
 609                return nfs_file_direct_write(iocb, from);
 610
 611        dprintk("NFS: write(%pD2, %zu@%Ld)\n",
 612                file, iov_iter_count(from), (long long) iocb->ki_pos);
 613
 614        if (IS_SWAPFILE(inode))
 615                goto out_swapfile;
 616        /*
 617         * O_APPEND implies that we must revalidate the file length.
 618         */
 619        if (iocb->ki_flags & IOCB_APPEND) {
 620                result = nfs_revalidate_file_size(inode, file);
 621                if (result)
 622                        goto out;
 623        }
 624        if (iocb->ki_pos > i_size_read(inode))
 625                nfs_revalidate_mapping(inode, file->f_mapping);
 626
 627        nfs_start_io_write(inode);
 628        result = generic_write_checks(iocb, from);
 629        if (result > 0) {
 630                current->backing_dev_info = inode_to_bdi(inode);
 631                result = generic_perform_write(file, from, iocb->ki_pos);
 632                current->backing_dev_info = NULL;
 633        }
 634        nfs_end_io_write(inode);
 635        if (result <= 0)
 636                goto out;
 637
 638        written = result;
 639        iocb->ki_pos += written;
 640        result = generic_write_sync(iocb, written);
 641        if (result < 0)
 642                goto out;
 643
 644        /* Return error values */
 645        if (nfs_need_check_write(file, inode)) {
 646                int err = vfs_fsync(file, 0);
 647                if (err < 0)
 648                        result = err;
 649        }
 650        nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
 651out:
 652        return result;
 653
 654out_swapfile:
 655        printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
 656        return -EBUSY;
 657}
 658EXPORT_SYMBOL_GPL(nfs_file_write);
 659
 660static int
 661do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 662{
 663        struct inode *inode = filp->f_mapping->host;
 664        int status = 0;
 665        unsigned int saved_type = fl->fl_type;
 666
 667        /* Try local locking first */
 668        posix_test_lock(filp, fl);
 669        if (fl->fl_type != F_UNLCK) {
 670                /* found a conflict */
 671                goto out;
 672        }
 673        fl->fl_type = saved_type;
 674
 675        if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
 676                goto out_noconflict;
 677
 678        if (is_local)
 679                goto out_noconflict;
 680
 681        status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 682out:
 683        return status;
 684out_noconflict:
 685        fl->fl_type = F_UNLCK;
 686        goto out;
 687}
 688
 689static int
 690do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 691{
 692        struct inode *inode = filp->f_mapping->host;
 693        struct nfs_lock_context *l_ctx;
 694        int status;
 695
 696        /*
 697         * Flush all pending writes before doing anything
 698         * with locks..
 699         */
 700        vfs_fsync(filp, 0);
 701
 702        l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
 703        if (!IS_ERR(l_ctx)) {
 704                status = nfs_iocounter_wait(l_ctx);
 705                nfs_put_lock_context(l_ctx);
 706                /*  NOTE: special case
 707                 *      If we're signalled while cleaning up locks on process exit, we
 708                 *      still need to complete the unlock.
 709                 */
 710                if (status < 0 && !(fl->fl_flags & FL_CLOSE))
 711                        return status;
 712        }
 713
 714        /*
 715         * Use local locking if mounted with "-onolock" or with appropriate
 716         * "-olocal_lock="
 717         */
 718        if (!is_local)
 719                status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 720        else
 721                status = locks_lock_file_wait(filp, fl);
 722        return status;
 723}
 724
 725static int
 726do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 727{
 728        struct inode *inode = filp->f_mapping->host;
 729        int status;
 730
 731        /*
 732         * Flush all pending writes before doing anything
 733         * with locks..
 734         */
 735        status = nfs_sync_mapping(filp->f_mapping);
 736        if (status != 0)
 737                goto out;
 738
 739        /*
 740         * Use local locking if mounted with "-onolock" or with appropriate
 741         * "-olocal_lock="
 742         */
 743        if (!is_local)
 744                status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 745        else
 746                status = locks_lock_file_wait(filp, fl);
 747        if (status < 0)
 748                goto out;
 749
 750        /*
 751         * Invalidate cache to prevent missing any changes.  If
 752         * the file is mapped, clear the page cache as well so
 753         * those mappings will be loaded.
 754         *
 755         * This makes locking act as a cache coherency point.
 756         */
 757        nfs_sync_mapping(filp->f_mapping);
 758        if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
 759                nfs_zap_caches(inode);
 760                if (mapping_mapped(filp->f_mapping))
 761                        nfs_revalidate_mapping(inode, filp->f_mapping);
 762        }
 763out:
 764        return status;
 765}
 766
 767/*
 768 * Lock a (portion of) a file
 769 */
 770int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
 771{
 772        struct inode *inode = filp->f_mapping->host;
 773        int ret = -ENOLCK;
 774        int is_local = 0;
 775
 776        dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
 777                        filp, fl->fl_type, fl->fl_flags,
 778                        (long long)fl->fl_start, (long long)fl->fl_end);
 779
 780        nfs_inc_stats(inode, NFSIOS_VFSLOCK);
 781
 782        /* No mandatory locks over NFS */
 783        if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 784                goto out_err;
 785
 786        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
 787                is_local = 1;
 788
 789        if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
 790                ret = NFS_PROTO(inode)->lock_check_bounds(fl);
 791                if (ret < 0)
 792                        goto out_err;
 793        }
 794
 795        if (IS_GETLK(cmd))
 796                ret = do_getlk(filp, cmd, fl, is_local);
 797        else if (fl->fl_type == F_UNLCK)
 798                ret = do_unlk(filp, cmd, fl, is_local);
 799        else
 800                ret = do_setlk(filp, cmd, fl, is_local);
 801out_err:
 802        return ret;
 803}
 804EXPORT_SYMBOL_GPL(nfs_lock);
 805
 806/*
 807 * Lock a (portion of) a file
 808 */
 809int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
 810{
 811        struct inode *inode = filp->f_mapping->host;
 812        int is_local = 0;
 813
 814        dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
 815                        filp, fl->fl_type, fl->fl_flags);
 816
 817        if (!(fl->fl_flags & FL_FLOCK))
 818                return -ENOLCK;
 819
 820        /*
 821         * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
 822         * any standard. In principle we might be able to support LOCK_MAND
 823         * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
 824         * NFS code is not set up for it.
 825         */
 826        if (fl->fl_type & LOCK_MAND)
 827                return -EINVAL;
 828
 829        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
 830                is_local = 1;
 831
 832        /*
 833         * VFS doesn't require the open mode to match a flock() lock's type.
 834         * NFS, however, may simulate flock() locking with posix locking which
 835         * requires the open mode to match the lock type.
 836         */
 837        switch (fl->fl_type) {
 838        case F_UNLCK:
 839                return do_unlk(filp, cmd, fl, is_local);
 840        case F_RDLCK:
 841                if (!(filp->f_mode & FMODE_READ))
 842                        return -EBADF;
 843                break;
 844        case F_WRLCK:
 845                if (!(filp->f_mode & FMODE_WRITE))
 846                        return -EBADF;
 847        }
 848
 849        return do_setlk(filp, cmd, fl, is_local);
 850}
 851EXPORT_SYMBOL_GPL(nfs_flock);
 852
 853const struct file_operations nfs_file_operations = {
 854        .llseek         = nfs_file_llseek,
 855        .read_iter      = nfs_file_read,
 856        .write_iter     = nfs_file_write,
 857        .mmap           = nfs_file_mmap,
 858        .open           = nfs_file_open,
 859        .flush          = nfs_file_flush,
 860        .release        = nfs_file_release,
 861        .fsync          = nfs_file_fsync,
 862        .lock           = nfs_lock,
 863        .flock          = nfs_flock,
 864        .splice_read    = generic_file_splice_read,
 865        .splice_write   = iter_file_splice_write,
 866        .check_flags    = nfs_check_flags,
 867        .setlease       = simple_nosetlease,
 868};
 869EXPORT_SYMBOL_GPL(nfs_file_operations);
 870