xref: /linux/fs/nfs/dir.c (revision f3d9478b2ce468c3115b02ecae7e975990697f15)
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/smp_lock.h>
33 #include <linux/namei.h>
34 
35 #include "nfs4_fs.h"
36 #include "delegation.h"
37 #include "iostat.h"
38 
39 #define NFS_PARANOIA 1
40 /* #define NFS_DEBUG_VERBOSE 1 */
41 
42 static int nfs_opendir(struct inode *, struct file *);
43 static int nfs_readdir(struct file *, void *, filldir_t);
44 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
45 static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
46 static int nfs_mkdir(struct inode *, struct dentry *, int);
47 static int nfs_rmdir(struct inode *, struct dentry *);
48 static int nfs_unlink(struct inode *, struct dentry *);
49 static int nfs_symlink(struct inode *, struct dentry *, const char *);
50 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
51 static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
52 static int nfs_rename(struct inode *, struct dentry *,
53 		      struct inode *, struct dentry *);
54 static int nfs_fsync_dir(struct file *, struct dentry *, int);
55 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
56 
57 const struct file_operations nfs_dir_operations = {
58 	.llseek		= nfs_llseek_dir,
59 	.read		= generic_read_dir,
60 	.readdir	= nfs_readdir,
61 	.open		= nfs_opendir,
62 	.release	= nfs_release,
63 	.fsync		= nfs_fsync_dir,
64 };
65 
66 struct inode_operations nfs_dir_inode_operations = {
67 	.create		= nfs_create,
68 	.lookup		= nfs_lookup,
69 	.link		= nfs_link,
70 	.unlink		= nfs_unlink,
71 	.symlink	= nfs_symlink,
72 	.mkdir		= nfs_mkdir,
73 	.rmdir		= nfs_rmdir,
74 	.mknod		= nfs_mknod,
75 	.rename		= nfs_rename,
76 	.permission	= nfs_permission,
77 	.getattr	= nfs_getattr,
78 	.setattr	= nfs_setattr,
79 };
80 
81 #ifdef CONFIG_NFS_V3
82 struct inode_operations nfs3_dir_inode_operations = {
83 	.create		= nfs_create,
84 	.lookup		= nfs_lookup,
85 	.link		= nfs_link,
86 	.unlink		= nfs_unlink,
87 	.symlink	= nfs_symlink,
88 	.mkdir		= nfs_mkdir,
89 	.rmdir		= nfs_rmdir,
90 	.mknod		= nfs_mknod,
91 	.rename		= nfs_rename,
92 	.permission	= nfs_permission,
93 	.getattr	= nfs_getattr,
94 	.setattr	= nfs_setattr,
95 	.listxattr	= nfs3_listxattr,
96 	.getxattr	= nfs3_getxattr,
97 	.setxattr	= nfs3_setxattr,
98 	.removexattr	= nfs3_removexattr,
99 };
100 #endif  /* CONFIG_NFS_V3 */
101 
102 #ifdef CONFIG_NFS_V4
103 
104 static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
105 struct inode_operations nfs4_dir_inode_operations = {
106 	.create		= nfs_create,
107 	.lookup		= nfs_atomic_lookup,
108 	.link		= nfs_link,
109 	.unlink		= nfs_unlink,
110 	.symlink	= nfs_symlink,
111 	.mkdir		= nfs_mkdir,
112 	.rmdir		= nfs_rmdir,
113 	.mknod		= nfs_mknod,
114 	.rename		= nfs_rename,
115 	.permission	= nfs_permission,
116 	.getattr	= nfs_getattr,
117 	.setattr	= nfs_setattr,
118 	.getxattr       = nfs4_getxattr,
119 	.setxattr       = nfs4_setxattr,
120 	.listxattr      = nfs4_listxattr,
121 };
122 
123 #endif /* CONFIG_NFS_V4 */
124 
125 /*
126  * Open file
127  */
128 static int
129 nfs_opendir(struct inode *inode, struct file *filp)
130 {
131 	int res;
132 
133 	dfprintk(VFS, "NFS: opendir(%s/%ld)\n",
134 			inode->i_sb->s_id, inode->i_ino);
135 
136 	lock_kernel();
137 	/* Call generic open code in order to cache credentials */
138 	res = nfs_open(inode, filp);
139 	unlock_kernel();
140 	return res;
141 }
142 
143 typedef u32 * (*decode_dirent_t)(u32 *, struct nfs_entry *, int);
144 typedef struct {
145 	struct file	*file;
146 	struct page	*page;
147 	unsigned long	page_index;
148 	u32		*ptr;
149 	u64		*dir_cookie;
150 	loff_t		current_index;
151 	struct nfs_entry *entry;
152 	decode_dirent_t	decode;
153 	int		plus;
154 	int		error;
155 } nfs_readdir_descriptor_t;
156 
157 /* Now we cache directories properly, by stuffing the dirent
158  * data directly in the page cache.
159  *
160  * Inode invalidation due to refresh etc. takes care of
161  * _everything_, no sloppy entry flushing logic, no extraneous
162  * copying, network direct to page cache, the way it was meant
163  * to be.
164  *
165  * NOTE: Dirent information verification is done always by the
166  *	 page-in of the RPC reply, nowhere else, this simplies
167  *	 things substantially.
168  */
169 static
170 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
171 {
172 	struct file	*file = desc->file;
173 	struct inode	*inode = file->f_dentry->d_inode;
174 	struct rpc_cred	*cred = nfs_file_cred(file);
175 	unsigned long	timestamp;
176 	int		error;
177 
178 	dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",
179 			__FUNCTION__, (long long)desc->entry->cookie,
180 			page->index);
181 
182  again:
183 	timestamp = jiffies;
184 	error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->entry->cookie, page,
185 					  NFS_SERVER(inode)->dtsize, desc->plus);
186 	if (error < 0) {
187 		/* We requested READDIRPLUS, but the server doesn't grok it */
188 		if (error == -ENOTSUPP && desc->plus) {
189 			NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
190 			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
191 			desc->plus = 0;
192 			goto again;
193 		}
194 		goto error;
195 	}
196 	SetPageUptodate(page);
197 	spin_lock(&inode->i_lock);
198 	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
199 	spin_unlock(&inode->i_lock);
200 	/* Ensure consistent page alignment of the data.
201 	 * Note: assumes we have exclusive access to this mapping either
202 	 *	 through inode->i_mutex or some other mechanism.
203 	 */
204 	if (page->index == 0)
205 		invalidate_inode_pages2_range(inode->i_mapping, PAGE_CACHE_SIZE, -1);
206 	unlock_page(page);
207 	return 0;
208  error:
209 	SetPageError(page);
210 	unlock_page(page);
211 	nfs_zap_caches(inode);
212 	desc->error = error;
213 	return -EIO;
214 }
215 
216 static inline
217 int dir_decode(nfs_readdir_descriptor_t *desc)
218 {
219 	u32	*p = desc->ptr;
220 	p = desc->decode(p, desc->entry, desc->plus);
221 	if (IS_ERR(p))
222 		return PTR_ERR(p);
223 	desc->ptr = p;
224 	return 0;
225 }
226 
227 static inline
228 void dir_page_release(nfs_readdir_descriptor_t *desc)
229 {
230 	kunmap(desc->page);
231 	page_cache_release(desc->page);
232 	desc->page = NULL;
233 	desc->ptr = NULL;
234 }
235 
236 /*
237  * Given a pointer to a buffer that has already been filled by a call
238  * to readdir, find the next entry with cookie '*desc->dir_cookie'.
239  *
240  * If the end of the buffer has been reached, return -EAGAIN, if not,
241  * return the offset within the buffer of the next entry to be
242  * read.
243  */
244 static inline
245 int find_dirent(nfs_readdir_descriptor_t *desc)
246 {
247 	struct nfs_entry *entry = desc->entry;
248 	int		loop_count = 0,
249 			status;
250 
251 	while((status = dir_decode(desc)) == 0) {
252 		dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n",
253 				__FUNCTION__, (unsigned long long)entry->cookie);
254 		if (entry->prev_cookie == *desc->dir_cookie)
255 			break;
256 		if (loop_count++ > 200) {
257 			loop_count = 0;
258 			schedule();
259 		}
260 	}
261 	return status;
262 }
263 
264 /*
265  * Given a pointer to a buffer that has already been filled by a call
266  * to readdir, find the entry at offset 'desc->file->f_pos'.
267  *
268  * If the end of the buffer has been reached, return -EAGAIN, if not,
269  * return the offset within the buffer of the next entry to be
270  * read.
271  */
272 static inline
273 int find_dirent_index(nfs_readdir_descriptor_t *desc)
274 {
275 	struct nfs_entry *entry = desc->entry;
276 	int		loop_count = 0,
277 			status;
278 
279 	for(;;) {
280 		status = dir_decode(desc);
281 		if (status)
282 			break;
283 
284 		dfprintk(DIRCACHE, "NFS: found cookie %Lu at index %Ld\n",
285 				(unsigned long long)entry->cookie, desc->current_index);
286 
287 		if (desc->file->f_pos == desc->current_index) {
288 			*desc->dir_cookie = entry->cookie;
289 			break;
290 		}
291 		desc->current_index++;
292 		if (loop_count++ > 200) {
293 			loop_count = 0;
294 			schedule();
295 		}
296 	}
297 	return status;
298 }
299 
300 /*
301  * Find the given page, and call find_dirent() or find_dirent_index in
302  * order to try to return the next entry.
303  */
304 static inline
305 int find_dirent_page(nfs_readdir_descriptor_t *desc)
306 {
307 	struct inode	*inode = desc->file->f_dentry->d_inode;
308 	struct page	*page;
309 	int		status;
310 
311 	dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n",
312 			__FUNCTION__, desc->page_index,
313 			(long long) *desc->dir_cookie);
314 
315 	page = read_cache_page(inode->i_mapping, desc->page_index,
316 			       (filler_t *)nfs_readdir_filler, desc);
317 	if (IS_ERR(page)) {
318 		status = PTR_ERR(page);
319 		goto out;
320 	}
321 	if (!PageUptodate(page))
322 		goto read_error;
323 
324 	/* NOTE: Someone else may have changed the READDIRPLUS flag */
325 	desc->page = page;
326 	desc->ptr = kmap(page);		/* matching kunmap in nfs_do_filldir */
327 	if (*desc->dir_cookie != 0)
328 		status = find_dirent(desc);
329 	else
330 		status = find_dirent_index(desc);
331 	if (status < 0)
332 		dir_page_release(desc);
333  out:
334 	dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, status);
335 	return status;
336  read_error:
337 	page_cache_release(page);
338 	return -EIO;
339 }
340 
341 /*
342  * Recurse through the page cache pages, and return a
343  * filled nfs_entry structure of the next directory entry if possible.
344  *
345  * The target for the search is '*desc->dir_cookie' if non-0,
346  * 'desc->file->f_pos' otherwise
347  */
348 static inline
349 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
350 {
351 	int		loop_count = 0;
352 	int		res;
353 
354 	/* Always search-by-index from the beginning of the cache */
355 	if (*desc->dir_cookie == 0) {
356 		dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for offset %Ld\n",
357 				(long long)desc->file->f_pos);
358 		desc->page_index = 0;
359 		desc->entry->cookie = desc->entry->prev_cookie = 0;
360 		desc->entry->eof = 0;
361 		desc->current_index = 0;
362 	} else
363 		dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for cookie %Lu\n",
364 				(unsigned long long)*desc->dir_cookie);
365 
366 	for (;;) {
367 		res = find_dirent_page(desc);
368 		if (res != -EAGAIN)
369 			break;
370 		/* Align to beginning of next page */
371 		desc->page_index ++;
372 		if (loop_count++ > 200) {
373 			loop_count = 0;
374 			schedule();
375 		}
376 	}
377 
378 	dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, res);
379 	return res;
380 }
381 
382 static inline unsigned int dt_type(struct inode *inode)
383 {
384 	return (inode->i_mode >> 12) & 15;
385 }
386 
387 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc);
388 
389 /*
390  * Once we've found the start of the dirent within a page: fill 'er up...
391  */
392 static
393 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
394 		   filldir_t filldir)
395 {
396 	struct file	*file = desc->file;
397 	struct nfs_entry *entry = desc->entry;
398 	struct dentry	*dentry = NULL;
399 	unsigned long	fileid;
400 	int		loop_count = 0,
401 			res;
402 
403 	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n",
404 			(unsigned long long)entry->cookie);
405 
406 	for(;;) {
407 		unsigned d_type = DT_UNKNOWN;
408 		/* Note: entry->prev_cookie contains the cookie for
409 		 *	 retrieving the current dirent on the server */
410 		fileid = nfs_fileid_to_ino_t(entry->ino);
411 
412 		/* Get a dentry if we have one */
413 		if (dentry != NULL)
414 			dput(dentry);
415 		dentry = nfs_readdir_lookup(desc);
416 
417 		/* Use readdirplus info */
418 		if (dentry != NULL && dentry->d_inode != NULL) {
419 			d_type = dt_type(dentry->d_inode);
420 			fileid = dentry->d_inode->i_ino;
421 		}
422 
423 		res = filldir(dirent, entry->name, entry->len,
424 			      file->f_pos, fileid, d_type);
425 		if (res < 0)
426 			break;
427 		file->f_pos++;
428 		*desc->dir_cookie = entry->cookie;
429 		if (dir_decode(desc) != 0) {
430 			desc->page_index ++;
431 			break;
432 		}
433 		if (loop_count++ > 200) {
434 			loop_count = 0;
435 			schedule();
436 		}
437 	}
438 	dir_page_release(desc);
439 	if (dentry != NULL)
440 		dput(dentry);
441 	dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
442 			(unsigned long long)*desc->dir_cookie, res);
443 	return res;
444 }
445 
446 /*
447  * If we cannot find a cookie in our cache, we suspect that this is
448  * because it points to a deleted file, so we ask the server to return
449  * whatever it thinks is the next entry. We then feed this to filldir.
450  * If all goes well, we should then be able to find our way round the
451  * cache on the next call to readdir_search_pagecache();
452  *
453  * NOTE: we cannot add the anonymous page to the pagecache because
454  *	 the data it contains might not be page aligned. Besides,
455  *	 we should already have a complete representation of the
456  *	 directory in the page cache by the time we get here.
457  */
458 static inline
459 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
460 		     filldir_t filldir)
461 {
462 	struct file	*file = desc->file;
463 	struct inode	*inode = file->f_dentry->d_inode;
464 	struct rpc_cred	*cred = nfs_file_cred(file);
465 	struct page	*page = NULL;
466 	int		status;
467 
468 	dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
469 			(unsigned long long)*desc->dir_cookie);
470 
471 	page = alloc_page(GFP_HIGHUSER);
472 	if (!page) {
473 		status = -ENOMEM;
474 		goto out;
475 	}
476 	desc->error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, *desc->dir_cookie,
477 						page,
478 						NFS_SERVER(inode)->dtsize,
479 						desc->plus);
480 	spin_lock(&inode->i_lock);
481 	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
482 	spin_unlock(&inode->i_lock);
483 	desc->page = page;
484 	desc->ptr = kmap(page);		/* matching kunmap in nfs_do_filldir */
485 	if (desc->error >= 0) {
486 		if ((status = dir_decode(desc)) == 0)
487 			desc->entry->prev_cookie = *desc->dir_cookie;
488 	} else
489 		status = -EIO;
490 	if (status < 0)
491 		goto out_release;
492 
493 	status = nfs_do_filldir(desc, dirent, filldir);
494 
495 	/* Reset read descriptor so it searches the page cache from
496 	 * the start upon the next call to readdir_search_pagecache() */
497 	desc->page_index = 0;
498 	desc->entry->cookie = desc->entry->prev_cookie = 0;
499 	desc->entry->eof = 0;
500  out:
501 	dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
502 			__FUNCTION__, status);
503 	return status;
504  out_release:
505 	dir_page_release(desc);
506 	goto out;
507 }
508 
509 /* The file offset position represents the dirent entry number.  A
510    last cookie cache takes care of the common case of reading the
511    whole directory.
512  */
513 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
514 {
515 	struct dentry	*dentry = filp->f_dentry;
516 	struct inode	*inode = dentry->d_inode;
517 	nfs_readdir_descriptor_t my_desc,
518 			*desc = &my_desc;
519 	struct nfs_entry my_entry;
520 	struct nfs_fh	 fh;
521 	struct nfs_fattr fattr;
522 	long		res;
523 
524 	dfprintk(VFS, "NFS: readdir(%s/%s) starting at cookie %Lu\n",
525 			dentry->d_parent->d_name.name, dentry->d_name.name,
526 			(long long)filp->f_pos);
527 	nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
528 
529 	lock_kernel();
530 
531 	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
532 	if (res < 0) {
533 		unlock_kernel();
534 		return res;
535 	}
536 
537 	/*
538 	 * filp->f_pos points to the dirent entry number.
539 	 * *desc->dir_cookie has the cookie for the next entry. We have
540 	 * to either find the entry with the appropriate number or
541 	 * revalidate the cookie.
542 	 */
543 	memset(desc, 0, sizeof(*desc));
544 
545 	desc->file = filp;
546 	desc->dir_cookie = &((struct nfs_open_context *)filp->private_data)->dir_cookie;
547 	desc->decode = NFS_PROTO(inode)->decode_dirent;
548 	desc->plus = NFS_USE_READDIRPLUS(inode);
549 
550 	my_entry.cookie = my_entry.prev_cookie = 0;
551 	my_entry.eof = 0;
552 	my_entry.fh = &fh;
553 	my_entry.fattr = &fattr;
554 	nfs_fattr_init(&fattr);
555 	desc->entry = &my_entry;
556 
557 	while(!desc->entry->eof) {
558 		res = readdir_search_pagecache(desc);
559 
560 		if (res == -EBADCOOKIE) {
561 			/* This means either end of directory */
562 			if (*desc->dir_cookie && desc->entry->cookie != *desc->dir_cookie) {
563 				/* Or that the server has 'lost' a cookie */
564 				res = uncached_readdir(desc, dirent, filldir);
565 				if (res >= 0)
566 					continue;
567 			}
568 			res = 0;
569 			break;
570 		}
571 		if (res == -ETOOSMALL && desc->plus) {
572 			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
573 			nfs_zap_caches(inode);
574 			desc->plus = 0;
575 			desc->entry->eof = 0;
576 			continue;
577 		}
578 		if (res < 0)
579 			break;
580 
581 		res = nfs_do_filldir(desc, dirent, filldir);
582 		if (res < 0) {
583 			res = 0;
584 			break;
585 		}
586 	}
587 	unlock_kernel();
588 	if (res > 0)
589 		res = 0;
590 	dfprintk(VFS, "NFS: readdir(%s/%s) returns %ld\n",
591 			dentry->d_parent->d_name.name, dentry->d_name.name,
592 			res);
593 	return res;
594 }
595 
596 loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
597 {
598 	mutex_lock(&filp->f_dentry->d_inode->i_mutex);
599 	switch (origin) {
600 		case 1:
601 			offset += filp->f_pos;
602 		case 0:
603 			if (offset >= 0)
604 				break;
605 		default:
606 			offset = -EINVAL;
607 			goto out;
608 	}
609 	if (offset != filp->f_pos) {
610 		filp->f_pos = offset;
611 		((struct nfs_open_context *)filp->private_data)->dir_cookie = 0;
612 	}
613 out:
614 	mutex_unlock(&filp->f_dentry->d_inode->i_mutex);
615 	return offset;
616 }
617 
618 /*
619  * All directory operations under NFS are synchronous, so fsync()
620  * is a dummy operation.
621  */
622 int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
623 {
624 	dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n",
625 			dentry->d_parent->d_name.name, dentry->d_name.name,
626 			datasync);
627 
628 	return 0;
629 }
630 
631 /*
632  * A check for whether or not the parent directory has changed.
633  * In the case it has, we assume that the dentries are untrustworthy
634  * and may need to be looked up again.
635  */
636 static inline int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
637 {
638 	if (IS_ROOT(dentry))
639 		return 1;
640 	if ((NFS_I(dir)->cache_validity & NFS_INO_INVALID_ATTR) != 0
641 			|| nfs_attribute_timeout(dir))
642 		return 0;
643 	return nfs_verify_change_attribute(dir, (unsigned long)dentry->d_fsdata);
644 }
645 
646 static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf)
647 {
648 	dentry->d_fsdata = (void *)verf;
649 }
650 
651 /*
652  * Whenever an NFS operation succeeds, we know that the dentry
653  * is valid, so we update the revalidation timestamp.
654  */
655 static inline void nfs_renew_times(struct dentry * dentry)
656 {
657 	dentry->d_time = jiffies;
658 }
659 
660 /*
661  * Return the intent data that applies to this particular path component
662  *
663  * Note that the current set of intents only apply to the very last
664  * component of the path.
665  * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT.
666  */
667 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask)
668 {
669 	if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))
670 		return 0;
671 	return nd->flags & mask;
672 }
673 
674 /*
675  * Inode and filehandle revalidation for lookups.
676  *
677  * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
678  * or if the intent information indicates that we're about to open this
679  * particular file and the "nocto" mount flag is not set.
680  *
681  */
682 static inline
683 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
684 {
685 	struct nfs_server *server = NFS_SERVER(inode);
686 
687 	if (nd != NULL) {
688 		/* VFS wants an on-the-wire revalidation */
689 		if (nd->flags & LOOKUP_REVAL)
690 			goto out_force;
691 		/* This is an open(2) */
692 		if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
693 				!(server->flags & NFS_MOUNT_NOCTO))
694 			goto out_force;
695 	}
696 	return nfs_revalidate_inode(server, inode);
697 out_force:
698 	return __nfs_revalidate_inode(server, inode);
699 }
700 
701 /*
702  * We judge how long we want to trust negative
703  * dentries by looking at the parent inode mtime.
704  *
705  * If parent mtime has changed, we revalidate, else we wait for a
706  * period corresponding to the parent's attribute cache timeout value.
707  */
708 static inline
709 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
710 		       struct nameidata *nd)
711 {
712 	/* Don't revalidate a negative dentry if we're creating a new file */
713 	if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
714 		return 0;
715 	return !nfs_check_verifier(dir, dentry);
716 }
717 
718 /*
719  * This is called every time the dcache has a lookup hit,
720  * and we should check whether we can really trust that
721  * lookup.
722  *
723  * NOTE! The hit can be a negative hit too, don't assume
724  * we have an inode!
725  *
726  * If the parent directory is seen to have changed, we throw out the
727  * cached dentry and do a new lookup.
728  */
729 static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
730 {
731 	struct inode *dir;
732 	struct inode *inode;
733 	struct dentry *parent;
734 	int error;
735 	struct nfs_fh fhandle;
736 	struct nfs_fattr fattr;
737 	unsigned long verifier;
738 
739 	parent = dget_parent(dentry);
740 	lock_kernel();
741 	dir = parent->d_inode;
742 	nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
743 	inode = dentry->d_inode;
744 
745 	if (!inode) {
746 		if (nfs_neg_need_reval(dir, dentry, nd))
747 			goto out_bad;
748 		goto out_valid;
749 	}
750 
751 	if (is_bad_inode(inode)) {
752 		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
753 				__FUNCTION__, dentry->d_parent->d_name.name,
754 				dentry->d_name.name);
755 		goto out_bad;
756 	}
757 
758 	/* Revalidate parent directory attribute cache */
759 	if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
760 		goto out_zap_parent;
761 
762 	/* Force a full look up iff the parent directory has changed */
763 	if (nfs_check_verifier(dir, dentry)) {
764 		if (nfs_lookup_verify_inode(inode, nd))
765 			goto out_zap_parent;
766 		goto out_valid;
767 	}
768 
769 	if (NFS_STALE(inode))
770 		goto out_bad;
771 
772 	verifier = nfs_save_change_attribute(dir);
773 	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
774 	if (error)
775 		goto out_bad;
776 	if (nfs_compare_fh(NFS_FH(inode), &fhandle))
777 		goto out_bad;
778 	if ((error = nfs_refresh_inode(inode, &fattr)) != 0)
779 		goto out_bad;
780 
781 	nfs_renew_times(dentry);
782 	nfs_set_verifier(dentry, verifier);
783  out_valid:
784 	unlock_kernel();
785 	dput(parent);
786 	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
787 			__FUNCTION__, dentry->d_parent->d_name.name,
788 			dentry->d_name.name);
789 	return 1;
790 out_zap_parent:
791 	nfs_zap_caches(dir);
792  out_bad:
793 	NFS_CACHEINV(dir);
794 	if (inode && S_ISDIR(inode->i_mode)) {
795 		/* Purge readdir caches. */
796 		nfs_zap_caches(inode);
797 		/* If we have submounts, don't unhash ! */
798 		if (have_submounts(dentry))
799 			goto out_valid;
800 		shrink_dcache_parent(dentry);
801 	}
802 	d_drop(dentry);
803 	unlock_kernel();
804 	dput(parent);
805 	dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
806 			__FUNCTION__, dentry->d_parent->d_name.name,
807 			dentry->d_name.name);
808 	return 0;
809 }
810 
811 /*
812  * This is called from dput() when d_count is going to 0.
813  */
814 static int nfs_dentry_delete(struct dentry *dentry)
815 {
816 	dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
817 		dentry->d_parent->d_name.name, dentry->d_name.name,
818 		dentry->d_flags);
819 
820 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
821 		/* Unhash it, so that ->d_iput() would be called */
822 		return 1;
823 	}
824 	if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
825 		/* Unhash it, so that ancestors of killed async unlink
826 		 * files will be cleaned up during umount */
827 		return 1;
828 	}
829 	return 0;
830 
831 }
832 
833 /*
834  * Called when the dentry loses inode.
835  * We use it to clean up silly-renamed files.
836  */
837 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
838 {
839 	nfs_inode_return_delegation(inode);
840 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
841 		lock_kernel();
842 		inode->i_nlink--;
843 		nfs_complete_unlink(dentry);
844 		unlock_kernel();
845 	}
846 	/* When creating a negative dentry, we want to renew d_time */
847 	nfs_renew_times(dentry);
848 	iput(inode);
849 }
850 
851 struct dentry_operations nfs_dentry_operations = {
852 	.d_revalidate	= nfs_lookup_revalidate,
853 	.d_delete	= nfs_dentry_delete,
854 	.d_iput		= nfs_dentry_iput,
855 };
856 
857 /*
858  * Use intent information to check whether or not we're going to do
859  * an O_EXCL create using this path component.
860  */
861 static inline
862 int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
863 {
864 	if (NFS_PROTO(dir)->version == 2)
865 		return 0;
866 	if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_CREATE) == 0)
867 		return 0;
868 	return (nd->intent.open.flags & O_EXCL) != 0;
869 }
870 
871 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
872 {
873 	struct dentry *res;
874 	struct inode *inode = NULL;
875 	int error;
876 	struct nfs_fh fhandle;
877 	struct nfs_fattr fattr;
878 
879 	dfprintk(VFS, "NFS: lookup(%s/%s)\n",
880 		dentry->d_parent->d_name.name, dentry->d_name.name);
881 	nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
882 
883 	res = ERR_PTR(-ENAMETOOLONG);
884 	if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
885 		goto out;
886 
887 	res = ERR_PTR(-ENOMEM);
888 	dentry->d_op = NFS_PROTO(dir)->dentry_ops;
889 
890 	lock_kernel();
891 
892 	/* If we're doing an exclusive create, optimize away the lookup */
893 	if (nfs_is_exclusive_create(dir, nd))
894 		goto no_entry;
895 
896 	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
897 	if (error == -ENOENT)
898 		goto no_entry;
899 	if (error < 0) {
900 		res = ERR_PTR(error);
901 		goto out_unlock;
902 	}
903 	inode = nfs_fhget(dentry->d_sb, &fhandle, &fattr);
904 	res = (struct dentry *)inode;
905 	if (IS_ERR(res))
906 		goto out_unlock;
907 no_entry:
908 	res = d_add_unique(dentry, inode);
909 	if (res != NULL)
910 		dentry = res;
911 	nfs_renew_times(dentry);
912 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
913 out_unlock:
914 	unlock_kernel();
915 out:
916 	return res;
917 }
918 
919 #ifdef CONFIG_NFS_V4
920 static int nfs_open_revalidate(struct dentry *, struct nameidata *);
921 
922 struct dentry_operations nfs4_dentry_operations = {
923 	.d_revalidate	= nfs_open_revalidate,
924 	.d_delete	= nfs_dentry_delete,
925 	.d_iput		= nfs_dentry_iput,
926 };
927 
928 /*
929  * Use intent information to determine whether we need to substitute
930  * the NFSv4-style stateful OPEN for the LOOKUP call
931  */
932 static int is_atomic_open(struct inode *dir, struct nameidata *nd)
933 {
934 	if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
935 		return 0;
936 	/* NFS does not (yet) have a stateful open for directories */
937 	if (nd->flags & LOOKUP_DIRECTORY)
938 		return 0;
939 	/* Are we trying to write to a read only partition? */
940 	if (IS_RDONLY(dir) && (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
941 		return 0;
942 	return 1;
943 }
944 
945 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
946 {
947 	struct dentry *res = NULL;
948 	int error;
949 
950 	dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
951 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
952 
953 	/* Check that we are indeed trying to open this file */
954 	if (!is_atomic_open(dir, nd))
955 		goto no_open;
956 
957 	if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
958 		res = ERR_PTR(-ENAMETOOLONG);
959 		goto out;
960 	}
961 	dentry->d_op = NFS_PROTO(dir)->dentry_ops;
962 
963 	/* Let vfs_create() deal with O_EXCL */
964 	if (nd->intent.open.flags & O_EXCL) {
965 		d_add(dentry, NULL);
966 		goto out;
967 	}
968 
969 	/* Open the file on the server */
970 	lock_kernel();
971 	/* Revalidate parent directory attribute cache */
972 	error = nfs_revalidate_inode(NFS_SERVER(dir), dir);
973 	if (error < 0) {
974 		res = ERR_PTR(error);
975 		unlock_kernel();
976 		goto out;
977 	}
978 
979 	if (nd->intent.open.flags & O_CREAT) {
980 		nfs_begin_data_update(dir);
981 		res = nfs4_atomic_open(dir, dentry, nd);
982 		nfs_end_data_update(dir);
983 	} else
984 		res = nfs4_atomic_open(dir, dentry, nd);
985 	unlock_kernel();
986 	if (IS_ERR(res)) {
987 		error = PTR_ERR(res);
988 		switch (error) {
989 			/* Make a negative dentry */
990 			case -ENOENT:
991 				res = NULL;
992 				goto out;
993 			/* This turned out not to be a regular file */
994 			case -EISDIR:
995 			case -ENOTDIR:
996 				goto no_open;
997 			case -ELOOP:
998 				if (!(nd->intent.open.flags & O_NOFOLLOW))
999 					goto no_open;
1000 			/* case -EINVAL: */
1001 			default:
1002 				goto out;
1003 		}
1004 	} else if (res != NULL)
1005 		dentry = res;
1006 	nfs_renew_times(dentry);
1007 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1008 out:
1009 	return res;
1010 no_open:
1011 	return nfs_lookup(dir, dentry, nd);
1012 }
1013 
1014 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
1015 {
1016 	struct dentry *parent = NULL;
1017 	struct inode *inode = dentry->d_inode;
1018 	struct inode *dir;
1019 	unsigned long verifier;
1020 	int openflags, ret = 0;
1021 
1022 	parent = dget_parent(dentry);
1023 	dir = parent->d_inode;
1024 	if (!is_atomic_open(dir, nd))
1025 		goto no_open;
1026 	/* We can't create new files in nfs_open_revalidate(), so we
1027 	 * optimize away revalidation of negative dentries.
1028 	 */
1029 	if (inode == NULL)
1030 		goto out;
1031 	/* NFS only supports OPEN on regular files */
1032 	if (!S_ISREG(inode->i_mode))
1033 		goto no_open;
1034 	openflags = nd->intent.open.flags;
1035 	/* We cannot do exclusive creation on a positive dentry */
1036 	if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
1037 		goto no_open;
1038 	/* We can't create new files, or truncate existing ones here */
1039 	openflags &= ~(O_CREAT|O_TRUNC);
1040 
1041 	/*
1042 	 * Note: we're not holding inode->i_mutex and so may be racing with
1043 	 * operations that change the directory. We therefore save the
1044 	 * change attribute *before* we do the RPC call.
1045 	 */
1046 	lock_kernel();
1047 	verifier = nfs_save_change_attribute(dir);
1048 	ret = nfs4_open_revalidate(dir, dentry, openflags, nd);
1049 	if (!ret)
1050 		nfs_set_verifier(dentry, verifier);
1051 	unlock_kernel();
1052 out:
1053 	dput(parent);
1054 	if (!ret)
1055 		d_drop(dentry);
1056 	return ret;
1057 no_open:
1058 	dput(parent);
1059 	if (inode != NULL && nfs_have_delegation(inode, FMODE_READ))
1060 		return 1;
1061 	return nfs_lookup_revalidate(dentry, nd);
1062 }
1063 #endif /* CONFIG_NFSV4 */
1064 
1065 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc)
1066 {
1067 	struct dentry *parent = desc->file->f_dentry;
1068 	struct inode *dir = parent->d_inode;
1069 	struct nfs_entry *entry = desc->entry;
1070 	struct dentry *dentry, *alias;
1071 	struct qstr name = {
1072 		.name = entry->name,
1073 		.len = entry->len,
1074 	};
1075 	struct inode *inode;
1076 
1077 	switch (name.len) {
1078 		case 2:
1079 			if (name.name[0] == '.' && name.name[1] == '.')
1080 				return dget_parent(parent);
1081 			break;
1082 		case 1:
1083 			if (name.name[0] == '.')
1084 				return dget(parent);
1085 	}
1086 	name.hash = full_name_hash(name.name, name.len);
1087 	dentry = d_lookup(parent, &name);
1088 	if (dentry != NULL)
1089 		return dentry;
1090 	if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR))
1091 		return NULL;
1092 	/* Note: caller is already holding the dir->i_mutex! */
1093 	dentry = d_alloc(parent, &name);
1094 	if (dentry == NULL)
1095 		return NULL;
1096 	dentry->d_op = NFS_PROTO(dir)->dentry_ops;
1097 	inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
1098 	if (IS_ERR(inode)) {
1099 		dput(dentry);
1100 		return NULL;
1101 	}
1102 	alias = d_add_unique(dentry, inode);
1103 	if (alias != NULL) {
1104 		dput(dentry);
1105 		dentry = alias;
1106 	}
1107 	nfs_renew_times(dentry);
1108 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1109 	return dentry;
1110 }
1111 
1112 /*
1113  * Code common to create, mkdir, and mknod.
1114  */
1115 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1116 				struct nfs_fattr *fattr)
1117 {
1118 	struct inode *inode;
1119 	int error = -EACCES;
1120 
1121 	/* We may have been initialized further down */
1122 	if (dentry->d_inode)
1123 		return 0;
1124 	if (fhandle->size == 0) {
1125 		struct inode *dir = dentry->d_parent->d_inode;
1126 		error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1127 		if (error)
1128 			goto out_err;
1129 	}
1130 	if (!(fattr->valid & NFS_ATTR_FATTR)) {
1131 		struct nfs_server *server = NFS_SB(dentry->d_sb);
1132 		error = server->rpc_ops->getattr(server, fhandle, fattr);
1133 		if (error < 0)
1134 			goto out_err;
1135 	}
1136 	inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1137 	error = PTR_ERR(inode);
1138 	if (IS_ERR(inode))
1139 		goto out_err;
1140 	d_instantiate(dentry, inode);
1141 	return 0;
1142 out_err:
1143 	d_drop(dentry);
1144 	return error;
1145 }
1146 
1147 /*
1148  * Following a failed create operation, we drop the dentry rather
1149  * than retain a negative dentry. This avoids a problem in the event
1150  * that the operation succeeded on the server, but an error in the
1151  * reply path made it appear to have failed.
1152  */
1153 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
1154 		struct nameidata *nd)
1155 {
1156 	struct iattr attr;
1157 	int error;
1158 	int open_flags = 0;
1159 
1160 	dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1161 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1162 
1163 	attr.ia_mode = mode;
1164 	attr.ia_valid = ATTR_MODE;
1165 
1166 	if (nd && (nd->flags & LOOKUP_CREATE))
1167 		open_flags = nd->intent.open.flags;
1168 
1169 	lock_kernel();
1170 	nfs_begin_data_update(dir);
1171 	error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, nd);
1172 	nfs_end_data_update(dir);
1173 	if (error != 0)
1174 		goto out_err;
1175 	nfs_renew_times(dentry);
1176 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1177 	unlock_kernel();
1178 	return 0;
1179 out_err:
1180 	unlock_kernel();
1181 	d_drop(dentry);
1182 	return error;
1183 }
1184 
1185 /*
1186  * See comments for nfs_proc_create regarding failed operations.
1187  */
1188 static int
1189 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1190 {
1191 	struct iattr attr;
1192 	int status;
1193 
1194 	dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
1195 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1196 
1197 	if (!new_valid_dev(rdev))
1198 		return -EINVAL;
1199 
1200 	attr.ia_mode = mode;
1201 	attr.ia_valid = ATTR_MODE;
1202 
1203 	lock_kernel();
1204 	nfs_begin_data_update(dir);
1205 	status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1206 	nfs_end_data_update(dir);
1207 	if (status != 0)
1208 		goto out_err;
1209 	nfs_renew_times(dentry);
1210 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1211 	unlock_kernel();
1212 	return 0;
1213 out_err:
1214 	unlock_kernel();
1215 	d_drop(dentry);
1216 	return status;
1217 }
1218 
1219 /*
1220  * See comments for nfs_proc_create regarding failed operations.
1221  */
1222 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1223 {
1224 	struct iattr attr;
1225 	int error;
1226 
1227 	dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
1228 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1229 
1230 	attr.ia_valid = ATTR_MODE;
1231 	attr.ia_mode = mode | S_IFDIR;
1232 
1233 	lock_kernel();
1234 	nfs_begin_data_update(dir);
1235 	error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1236 	nfs_end_data_update(dir);
1237 	if (error != 0)
1238 		goto out_err;
1239 	nfs_renew_times(dentry);
1240 	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1241 	unlock_kernel();
1242 	return 0;
1243 out_err:
1244 	d_drop(dentry);
1245 	unlock_kernel();
1246 	return error;
1247 }
1248 
1249 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1250 {
1251 	int error;
1252 
1253 	dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
1254 			dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1255 
1256 	lock_kernel();
1257 	nfs_begin_data_update(dir);
1258 	error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1259 	/* Ensure the VFS deletes this inode */
1260 	if (error == 0 && dentry->d_inode != NULL)
1261 		dentry->d_inode->i_nlink = 0;
1262 	nfs_end_data_update(dir);
1263 	unlock_kernel();
1264 
1265 	return error;
1266 }
1267 
1268 static int nfs_sillyrename(struct inode *dir, struct dentry *dentry)
1269 {
1270 	static unsigned int sillycounter;
1271 	const int      i_inosize  = sizeof(dir->i_ino)*2;
1272 	const int      countersize = sizeof(sillycounter)*2;
1273 	const int      slen       = sizeof(".nfs") + i_inosize + countersize - 1;
1274 	char           silly[slen+1];
1275 	struct qstr    qsilly;
1276 	struct dentry *sdentry;
1277 	int            error = -EIO;
1278 
1279 	dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
1280 		dentry->d_parent->d_name.name, dentry->d_name.name,
1281 		atomic_read(&dentry->d_count));
1282 	nfs_inc_stats(dir, NFSIOS_SILLYRENAME);
1283 
1284 #ifdef NFS_PARANOIA
1285 if (!dentry->d_inode)
1286 printk("NFS: silly-renaming %s/%s, negative dentry??\n",
1287 dentry->d_parent->d_name.name, dentry->d_name.name);
1288 #endif
1289 	/*
1290 	 * We don't allow a dentry to be silly-renamed twice.
1291 	 */
1292 	error = -EBUSY;
1293 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1294 		goto out;
1295 
1296 	sprintf(silly, ".nfs%*.*lx",
1297 		i_inosize, i_inosize, dentry->d_inode->i_ino);
1298 
1299 	/* Return delegation in anticipation of the rename */
1300 	nfs_inode_return_delegation(dentry->d_inode);
1301 
1302 	sdentry = NULL;
1303 	do {
1304 		char *suffix = silly + slen - countersize;
1305 
1306 		dput(sdentry);
1307 		sillycounter++;
1308 		sprintf(suffix, "%*.*x", countersize, countersize, sillycounter);
1309 
1310 		dfprintk(VFS, "NFS: trying to rename %s to %s\n",
1311 				dentry->d_name.name, silly);
1312 
1313 		sdentry = lookup_one_len(silly, dentry->d_parent, slen);
1314 		/*
1315 		 * N.B. Better to return EBUSY here ... it could be
1316 		 * dangerous to delete the file while it's in use.
1317 		 */
1318 		if (IS_ERR(sdentry))
1319 			goto out;
1320 	} while(sdentry->d_inode != NULL); /* need negative lookup */
1321 
1322 	qsilly.name = silly;
1323 	qsilly.len  = strlen(silly);
1324 	nfs_begin_data_update(dir);
1325 	if (dentry->d_inode) {
1326 		nfs_begin_data_update(dentry->d_inode);
1327 		error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1328 				dir, &qsilly);
1329 		nfs_mark_for_revalidate(dentry->d_inode);
1330 		nfs_end_data_update(dentry->d_inode);
1331 	} else
1332 		error = NFS_PROTO(dir)->rename(dir, &dentry->d_name,
1333 				dir, &qsilly);
1334 	nfs_end_data_update(dir);
1335 	if (!error) {
1336 		nfs_renew_times(dentry);
1337 		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1338 		d_move(dentry, sdentry);
1339 		error = nfs_async_unlink(dentry);
1340  		/* If we return 0 we don't unlink */
1341 	}
1342 	dput(sdentry);
1343 out:
1344 	return error;
1345 }
1346 
1347 /*
1348  * Remove a file after making sure there are no pending writes,
1349  * and after checking that the file has only one user.
1350  *
1351  * We invalidate the attribute cache and free the inode prior to the operation
1352  * to avoid possible races if the server reuses the inode.
1353  */
1354 static int nfs_safe_remove(struct dentry *dentry)
1355 {
1356 	struct inode *dir = dentry->d_parent->d_inode;
1357 	struct inode *inode = dentry->d_inode;
1358 	int error = -EBUSY;
1359 
1360 	dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1361 		dentry->d_parent->d_name.name, dentry->d_name.name);
1362 
1363 	/* If the dentry was sillyrenamed, we simply call d_delete() */
1364 	if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1365 		error = 0;
1366 		goto out;
1367 	}
1368 
1369 	nfs_begin_data_update(dir);
1370 	if (inode != NULL) {
1371 		nfs_inode_return_delegation(inode);
1372 		nfs_begin_data_update(inode);
1373 		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1374 		/* The VFS may want to delete this inode */
1375 		if (error == 0)
1376 			inode->i_nlink--;
1377 		nfs_mark_for_revalidate(inode);
1378 		nfs_end_data_update(inode);
1379 	} else
1380 		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1381 	nfs_end_data_update(dir);
1382 out:
1383 	return error;
1384 }
1385 
1386 /*  We do silly rename. In case sillyrename() returns -EBUSY, the inode
1387  *  belongs to an active ".nfs..." file and we return -EBUSY.
1388  *
1389  *  If sillyrename() returns 0, we do nothing, otherwise we unlink.
1390  */
1391 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1392 {
1393 	int error;
1394 	int need_rehash = 0;
1395 
1396 	dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1397 		dir->i_ino, dentry->d_name.name);
1398 
1399 	lock_kernel();
1400 	spin_lock(&dcache_lock);
1401 	spin_lock(&dentry->d_lock);
1402 	if (atomic_read(&dentry->d_count) > 1) {
1403 		spin_unlock(&dentry->d_lock);
1404 		spin_unlock(&dcache_lock);
1405 		error = nfs_sillyrename(dir, dentry);
1406 		unlock_kernel();
1407 		return error;
1408 	}
1409 	if (!d_unhashed(dentry)) {
1410 		__d_drop(dentry);
1411 		need_rehash = 1;
1412 	}
1413 	spin_unlock(&dentry->d_lock);
1414 	spin_unlock(&dcache_lock);
1415 	error = nfs_safe_remove(dentry);
1416 	if (!error) {
1417 		nfs_renew_times(dentry);
1418 		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1419 	} else if (need_rehash)
1420 		d_rehash(dentry);
1421 	unlock_kernel();
1422 	return error;
1423 }
1424 
1425 static int
1426 nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1427 {
1428 	struct iattr attr;
1429 	struct nfs_fattr sym_attr;
1430 	struct nfs_fh sym_fh;
1431 	struct qstr qsymname;
1432 	int error;
1433 
1434 	dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1435 		dir->i_ino, dentry->d_name.name, symname);
1436 
1437 #ifdef NFS_PARANOIA
1438 if (dentry->d_inode)
1439 printk("nfs_proc_symlink: %s/%s not negative!\n",
1440 dentry->d_parent->d_name.name, dentry->d_name.name);
1441 #endif
1442 	/*
1443 	 * Fill in the sattr for the call.
1444  	 * Note: SunOS 4.1.2 crashes if the mode isn't initialized!
1445 	 */
1446 	attr.ia_valid = ATTR_MODE;
1447 	attr.ia_mode = S_IFLNK | S_IRWXUGO;
1448 
1449 	qsymname.name = symname;
1450 	qsymname.len  = strlen(symname);
1451 
1452 	lock_kernel();
1453 	nfs_begin_data_update(dir);
1454 	error = NFS_PROTO(dir)->symlink(dir, &dentry->d_name, &qsymname,
1455 					  &attr, &sym_fh, &sym_attr);
1456 	nfs_end_data_update(dir);
1457 	if (!error) {
1458 		error = nfs_instantiate(dentry, &sym_fh, &sym_attr);
1459 	} else {
1460 		if (error == -EEXIST)
1461 			printk("nfs_proc_symlink: %s/%s already exists??\n",
1462 			       dentry->d_parent->d_name.name, dentry->d_name.name);
1463 		d_drop(dentry);
1464 	}
1465 	unlock_kernel();
1466 	return error;
1467 }
1468 
1469 static int
1470 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1471 {
1472 	struct inode *inode = old_dentry->d_inode;
1473 	int error;
1474 
1475 	dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1476 		old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1477 		dentry->d_parent->d_name.name, dentry->d_name.name);
1478 
1479 	lock_kernel();
1480 	nfs_begin_data_update(dir);
1481 	nfs_begin_data_update(inode);
1482 	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1483 	if (error == 0) {
1484 		atomic_inc(&inode->i_count);
1485 		d_instantiate(dentry, inode);
1486 	}
1487 	nfs_end_data_update(inode);
1488 	nfs_end_data_update(dir);
1489 	unlock_kernel();
1490 	return error;
1491 }
1492 
1493 /*
1494  * RENAME
1495  * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1496  * different file handle for the same inode after a rename (e.g. when
1497  * moving to a different directory). A fail-safe method to do so would
1498  * be to look up old_dir/old_name, create a link to new_dir/new_name and
1499  * rename the old file using the sillyrename stuff. This way, the original
1500  * file in old_dir will go away when the last process iput()s the inode.
1501  *
1502  * FIXED.
1503  *
1504  * It actually works quite well. One needs to have the possibility for
1505  * at least one ".nfs..." file in each directory the file ever gets
1506  * moved or linked to which happens automagically with the new
1507  * implementation that only depends on the dcache stuff instead of
1508  * using the inode layer
1509  *
1510  * Unfortunately, things are a little more complicated than indicated
1511  * above. For a cross-directory move, we want to make sure we can get
1512  * rid of the old inode after the operation.  This means there must be
1513  * no pending writes (if it's a file), and the use count must be 1.
1514  * If these conditions are met, we can drop the dentries before doing
1515  * the rename.
1516  */
1517 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1518 		      struct inode *new_dir, struct dentry *new_dentry)
1519 {
1520 	struct inode *old_inode = old_dentry->d_inode;
1521 	struct inode *new_inode = new_dentry->d_inode;
1522 	struct dentry *dentry = NULL, *rehash = NULL;
1523 	int error = -EBUSY;
1524 
1525 	/*
1526 	 * To prevent any new references to the target during the rename,
1527 	 * we unhash the dentry and free the inode in advance.
1528 	 */
1529 	lock_kernel();
1530 	if (!d_unhashed(new_dentry)) {
1531 		d_drop(new_dentry);
1532 		rehash = new_dentry;
1533 	}
1534 
1535 	dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1536 		 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1537 		 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1538 		 atomic_read(&new_dentry->d_count));
1539 
1540 	/*
1541 	 * First check whether the target is busy ... we can't
1542 	 * safely do _any_ rename if the target is in use.
1543 	 *
1544 	 * For files, make a copy of the dentry and then do a
1545 	 * silly-rename. If the silly-rename succeeds, the
1546 	 * copied dentry is hashed and becomes the new target.
1547 	 */
1548 	if (!new_inode)
1549 		goto go_ahead;
1550 	if (S_ISDIR(new_inode->i_mode)) {
1551 		error = -EISDIR;
1552 		if (!S_ISDIR(old_inode->i_mode))
1553 			goto out;
1554 	} else if (atomic_read(&new_dentry->d_count) > 2) {
1555 		int err;
1556 		/* copy the target dentry's name */
1557 		dentry = d_alloc(new_dentry->d_parent,
1558 				 &new_dentry->d_name);
1559 		if (!dentry)
1560 			goto out;
1561 
1562 		/* silly-rename the existing target ... */
1563 		err = nfs_sillyrename(new_dir, new_dentry);
1564 		if (!err) {
1565 			new_dentry = rehash = dentry;
1566 			new_inode = NULL;
1567 			/* instantiate the replacement target */
1568 			d_instantiate(new_dentry, NULL);
1569 		} else if (atomic_read(&new_dentry->d_count) > 1) {
1570 		/* dentry still busy? */
1571 #ifdef NFS_PARANOIA
1572 			printk("nfs_rename: target %s/%s busy, d_count=%d\n",
1573 			       new_dentry->d_parent->d_name.name,
1574 			       new_dentry->d_name.name,
1575 			       atomic_read(&new_dentry->d_count));
1576 #endif
1577 			goto out;
1578 		}
1579 	} else
1580 		new_inode->i_nlink--;
1581 
1582 go_ahead:
1583 	/*
1584 	 * ... prune child dentries and writebacks if needed.
1585 	 */
1586 	if (atomic_read(&old_dentry->d_count) > 1) {
1587 		nfs_wb_all(old_inode);
1588 		shrink_dcache_parent(old_dentry);
1589 	}
1590 	nfs_inode_return_delegation(old_inode);
1591 
1592 	if (new_inode != NULL) {
1593 		nfs_inode_return_delegation(new_inode);
1594 		d_delete(new_dentry);
1595 	}
1596 
1597 	nfs_begin_data_update(old_dir);
1598 	nfs_begin_data_update(new_dir);
1599 	nfs_begin_data_update(old_inode);
1600 	error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1601 					   new_dir, &new_dentry->d_name);
1602 	nfs_mark_for_revalidate(old_inode);
1603 	nfs_end_data_update(old_inode);
1604 	nfs_end_data_update(new_dir);
1605 	nfs_end_data_update(old_dir);
1606 out:
1607 	if (rehash)
1608 		d_rehash(rehash);
1609 	if (!error) {
1610 		if (!S_ISDIR(old_inode->i_mode))
1611 			d_move(old_dentry, new_dentry);
1612 		nfs_renew_times(new_dentry);
1613 		nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir));
1614 	}
1615 
1616 	/* new dentry created? */
1617 	if (dentry)
1618 		dput(dentry);
1619 	unlock_kernel();
1620 	return error;
1621 }
1622 
1623 int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
1624 {
1625 	struct nfs_inode *nfsi = NFS_I(inode);
1626 	struct nfs_access_entry *cache = &nfsi->cache_access;
1627 
1628 	if (cache->cred != cred
1629 			|| time_after(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode))
1630 			|| (nfsi->cache_validity & NFS_INO_INVALID_ACCESS))
1631 		return -ENOENT;
1632 	memcpy(res, cache, sizeof(*res));
1633 	return 0;
1634 }
1635 
1636 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
1637 {
1638 	struct nfs_inode *nfsi = NFS_I(inode);
1639 	struct nfs_access_entry *cache = &nfsi->cache_access;
1640 
1641 	if (cache->cred != set->cred) {
1642 		if (cache->cred)
1643 			put_rpccred(cache->cred);
1644 		cache->cred = get_rpccred(set->cred);
1645 	}
1646 	/* FIXME: replace current access_cache BKL reliance with inode->i_lock */
1647 	spin_lock(&inode->i_lock);
1648 	nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
1649 	spin_unlock(&inode->i_lock);
1650 	cache->jiffies = set->jiffies;
1651 	cache->mask = set->mask;
1652 }
1653 
1654 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
1655 {
1656 	struct nfs_access_entry cache;
1657 	int status;
1658 
1659 	status = nfs_access_get_cached(inode, cred, &cache);
1660 	if (status == 0)
1661 		goto out;
1662 
1663 	/* Be clever: ask server to check for all possible rights */
1664 	cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
1665 	cache.cred = cred;
1666 	cache.jiffies = jiffies;
1667 	status = NFS_PROTO(inode)->access(inode, &cache);
1668 	if (status != 0)
1669 		return status;
1670 	nfs_access_add_cache(inode, &cache);
1671 out:
1672 	if ((cache.mask & mask) == mask)
1673 		return 0;
1674 	return -EACCES;
1675 }
1676 
1677 int nfs_permission(struct inode *inode, int mask, struct nameidata *nd)
1678 {
1679 	struct rpc_cred *cred;
1680 	int res = 0;
1681 
1682 	nfs_inc_stats(inode, NFSIOS_VFSACCESS);
1683 
1684 	if (mask == 0)
1685 		goto out;
1686 	/* Is this sys_access() ? */
1687 	if (nd != NULL && (nd->flags & LOOKUP_ACCESS))
1688 		goto force_lookup;
1689 
1690 	switch (inode->i_mode & S_IFMT) {
1691 		case S_IFLNK:
1692 			goto out;
1693 		case S_IFREG:
1694 			/* NFSv4 has atomic_open... */
1695 			if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
1696 					&& nd != NULL
1697 					&& (nd->flags & LOOKUP_OPEN))
1698 				goto out;
1699 			break;
1700 		case S_IFDIR:
1701 			/*
1702 			 * Optimize away all write operations, since the server
1703 			 * will check permissions when we perform the op.
1704 			 */
1705 			if ((mask & MAY_WRITE) && !(mask & MAY_READ))
1706 				goto out;
1707 	}
1708 
1709 force_lookup:
1710 	lock_kernel();
1711 
1712 	if (!NFS_PROTO(inode)->access)
1713 		goto out_notsup;
1714 
1715 	cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
1716 	if (!IS_ERR(cred)) {
1717 		res = nfs_do_access(inode, cred, mask);
1718 		put_rpccred(cred);
1719 	} else
1720 		res = PTR_ERR(cred);
1721 	unlock_kernel();
1722 out:
1723 	dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
1724 		inode->i_sb->s_id, inode->i_ino, mask, res);
1725 	return res;
1726 out_notsup:
1727 	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
1728 	if (res == 0)
1729 		res = generic_permission(inode, mask, NULL);
1730 	unlock_kernel();
1731 	goto out;
1732 }
1733 
1734 /*
1735  * Local variables:
1736  *  version-control: t
1737  *  kept-new-versions: 5
1738  * End:
1739  */
1740