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/aio.h>
  30#include <linux/gfp.h>
  31#include <linux/swap.h>
  32
  33#include <asm/uaccess.h>
  34
  35#include "delegation.h"
  36#include "internal.h"
  37#include "iostat.h"
  38#include "fscache.h"
  39
  40#define NFSDBG_FACILITY         NFSDBG_FILE
  41
  42static const struct vm_operations_struct nfs_file_vm_ops;
  43
  44/* Hack for future NFS swap support */
  45#ifndef IS_SWAPFILE
  46# define IS_SWAPFILE(inode)     (0)
  47#endif
  48
  49int nfs_check_flags(int flags)
  50{
  51        if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
  52                return -EINVAL;
  53
  54        return 0;
  55}
  56EXPORT_SYMBOL_GPL(nfs_check_flags);
  57
  58/*
  59 * Open file
  60 */
  61static int
  62nfs_file_open(struct inode *inode, struct file *filp)
  63{
  64        int res;
  65
  66        dprintk("NFS: open file(%s/%s)\n",
  67                        filp->f_path.dentry->d_parent->d_name.name,
  68                        filp->f_path.dentry->d_name.name);
  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(%s/%s)\n",
  83                        filp->f_path.dentry->d_parent->d_name.name,
  84                        filp->f_path.dentry->d_name.name);
  85
  86        nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
  87        return nfs_release(inode, filp);
  88}
  89EXPORT_SYMBOL_GPL(nfs_file_release);
  90
  91/**
  92 * nfs_revalidate_size - Revalidate the file size
  93 * @inode - pointer to inode struct
  94 * @file - pointer to struct file
  95 *
  96 * Revalidates the file length. This is basically a wrapper around
  97 * nfs_revalidate_inode() that takes into account the fact that we may
  98 * have cached writes (in which case we don't care about the server's
  99 * idea of what the file length is), or O_DIRECT (in which case we
 100 * shouldn't trust the cache).
 101 */
 102static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
 103{
 104        struct nfs_server *server = NFS_SERVER(inode);
 105        struct nfs_inode *nfsi = NFS_I(inode);
 106
 107        if (nfs_have_delegated_attributes(inode))
 108                goto out_noreval;
 109
 110        if (filp->f_flags & O_DIRECT)
 111                goto force_reval;
 112        if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
 113                goto force_reval;
 114        if (nfs_attribute_timeout(inode))
 115                goto force_reval;
 116out_noreval:
 117        return 0;
 118force_reval:
 119        return __nfs_revalidate_inode(server, inode);
 120}
 121
 122loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
 123{
 124        dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
 125                        filp->f_path.dentry->d_parent->d_name.name,
 126                        filp->f_path.dentry->d_name.name,
 127                        offset, origin);
 128
 129        /*
 130         * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 131         * the cached file length
 132         */
 133        if (origin != SEEK_SET && origin != SEEK_CUR) {
 134                struct inode *inode = filp->f_mapping->host;
 135
 136                int retval = nfs_revalidate_file_size(inode, filp);
 137                if (retval < 0)
 138                        return (loff_t)retval;
 139        }
 140
 141        return generic_file_llseek(filp, offset, origin);
 142}
 143EXPORT_SYMBOL_GPL(nfs_file_llseek);
 144
 145/*
 146 * Flush all dirty pages, and check for write errors.
 147 */
 148int
 149nfs_file_flush(struct file *file, fl_owner_t id)
 150{
 151        struct dentry   *dentry = file->f_path.dentry;
 152        struct inode    *inode = dentry->d_inode;
 153
 154        dprintk("NFS: flush(%s/%s)\n",
 155                        dentry->d_parent->d_name.name,
 156                        dentry->d_name.name);
 157
 158        nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
 159        if ((file->f_mode & FMODE_WRITE) == 0)
 160                return 0;
 161
 162        /*
 163         * If we're holding a write delegation, then just start the i/o
 164         * but don't wait for completion (or send a commit).
 165         */
 166        if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
 167                return filemap_fdatawrite(file->f_mapping);
 168
 169        /* Flush writes to the server and return any errors */
 170        return vfs_fsync(file, 0);
 171}
 172EXPORT_SYMBOL_GPL(nfs_file_flush);
 173
 174ssize_t
 175nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
 176                unsigned long nr_segs, loff_t pos)
 177{
 178        struct dentry * dentry = iocb->ki_filp->f_path.dentry;
 179        struct inode * inode = dentry->d_inode;
 180        ssize_t result;
 181
 182        if (iocb->ki_filp->f_flags & O_DIRECT)
 183                return nfs_file_direct_read(iocb, iov, nr_segs, pos, true);
 184
 185        dprintk("NFS: read(%s/%s, %lu@%lu)\n",
 186                dentry->d_parent->d_name.name, dentry->d_name.name,
 187                (unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
 188
 189        result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
 190        if (!result) {
 191                result = generic_file_aio_read(iocb, iov, nr_segs, pos);
 192                if (result > 0)
 193                        nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
 194        }
 195        return result;
 196}
 197EXPORT_SYMBOL_GPL(nfs_file_read);
 198
 199ssize_t
 200nfs_file_splice_read(struct file *filp, loff_t *ppos,
 201                     struct pipe_inode_info *pipe, size_t count,
 202                     unsigned int flags)
 203{
 204        struct dentry *dentry = filp->f_path.dentry;
 205        struct inode *inode = dentry->d_inode;
 206        ssize_t res;
 207
 208        dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
 209                dentry->d_parent->d_name.name, dentry->d_name.name,
 210                (unsigned long) count, (unsigned long long) *ppos);
 211
 212        res = nfs_revalidate_mapping(inode, filp->f_mapping);
 213        if (!res) {
 214                res = generic_file_splice_read(filp, ppos, pipe, count, flags);
 215                if (res > 0)
 216                        nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
 217        }
 218        return res;
 219}
 220EXPORT_SYMBOL_GPL(nfs_file_splice_read);
 221
 222int
 223nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
 224{
 225        struct dentry *dentry = file->f_path.dentry;
 226        struct inode *inode = dentry->d_inode;
 227        int     status;
 228
 229        dprintk("NFS: mmap(%s/%s)\n",
 230                dentry->d_parent->d_name.name, dentry->d_name.name);
 231
 232        /* Note: generic_file_mmap() returns ENOSYS on nommu systems
 233         *       so we call that before revalidating the mapping
 234         */
 235        status = generic_file_mmap(file, vma);
 236        if (!status) {
 237                vma->vm_ops = &nfs_file_vm_ops;
 238                status = nfs_revalidate_mapping(inode, file->f_mapping);
 239        }
 240        return status;
 241}
 242EXPORT_SYMBOL_GPL(nfs_file_mmap);
 243
 244/*
 245 * Flush any dirty pages for this process, and check for write errors.
 246 * The return status from this call provides a reliable indication of
 247 * whether any write errors occurred for this process.
 248 *
 249 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
 250 * disk, but it retrieves and clears ctx->error after synching, despite
 251 * the two being set at the same time in nfs_context_set_write_error().
 252 * This is because the former is used to notify the _next_ call to
 253 * nfs_file_write() that a write error occurred, and hence cause it to
 254 * fall back to doing a synchronous write.
 255 */
 256int
 257nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
 258{
 259        struct dentry *dentry = file->f_path.dentry;
 260        struct nfs_open_context *ctx = nfs_file_open_context(file);
 261        struct inode *inode = dentry->d_inode;
 262        int have_error, do_resend, status;
 263        int ret = 0;
 264
 265        dprintk("NFS: fsync file(%s/%s) datasync %d\n",
 266                        dentry->d_parent->d_name.name, dentry->d_name.name,
 267                        datasync);
 268
 269        nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
 270        do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
 271        have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
 272        status = nfs_commit_inode(inode, FLUSH_SYNC);
 273        have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
 274        if (have_error) {
 275                ret = xchg(&ctx->error, 0);
 276                if (ret)
 277                        goto out;
 278        }
 279        if (status < 0) {
 280                ret = status;
 281                goto out;
 282        }
 283        do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
 284        if (do_resend)
 285                ret = -EAGAIN;
 286out:
 287        return ret;
 288}
 289EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
 290
 291static int
 292nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 293{
 294        int ret;
 295        struct inode *inode = file->f_path.dentry->d_inode;
 296
 297        do {
 298                ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
 299                if (ret != 0)
 300                        break;
 301                mutex_lock(&inode->i_mutex);
 302                ret = nfs_file_fsync_commit(file, start, end, datasync);
 303                mutex_unlock(&inode->i_mutex);
 304                /*
 305                 * If nfs_file_fsync_commit detected a server reboot, then
 306                 * resend all dirty pages that might have been covered by
 307                 * the NFS_CONTEXT_RESEND_WRITES flag
 308                 */
 309                start = 0;
 310                end = LLONG_MAX;
 311        } while (ret == -EAGAIN);
 312
 313        return ret;
 314}
 315
 316/*
 317 * Decide whether a read/modify/write cycle may be more efficient
 318 * then a modify/write/read cycle when writing to a page in the
 319 * page cache.
 320 *
 321 * The modify/write/read cycle may occur if a page is read before
 322 * being completely filled by the writer.  In this situation, the
 323 * page must be completely written to stable storage on the server
 324 * before it can be refilled by reading in the page from the server.
 325 * This can lead to expensive, small, FILE_SYNC mode writes being
 326 * done.
 327 *
 328 * It may be more efficient to read the page first if the file is
 329 * open for reading in addition to writing, the page is not marked
 330 * as Uptodate, it is not dirty or waiting to be committed,
 331 * indicating that it was previously allocated and then modified,
 332 * that there were valid bytes of data in that range of the file,
 333 * and that the new data won't completely replace the old data in
 334 * that range of the file.
 335 */
 336static int nfs_want_read_modify_write(struct file *file, struct page *page,
 337                        loff_t pos, unsigned len)
 338{
 339        unsigned int pglen = nfs_page_length(page);
 340        unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
 341        unsigned int end = offset + len;
 342
 343        if ((file->f_mode & FMODE_READ) &&      /* open for read? */
 344            !PageUptodate(page) &&              /* Uptodate? */
 345            !PagePrivate(page) &&               /* i/o request already? */
 346            pglen &&                            /* valid bytes of file? */
 347            (end < pglen || offset))            /* replace all valid bytes? */
 348                return 1;
 349        return 0;
 350}
 351
 352/*
 353 * This does the "real" work of the write. We must allocate and lock the
 354 * page to be sent back to the generic routine, which then copies the
 355 * data from user space.
 356 *
 357 * If the writer ends up delaying the write, the writer needs to
 358 * increment the page use counts until he is done with the page.
 359 */
 360static int nfs_write_begin(struct file *file, struct address_space *mapping,
 361                        loff_t pos, unsigned len, unsigned flags,
 362                        struct page **pagep, void **fsdata)
 363{
 364        int ret;
 365        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 366        struct page *page;
 367        int once_thru = 0;
 368
 369        dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
 370                file->f_path.dentry->d_parent->d_name.name,
 371                file->f_path.dentry->d_name.name,
 372                mapping->host->i_ino, len, (long long) pos);
 373
 374start:
 375        /*
 376         * Prevent starvation issues if someone is doing a consistency
 377         * sync-to-disk
 378         */
 379        ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
 380                        nfs_wait_bit_killable, TASK_KILLABLE);
 381        if (ret)
 382                return ret;
 383
 384        page = grab_cache_page_write_begin(mapping, index, flags);
 385        if (!page)
 386                return -ENOMEM;
 387        *pagep = page;
 388
 389        ret = nfs_flush_incompatible(file, page);
 390        if (ret) {
 391                unlock_page(page);
 392                page_cache_release(page);
 393        } else if (!once_thru &&
 394                   nfs_want_read_modify_write(file, page, pos, len)) {
 395                once_thru = 1;
 396                ret = nfs_readpage(file, page);
 397                page_cache_release(page);
 398                if (!ret)
 399                        goto start;
 400        }
 401        return ret;
 402}
 403
 404static int nfs_write_end(struct file *file, struct address_space *mapping,
 405                        loff_t pos, unsigned len, unsigned copied,
 406                        struct page *page, void *fsdata)
 407{
 408        unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
 409        int status;
 410
 411        dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
 412                file->f_path.dentry->d_parent->d_name.name,
 413                file->f_path.dentry->d_name.name,
 414                mapping->host->i_ino, len, (long long) pos);
 415
 416        /*
 417         * Zero any uninitialised parts of the page, and then mark the page
 418         * as up to date if it turns out that we're extending the file.
 419         */
 420        if (!PageUptodate(page)) {
 421                unsigned pglen = nfs_page_length(page);
 422                unsigned end = offset + len;
 423
 424                if (pglen == 0) {
 425                        zero_user_segments(page, 0, offset,
 426                                        end, PAGE_CACHE_SIZE);
 427                        SetPageUptodate(page);
 428                } else if (end >= pglen) {
 429                        zero_user_segment(page, end, PAGE_CACHE_SIZE);
 430                        if (offset == 0)
 431                                SetPageUptodate(page);
 432                } else
 433                        zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
 434        }
 435
 436        status = nfs_updatepage(file, page, offset, copied);
 437
 438        unlock_page(page);
 439        page_cache_release(page);
 440
 441        if (status < 0)
 442                return status;
 443        NFS_I(mapping->host)->write_io += copied;
 444        return copied;
 445}
 446
 447/*
 448 * Partially or wholly invalidate a page
 449 * - Release the private state associated with a page if undergoing complete
 450 *   page invalidation
 451 * - Called if either PG_private or PG_fscache is set on the page
 452 * - Caller holds page lock
 453 */
 454static void nfs_invalidate_page(struct page *page, unsigned long offset)
 455{
 456        dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);
 457
 458        if (offset != 0)
 459                return;
 460        /* Cancel any unstarted writes on this page */
 461        nfs_wb_page_cancel(page_file_mapping(page)->host, page);
 462
 463        nfs_fscache_invalidate_page(page, page->mapping->host);
 464}
 465
 466/*
 467 * Attempt to release the private state associated with a page
 468 * - Called if either PG_private or PG_fscache is set on the page
 469 * - Caller holds page lock
 470 * - Return true (may release page) or false (may not)
 471 */
 472static int nfs_release_page(struct page *page, gfp_t gfp)
 473{
 474        struct address_space *mapping = page->mapping;
 475
 476        dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
 477
 478        /* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not
 479         * doing this memory reclaim for a fs-related allocation.
 480         */
 481        if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL &&
 482            !(current->flags & PF_FSTRANS)) {
 483                int how = FLUSH_SYNC;
 484
 485                /* Don't let kswapd deadlock waiting for OOM RPC calls */
 486                if (current_is_kswapd())
 487                        how = 0;
 488                nfs_commit_inode(mapping->host, how);
 489        }
 490        /* If PagePrivate() is set, then the page is not freeable */
 491        if (PagePrivate(page))
 492                return 0;
 493        return nfs_fscache_release_page(page, gfp);
 494}
 495
 496/*
 497 * Attempt to clear the private state associated with a page when an error
 498 * occurs that requires the cached contents of an inode to be written back or
 499 * destroyed
 500 * - Called if either PG_private or fscache is set on the page
 501 * - Caller holds page lock
 502 * - Return 0 if successful, -error otherwise
 503 */
 504static int nfs_launder_page(struct page *page)
 505{
 506        struct inode *inode = page_file_mapping(page)->host;
 507        struct nfs_inode *nfsi = NFS_I(inode);
 508
 509        dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
 510                inode->i_ino, (long long)page_offset(page));
 511
 512        nfs_fscache_wait_on_page_write(nfsi, page);
 513        return nfs_wb_page(inode, page);
 514}
 515
 516#ifdef CONFIG_NFS_SWAP
 517static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
 518                                                sector_t *span)
 519{
 520        *span = sis->pages;
 521        return xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 1);
 522}
 523
 524static void nfs_swap_deactivate(struct file *file)
 525{
 526        xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 0);
 527}
 528#endif
 529
 530const struct address_space_operations nfs_file_aops = {
 531        .readpage = nfs_readpage,
 532        .readpages = nfs_readpages,
 533        .set_page_dirty = __set_page_dirty_nobuffers,
 534        .writepage = nfs_writepage,
 535        .writepages = nfs_writepages,
 536        .write_begin = nfs_write_begin,
 537        .write_end = nfs_write_end,
 538        .invalidatepage = nfs_invalidate_page,
 539        .releasepage = nfs_release_page,
 540        .direct_IO = nfs_direct_IO,
 541        .migratepage = nfs_migrate_page,
 542        .launder_page = nfs_launder_page,
 543        .error_remove_page = generic_error_remove_page,
 544#ifdef CONFIG_NFS_SWAP
 545        .swap_activate = nfs_swap_activate,
 546        .swap_deactivate = nfs_swap_deactivate,
 547#endif
 548};
 549
 550/*
 551 * Notification that a PTE pointing to an NFS page is about to be made
 552 * writable, implying that someone is about to modify the page through a
 553 * shared-writable mapping
 554 */
 555static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 556{
 557        struct page *page = vmf->page;
 558        struct file *filp = vma->vm_file;
 559        struct dentry *dentry = filp->f_path.dentry;
 560        unsigned pagelen;
 561        int ret = VM_FAULT_NOPAGE;
 562        struct address_space *mapping;
 563
 564        dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
 565                dentry->d_parent->d_name.name, dentry->d_name.name,
 566                filp->f_mapping->host->i_ino,
 567                (long long)page_offset(page));
 568
 569        /* make sure the cache has finished storing the page */
 570        nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
 571
 572        lock_page(page);
 573        mapping = page_file_mapping(page);
 574        if (mapping != dentry->d_inode->i_mapping)
 575                goto out_unlock;
 576
 577        wait_on_page_writeback(page);
 578
 579        pagelen = nfs_page_length(page);
 580        if (pagelen == 0)
 581                goto out_unlock;
 582
 583        ret = VM_FAULT_LOCKED;
 584        if (nfs_flush_incompatible(filp, page) == 0 &&
 585            nfs_updatepage(filp, page, 0, pagelen) == 0)
 586                goto out;
 587
 588        ret = VM_FAULT_SIGBUS;
 589out_unlock:
 590        unlock_page(page);
 591out:
 592        return ret;
 593}
 594
 595static const struct vm_operations_struct nfs_file_vm_ops = {
 596        .fault = filemap_fault,
 597        .page_mkwrite = nfs_vm_page_mkwrite,
 598        .remap_pages = generic_file_remap_pages,
 599};
 600
 601static int nfs_need_sync_write(struct file *filp, struct inode *inode)
 602{
 603        struct nfs_open_context *ctx;
 604
 605        if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
 606                return 1;
 607        ctx = nfs_file_open_context(filp);
 608        if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags))
 609                return 1;
 610        return 0;
 611}
 612
 613ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
 614                       unsigned long nr_segs, loff_t pos)
 615{
 616        struct dentry * dentry = iocb->ki_filp->f_path.dentry;
 617        struct inode * inode = dentry->d_inode;
 618        unsigned long written = 0;
 619        ssize_t result;
 620        size_t count = iov_length(iov, nr_segs);
 621
 622        if (iocb->ki_filp->f_flags & O_DIRECT)
 623                return nfs_file_direct_write(iocb, iov, nr_segs, pos, true);
 624
 625        dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
 626                dentry->d_parent->d_name.name, dentry->d_name.name,
 627                (unsigned long) count, (long long) pos);
 628
 629        result = -EBUSY;
 630        if (IS_SWAPFILE(inode))
 631                goto out_swapfile;
 632        /*
 633         * O_APPEND implies that we must revalidate the file length.
 634         */
 635        if (iocb->ki_filp->f_flags & O_APPEND) {
 636                result = nfs_revalidate_file_size(inode, iocb->ki_filp);
 637                if (result)
 638                        goto out;
 639        }
 640
 641        result = count;
 642        if (!count)
 643                goto out;
 644
 645        result = generic_file_aio_write(iocb, iov, nr_segs, pos);
 646        if (result > 0)
 647                written = result;
 648
 649        /* Return error values for O_DSYNC and IS_SYNC() */
 650        if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
 651                int err = vfs_fsync(iocb->ki_filp, 0);
 652                if (err < 0)
 653                        result = err;
 654        }
 655        if (result > 0)
 656                nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
 657out:
 658        return result;
 659
 660out_swapfile:
 661        printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
 662        goto out;
 663}
 664EXPORT_SYMBOL_GPL(nfs_file_write);
 665
 666ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
 667                              struct file *filp, loff_t *ppos,
 668                              size_t count, unsigned int flags)
 669{
 670        struct dentry *dentry = filp->f_path.dentry;
 671        struct inode *inode = dentry->d_inode;
 672        unsigned long written = 0;
 673        ssize_t ret;
 674
 675        dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
 676                dentry->d_parent->d_name.name, dentry->d_name.name,
 677                (unsigned long) count, (unsigned long long) *ppos);
 678
 679        /*
 680         * The combination of splice and an O_APPEND destination is disallowed.
 681         */
 682
 683        ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
 684        if (ret > 0)
 685                written = ret;
 686
 687        if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
 688                int err = vfs_fsync(filp, 0);
 689                if (err < 0)
 690                        ret = err;
 691        }
 692        if (ret > 0)
 693                nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
 694        return ret;
 695}
 696EXPORT_SYMBOL_GPL(nfs_file_splice_write);
 697
 698static int
 699do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 700{
 701        struct inode *inode = filp->f_mapping->host;
 702        int status = 0;
 703        unsigned int saved_type = fl->fl_type;
 704
 705        /* Try local locking first */
 706        posix_test_lock(filp, fl);
 707        if (fl->fl_type != F_UNLCK) {
 708                /* found a conflict */
 709                goto out;
 710        }
 711        fl->fl_type = saved_type;
 712
 713        if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
 714                goto out_noconflict;
 715
 716        if (is_local)
 717                goto out_noconflict;
 718
 719        status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 720out:
 721        return status;
 722out_noconflict:
 723        fl->fl_type = F_UNLCK;
 724        goto out;
 725}
 726
 727static int do_vfs_lock(struct file *file, struct file_lock *fl)
 728{
 729        int res = 0;
 730        switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
 731                case FL_POSIX:
 732                        res = posix_lock_file_wait(file, fl);
 733                        break;
 734                case FL_FLOCK:
 735                        res = flock_lock_file_wait(file, fl);
 736                        break;
 737                default:
 738                        BUG();
 739        }
 740        return res;
 741}
 742
 743static int
 744do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 745{
 746        struct inode *inode = filp->f_mapping->host;
 747        int status;
 748
 749        /*
 750         * Flush all pending writes before doing anything
 751         * with locks..
 752         */
 753        nfs_sync_mapping(filp->f_mapping);
 754
 755        /* NOTE: special case
 756         *      If we're signalled while cleaning up locks on process exit, we
 757         *      still need to complete the unlock.
 758         */
 759        /*
 760         * Use local locking if mounted with "-onolock" or with appropriate
 761         * "-olocal_lock="
 762         */
 763        if (!is_local)
 764                status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 765        else
 766                status = do_vfs_lock(filp, fl);
 767        return status;
 768}
 769
 770static int
 771is_time_granular(struct timespec *ts) {
 772        return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
 773}
 774
 775static int
 776do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
 777{
 778        struct inode *inode = filp->f_mapping->host;
 779        int status;
 780
 781        /*
 782         * Flush all pending writes before doing anything
 783         * with locks..
 784         */
 785        status = nfs_sync_mapping(filp->f_mapping);
 786        if (status != 0)
 787                goto out;
 788
 789        /*
 790         * Use local locking if mounted with "-onolock" or with appropriate
 791         * "-olocal_lock="
 792         */
 793        if (!is_local)
 794                status = NFS_PROTO(inode)->lock(filp, cmd, fl);
 795        else
 796                status = do_vfs_lock(filp, fl);
 797        if (status < 0)
 798                goto out;
 799
 800        /*
 801         * Revalidate the cache if the server has time stamps granular
 802         * enough to detect subsecond changes.  Otherwise, clear the
 803         * cache to prevent missing any changes.
 804         *
 805         * This makes locking act as a cache coherency point.
 806         */
 807        nfs_sync_mapping(filp->f_mapping);
 808        if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
 809                if (is_time_granular(&NFS_SERVER(inode)->time_delta))
 810                        __nfs_revalidate_inode(NFS_SERVER(inode), inode);
 811                else
 812                        nfs_zap_caches(inode);
 813        }
 814out:
 815        return status;
 816}
 817
 818/*
 819 * Lock a (portion of) a file
 820 */
 821int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
 822{
 823        struct inode *inode = filp->f_mapping->host;
 824        int ret = -ENOLCK;
 825        int is_local = 0;
 826
 827        dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
 828                        filp->f_path.dentry->d_parent->d_name.name,
 829                        filp->f_path.dentry->d_name.name,
 830                        fl->fl_type, fl->fl_flags,
 831                        (long long)fl->fl_start, (long long)fl->fl_end);
 832
 833        nfs_inc_stats(inode, NFSIOS_VFSLOCK);
 834
 835        /* No mandatory locks over NFS */
 836        if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 837                goto out_err;
 838
 839        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
 840                is_local = 1;
 841
 842        if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
 843                ret = NFS_PROTO(inode)->lock_check_bounds(fl);
 844                if (ret < 0)
 845                        goto out_err;
 846        }
 847
 848        if (IS_GETLK(cmd))
 849                ret = do_getlk(filp, cmd, fl, is_local);
 850        else if (fl->fl_type == F_UNLCK)
 851                ret = do_unlk(filp, cmd, fl, is_local);
 852        else
 853                ret = do_setlk(filp, cmd, fl, is_local);
 854out_err:
 855        return ret;
 856}
 857EXPORT_SYMBOL_GPL(nfs_lock);
 858
 859/*
 860 * Lock a (portion of) a file
 861 */
 862int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
 863{
 864        struct inode *inode = filp->f_mapping->host;
 865        int is_local = 0;
 866
 867        dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
 868                        filp->f_path.dentry->d_parent->d_name.name,
 869                        filp->f_path.dentry->d_name.name,
 870                        fl->fl_type, fl->fl_flags);
 871
 872        if (!(fl->fl_flags & FL_FLOCK))
 873                return -ENOLCK;
 874
 875        /*
 876         * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
 877         * any standard. In principle we might be able to support LOCK_MAND
 878         * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
 879         * NFS code is not set up for it.
 880         */
 881        if (fl->fl_type & LOCK_MAND)
 882                return -EINVAL;
 883
 884        if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
 885                is_local = 1;
 886
 887        /* We're simulating flock() locks using posix locks on the server */
 888        fl->fl_owner = (fl_owner_t)filp;
 889        fl->fl_start = 0;
 890        fl->fl_end = OFFSET_MAX;
 891
 892        if (fl->fl_type == F_UNLCK)
 893                return do_unlk(filp, cmd, fl, is_local);
 894        return do_setlk(filp, cmd, fl, is_local);
 895}
 896EXPORT_SYMBOL_GPL(nfs_flock);
 897
 898/*
 899 * There is no protocol support for leases, so we have no way to implement
 900 * them correctly in the face of opens by other clients.
 901 */
 902int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
 903{
 904        dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
 905                        file->f_path.dentry->d_parent->d_name.name,
 906                        file->f_path.dentry->d_name.name, arg);
 907        return -EINVAL;
 908}
 909EXPORT_SYMBOL_GPL(nfs_setlease);
 910
 911const struct file_operations nfs_file_operations = {
 912        .llseek         = nfs_file_llseek,
 913        .read           = do_sync_read,
 914        .write          = do_sync_write,
 915        .aio_read       = nfs_file_read,
 916        .aio_write      = nfs_file_write,
 917        .mmap           = nfs_file_mmap,
 918        .open           = nfs_file_open,
 919        .flush          = nfs_file_flush,
 920        .release        = nfs_file_release,
 921        .fsync          = nfs_file_fsync,
 922        .lock           = nfs_lock,
 923        .flock          = nfs_flock,
 924        .splice_read    = nfs_file_splice_read,
 925        .splice_write   = nfs_file_splice_write,
 926        .check_flags    = nfs_check_flags,
 927        .setlease       = nfs_setlease,
 928};
 929EXPORT_SYMBOL_GPL(nfs_file_operations);
 930
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.