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