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