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