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/sched.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/malloc.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
34 #define NFS_PARANOIA 1
35 /* #define NFS_DEBUG_VERBOSE 1 */
36
37 static int nfs_readdir(struct file *, void *, filldir_t);
38 static struct dentry *nfs_lookup(struct inode *, struct dentry *);
39 static int nfs_create(struct inode *, struct dentry *, int);
40 static int nfs_mkdir(struct inode *, struct dentry *, int);
41 static int nfs_rmdir(struct inode *, struct dentry *);
42 static int nfs_unlink(struct inode *, struct dentry *);
43 static int nfs_symlink(struct inode *, struct dentry *, const char *);
44 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
45 static int nfs_mknod(struct inode *, struct dentry *, int, int);
46 static int nfs_rename(struct inode *, struct dentry *,
47 struct inode *, struct dentry *);
48
49 struct file_operations nfs_dir_operations = {
50 read: generic_read_dir,
51 readdir: nfs_readdir,
52 open: nfs_open,
53 release: nfs_release,
54 };
55
56 struct inode_operations nfs_dir_inode_operations = {
57 create: nfs_create,
58 lookup: nfs_lookup,
59 link: nfs_link,
60 unlink: nfs_unlink,
61 symlink: nfs_symlink,
62 mkdir: nfs_mkdir,
63 rmdir: nfs_rmdir,
64 mknod: nfs_mknod,
65 rename: nfs_rename,
66 permission: nfs_permission,
67 revalidate: nfs_revalidate,
68 setattr: nfs_notify_change,
69 };
70
71 typedef u32 * (*decode_dirent_t)(u32 *, struct nfs_entry *, int);
72 typedef struct {
73 struct file *file;
74 struct page *page;
75 unsigned long page_index;
76 unsigned page_offset;
77 u64 target;
78 struct nfs_entry *entry;
79 decode_dirent_t decode;
80 int plus;
81 int error;
82 } nfs_readdir_descriptor_t;
83
84 /* Now we cache directories properly, by stuffing the dirent
85 * data directly in the page cache.
86 *
87 * Inode invalidation due to refresh etc. takes care of
88 * _everything_, no sloppy entry flushing logic, no extraneous
89 * copying, network direct to page cache, the way it was meant
90 * to be.
91 *
92 * NOTE: Dirent information verification is done always by the
93 * page-in of the RPC reply, nowhere else, this simplies
94 * things substantially.
95 */
96 static
97 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
98 {
99 struct file *file = desc->file;
100 struct inode *inode = file->f_dentry->d_inode;
101 struct rpc_cred *cred = nfs_file_cred(file);
102 void *buffer = kmap(page);
103 int plus = NFS_USE_READDIRPLUS(inode);
104 int error;
105
106 dfprintk(VFS, "NFS: nfs_readdir_filler() reading cookie %Lu into page %lu.\n", (long long)desc->entry->cookie, page->index);
107
108 again:
109 error = NFS_PROTO(inode)->readdir(inode, cred, desc->entry->cookie, buffer,
110 NFS_SERVER(inode)->dtsize, plus);
111 /* We requested READDIRPLUS, but the server doesn't grok it */
112 if (desc->plus && error == -ENOTSUPP) {
113 NFS_FLAGS(inode) &= ~NFS_INO_ADVISE_RDPLUS;
114 plus = 0;
115 goto again;
116 }
117 if (error < 0)
118 goto error;
119 SetPageUptodate(page);
120 kunmap(page);
121 /* Ensure consistent page alignment of the data.
122 * Note: assumes we have exclusive access to this mapping either
123 * throught inode->i_sem or some other mechanism.
124 */
125 if (page->index == 0)
126 invalidate_inode_pages(inode);
127 UnlockPage(page);
128 return 0;
129 error:
130 SetPageError(page);
131 kunmap(page);
132 UnlockPage(page);
133 invalidate_inode_pages(inode);
134 desc->error = error;
135 return -EIO;
136 }
137
138 /*
139 * Given a pointer to a buffer that has already been filled by a call
140 * to readdir, find the next entry.
141 *
142 * If the end of the buffer has been reached, return -EAGAIN, if not,
143 * return the offset within the buffer of the next entry to be
144 * read.
145 */
146 static inline
147 int find_dirent(nfs_readdir_descriptor_t *desc, struct page *page)
148 {
149 struct nfs_entry *entry = desc->entry;
150 char *start = kmap(page),
151 *p = start;
152 int loop_count = 0,
153 status = 0;
154
155 for(;;) {
156 p = (char *)desc->decode((u32*)p, entry, desc->plus);
157 if (IS_ERR(p)) {
158 status = PTR_ERR(p);
159 break;
160 }
161 desc->page_offset = p - start;
162 dfprintk(VFS, "NFS: found cookie %Lu\n", (long long)entry->cookie);
163 if (entry->prev_cookie == desc->target)
164 break;
165 if (loop_count++ > 200) {
166 loop_count = 0;
167 schedule();
168 }
169 }
170 kunmap(page);
171 dfprintk(VFS, "NFS: find_dirent() returns %d\n", status);
172 return status;
173 }
174
175 /*
176 * Find the given page, and call find_dirent() in order to try to
177 * return the next entry.
178 */
179 static inline
180 int find_dirent_page(nfs_readdir_descriptor_t *desc)
181 {
182 struct inode *inode = desc->file->f_dentry->d_inode;
183 struct page *page;
184 unsigned long index = desc->page_index;
185 int status;
186
187 dfprintk(VFS, "NFS: find_dirent_page() searching directory page %ld\n", desc->page_index);
188
189 if (desc->page) {
190 page_cache_release(desc->page);
191 desc->page = NULL;
192 }
193
194 page = read_cache_page(&inode->i_data, index,
195 (filler_t *)nfs_readdir_filler, desc);
196 if (IS_ERR(page)) {
197 status = PTR_ERR(page);
198 goto out;
199 }
200 if (!Page_Uptodate(page))
201 goto read_error;
202
203 /* NOTE: Someone else may have changed the READDIRPLUS flag */
204 desc->plus = NFS_USE_READDIRPLUS(inode);
205 status = find_dirent(desc, page);
206 if (status >= 0)
207 desc->page = page;
208 else
209 page_cache_release(page);
210 out:
211 dfprintk(VFS, "NFS: find_dirent_page() returns %d\n", status);
212 return status;
213 read_error:
214 page_cache_release(page);
215 return -EIO;
216 }
217
218 /*
219 * Recurse through the page cache pages, and return a
220 * filled nfs_entry structure of the next directory entry if possible.
221 *
222 * The target for the search is 'desc->target'.
223 */
224 static inline
225 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
226 {
227 int res = 0;
228 int loop_count = 0;
229
230 dfprintk(VFS, "NFS: readdir_search_pagecache() searching for cookie %Lu\n", (long long)desc->target);
231 for (;;) {
232 res = find_dirent_page(desc);
233 if (res != -EAGAIN)
234 break;
235 /* Align to beginning of next page */
236 desc->page_offset = 0;
237 desc->page_index ++;
238 if (loop_count++ > 200) {
239 loop_count = 0;
240 schedule();
241 }
242 }
243 dfprintk(VFS, "NFS: readdir_search_pagecache() returned %d\n", res);
244 return res;
245 }
246
247 /*
248 * Once we've found the start of the dirent within a page: fill 'er up...
249 */
250 static
251 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
252 filldir_t filldir)
253 {
254 struct file *file = desc->file;
255 struct nfs_entry *entry = desc->entry;
256 char *start = kmap(desc->page),
257 *p = start + desc->page_offset;
258 unsigned long fileid;
259 int loop_count = 0,
260 res = 0;
261
262 dfprintk(VFS, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n", (long long)desc->target);
263
264 for(;;) {
265 /* Note: entry->prev_cookie contains the cookie for
266 * retrieving the current dirent on the server */
267 fileid = nfs_fileid_to_ino_t(entry->ino);
268 res = filldir(dirent, entry->name, entry->len,
269 entry->prev_cookie, fileid, DT_UNKNOWN);
270 if (res < 0)
271 break;
272 file->f_pos = desc->target = entry->cookie;
273 p = (char *)desc->decode((u32 *)p, entry, desc->plus);
274 if (IS_ERR(p)) {
275 if (PTR_ERR(p) == -EAGAIN) {
276 desc->page_offset = 0;
277 desc->page_index ++;
278 }
279 break;
280 }
281 desc->page_offset = p - start;
282 if (loop_count++ > 200) {
283 loop_count = 0;
284 schedule();
285 }
286 }
287 kunmap(desc->page);
288 page_cache_release(desc->page);
289 desc->page = NULL;
290
291 dfprintk(VFS, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", (long long)desc->target, res);
292 return res;
293 }
294
295 /*
296 * If we cannot find a cookie in our cache, we suspect that this is
297 * because it points to a deleted file, so we ask the server to return
298 * whatever it thinks is the next entry. We then feed this to filldir.
299 * If all goes well, we should then be able to find our way round the
300 * cache on the next call to readdir_search_pagecache();
301 *
302 * NOTE: we cannot add the anonymous page to the pagecache because
303 * the data it contains might not be page aligned. Besides,
304 * we should already have a complete representation of the
305 * directory in the page cache by the time we get here.
306 */
307 static inline
308 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
309 filldir_t filldir)
310 {
311 struct file *file = desc->file;
312 struct inode *inode = file->f_dentry->d_inode;
313 struct rpc_cred *cred = nfs_file_cred(file);
314 struct page *page = NULL;
315 u32 *p;
316 int status = -EIO;
317
318 dfprintk(VFS, "NFS: uncached_readdir() searching for cookie %Lu\n", (long long)desc->target);
319 if (desc->page) {
320 page_cache_release(desc->page);
321 desc->page = NULL;
322 }
323
324 page = page_cache_alloc();
325 if (!page) {
326 status = -ENOMEM;
327 goto out;
328 }
329 p = kmap(page);
330 status = NFS_PROTO(inode)->readdir(inode, cred, desc->target, p,
331 NFS_SERVER(inode)->dtsize, 0);
332 if (status >= 0) {
333 p = desc->decode(p, desc->entry, 0);
334 if (IS_ERR(p))
335 status = PTR_ERR(p);
336 else
337 desc->entry->prev_cookie = desc->target;
338 }
339 kunmap(page);
340 if (status < 0)
341 goto out_release;
342
343 desc->page_index = 0;
344 desc->page_offset = 0;
345 desc->page = page;
346 status = nfs_do_filldir(desc, dirent, filldir);
347
348 /* Reset read descriptor so it searches the page cache from
349 * the start upon the next call to readdir_search_pagecache() */
350 desc->page_index = 0;
351 desc->page_offset = 0;
352 memset(desc->entry, 0, sizeof(*desc->entry));
353 out:
354 dfprintk(VFS, "NFS: uncached_readdir() returns %d\n", status);
355 return status;
356 out_release:
357 page_cache_release(page);
358 goto out;
359 }
360
361 /* The file offset position is now represented as a true offset into the
362 * page cache as is the case in most of the other filesystems.
363 */
364 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
365 {
366 struct dentry *dentry = filp->f_dentry;
367 struct inode *inode = dentry->d_inode;
368 nfs_readdir_descriptor_t my_desc,
369 *desc = &my_desc;
370 struct nfs_entry my_entry;
371 long res;
372
373 res = nfs_revalidate(dentry);
374 if (res < 0)
375 return res;
376
377 /*
378 * filp->f_pos points to the file offset in the page cache.
379 * but if the cache has meanwhile been zapped, we need to
380 * read from the last dirent to revalidate f_pos
381 * itself.
382 */
383 memset(desc, 0, sizeof(*desc));
384 memset(&my_entry, 0, sizeof(my_entry));
385
386 desc->file = filp;
387 desc->target = filp->f_pos;
388 desc->entry = &my_entry;
389 desc->decode = NFS_PROTO(inode)->decode_dirent;
390
391 while(!desc->entry->eof) {
392 res = readdir_search_pagecache(desc);
393 if (res == -EBADCOOKIE) {
394 /* This means either end of directory */
395 if (desc->entry->cookie == desc->target) {
396 res = 0;
397 break;
398 }
399 /* Or that the server has 'lost' a cookie */
400 res = uncached_readdir(desc, dirent, filldir);
401 if (res >= 0)
402 continue;
403 }
404 if (res < 0)
405 break;
406
407 res = nfs_do_filldir(desc, dirent, filldir);
408 if (res < 0) {
409 res = 0;
410 break;
411 }
412 }
413 if (desc->page)
414 page_cache_release(desc->page);
415 if (desc->error < 0)
416 return desc->error;
417 if (res < 0)
418 return res;
419 return 0;
420 }
421
422 /*
423 * Whenever an NFS operation succeeds, we know that the dentry
424 * is valid, so we update the revalidation timestamp.
425 */
426 static inline void nfs_renew_times(struct dentry * dentry)
427 {
428 dentry->d_time = jiffies;
429 }
430
431 static inline int nfs_dentry_force_reval(struct dentry *dentry, int flags)
432 {
433 struct inode *inode = dentry->d_inode;
434 unsigned long timeout = NFS_ATTRTIMEO(inode);
435
436 /*
437 * If it's the last lookup in a series, we use a stricter
438 * cache consistency check by looking at the parent mtime.
439 *
440 * If it's been modified in the last hour, be really strict.
441 * (This still means that we can avoid doing unnecessary
442 * work on directories like /usr/share/bin etc which basically
443 * never change).
444 */
445 if (!(flags & LOOKUP_CONTINUE)) {
446 long diff = CURRENT_TIME - dentry->d_parent->d_inode->i_mtime;
447
448 if (diff < 15*60)
449 timeout = 0;
450 }
451
452 return time_after(jiffies,dentry->d_time + timeout);
453 }
454
455 /*
456 * We judge how long we want to trust negative
457 * dentries by looking at the parent inode mtime.
458 *
459 * If mtime is close to present time, we revalidate
460 * more often.
461 */
462 #define NFS_REVALIDATE_NEGATIVE (1 * HZ)
463 static inline int nfs_neg_need_reval(struct dentry *dentry)
464 {
465 struct inode *dir = dentry->d_parent->d_inode;
466 unsigned long timeout = NFS_ATTRTIMEO(dir);
467 long diff = CURRENT_TIME - dir->i_mtime;
468
469 if (diff < 5*60 && timeout > NFS_REVALIDATE_NEGATIVE)
470 timeout = NFS_REVALIDATE_NEGATIVE;
471
472 return time_after(jiffies, dentry->d_time + timeout);
473 }
474
475 /*
476 * This is called every time the dcache has a lookup hit,
477 * and we should check whether we can really trust that
478 * lookup.
479 *
480 * NOTE! The hit can be a negative hit too, don't assume
481 * we have an inode!
482 *
483 * If the dentry is older than the revalidation interval,
484 * we do a new lookup and verify that the dentry is still
485 * correct.
486 */
487 static int nfs_lookup_revalidate(struct dentry * dentry, int flags)
488 {
489 struct inode *dir;
490 struct inode *inode;
491 int error;
492 struct nfs_fh fhandle;
493 struct nfs_fattr fattr;
494
495 lock_kernel();
496 dir = dentry->d_parent->d_inode;
497 inode = dentry->d_inode;
498 /*
499 * If we don't have an inode, let's look at the parent
500 * directory mtime to get a hint about how often we
501 * should validate things..
502 */
503 if (!inode) {
504 if (nfs_neg_need_reval(dentry))
505 goto out_bad;
506 goto out_valid;
507 }
508
509 if (is_bad_inode(inode)) {
510 dfprintk(VFS, "nfs_lookup_validate: %s/%s has dud inode\n",
511 dentry->d_parent->d_name.name, dentry->d_name.name);
512 goto out_bad;
513 }
514
515 if (!nfs_dentry_force_reval(dentry, flags))
516 goto out_valid;
517
518 if (IS_ROOT(dentry)) {
519 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
520 goto out_valid_renew;
521 }
522
523 /*
524 * Do a new lookup and check the dentry attributes.
525 */
526 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
527 if (error)
528 goto out_bad;
529
530 /* Inode number matches? */
531 if (!(fattr.valid & NFS_ATTR_FATTR) ||
532 NFS_FSID(inode) != fattr.fsid ||
533 NFS_FILEID(inode) != fattr.fileid)
534 goto out_bad;
535
536 /* Ok, remember that we successfully checked it.. */
537 nfs_refresh_inode(inode, &fattr);
538
539 if (nfs_inode_is_stale(inode, &fhandle, &fattr))
540 goto out_bad;
541
542 out_valid_renew:
543 nfs_renew_times(dentry);
544 out_valid:
545 unlock_kernel();
546 return 1;
547 out_bad:
548 shrink_dcache_parent(dentry);
549 /* If we have submounts, don't unhash ! */
550 if (have_submounts(dentry))
551 goto out_valid;
552 d_drop(dentry);
553 /* Purge readdir caches. */
554 nfs_zap_caches(dir);
555 if (inode && S_ISDIR(inode->i_mode))
556 nfs_zap_caches(inode);
557 unlock_kernel();
558 return 0;
559 }
560
561 /*
562 * This is called from dput() when d_count is going to 0.
563 */
564 static int nfs_dentry_delete(struct dentry *dentry)
565 {
566 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
567 dentry->d_parent->d_name.name, dentry->d_name.name,
568 dentry->d_flags);
569
570 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
571 /* Unhash it, so that ->d_iput() would be called */
572 return 1;
573 }
574 return 0;
575
576 }
577
578 /*
579 * Called when the dentry loses inode.
580 * We use it to clean up silly-renamed files.
581 */
582 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
583 {
584 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
585 lock_kernel();
586 nfs_complete_unlink(dentry);
587 unlock_kernel();
588 }
589 iput(inode);
590 }
591
592 struct dentry_operations nfs_dentry_operations = {
593 d_revalidate: nfs_lookup_revalidate,
594 d_delete: nfs_dentry_delete,
595 d_iput: nfs_dentry_iput,
596 };
597
598 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry)
599 {
600 struct inode *inode;
601 int error;
602 struct nfs_fh fhandle;
603 struct nfs_fattr fattr;
604
605 dfprintk(VFS, "NFS: lookup(%s/%s)\n",
606 dentry->d_parent->d_name.name, dentry->d_name.name);
607
608 error = -ENAMETOOLONG;
609 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
610 goto out;
611
612 error = -ENOMEM;
613 dentry->d_op = &nfs_dentry_operations;
614
615 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr);
616 inode = NULL;
617 if (error == -ENOENT)
618 goto no_entry;
619 if (!error) {
620 error = -EACCES;
621 inode = nfs_fhget(dentry, &fhandle, &fattr);
622 if (inode) {
623 no_entry:
624 d_add(dentry, inode);
625 nfs_renew_times(dentry);
626 error = 0;
627 }
628 }
629 out:
630 return ERR_PTR(error);
631 }
632
633 /*
634 * Code common to create, mkdir, and mknod.
635 */
636 static int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
637 struct nfs_fattr *fattr)
638 {
639 struct inode *inode;
640 int error = -EACCES;
641
642 inode = nfs_fhget(dentry, fhandle, fattr);
643 if (inode) {
644 d_instantiate(dentry, inode);
645 nfs_renew_times(dentry);
646 error = 0;
647 }
648 return error;
649 }
650
651 /*
652 * Following a failed create operation, we drop the dentry rather
653 * than retain a negative dentry. This avoids a problem in the event
654 * that the operation succeeded on the server, but an error in the
655 * reply path made it appear to have failed.
656 */
657 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode)
658 {
659 struct iattr attr;
660 struct nfs_fattr fattr;
661 struct nfs_fh fhandle;
662 int error;
663
664 dfprintk(VFS, "NFS: create(%x/%ld, %s\n",
665 dir->i_dev, dir->i_ino, dentry->d_name.name);
666
667 attr.ia_mode = mode;
668 attr.ia_valid = ATTR_MODE;
669
670 /*
671 * The 0 argument passed into the create function should one day
672 * contain the O_EXCL flag if requested. This allows NFSv3 to
673 * select the appropriate create strategy. Currently open_namei
674 * does not pass the create flags.
675 */
676 nfs_zap_caches(dir);
677 error = NFS_PROTO(dir)->create(dir, &dentry->d_name,
678 &attr, 0, &fhandle, &fattr);
679 if (!error && fhandle.size != 0)
680 error = nfs_instantiate(dentry, &fhandle, &fattr);
681 if (error || fhandle.size == 0)
682 d_drop(dentry);
683 return error;
684 }
685
686 /*
687 * See comments for nfs_proc_create regarding failed operations.
688 */
689 static int nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
690 {
691 struct iattr attr;
692 struct nfs_fattr fattr;
693 struct nfs_fh fhandle;
694 int error;
695
696 dfprintk(VFS, "NFS: mknod(%x/%ld, %s\n",
697 dir->i_dev, dir->i_ino, dentry->d_name.name);
698
699 attr.ia_mode = mode;
700 attr.ia_valid = ATTR_MODE;
701
702 nfs_zap_caches(dir);
703 error = NFS_PROTO(dir)->mknod(dir, &dentry->d_name, &attr, rdev,
704 &fhandle, &fattr);
705 if (!error && fhandle.size != 0)
706 error = nfs_instantiate(dentry, &fhandle, &fattr);
707 if (error || fhandle.size == 0)
708 d_drop(dentry);
709 return error;
710 }
711
712 /*
713 * See comments for nfs_proc_create regarding failed operations.
714 */
715 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
716 {
717 struct iattr attr;
718 struct nfs_fattr fattr;
719 struct nfs_fh fhandle;
720 int error;
721
722 dfprintk(VFS, "NFS: mkdir(%x/%ld, %s\n",
723 dir->i_dev, dir->i_ino, dentry->d_name.name);
724
725 attr.ia_valid = ATTR_MODE;
726 attr.ia_mode = mode | S_IFDIR;
727
728 #if 0
729 /*
730 * Always drop the dentry, we can't always depend on
731 * the fattr returned by the server (AIX seems to be
732 * broken). We're better off doing another lookup than
733 * depending on potentially bogus information.
734 */
735 d_drop(dentry);
736 #endif
737 nfs_zap_caches(dir);
738 error = NFS_PROTO(dir)->mkdir(dir, &dentry->d_name, &attr, &fhandle,
739 &fattr);
740 if (!error && fhandle.size != 0)
741 error = nfs_instantiate(dentry, &fhandle, &fattr);
742 if (error || fhandle.size == 0)
743 d_drop(dentry);
744 return error;
745 }
746
747 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
748 {
749 int error;
750
751 dfprintk(VFS, "NFS: rmdir(%x/%ld, %s\n",
752 dir->i_dev, dir->i_ino, dentry->d_name.name);
753
754 nfs_zap_caches(dir);
755 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
756
757 return error;
758 }
759
760 static int nfs_sillyrename(struct inode *dir, struct dentry *dentry)
761 {
762 static unsigned int sillycounter;
763 const int i_inosize = sizeof(dir->i_ino)*2;
764 const int countersize = sizeof(sillycounter)*2;
765 const int slen = strlen(".nfs") + i_inosize + countersize;
766 char silly[slen+1];
767 struct qstr qsilly;
768 struct dentry *sdentry;
769 int error = -EIO;
770
771 dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
772 dentry->d_parent->d_name.name, dentry->d_name.name,
773 atomic_read(&dentry->d_count));
774
775 if (atomic_read(&dentry->d_count) == 1)
776 goto out; /* No need to silly rename. */
777
778
779 #ifdef NFS_PARANOIA
780 if (!dentry->d_inode)
781 printk("NFS: silly-renaming %s/%s, negative dentry??\n",
782 dentry->d_parent->d_name.name, dentry->d_name.name);
783 #endif
784 /*
785 * We don't allow a dentry to be silly-renamed twice.
786 */
787 error = -EBUSY;
788 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
789 goto out;
790
791 sprintf(silly, ".nfs%*.*lx",
792 i_inosize, i_inosize, dentry->d_inode->i_ino);
793
794 sdentry = NULL;
795 do {
796 char *suffix = silly + slen - countersize;
797
798 dput(sdentry);
799 sillycounter++;
800 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter);
801
802 dfprintk(VFS, "trying to rename %s to %s\n",
803 dentry->d_name.name, silly);
804
805 sdentry = lookup_one(silly, dentry->d_parent);
806 /*
807 * N.B. Better to return EBUSY here ... it could be
808 * dangerous to delete the file while it's in use.
809 */
810 if (IS_ERR(sdentry))
811 goto out;
812 } while(sdentry->d_inode != NULL); /* need negative lookup */
813
814 nfs_zap_caches(dir);
815 qsilly.name = silly;
816 qsilly.len = strlen(silly);
817 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name, dir, &qsilly);
818 if (!error) {
819 nfs_renew_times(dentry);
820 d_move(dentry, sdentry);
821 error = nfs_async_unlink(dentry);
822 /* If we return 0 we don't unlink */
823 }
824 dput(sdentry);
825 out:
826 return error;
827 }
828
829 /*
830 * Remove a file after making sure there are no pending writes,
831 * and after checking that the file has only one user.
832 *
833 * We invalidate the attribute cache and free the inode prior to the operation
834 * to avoid possible races if the server reuses the inode.
835 */
836 static int nfs_safe_remove(struct dentry *dentry)
837 {
838 struct inode *dir = dentry->d_parent->d_inode;
839 struct inode *inode = dentry->d_inode;
840 int error = -EBUSY, rehash = 0;
841
842 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
843 dentry->d_parent->d_name.name, dentry->d_name.name);
844
845 /*
846 * Unhash the dentry while we remove the file ...
847 */
848 if (!d_unhashed(dentry)) {
849 d_drop(dentry);
850 rehash = 1;
851 }
852 if (atomic_read(&dentry->d_count) > 1) {
853 #ifdef NFS_PARANOIA
854 printk("nfs_safe_remove: %s/%s busy, d_count=%d\n",
855 dentry->d_parent->d_name.name, dentry->d_name.name,
856 atomic_read(&dentry->d_count));
857 #endif
858 goto out;
859 }
860
861 /* If the dentry was sillyrenamed, we simply call d_delete() */
862 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
863 error = 0;
864 goto out_delete;
865 }
866
867 nfs_zap_caches(dir);
868 if (inode)
869 NFS_CACHEINV(inode);
870 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
871 if (error < 0)
872 goto out;
873
874 out_delete:
875 /*
876 * Free the inode
877 */
878 d_delete(dentry);
879 out:
880 if (rehash)
881 d_rehash(dentry);
882 return error;
883 }
884
885 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode
886 * belongs to an active ".nfs..." file and we return -EBUSY.
887 *
888 * If sillyrename() returns 0, we do nothing, otherwise we unlink.
889 */
890 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
891 {
892 int error;
893
894 dfprintk(VFS, "NFS: unlink(%x/%ld, %s)\n",
895 dir->i_dev, dir->i_ino, dentry->d_name.name);
896
897 error = nfs_sillyrename(dir, dentry);
898 if (error && error != -EBUSY) {
899 error = nfs_safe_remove(dentry);
900 if (!error) {
901 nfs_renew_times(dentry);
902 }
903 }
904 return error;
905 }
906
907 static int
908 nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
909 {
910 struct iattr attr;
911 struct nfs_fattr sym_attr;
912 struct nfs_fh sym_fh;
913 struct qstr qsymname;
914 unsigned int maxlen;
915 int error;
916
917 dfprintk(VFS, "NFS: symlink(%x/%ld, %s, %s)\n",
918 dir->i_dev, dir->i_ino, dentry->d_name.name, symname);
919
920 error = -ENAMETOOLONG;
921 maxlen = (NFS_PROTO(dir)->version==2) ? NFS2_MAXPATHLEN : NFS3_MAXPATHLEN;
922 if (strlen(symname) > maxlen)
923 goto out;
924
925 #ifdef NFS_PARANOIA
926 if (dentry->d_inode)
927 printk("nfs_proc_symlink: %s/%s not negative!\n",
928 dentry->d_parent->d_name.name, dentry->d_name.name);
929 #endif
930 /*
931 * Fill in the sattr for the call.
932 * Note: SunOS 4.1.2 crashes if the mode isn't initialized!
933 */
934 attr.ia_valid = ATTR_MODE;
935 attr.ia_mode = S_IFLNK | S_IRWXUGO;
936
937 qsymname.name = symname;
938 qsymname.len = strlen(symname);
939
940 nfs_zap_caches(dir);
941 error = NFS_PROTO(dir)->symlink(dir, &dentry->d_name, &qsymname,
942 &attr, &sym_fh, &sym_attr);
943 if (!error && sym_fh.size != 0 && (sym_attr.valid & NFS_ATTR_FATTR)) {
944 error = nfs_instantiate(dentry, &sym_fh, &sym_attr);
945 } else {
946 if (error == -EEXIST)
947 printk("nfs_proc_symlink: %s/%s already exists??\n",
948 dentry->d_parent->d_name.name, dentry->d_name.name);
949 d_drop(dentry);
950 }
951
952 out:
953 return error;
954 }
955
956 static int
957 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
958 {
959 struct inode *inode = old_dentry->d_inode;
960 int error;
961
962 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
963 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
964 dentry->d_parent->d_name.name, dentry->d_name.name);
965
966 /*
967 * Drop the dentry in advance to force a new lookup.
968 * Since nfs_proc_link doesn't return a file handle,
969 * we can't use the existing dentry.
970 */
971 d_drop(dentry);
972 nfs_zap_caches(dir);
973 NFS_CACHEINV(inode);
974 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
975 return error;
976 }
977
978 /*
979 * RENAME
980 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
981 * different file handle for the same inode after a rename (e.g. when
982 * moving to a different directory). A fail-safe method to do so would
983 * be to look up old_dir/old_name, create a link to new_dir/new_name and
984 * rename the old file using the sillyrename stuff. This way, the original
985 * file in old_dir will go away when the last process iput()s the inode.
986 *
987 * FIXED.
988 *
989 * It actually works quite well. One needs to have the possibility for
990 * at least one ".nfs..." file in each directory the file ever gets
991 * moved or linked to which happens automagically with the new
992 * implementation that only depends on the dcache stuff instead of
993 * using the inode layer
994 *
995 * Unfortunately, things are a little more complicated than indicated
996 * above. For a cross-directory move, we want to make sure we can get
997 * rid of the old inode after the operation. This means there must be
998 * no pending writes (if it's a file), and the use count must be 1.
999 * If these conditions are met, we can drop the dentries before doing
1000 * the rename.
1001 */
1002 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1003 struct inode *new_dir, struct dentry *new_dentry)
1004 {
1005 struct inode *old_inode = old_dentry->d_inode;
1006 struct inode *new_inode = new_dentry->d_inode;
1007 struct dentry *dentry = NULL, *rehash = NULL;
1008 int error = -EBUSY;
1009
1010 /*
1011 * To prevent any new references to the target during the rename,
1012 * we unhash the dentry and free the inode in advance.
1013 */
1014 if (!d_unhashed(new_dentry)) {
1015 d_drop(new_dentry);
1016 rehash = new_dentry;
1017 }
1018
1019 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1020 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1021 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1022 atomic_read(&new_dentry->d_count));
1023
1024 /*
1025 * First check whether the target is busy ... we can't
1026 * safely do _any_ rename if the target is in use.
1027 *
1028 * For files, make a copy of the dentry and then do a
1029 * silly-rename. If the silly-rename succeeds, the
1030 * copied dentry is hashed and becomes the new target.
1031 */
1032 if (!new_inode)
1033 goto go_ahead;
1034 if (S_ISDIR(new_inode->i_mode))
1035 goto out;
1036 else if (atomic_read(&new_dentry->d_count) > 1) {
1037 int err;
1038 /* copy the target dentry's name */
1039 dentry = d_alloc(new_dentry->d_parent,
1040 &new_dentry->d_name);
1041 if (!dentry)
1042 goto out;
1043
1044 /* silly-rename the existing target ... */
1045 err = nfs_sillyrename(new_dir, new_dentry);
1046 if (!err) {
1047 new_dentry = rehash = dentry;
1048 new_inode = NULL;
1049 /* instantiate the replacement target */
1050 d_instantiate(new_dentry, NULL);
1051 }
1052
1053 /* dentry still busy? */
1054 if (atomic_read(&new_dentry->d_count) > 1) {
1055 #ifdef NFS_PARANOIA
1056 printk("nfs_rename: target %s/%s busy, d_count=%d\n",
1057 new_dentry->d_parent->d_name.name,
1058 new_dentry->d_name.name,
1059 atomic_read(&new_dentry->d_count));
1060 #endif
1061 goto out;
1062 }
1063 }
1064
1065 go_ahead:
1066 /*
1067 * ... prune child dentries and writebacks if needed.
1068 */
1069 if (atomic_read(&old_dentry->d_count) > 1) {
1070 nfs_wb_all(old_inode);
1071 shrink_dcache_parent(old_dentry);
1072 }
1073
1074 if (new_inode)
1075 d_delete(new_dentry);
1076
1077 nfs_zap_caches(new_dir);
1078 nfs_zap_caches(old_dir);
1079 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1080 new_dir, &new_dentry->d_name);
1081 out:
1082 if (rehash)
1083 d_rehash(rehash);
1084 if (!error && !S_ISDIR(old_inode->i_mode))
1085 d_move(old_dentry, new_dentry);
1086
1087 /* new dentry created? */
1088 if (dentry)
1089 dput(dentry);
1090 return error;
1091 }
1092
1093 int
1094 nfs_permission(struct inode *inode, int mask)
1095 {
1096 int error = vfs_permission(inode, mask);
1097
1098 if (!NFS_PROTO(inode)->access)
1099 goto out;
1100 /*
1101 * Trust UNIX mode bits except:
1102 *
1103 * 1) When override capabilities may have been invoked
1104 * 2) When root squashing may be involved
1105 * 3) When ACLs may overturn a negative answer */
1106 if (!capable(CAP_DAC_OVERRIDE) && !capable(CAP_DAC_READ_SEARCH)
1107 && (current->fsuid != 0) && (current->fsgid != 0)
1108 && error != -EACCES)
1109 goto out;
1110
1111 error = NFS_PROTO(inode)->access(inode, mask, 0);
1112
1113 if (error == -EACCES && NFS_CLIENT(inode)->cl_droppriv &&
1114 current->uid != 0 && current->gid != 0 &&
1115 (current->fsuid != current->uid || current->fsgid != current->gid))
1116 error = NFS_PROTO(inode)->access(inode, mask, 1);
1117
1118 out:
1119 return error;
1120 }
1121
1122 /*
1123 * Local variables:
1124 * version-control: t
1125 * kept-new-versions: 5
1126 * End:
1127 */
1128
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.