~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/file.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 42 static 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 
 49 int 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 }
 56 EXPORT_SYMBOL_GPL(nfs_check_flags);
 57 
 58 /*
 59  * Open file
 60  */
 61 static int
 62 nfs_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 
 79 int
 80 nfs_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 }
 89 EXPORT_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  */
102 static 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;
116 out_noreval:
117         return 0;
118 force_reval:
119         return __nfs_revalidate_inode(server, inode);
120 }
121 
122 loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
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, whence);
128 
129         /*
130          * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
131          * the cached file length
132          */
133         if (whence != SEEK_SET && whence != 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, whence);
142 }
143 EXPORT_SYMBOL_GPL(nfs_file_llseek);
144 
145 /*
146  * Flush all dirty pages, and check for write errors.
147  */
148 int
149 nfs_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 }
172 EXPORT_SYMBOL_GPL(nfs_file_flush);
173 
174 ssize_t
175 nfs_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 }
197 EXPORT_SYMBOL_GPL(nfs_file_read);
198 
199 ssize_t
200 nfs_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 }
220 EXPORT_SYMBOL_GPL(nfs_file_splice_read);
221 
222 int
223 nfs_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 }
242 EXPORT_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  */
256 int
257 nfs_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;
286 out:
287         return ret;
288 }
289 EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
290 
291 static int
292 nfs_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  */
336 static 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  */
360 static 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 
374 start:
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 
404 static 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  */
454 static 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  */
472 static 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  */
504 static 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
517 static 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 
524 static void nfs_swap_deactivate(struct file *file)
525 {
526         xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 0);
527 }
528 #endif
529 
530 const 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  */
555 static 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;
589 out_unlock:
590         unlock_page(page);
591 out:
592         return ret;
593 }
594 
595 static 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 
601 static 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 
613 ssize_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);
657 out:
658         return result;
659 
660 out_swapfile:
661         printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
662         goto out;
663 }
664 EXPORT_SYMBOL_GPL(nfs_file_write);
665 
666 ssize_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 }
696 EXPORT_SYMBOL_GPL(nfs_file_splice_write);
697 
698 static int
699 do_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);
720 out:
721         return status;
722 out_noconflict:
723         fl->fl_type = F_UNLCK;
724         goto out;
725 }
726 
727 static 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 
743 static int
744 do_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 
770 static int
771 is_time_granular(struct timespec *ts) {
772         return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
773 }
774 
775 static int
776 do_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         }
814 out:
815         return status;
816 }
817 
818 /*
819  * Lock a (portion of) a file
820  */
821 int 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);
854 out_err:
855         return ret;
856 }
857 EXPORT_SYMBOL_GPL(nfs_lock);
858 
859 /*
860  * Lock a (portion of) a file
861  */
862 int 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 }
896 EXPORT_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  */
902 int 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 }
909 EXPORT_SYMBOL_GPL(nfs_setlease);
910 
911 const 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 };
929 EXPORT_SYMBOL_GPL(nfs_file_operations);
930 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp