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

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

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

~ [ 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