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