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