projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
NFS: Split out NFS v3 inode operations
[deliverable/linux.git] / fs / nfs / dir.c
... / ...
CommitLineData
1/*
2 * linux/fs/nfs/dir.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs directory handling functions
7 *
8 * 10 Apr 1996 Added silly rename for unlink --okir
9 * 28 Sep 1996 Improved directory cache --okir
10 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de
11 * Re-implemented silly rename for unlink, newly implemented
12 * silly rename for nfs_rename() following the suggestions
13 * of Olaf Kirch (okir) found in this file.
14 * Following Linus comments on my original hack, this version
15 * depends only on the dcache stuff and doesn't touch the inode
16 * layer (iput() and friends).
17 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM
18 */
19
20#include <linux/time.h>
21#include <linux/errno.h>
22#include <linux/stat.h>
23#include <linux/fcntl.h>
24#include <linux/string.h>
25#include <linux/kernel.h>
26#include <linux/slab.h>
27#include <linux/mm.h>
28#include <linux/sunrpc/clnt.h>
29#include <linux/nfs_fs.h>
30#include <linux/nfs_mount.h>
31#include <linux/pagemap.h>
32#include <linux/pagevec.h>
33#include <linux/namei.h>
34#include <linux/mount.h>
35#include <linux/sched.h>
36#include <linux/kmemleak.h>
37#include <linux/xattr.h>
38
39#include "delegation.h"
40#include "iostat.h"
41#include "internal.h"
42#include "fscache.h"
43
44/* #define NFS_DEBUG_VERBOSE 1 */
45
46static int nfs_opendir(struct inode *, struct file *);
47static int nfs_closedir(struct inode *, struct file *);
48static int nfs_readdir(struct file *, void *, filldir_t);
49static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
50static loff_t nfs_llseek_dir(struct file *, loff_t, int);
51static void nfs_readdir_clear_array(struct page*);
52
53const struct file_operations nfs_dir_operations = {
54 .llseek = nfs_llseek_dir,
55 .read = generic_read_dir,
56 .readdir = nfs_readdir,
57 .open = nfs_opendir,
58 .release = nfs_closedir,
59 .fsync = nfs_fsync_dir,
60};
61
62const struct address_space_operations nfs_dir_aops = {
63 .freepage = nfs_readdir_clear_array,
64};
65
66#ifdef CONFIG_NFS_V4
67
68static int nfs_atomic_open(struct inode *, struct dentry *,
69 struct file *, unsigned, umode_t,
70 int *);
71const struct inode_operations nfs4_dir_inode_operations = {
72 .create = nfs_create,
73 .lookup = nfs_lookup,
74 .atomic_open = nfs_atomic_open,
75 .link = nfs_link,
76 .unlink = nfs_unlink,
77 .symlink = nfs_symlink,
78 .mkdir = nfs_mkdir,
79 .rmdir = nfs_rmdir,
80 .mknod = nfs_mknod,
81 .rename = nfs_rename,
82 .permission = nfs_permission,
83 .getattr = nfs_getattr,
84 .setattr = nfs_setattr,
85 .getxattr = generic_getxattr,
86 .setxattr = generic_setxattr,
87 .listxattr = generic_listxattr,
88 .removexattr = generic_removexattr,
89};
90
91#endif /* CONFIG_NFS_V4 */
92
93static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
94{
95 struct nfs_open_dir_context *ctx;
96 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
97 if (ctx != NULL) {
98 ctx->duped = 0;
99 ctx->attr_gencount = NFS_I(dir)->attr_gencount;
100 ctx->dir_cookie = 0;
101 ctx->dup_cookie = 0;
102 ctx->cred = get_rpccred(cred);
103 return ctx;
104 }
105 return ERR_PTR(-ENOMEM);
106}
107
108static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)
109{
110 put_rpccred(ctx->cred);
111 kfree(ctx);
112}
113
114/*
115 * Open file
116 */
117static int
118nfs_opendir(struct inode *inode, struct file *filp)
119{
120 int res = 0;
121 struct nfs_open_dir_context *ctx;
122 struct rpc_cred *cred;
123
124 dfprintk(FILE, "NFS: open dir(%s/%s)\n",
125 filp->f_path.dentry->d_parent->d_name.name,
126 filp->f_path.dentry->d_name.name);
127
128 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
129
130 cred = rpc_lookup_cred();
131 if (IS_ERR(cred))
132 return PTR_ERR(cred);
133 ctx = alloc_nfs_open_dir_context(inode, cred);
134 if (IS_ERR(ctx)) {
135 res = PTR_ERR(ctx);
136 goto out;
137 }
138 filp->private_data = ctx;
139 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
140 /* This is a mountpoint, so d_revalidate will never
141 * have been called, so we need to refresh the
142 * inode (for close-open consistency) ourselves.
143 */
144 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
145 }
146out:
147 put_rpccred(cred);
148 return res;
149}
150
151static int
152nfs_closedir(struct inode *inode, struct file *filp)
153{
154 put_nfs_open_dir_context(filp->private_data);
155 return 0;
156}
157
158struct nfs_cache_array_entry {
159 u64 cookie;
160 u64 ino;
161 struct qstr string;
162 unsigned char d_type;
163};
164
165struct nfs_cache_array {
166 int size;
167 int eof_index;
168 u64 last_cookie;
169 struct nfs_cache_array_entry array[0];
170};
171
172typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
173typedef struct {
174 struct file *file;
175 struct page *page;
176 unsigned long page_index;
177 u64 *dir_cookie;
178 u64 last_cookie;
179 loff_t current_index;
180 decode_dirent_t decode;
181
182 unsigned long timestamp;
183 unsigned long gencount;
184 unsigned int cache_entry_index;
185 unsigned int plus:1;
186 unsigned int eof:1;
187} nfs_readdir_descriptor_t;
188
189/*
190 * The caller is responsible for calling nfs_readdir_release_array(page)
191 */
192static
193struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
194{
195 void *ptr;
196 if (page == NULL)
197 return ERR_PTR(-EIO);
198 ptr = kmap(page);
199 if (ptr == NULL)
200 return ERR_PTR(-ENOMEM);
201 return ptr;
202}
203
204static
205void nfs_readdir_release_array(struct page *page)
206{
207 kunmap(page);
208}
209
210/*
211 * we are freeing strings created by nfs_add_to_readdir_array()
212 */
213static
214void nfs_readdir_clear_array(struct page *page)
215{
216 struct nfs_cache_array *array;
217 int i;
218
219 array = kmap_atomic(page);
220 for (i = 0; i < array->size; i++)
221 kfree(array->array[i].string.name);
222 kunmap_atomic(array);
223}
224
225/*
226 * the caller is responsible for freeing qstr.name
227 * when called by nfs_readdir_add_to_array, the strings will be freed in
228 * nfs_clear_readdir_array()
229 */
230static
231int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
232{
233 string->len = len;
234 string->name = kmemdup(name, len, GFP_KERNEL);
235 if (string->name == NULL)
236 return -ENOMEM;
237 /*
238 * Avoid a kmemleak false positive. The pointer to the name is stored
239 * in a page cache page which kmemleak does not scan.
240 */
241 kmemleak_not_leak(string->name);
242 string->hash = full_name_hash(name, len);
243 return 0;
244}
245
246static
247int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
248{
249 struct nfs_cache_array *array = nfs_readdir_get_array(page);
250 struct nfs_cache_array_entry *cache_entry;
251 int ret;
252
253 if (IS_ERR(array))
254 return PTR_ERR(array);
255
256 cache_entry = &array->array[array->size];
257
258 /* Check that this entry lies within the page bounds */
259 ret = -ENOSPC;
260 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
261 goto out;
262
263 cache_entry->cookie = entry->prev_cookie;
264 cache_entry->ino = entry->ino;
265 cache_entry->d_type = entry->d_type;
266 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
267 if (ret)
268 goto out;
269 array->last_cookie = entry->cookie;
270 array->size++;
271 if (entry->eof != 0)
272 array->eof_index = array->size;
273out:
274 nfs_readdir_release_array(page);
275 return ret;
276}
277
278static
279int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
280{
281 loff_t diff = desc->file->f_pos - desc->current_index;
282 unsigned int index;
283
284 if (diff < 0)
285 goto out_eof;
286 if (diff >= array->size) {
287 if (array->eof_index >= 0)
288 goto out_eof;
289 return -EAGAIN;
290 }
291
292 index = (unsigned int)diff;
293 *desc->dir_cookie = array->array[index].cookie;
294 desc->cache_entry_index = index;
295 return 0;
296out_eof:
297 desc->eof = 1;
298 return -EBADCOOKIE;
299}
300
301static
302int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
303{
304 int i;
305 loff_t new_pos;
306 int status = -EAGAIN;
307
308 for (i = 0; i < array->size; i++) {
309 if (array->array[i].cookie == *desc->dir_cookie) {
310 struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
311 struct nfs_open_dir_context *ctx = desc->file->private_data;
312
313 new_pos = desc->current_index + i;
314 if (ctx->attr_gencount != nfsi->attr_gencount
315 || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
316 ctx->duped = 0;
317 ctx->attr_gencount = nfsi->attr_gencount;
318 } else if (new_pos < desc->file->f_pos) {
319 if (ctx->duped > 0
320 && ctx->dup_cookie == *desc->dir_cookie) {
321 if (printk_ratelimit()) {
322 pr_notice("NFS: directory %s/%s contains a readdir loop."
323 "Please contact your server vendor. "
324 "The file: %s has duplicate cookie %llu\n",
325 desc->file->f_dentry->d_parent->d_name.name,
326 desc->file->f_dentry->d_name.name,
327 array->array[i].string.name,
328 *desc->dir_cookie);
329 }
330 status = -ELOOP;
331 goto out;
332 }
333 ctx->dup_cookie = *desc->dir_cookie;
334 ctx->duped = -1;
335 }
336 desc->file->f_pos = new_pos;
337 desc->cache_entry_index = i;
338 return 0;
339 }
340 }
341 if (array->eof_index >= 0) {
342 status = -EBADCOOKIE;
343 if (*desc->dir_cookie == array->last_cookie)
344 desc->eof = 1;
345 }
346out:
347 return status;
348}
349
350static
351int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
352{
353 struct nfs_cache_array *array;
354 int status;
355
356 array = nfs_readdir_get_array(desc->page);
357 if (IS_ERR(array)) {
358 status = PTR_ERR(array);
359 goto out;
360 }
361
362 if (*desc->dir_cookie == 0)
363 status = nfs_readdir_search_for_pos(array, desc);
364 else
365 status = nfs_readdir_search_for_cookie(array, desc);
366
367 if (status == -EAGAIN) {
368 desc->last_cookie = array->last_cookie;
369 desc->current_index += array->size;
370 desc->page_index++;
371 }
372 nfs_readdir_release_array(desc->page);
373out:
374 return status;
375}
376
377/* Fill a page with xdr information before transferring to the cache page */
378static
379int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
380 struct nfs_entry *entry, struct file *file, struct inode *inode)
381{
382 struct nfs_open_dir_context *ctx = file->private_data;
383 struct rpc_cred *cred = ctx->cred;
384 unsigned long timestamp, gencount;
385 int error;
386
387 again:
388 timestamp = jiffies;
389 gencount = nfs_inc_attr_generation_counter();
390 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
391 NFS_SERVER(inode)->dtsize, desc->plus);
392 if (error < 0) {
393 /* We requested READDIRPLUS, but the server doesn't grok it */
394 if (error == -ENOTSUPP && desc->plus) {
395 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
396 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
397 desc->plus = 0;
398 goto again;
399 }
400 goto error;
401 }
402 desc->timestamp = timestamp;
403 desc->gencount = gencount;
404error:
405 return error;
406}
407
408static int xdr_decode(nfs_readdir_descriptor_t *desc,
409 struct nfs_entry *entry, struct xdr_stream *xdr)
410{
411 int error;
412
413 error = desc->decode(xdr, entry, desc->plus);
414 if (error)
415 return error;
416 entry->fattr->time_start = desc->timestamp;
417 entry->fattr->gencount = desc->gencount;
418 return 0;
419}
420
421static
422int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
423{
424 if (dentry->d_inode == NULL)
425 goto different;
426 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
427 goto different;
428 return 1;
429different:
430 return 0;
431}
432
433static
434bool nfs_use_readdirplus(struct inode *dir, struct file *filp)
435{
436 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
437 return false;
438 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
439 return true;
440 if (filp->f_pos == 0)
441 return true;
442 return false;
443}
444
445/*
446 * This function is called by the lookup code to request the use of
447 * readdirplus to accelerate any future lookups in the same
448 * directory.
449 */
450static
451void nfs_advise_use_readdirplus(struct inode *dir)
452{
453 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);
454}
455
456static
457void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
458{
459 struct qstr filename = QSTR_INIT(entry->name, entry->len);
460 struct dentry *dentry;
461 struct dentry *alias;
462 struct inode *dir = parent->d_inode;
463 struct inode *inode;
464
465 if (filename.name[0] == '.') {
466 if (filename.len == 1)
467 return;
468 if (filename.len == 2 && filename.name[1] == '.')
469 return;
470 }
471 filename.hash = full_name_hash(filename.name, filename.len);
472
473 dentry = d_lookup(parent, &filename);
474 if (dentry != NULL) {
475 if (nfs_same_file(dentry, entry)) {
476 nfs_refresh_inode(dentry->d_inode, entry->fattr);
477 goto out;
478 } else {
479 d_drop(dentry);
480 dput(dentry);
481 }
482 }
483
484 dentry = d_alloc(parent, &filename);
485 if (dentry == NULL)
486 return;
487
488 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
489 if (IS_ERR(inode))
490 goto out;
491
492 alias = d_materialise_unique(dentry, inode);
493 if (IS_ERR(alias))
494 goto out;
495 else if (alias) {
496 nfs_set_verifier(alias, nfs_save_change_attribute(dir));
497 dput(alias);
498 } else
499 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
500
501out:
502 dput(dentry);
503}
504
505/* Perform conversion from xdr to cache array */
506static
507int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
508 struct page **xdr_pages, struct page *page, unsigned int buflen)
509{
510 struct xdr_stream stream;
511 struct xdr_buf buf;
512 struct page *scratch;
513 struct nfs_cache_array *array;
514 unsigned int count = 0;
515 int status;
516
517 scratch = alloc_page(GFP_KERNEL);
518 if (scratch == NULL)
519 return -ENOMEM;
520
521 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
522 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
523
524 do {
525 status = xdr_decode(desc, entry, &stream);
526 if (status != 0) {
527 if (status == -EAGAIN)
528 status = 0;
529 break;
530 }
531
532 count++;
533
534 if (desc->plus != 0)
535 nfs_prime_dcache(desc->file->f_path.dentry, entry);
536
537 status = nfs_readdir_add_to_array(entry, page);
538 if (status != 0)
539 break;
540 } while (!entry->eof);
541
542 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
543 array = nfs_readdir_get_array(page);
544 if (!IS_ERR(array)) {
545 array->eof_index = array->size;
546 status = 0;
547 nfs_readdir_release_array(page);
548 } else
549 status = PTR_ERR(array);
550 }
551
552 put_page(scratch);
553 return status;
554}
555
556static
557void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
558{
559 unsigned int i;
560 for (i = 0; i < npages; i++)
561 put_page(pages[i]);
562}
563
564static
565void nfs_readdir_free_large_page(void *ptr, struct page **pages,
566 unsigned int npages)
567{
568 nfs_readdir_free_pagearray(pages, npages);
569}
570
571/*
572 * nfs_readdir_large_page will allocate pages that must be freed with a call
573 * to nfs_readdir_free_large_page
574 */
575static
576int nfs_readdir_large_page(struct page **pages, unsigned int npages)
577{
578 unsigned int i;
579
580 for (i = 0; i < npages; i++) {
581 struct page *page = alloc_page(GFP_KERNEL);
582 if (page == NULL)
583 goto out_freepages;
584 pages[i] = page;
585 }
586 return 0;
587
588out_freepages:
589 nfs_readdir_free_pagearray(pages, i);
590 return -ENOMEM;
591}
592
593static
594int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
595{
596 struct page *pages[NFS_MAX_READDIR_PAGES];
597 void *pages_ptr = NULL;
598 struct nfs_entry entry;
599 struct file *file = desc->file;
600 struct nfs_cache_array *array;
601 int status = -ENOMEM;
602 unsigned int array_size = ARRAY_SIZE(pages);
603
604 entry.prev_cookie = 0;
605 entry.cookie = desc->last_cookie;
606 entry.eof = 0;
607 entry.fh = nfs_alloc_fhandle();
608 entry.fattr = nfs_alloc_fattr();
609 entry.server = NFS_SERVER(inode);
610 if (entry.fh == NULL || entry.fattr == NULL)
611 goto out;
612
613 array = nfs_readdir_get_array(page);
614 if (IS_ERR(array)) {
615 status = PTR_ERR(array);
616 goto out;
617 }
618 memset(array, 0, sizeof(struct nfs_cache_array));
619 array->eof_index = -1;
620
621 status = nfs_readdir_large_page(pages, array_size);
622 if (status < 0)
623 goto out_release_array;
624 do {
625 unsigned int pglen;
626 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
627
628 if (status < 0)
629 break;
630 pglen = status;
631 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
632 if (status < 0) {
633 if (status == -ENOSPC)
634 status = 0;
635 break;
636 }
637 } while (array->eof_index < 0);
638
639 nfs_readdir_free_large_page(pages_ptr, pages, array_size);
640out_release_array:
641 nfs_readdir_release_array(page);
642out:
643 nfs_free_fattr(entry.fattr);
644 nfs_free_fhandle(entry.fh);
645 return status;
646}
647
648/*
649 * Now we cache directories properly, by converting xdr information
650 * to an array that can be used for lookups later. This results in
651 * fewer cache pages, since we can store more information on each page.
652 * We only need to convert from xdr once so future lookups are much simpler
653 */
654static
655int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
656{
657 struct inode *inode = desc->file->f_path.dentry->d_inode;
658 int ret;
659
660 ret = nfs_readdir_xdr_to_array(desc, page, inode);
661 if (ret < 0)
662 goto error;
663 SetPageUptodate(page);
664
665 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
666 /* Should never happen */
667 nfs_zap_mapping(inode, inode->i_mapping);
668 }
669 unlock_page(page);
670 return 0;
671 error:
672 unlock_page(page);
673 return ret;
674}
675
676static
677void cache_page_release(nfs_readdir_descriptor_t *desc)
678{
679 if (!desc->page->mapping)
680 nfs_readdir_clear_array(desc->page);
681 page_cache_release(desc->page);
682 desc->page = NULL;
683}
684
685static
686struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
687{
688 return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
689 desc->page_index, (filler_t *)nfs_readdir_filler, desc);
690}
691
692/*
693 * Returns 0 if desc->dir_cookie was found on page desc->page_index
694 */
695static
696int find_cache_page(nfs_readdir_descriptor_t *desc)
697{
698 int res;
699
700 desc->page = get_cache_page(desc);
701 if (IS_ERR(desc->page))
702 return PTR_ERR(desc->page);
703
704 res = nfs_readdir_search_array(desc);
705 if (res != 0)
706 cache_page_release(desc);
707 return res;
708}
709
710/* Search for desc->dir_cookie from the beginning of the page cache */
711static inline
712int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
713{
714 int res;
715
716 if (desc->page_index == 0) {
717 desc->current_index = 0;
718 desc->last_cookie = 0;
719 }
720 do {
721 res = find_cache_page(desc);
722 } while (res == -EAGAIN);
723 return res;
724}
725
726/*
727 * Once we've found the start of the dirent within a page: fill 'er up...
728 */
729static
730int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
731 filldir_t filldir)
732{
733 struct file *file = desc->file;
734 int i = 0;
735 int res = 0;
736 struct nfs_cache_array *array = NULL;
737 struct nfs_open_dir_context *ctx = file->private_data;
738
739 array = nfs_readdir_get_array(desc->page);
740 if (IS_ERR(array)) {
741 res = PTR_ERR(array);
742 goto out;
743 }
744
745 for (i = desc->cache_entry_index; i < array->size; i++) {
746 struct nfs_cache_array_entry *ent;
747
748 ent = &array->array[i];
749 if (filldir(dirent, ent->string.name, ent->string.len,
750 file->f_pos, nfs_compat_user_ino64(ent->ino),
751 ent->d_type) < 0) {
752 desc->eof = 1;
753 break;
754 }
755 file->f_pos++;
756 if (i < (array->size-1))
757 *desc->dir_cookie = array->array[i+1].cookie;
758 else
759 *desc->dir_cookie = array->last_cookie;
760 if (ctx->duped != 0)
761 ctx->duped = 1;
762 }
763 if (array->eof_index >= 0)
764 desc->eof = 1;
765
766 nfs_readdir_release_array(desc->page);
767out:
768 cache_page_release(desc);
769 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
770 (unsigned long long)*desc->dir_cookie, res);
771 return res;
772}
773
774/*
775 * If we cannot find a cookie in our cache, we suspect that this is
776 * because it points to a deleted file, so we ask the server to return
777 * whatever it thinks is the next entry. We then feed this to filldir.
778 * If all goes well, we should then be able to find our way round the
779 * cache on the next call to readdir_search_pagecache();
780 *
781 * NOTE: we cannot add the anonymous page to the pagecache because
782 * the data it contains might not be page aligned. Besides,
783 * we should already have a complete representation of the
784 * directory in the page cache by the time we get here.
785 */
786static inline
787int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
788 filldir_t filldir)
789{
790 struct page *page = NULL;
791 int status;
792 struct inode *inode = desc->file->f_path.dentry->d_inode;
793 struct nfs_open_dir_context *ctx = desc->file->private_data;
794
795 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
796 (unsigned long long)*desc->dir_cookie);
797
798 page = alloc_page(GFP_HIGHUSER);
799 if (!page) {
800 status = -ENOMEM;
801 goto out;
802 }
803
804 desc->page_index = 0;
805 desc->last_cookie = *desc->dir_cookie;
806 desc->page = page;
807 ctx->duped = 0;
808
809 status = nfs_readdir_xdr_to_array(desc, page, inode);
810 if (status < 0)
811 goto out_release;
812
813 status = nfs_do_filldir(desc, dirent, filldir);
814
815 out:
816 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
817 __func__, status);
818 return status;
819 out_release:
820 cache_page_release(desc);
821 goto out;
822}
823
824/* The file offset position represents the dirent entry number. A
825 last cookie cache takes care of the common case of reading the
826 whole directory.
827 */
828static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
829{
830 struct dentry *dentry = filp->f_path.dentry;
831 struct inode *inode = dentry->d_inode;
832 nfs_readdir_descriptor_t my_desc,
833 *desc = &my_desc;
834 struct nfs_open_dir_context *dir_ctx = filp->private_data;
835 int res;
836
837 dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
838 dentry->d_parent->d_name.name, dentry->d_name.name,
839 (long long)filp->f_pos);
840 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
841
842 /*
843 * filp->f_pos points to the dirent entry number.
844 * *desc->dir_cookie has the cookie for the next entry. We have
845 * to either find the entry with the appropriate number or
846 * revalidate the cookie.
847 */
848 memset(desc, 0, sizeof(*desc));
849
850 desc->file = filp;
851 desc->dir_cookie = &dir_ctx->dir_cookie;
852 desc->decode = NFS_PROTO(inode)->decode_dirent;
853 desc->plus = nfs_use_readdirplus(inode, filp) ? 1 : 0;
854
855 nfs_block_sillyrename(dentry);
856 res = nfs_revalidate_mapping(inode, filp->f_mapping);
857 if (res < 0)
858 goto out;
859
860 do {
861 res = readdir_search_pagecache(desc);
862
863 if (res == -EBADCOOKIE) {
864 res = 0;
865 /* This means either end of directory */
866 if (*desc->dir_cookie && desc->eof == 0) {
867 /* Or that the server has 'lost' a cookie */
868 res = uncached_readdir(desc, dirent, filldir);
869 if (res == 0)
870 continue;
871 }
872 break;
873 }
874 if (res == -ETOOSMALL && desc->plus) {
875 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
876 nfs_zap_caches(inode);
877 desc->page_index = 0;
878 desc->plus = 0;
879 desc->eof = 0;
880 continue;
881 }
882 if (res < 0)
883 break;
884
885 res = nfs_do_filldir(desc, dirent, filldir);
886 if (res < 0)
887 break;
888 } while (!desc->eof);
889out:
890 nfs_unblock_sillyrename(dentry);
891 if (res > 0)
892 res = 0;
893 dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
894 dentry->d_parent->d_name.name, dentry->d_name.name,
895 res);
896 return res;
897}
898
899static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
900{
901 struct dentry *dentry = filp->f_path.dentry;
902 struct inode *inode = dentry->d_inode;
903 struct nfs_open_dir_context *dir_ctx = filp->private_data;
904
905 dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
906 dentry->d_parent->d_name.name,
907 dentry->d_name.name,
908 offset, origin);
909
910 mutex_lock(&inode->i_mutex);
911 switch (origin) {
912 case 1:
913 offset += filp->f_pos;
914 case 0:
915 if (offset >= 0)
916 break;
917 default:
918 offset = -EINVAL;
919 goto out;
920 }
921 if (offset != filp->f_pos) {
922 filp->f_pos = offset;
923 dir_ctx->dir_cookie = 0;
924 dir_ctx->duped = 0;
925 }
926out:
927 mutex_unlock(&inode->i_mutex);
928 return offset;
929}
930
931/*
932 * All directory operations under NFS are synchronous, so fsync()
933 * is a dummy operation.
934 */
935static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
936 int datasync)
937{
938 struct dentry *dentry = filp->f_path.dentry;
939 struct inode *inode = dentry->d_inode;
940
941 dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
942 dentry->d_parent->d_name.name, dentry->d_name.name,
943 datasync);
944
945 mutex_lock(&inode->i_mutex);
946 nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
947 mutex_unlock(&inode->i_mutex);
948 return 0;
949}
950
951/**
952 * nfs_force_lookup_revalidate - Mark the directory as having changed
953 * @dir - pointer to directory inode
954 *
955 * This forces the revalidation code in nfs_lookup_revalidate() to do a
956 * full lookup on all child dentries of 'dir' whenever a change occurs
957 * on the server that might have invalidated our dcache.
958 *
959 * The caller should be holding dir->i_lock
960 */
961void nfs_force_lookup_revalidate(struct inode *dir)
962{
963 NFS_I(dir)->cache_change_attribute++;
964}
965
966/*
967 * A check for whether or not the parent directory has changed.
968 * In the case it has, we assume that the dentries are untrustworthy
969 * and may need to be looked up again.
970 */
971static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
972{
973 if (IS_ROOT(dentry))
974 return 1;
975 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
976 return 0;
977 if (!nfs_verify_change_attribute(dir, dentry->d_time))
978 return 0;
979 /* Revalidate nfsi->cache_change_attribute before we declare a match */
980 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
981 return 0;
982 if (!nfs_verify_change_attribute(dir, dentry->d_time))
983 return 0;
984 return 1;
985}
986
987/*
988 * Use intent information to check whether or not we're going to do
989 * an O_EXCL create using this path component.
990 */
991static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
992{
993 if (NFS_PROTO(dir)->version == 2)
994 return 0;
995 return flags & LOOKUP_EXCL;
996}
997
998/*
999 * Inode and filehandle revalidation for lookups.
1000 *
1001 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1002 * or if the intent information indicates that we're about to open this
1003 * particular file and the "nocto" mount flag is not set.
1004 *
1005 */
1006static inline
1007int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
1008{
1009 struct nfs_server *server = NFS_SERVER(inode);
1010
1011 if (IS_AUTOMOUNT(inode))
1012 return 0;
1013 /* VFS wants an on-the-wire revalidation */
1014 if (flags & LOOKUP_REVAL)
1015 goto out_force;
1016 /* This is an open(2) */
1017 if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
1018 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
1019 goto out_force;
1020 return 0;
1021out_force:
1022 return __nfs_revalidate_inode(server, inode);
1023}
1024
1025/*
1026 * We judge how long we want to trust negative
1027 * dentries by looking at the parent inode mtime.
1028 *
1029 * If parent mtime has changed, we revalidate, else we wait for a
1030 * period corresponding to the parent's attribute cache timeout value.
1031 */
1032static inline
1033int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1034 unsigned int flags)
1035{
1036 /* Don't revalidate a negative dentry if we're creating a new file */
1037 if (flags & LOOKUP_CREATE)
1038 return 0;
1039 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1040 return 1;
1041 return !nfs_check_verifier(dir, dentry);
1042}
1043
1044/*
1045 * This is called every time the dcache has a lookup hit,
1046 * and we should check whether we can really trust that
1047 * lookup.
1048 *
1049 * NOTE! The hit can be a negative hit too, don't assume
1050 * we have an inode!
1051 *
1052 * If the parent directory is seen to have changed, we throw out the
1053 * cached dentry and do a new lookup.
1054 */
1055static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1056{
1057 struct inode *dir;
1058 struct inode *inode;
1059 struct dentry *parent;
1060 struct nfs_fh *fhandle = NULL;
1061 struct nfs_fattr *fattr = NULL;
1062 int error;
1063
1064 if (flags & LOOKUP_RCU)
1065 return -ECHILD;
1066
1067 parent = dget_parent(dentry);
1068 dir = parent->d_inode;
1069 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1070 inode = dentry->d_inode;
1071
1072 if (!inode) {
1073 if (nfs_neg_need_reval(dir, dentry, flags))
1074 goto out_bad;
1075 goto out_valid_noent;
1076 }
1077
1078 if (is_bad_inode(inode)) {
1079 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1080 __func__, dentry->d_parent->d_name.name,
1081 dentry->d_name.name);
1082 goto out_bad;
1083 }
1084
1085 if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
1086 goto out_set_verifier;
1087
1088 /* Force a full look up iff the parent directory has changed */
1089 if (!nfs_is_exclusive_create(dir, flags) && nfs_check_verifier(dir, dentry)) {
1090 if (nfs_lookup_verify_inode(inode, flags))
1091 goto out_zap_parent;
1092 goto out_valid;
1093 }
1094
1095 if (NFS_STALE(inode))
1096 goto out_bad;
1097
1098 error = -ENOMEM;
1099 fhandle = nfs_alloc_fhandle();
1100 fattr = nfs_alloc_fattr();
1101 if (fhandle == NULL || fattr == NULL)
1102 goto out_error;
1103
1104 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1105 if (error)
1106 goto out_bad;
1107 if (nfs_compare_fh(NFS_FH(inode), fhandle))
1108 goto out_bad;
1109 if ((error = nfs_refresh_inode(inode, fattr)) != 0)
1110 goto out_bad;
1111
1112 nfs_free_fattr(fattr);
1113 nfs_free_fhandle(fhandle);
1114out_set_verifier:
1115 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1116 out_valid:
1117 /* Success: notify readdir to use READDIRPLUS */
1118 nfs_advise_use_readdirplus(dir);
1119 out_valid_noent:
1120 dput(parent);
1121 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1122 __func__, dentry->d_parent->d_name.name,
1123 dentry->d_name.name);
1124 return 1;
1125out_zap_parent:
1126 nfs_zap_caches(dir);
1127 out_bad:
1128 nfs_mark_for_revalidate(dir);
1129 if (inode && S_ISDIR(inode->i_mode)) {
1130 /* Purge readdir caches. */
1131 nfs_zap_caches(inode);
1132 /* If we have submounts, don't unhash ! */
1133 if (have_submounts(dentry))
1134 goto out_valid;
1135 if (dentry->d_flags & DCACHE_DISCONNECTED)
1136 goto out_valid;
1137 shrink_dcache_parent(dentry);
1138 }
1139 d_drop(dentry);
1140 nfs_free_fattr(fattr);
1141 nfs_free_fhandle(fhandle);
1142 dput(parent);
1143 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1144 __func__, dentry->d_parent->d_name.name,
1145 dentry->d_name.name);
1146 return 0;
1147out_error:
1148 nfs_free_fattr(fattr);
1149 nfs_free_fhandle(fhandle);
1150 dput(parent);
1151 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
1152 __func__, dentry->d_parent->d_name.name,
1153 dentry->d_name.name, error);
1154 return error;
1155}
1156
1157/*
1158 * This is called from dput() when d_count is going to 0.
1159 */
1160static int nfs_dentry_delete(const struct dentry *dentry)
1161{
1162 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
1163 dentry->d_parent->d_name.name, dentry->d_name.name,
1164 dentry->d_flags);
1165
1166 /* Unhash any dentry with a stale inode */
1167 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1168 return 1;
1169
1170 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1171 /* Unhash it, so that ->d_iput() would be called */
1172 return 1;
1173 }
1174 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1175 /* Unhash it, so that ancestors of killed async unlink
1176 * files will be cleaned up during umount */
1177 return 1;
1178 }
1179 return 0;
1180
1181}
1182
1183static void nfs_drop_nlink(struct inode *inode)
1184{
1185 spin_lock(&inode->i_lock);
1186 if (inode->i_nlink > 0)
1187 drop_nlink(inode);
1188 spin_unlock(&inode->i_lock);
1189}
1190
1191/*
1192 * Called when the dentry loses inode.
1193 * We use it to clean up silly-renamed files.
1194 */
1195static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1196{
1197 if (S_ISDIR(inode->i_mode))
1198 /* drop any readdir cache as it could easily be old */
1199 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1200
1201 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1202 drop_nlink(inode);
1203 nfs_complete_unlink(dentry, inode);
1204 }
1205 iput(inode);
1206}
1207
1208static void nfs_d_release(struct dentry *dentry)
1209{
1210 /* free cached devname value, if it survived that far */
1211 if (unlikely(dentry->d_fsdata)) {
1212 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1213 WARN_ON(1);
1214 else
1215 kfree(dentry->d_fsdata);
1216 }
1217}
1218
1219const struct dentry_operations nfs_dentry_operations = {
1220 .d_revalidate = nfs_lookup_revalidate,
1221 .d_delete = nfs_dentry_delete,
1222 .d_iput = nfs_dentry_iput,
1223 .d_automount = nfs_d_automount,
1224 .d_release = nfs_d_release,
1225};
1226
1227struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
1228{
1229 struct dentry *res;
1230 struct dentry *parent;
1231 struct inode *inode = NULL;
1232 struct nfs_fh *fhandle = NULL;
1233 struct nfs_fattr *fattr = NULL;
1234 int error;
1235
1236 dfprintk(VFS, "NFS: lookup(%s/%s)\n",
1237 dentry->d_parent->d_name.name, dentry->d_name.name);
1238 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1239
1240 res = ERR_PTR(-ENAMETOOLONG);
1241 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1242 goto out;
1243
1244 /*
1245 * If we're doing an exclusive create, optimize away the lookup
1246 * but don't hash the dentry.
1247 */
1248 if (nfs_is_exclusive_create(dir, flags)) {
1249 d_instantiate(dentry, NULL);
1250 res = NULL;
1251 goto out;
1252 }
1253
1254 res = ERR_PTR(-ENOMEM);
1255 fhandle = nfs_alloc_fhandle();
1256 fattr = nfs_alloc_fattr();
1257 if (fhandle == NULL || fattr == NULL)
1258 goto out;
1259
1260 parent = dentry->d_parent;
1261 /* Protect against concurrent sillydeletes */
1262 nfs_block_sillyrename(parent);
1263 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1264 if (error == -ENOENT)
1265 goto no_entry;
1266 if (error < 0) {
1267 res = ERR_PTR(error);
1268 goto out_unblock_sillyrename;
1269 }
1270 inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1271 res = ERR_CAST(inode);
1272 if (IS_ERR(res))
1273 goto out_unblock_sillyrename;
1274
1275 /* Success: notify readdir to use READDIRPLUS */
1276 nfs_advise_use_readdirplus(dir);
1277
1278no_entry:
1279 res = d_materialise_unique(dentry, inode);
1280 if (res != NULL) {
1281 if (IS_ERR(res))
1282 goto out_unblock_sillyrename;
1283 dentry = res;
1284 }
1285 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1286out_unblock_sillyrename:
1287 nfs_unblock_sillyrename(parent);
1288out:
1289 nfs_free_fattr(fattr);
1290 nfs_free_fhandle(fhandle);
1291 return res;
1292}
1293
1294#ifdef CONFIG_NFS_V4
1295static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
1296
1297const struct dentry_operations nfs4_dentry_operations = {
1298 .d_revalidate = nfs4_lookup_revalidate,
1299 .d_delete = nfs_dentry_delete,
1300 .d_iput = nfs_dentry_iput,
1301 .d_automount = nfs_d_automount,
1302 .d_release = nfs_d_release,
1303};
1304
1305static fmode_t flags_to_mode(int flags)
1306{
1307 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1308 if ((flags & O_ACCMODE) != O_WRONLY)
1309 res |= FMODE_READ;
1310 if ((flags & O_ACCMODE) != O_RDONLY)
1311 res |= FMODE_WRITE;
1312 return res;
1313}
1314
1315static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1316{
1317 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
1318}
1319
1320static int do_open(struct inode *inode, struct file *filp)
1321{
1322 nfs_fscache_set_inode_cookie(inode, filp);
1323 return 0;
1324}
1325
1326static int nfs_finish_open(struct nfs_open_context *ctx,
1327 struct dentry *dentry,
1328 struct file *file, unsigned open_flags,
1329 int *opened)
1330{
1331 int err;
1332
1333 if (ctx->dentry != dentry) {
1334 dput(ctx->dentry);
1335 ctx->dentry = dget(dentry);
1336 }
1337
1338 /* If the open_intent is for execute, we have an extra check to make */
1339 if (ctx->mode & FMODE_EXEC) {
1340 err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
1341 if (err < 0)
1342 goto out;
1343 }
1344
1345 err = finish_open(file, dentry, do_open, opened);
1346 if (err)
1347 goto out;
1348 nfs_file_set_open_context(file, ctx);
1349
1350out:
1351 put_nfs_open_context(ctx);
1352 return err;
1353}
1354
1355static int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1356 struct file *file, unsigned open_flags,
1357 umode_t mode, int *opened)
1358{
1359 struct nfs_open_context *ctx;
1360 struct dentry *res;
1361 struct iattr attr = { .ia_valid = ATTR_OPEN };
1362 struct inode *inode;
1363 int err;
1364
1365 /* Expect a negative dentry */
1366 BUG_ON(dentry->d_inode);
1367
1368 dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n",
1369 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1370
1371 /* NFS only supports OPEN on regular files */
1372 if ((open_flags & O_DIRECTORY)) {
1373 if (!d_unhashed(dentry)) {
1374 /*
1375 * Hashed negative dentry with O_DIRECTORY: dentry was
1376 * revalidated and is fine, no need to perform lookup
1377 * again
1378 */
1379 return -ENOENT;
1380 }
1381 goto no_open;
1382 }
1383
1384 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1385 return -ENAMETOOLONG;
1386
1387 if (open_flags & O_CREAT) {
1388 attr.ia_valid |= ATTR_MODE;
1389 attr.ia_mode = mode & ~current_umask();
1390 }
1391 if (open_flags & O_TRUNC) {
1392 attr.ia_valid |= ATTR_SIZE;
1393 attr.ia_size = 0;
1394 }
1395
1396 ctx = create_nfs_open_context(dentry, open_flags);
1397 err = PTR_ERR(ctx);
1398 if (IS_ERR(ctx))
1399 goto out;
1400
1401 nfs_block_sillyrename(dentry->d_parent);
1402 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1403 d_drop(dentry);
1404 if (IS_ERR(inode)) {
1405 nfs_unblock_sillyrename(dentry->d_parent);
1406 put_nfs_open_context(ctx);
1407 err = PTR_ERR(inode);
1408 switch (err) {
1409 case -ENOENT:
1410 d_add(dentry, NULL);
1411 break;
1412 case -EISDIR:
1413 case -ENOTDIR:
1414 goto no_open;
1415 case -ELOOP:
1416 if (!(open_flags & O_NOFOLLOW))
1417 goto no_open;
1418 break;
1419 /* case -EINVAL: */
1420 default:
1421 break;
1422 }
1423 goto out;
1424 }
1425 res = d_add_unique(dentry, inode);
1426 if (res != NULL)
1427 dentry = res;
1428
1429 nfs_unblock_sillyrename(dentry->d_parent);
1430 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1431
1432 err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
1433
1434 dput(res);
1435out:
1436 return err;
1437
1438no_open:
1439 res = nfs_lookup(dir, dentry, 0);
1440 err = PTR_ERR(res);
1441 if (IS_ERR(res))
1442 goto out;
1443
1444 return finish_no_open(file, res);
1445}
1446
1447static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
1448{
1449 struct dentry *parent = NULL;
1450 struct inode *inode;
1451 struct inode *dir;
1452 int ret = 0;
1453
1454 if (flags & LOOKUP_RCU)
1455 return -ECHILD;
1456
1457 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
1458 goto no_open;
1459 if (d_mountpoint(dentry))
1460 goto no_open;
1461
1462 inode = dentry->d_inode;
1463 parent = dget_parent(dentry);
1464 dir = parent->d_inode;
1465
1466 /* We can't create new files in nfs_open_revalidate(), so we
1467 * optimize away revalidation of negative dentries.
1468 */
1469 if (inode == NULL) {
1470 if (!nfs_neg_need_reval(dir, dentry, flags))
1471 ret = 1;
1472 goto out;
1473 }
1474
1475 /* NFS only supports OPEN on regular files */
1476 if (!S_ISREG(inode->i_mode))
1477 goto no_open_dput;
1478 /* We cannot do exclusive creation on a positive dentry */
1479 if (flags & LOOKUP_EXCL)
1480 goto no_open_dput;
1481
1482 /* Let f_op->open() actually open (and revalidate) the file */
1483 ret = 1;
1484
1485out:
1486 dput(parent);
1487 return ret;
1488
1489no_open_dput:
1490 dput(parent);
1491no_open:
1492 return nfs_lookup_revalidate(dentry, flags);
1493}
1494
1495#endif /* CONFIG_NFSV4 */
1496
1497/*
1498 * Code common to create, mkdir, and mknod.
1499 */
1500int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1501 struct nfs_fattr *fattr)
1502{
1503 struct dentry *parent = dget_parent(dentry);
1504 struct inode *dir = parent->d_inode;
1505 struct inode *inode;
1506 int error = -EACCES;
1507
1508 d_drop(dentry);
1509
1510 /* We may have been initialized further down */
1511 if (dentry->d_inode)
1512 goto out;
1513 if (fhandle->size == 0) {
1514 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1515 if (error)
1516 goto out_error;
1517 }
1518 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1519 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1520 struct nfs_server *server = NFS_SB(dentry->d_sb);
1521 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
1522 if (error < 0)
1523 goto out_error;
1524 }
1525 inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1526 error = PTR_ERR(inode);
1527 if (IS_ERR(inode))
1528 goto out_error;
1529 d_add(dentry, inode);
1530out:
1531 dput(parent);
1532 return 0;
1533out_error:
1534 nfs_mark_for_revalidate(dir);
1535 dput(parent);
1536 return error;
1537}
1538
1539/*
1540 * Following a failed create operation, we drop the dentry rather
1541 * than retain a negative dentry. This avoids a problem in the event
1542 * that the operation succeeded on the server, but an error in the
1543 * reply path made it appear to have failed.
1544 */
1545int nfs_create(struct inode *dir, struct dentry *dentry,
1546 umode_t mode, bool excl)
1547{
1548 struct iattr attr;
1549 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
1550 int error;
1551
1552 dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1553 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1554
1555 attr.ia_mode = mode;
1556 attr.ia_valid = ATTR_MODE;
1557
1558 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1559 if (error != 0)
1560 goto out_err;
1561 return 0;
1562out_err:
1563 d_drop(dentry);
1564 return error;
1565}
1566
1567/*
1568 * See comments for nfs_proc_create regarding failed operations.
1569 */
1570int
1571nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1572{
1573 struct iattr attr;
1574 int status;
1575
1576 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
1577 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1578
1579 if (!new_valid_dev(rdev))
1580 return -EINVAL;
1581
1582 attr.ia_mode = mode;
1583 attr.ia_valid = ATTR_MODE;
1584
1585 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1586 if (status != 0)
1587 goto out_err;
1588 return 0;
1589out_err:
1590 d_drop(dentry);
1591 return status;
1592}
1593
1594/*
1595 * See comments for nfs_proc_create regarding failed operations.
1596 */
1597int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1598{
1599 struct iattr attr;
1600 int error;
1601
1602 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
1603 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1604
1605 attr.ia_valid = ATTR_MODE;
1606 attr.ia_mode = mode | S_IFDIR;
1607
1608 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1609 if (error != 0)
1610 goto out_err;
1611 return 0;
1612out_err:
1613 d_drop(dentry);
1614 return error;
1615}
1616
1617static void nfs_dentry_handle_enoent(struct dentry *dentry)
1618{
1619 if (dentry->d_inode != NULL && !d_unhashed(dentry))
1620 d_delete(dentry);
1621}
1622
1623int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1624{
1625 int error;
1626
1627 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
1628 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1629
1630 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1631 /* Ensure the VFS deletes this inode */
1632 if (error == 0 && dentry->d_inode != NULL)
1633 clear_nlink(dentry->d_inode);
1634 else if (error == -ENOENT)
1635 nfs_dentry_handle_enoent(dentry);
1636
1637 return error;
1638}
1639
1640/*
1641 * Remove a file after making sure there are no pending writes,
1642 * and after checking that the file has only one user.
1643 *
1644 * We invalidate the attribute cache and free the inode prior to the operation
1645 * to avoid possible races if the server reuses the inode.
1646 */
1647static int nfs_safe_remove(struct dentry *dentry)
1648{
1649 struct inode *dir = dentry->d_parent->d_inode;
1650 struct inode *inode = dentry->d_inode;
1651 int error = -EBUSY;
1652
1653 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1654 dentry->d_parent->d_name.name, dentry->d_name.name);
1655
1656 /* If the dentry was sillyrenamed, we simply call d_delete() */
1657 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1658 error = 0;
1659 goto out;
1660 }
1661
1662 if (inode != NULL) {
1663 NFS_PROTO(inode)->return_delegation(inode);
1664 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1665 /* The VFS may want to delete this inode */
1666 if (error == 0)
1667 nfs_drop_nlink(inode);
1668 nfs_mark_for_revalidate(inode);
1669 } else
1670 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1671 if (error == -ENOENT)
1672 nfs_dentry_handle_enoent(dentry);
1673out:
1674 return error;
1675}
1676
1677/* We do silly rename. In case sillyrename() returns -EBUSY, the inode
1678 * belongs to an active ".nfs..." file and we return -EBUSY.
1679 *
1680 * If sillyrename() returns 0, we do nothing, otherwise we unlink.
1681 */
1682int nfs_unlink(struct inode *dir, struct dentry *dentry)
1683{
1684 int error;
1685 int need_rehash = 0;
1686
1687 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1688 dir->i_ino, dentry->d_name.name);
1689
1690 spin_lock(&dentry->d_lock);
1691 if (dentry->d_count > 1) {
1692 spin_unlock(&dentry->d_lock);
1693 /* Start asynchronous writeout of the inode */
1694 write_inode_now(dentry->d_inode, 0);
1695 error = nfs_sillyrename(dir, dentry);
1696 return error;
1697 }
1698 if (!d_unhashed(dentry)) {
1699 __d_drop(dentry);
1700 need_rehash = 1;
1701 }
1702 spin_unlock(&dentry->d_lock);
1703 error = nfs_safe_remove(dentry);
1704 if (!error || error == -ENOENT) {
1705 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1706 } else if (need_rehash)
1707 d_rehash(dentry);
1708 return error;
1709}
1710
1711/*
1712 * To create a symbolic link, most file systems instantiate a new inode,
1713 * add a page to it containing the path, then write it out to the disk
1714 * using prepare_write/commit_write.
1715 *
1716 * Unfortunately the NFS client can't create the in-core inode first
1717 * because it needs a file handle to create an in-core inode (see
1718 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the
1719 * symlink request has completed on the server.
1720 *
1721 * So instead we allocate a raw page, copy the symname into it, then do
1722 * the SYMLINK request with the page as the buffer. If it succeeds, we
1723 * now have a new file handle and can instantiate an in-core NFS inode
1724 * and move the raw page into its mapping.
1725 */
1726int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1727{
1728 struct pagevec lru_pvec;
1729 struct page *page;
1730 char *kaddr;
1731 struct iattr attr;
1732 unsigned int pathlen = strlen(symname);
1733 int error;
1734
1735 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1736 dir->i_ino, dentry->d_name.name, symname);
1737
1738 if (pathlen > PAGE_SIZE)
1739 return -ENAMETOOLONG;
1740
1741 attr.ia_mode = S_IFLNK | S_IRWXUGO;
1742 attr.ia_valid = ATTR_MODE;
1743
1744 page = alloc_page(GFP_HIGHUSER);
1745 if (!page)
1746 return -ENOMEM;
1747
1748 kaddr = kmap_atomic(page);
1749 memcpy(kaddr, symname, pathlen);
1750 if (pathlen < PAGE_SIZE)
1751 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1752 kunmap_atomic(kaddr);
1753
1754 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1755 if (error != 0) {
1756 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
1757 dir->i_sb->s_id, dir->i_ino,
1758 dentry->d_name.name, symname, error);
1759 d_drop(dentry);
1760 __free_page(page);
1761 return error;
1762 }
1763
1764 /*
1765 * No big deal if we can't add this page to the page cache here.
1766 * READLINK will get the missing page from the server if needed.
1767 */
1768 pagevec_init(&lru_pvec, 0);
1769 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
1770 GFP_KERNEL)) {
1771 pagevec_add(&lru_pvec, page);
1772 pagevec_lru_add_file(&lru_pvec);
1773 SetPageUptodate(page);
1774 unlock_page(page);
1775 } else
1776 __free_page(page);
1777
1778 return 0;
1779}
1780
1781int
1782nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1783{
1784 struct inode *inode = old_dentry->d_inode;
1785 int error;
1786
1787 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1788 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1789 dentry->d_parent->d_name.name, dentry->d_name.name);
1790
1791 NFS_PROTO(inode)->return_delegation(inode);
1792
1793 d_drop(dentry);
1794 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1795 if (error == 0) {
1796 ihold(inode);
1797 d_add(dentry, inode);
1798 }
1799 return error;
1800}
1801
1802/*
1803 * RENAME
1804 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1805 * different file handle for the same inode after a rename (e.g. when
1806 * moving to a different directory). A fail-safe method to do so would
1807 * be to look up old_dir/old_name, create a link to new_dir/new_name and
1808 * rename the old file using the sillyrename stuff. This way, the original
1809 * file in old_dir will go away when the last process iput()s the inode.
1810 *
1811 * FIXED.
1812 *
1813 * It actually works quite well. One needs to have the possibility for
1814 * at least one ".nfs..." file in each directory the file ever gets
1815 * moved or linked to which happens automagically with the new
1816 * implementation that only depends on the dcache stuff instead of
1817 * using the inode layer
1818 *
1819 * Unfortunately, things are a little more complicated than indicated
1820 * above. For a cross-directory move, we want to make sure we can get
1821 * rid of the old inode after the operation. This means there must be
1822 * no pending writes (if it's a file), and the use count must be 1.
1823 * If these conditions are met, we can drop the dentries before doing
1824 * the rename.
1825 */
1826int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1827 struct inode *new_dir, struct dentry *new_dentry)
1828{
1829 struct inode *old_inode = old_dentry->d_inode;
1830 struct inode *new_inode = new_dentry->d_inode;
1831 struct dentry *dentry = NULL, *rehash = NULL;
1832 int error = -EBUSY;
1833
1834 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1835 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1836 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1837 new_dentry->d_count);
1838
1839 /*
1840 * For non-directories, check whether the target is busy and if so,
1841 * make a copy of the dentry and then do a silly-rename. If the
1842 * silly-rename succeeds, the copied dentry is hashed and becomes
1843 * the new target.
1844 */
1845 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1846 /*
1847 * To prevent any new references to the target during the
1848 * rename, we unhash the dentry in advance.
1849 */
1850 if (!d_unhashed(new_dentry)) {
1851 d_drop(new_dentry);
1852 rehash = new_dentry;
1853 }
1854
1855 if (new_dentry->d_count > 2) {
1856 int err;
1857
1858 /* copy the target dentry's name */
1859 dentry = d_alloc(new_dentry->d_parent,
1860 &new_dentry->d_name);
1861 if (!dentry)
1862 goto out;
1863
1864 /* silly-rename the existing target ... */
1865 err = nfs_sillyrename(new_dir, new_dentry);
1866 if (err)
1867 goto out;
1868
1869 new_dentry = dentry;
1870 rehash = NULL;
1871 new_inode = NULL;
1872 }
1873 }
1874
1875 NFS_PROTO(old_inode)->return_delegation(old_inode);
1876 if (new_inode != NULL)
1877 NFS_PROTO(new_inode)->return_delegation(new_inode);
1878
1879 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1880 new_dir, &new_dentry->d_name);
1881 nfs_mark_for_revalidate(old_inode);
1882out:
1883 if (rehash)
1884 d_rehash(rehash);
1885 if (!error) {
1886 if (new_inode != NULL)
1887 nfs_drop_nlink(new_inode);
1888 d_move(old_dentry, new_dentry);
1889 nfs_set_verifier(new_dentry,
1890 nfs_save_change_attribute(new_dir));
1891 } else if (error == -ENOENT)
1892 nfs_dentry_handle_enoent(old_dentry);
1893
1894 /* new dentry created? */
1895 if (dentry)
1896 dput(dentry);
1897 return error;
1898}
1899
1900static DEFINE_SPINLOCK(nfs_access_lru_lock);
1901static LIST_HEAD(nfs_access_lru_list);
1902static atomic_long_t nfs_access_nr_entries;
1903
1904static void nfs_access_free_entry(struct nfs_access_entry *entry)
1905{
1906 put_rpccred(entry->cred);
1907 kfree(entry);
1908 smp_mb__before_atomic_dec();
1909 atomic_long_dec(&nfs_access_nr_entries);
1910 smp_mb__after_atomic_dec();
1911}
1912
1913static void nfs_access_free_list(struct list_head *head)
1914{
1915 struct nfs_access_entry *cache;
1916
1917 while (!list_empty(head)) {
1918 cache = list_entry(head->next, struct nfs_access_entry, lru);
1919 list_del(&cache->lru);
1920 nfs_access_free_entry(cache);
1921 }
1922}
1923
1924int nfs_access_cache_shrinker(struct shrinker *shrink,
1925 struct shrink_control *sc)
1926{
1927 LIST_HEAD(head);
1928 struct nfs_inode *nfsi, *next;
1929 struct nfs_access_entry *cache;
1930 int nr_to_scan = sc->nr_to_scan;
1931 gfp_t gfp_mask = sc->gfp_mask;
1932
1933 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
1934 return (nr_to_scan == 0) ? 0 : -1;
1935
1936 spin_lock(&nfs_access_lru_lock);
1937 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
1938 struct inode *inode;
1939
1940 if (nr_to_scan-- == 0)
1941 break;
1942 inode = &nfsi->vfs_inode;
1943 spin_lock(&inode->i_lock);
1944 if (list_empty(&nfsi->access_cache_entry_lru))
1945 goto remove_lru_entry;
1946 cache = list_entry(nfsi->access_cache_entry_lru.next,
1947 struct nfs_access_entry, lru);
1948 list_move(&cache->lru, &head);
1949 rb_erase(&cache->rb_node, &nfsi->access_cache);
1950 if (!list_empty(&nfsi->access_cache_entry_lru))
1951 list_move_tail(&nfsi->access_cache_inode_lru,
1952 &nfs_access_lru_list);
1953 else {
1954remove_lru_entry:
1955 list_del_init(&nfsi->access_cache_inode_lru);
1956 smp_mb__before_clear_bit();
1957 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
1958 smp_mb__after_clear_bit();
1959 }
1960 spin_unlock(&inode->i_lock);
1961 }
1962 spin_unlock(&nfs_access_lru_lock);
1963 nfs_access_free_list(&head);
1964 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
1965}
1966
1967static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
1968{
1969 struct rb_root *root_node = &nfsi->access_cache;
1970 struct rb_node *n;
1971 struct nfs_access_entry *entry;
1972
1973 /* Unhook entries from the cache */
1974 while ((n = rb_first(root_node)) != NULL) {
1975 entry = rb_entry(n, struct nfs_access_entry, rb_node);
1976 rb_erase(n, root_node);
1977 list_move(&entry->lru, head);
1978 }
1979 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
1980}
1981
1982void nfs_access_zap_cache(struct inode *inode)
1983{
1984 LIST_HEAD(head);
1985
1986 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
1987 return;
1988 /* Remove from global LRU init */
1989 spin_lock(&nfs_access_lru_lock);
1990 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
1991 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
1992
1993 spin_lock(&inode->i_lock);
1994 __nfs_access_zap_cache(NFS_I(inode), &head);
1995 spin_unlock(&inode->i_lock);
1996 spin_unlock(&nfs_access_lru_lock);
1997 nfs_access_free_list(&head);
1998}
1999
2000static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2001{
2002 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2003 struct nfs_access_entry *entry;
2004
2005 while (n != NULL) {
2006 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2007
2008 if (cred < entry->cred)
2009 n = n->rb_left;
2010 else if (cred > entry->cred)
2011 n = n->rb_right;
2012 else
2013 return entry;
2014 }
2015 return NULL;
2016}
2017
2018static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2019{
2020 struct nfs_inode *nfsi = NFS_I(inode);
2021 struct nfs_access_entry *cache;
2022 int err = -ENOENT;
2023
2024 spin_lock(&inode->i_lock);
2025 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2026 goto out_zap;
2027 cache = nfs_access_search_rbtree(inode, cred);
2028 if (cache == NULL)
2029 goto out;
2030 if (!nfs_have_delegated_attributes(inode) &&
2031 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2032 goto out_stale;
2033 res->jiffies = cache->jiffies;
2034 res->cred = cache->cred;
2035 res->mask = cache->mask;
2036 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2037 err = 0;
2038out:
2039 spin_unlock(&inode->i_lock);
2040 return err;
2041out_stale:
2042 rb_erase(&cache->rb_node, &nfsi->access_cache);
2043 list_del(&cache->lru);
2044 spin_unlock(&inode->i_lock);
2045 nfs_access_free_entry(cache);
2046 return -ENOENT;
2047out_zap:
2048 spin_unlock(&inode->i_lock);
2049 nfs_access_zap_cache(inode);
2050 return -ENOENT;
2051}
2052
2053static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2054{
2055 struct nfs_inode *nfsi = NFS_I(inode);
2056 struct rb_root *root_node = &nfsi->access_cache;
2057 struct rb_node **p = &root_node->rb_node;
2058 struct rb_node *parent = NULL;
2059 struct nfs_access_entry *entry;
2060
2061 spin_lock(&inode->i_lock);
2062 while (*p != NULL) {
2063 parent = *p;
2064 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2065
2066 if (set->cred < entry->cred)
2067 p = &parent->rb_left;
2068 else if (set->cred > entry->cred)
2069 p = &parent->rb_right;
2070 else
2071 goto found;
2072 }
2073 rb_link_node(&set->rb_node, parent, p);
2074 rb_insert_color(&set->rb_node, root_node);
2075 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2076 spin_unlock(&inode->i_lock);
2077 return;
2078found:
2079 rb_replace_node(parent, &set->rb_node, root_node);
2080 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2081 list_del(&entry->lru);
2082 spin_unlock(&inode->i_lock);
2083 nfs_access_free_entry(entry);
2084}
2085
2086static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2087{
2088 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2089 if (cache == NULL)
2090 return;
2091 RB_CLEAR_NODE(&cache->rb_node);
2092 cache->jiffies = set->jiffies;
2093 cache->cred = get_rpccred(set->cred);
2094 cache->mask = set->mask;
2095
2096 nfs_access_add_rbtree(inode, cache);
2097
2098 /* Update accounting */
2099 smp_mb__before_atomic_inc();
2100 atomic_long_inc(&nfs_access_nr_entries);
2101 smp_mb__after_atomic_inc();
2102
2103 /* Add inode to global LRU list */
2104 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2105 spin_lock(&nfs_access_lru_lock);
2106 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2107 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2108 &nfs_access_lru_list);
2109 spin_unlock(&nfs_access_lru_lock);
2110 }
2111}
2112
2113static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2114{
2115 struct nfs_access_entry cache;
2116 int status;
2117
2118 status = nfs_access_get_cached(inode, cred, &cache);
2119 if (status == 0)
2120 goto out;
2121
2122 /* Be clever: ask server to check for all possible rights */
2123 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2124 cache.cred = cred;
2125 cache.jiffies = jiffies;
2126 status = NFS_PROTO(inode)->access(inode, &cache);
2127 if (status != 0) {
2128 if (status == -ESTALE) {
2129 nfs_zap_caches(inode);
2130 if (!S_ISDIR(inode->i_mode))
2131 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2132 }
2133 return status;
2134 }
2135 nfs_access_add_cache(inode, &cache);
2136out:
2137 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2138 return 0;
2139 return -EACCES;
2140}
2141
2142static int nfs_open_permission_mask(int openflags)
2143{
2144 int mask = 0;
2145
2146 if ((openflags & O_ACCMODE) != O_WRONLY)
2147 mask |= MAY_READ;
2148 if ((openflags & O_ACCMODE) != O_RDONLY)
2149 mask |= MAY_WRITE;
2150 if (openflags & __FMODE_EXEC)
2151 mask |= MAY_EXEC;
2152 return mask;
2153}
2154
2155int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2156{
2157 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2158}
2159
2160int nfs_permission(struct inode *inode, int mask)
2161{
2162 struct rpc_cred *cred;
2163 int res = 0;
2164
2165 if (mask & MAY_NOT_BLOCK)
2166 return -ECHILD;
2167
2168 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2169
2170 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2171 goto out;
2172 /* Is this sys_access() ? */
2173 if (mask & (MAY_ACCESS | MAY_CHDIR))
2174 goto force_lookup;
2175
2176 switch (inode->i_mode & S_IFMT) {
2177 case S_IFLNK:
2178 goto out;
2179 case S_IFREG:
2180 /* NFSv4 has atomic_open... */
2181 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
2182 && (mask & MAY_OPEN)
2183 && !(mask & MAY_EXEC))
2184 goto out;
2185 break;
2186 case S_IFDIR:
2187 /*
2188 * Optimize away all write operations, since the server
2189 * will check permissions when we perform the op.
2190 */
2191 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2192 goto out;
2193 }
2194
2195force_lookup:
2196 if (!NFS_PROTO(inode)->access)
2197 goto out_notsup;
2198
2199 cred = rpc_lookup_cred();
2200 if (!IS_ERR(cred)) {
2201 res = nfs_do_access(inode, cred, mask);
2202 put_rpccred(cred);
2203 } else
2204 res = PTR_ERR(cred);
2205out:
2206 if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2207 res = -EACCES;
2208
2209 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
2210 inode->i_sb->s_id, inode->i_ino, mask, res);
2211 return res;
2212out_notsup:
2213 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2214 if (res == 0)
2215 res = generic_permission(inode, mask);
2216 goto out;
2217}
2218
2219/*
2220 * Local variables:
2221 * version-control: t
2222 * kept-new-versions: 5
2223 * End:
2224 */
Linux kernel - Deliverables
This page took 0.045207 seconds and 5 git commands to generate.