2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/dir.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992 Rick Sladkey
|
|
|
|
*
|
|
|
|
* nfs directory handling functions
|
|
|
|
*
|
|
|
|
* 10 Apr 1996 Added silly rename for unlink --okir
|
|
|
|
* 28 Sep 1996 Improved directory cache --okir
|
|
|
|
* 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de
|
|
|
|
* Re-implemented silly rename for unlink, newly implemented
|
|
|
|
* silly rename for nfs_rename() following the suggestions
|
|
|
|
* of Olaf Kirch (okir) found in this file.
|
|
|
|
* Following Linus comments on my original hack, this version
|
|
|
|
* depends only on the dcache stuff and doesn't touch the inode
|
|
|
|
* layer (iput() and friends).
|
|
|
|
* 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_mount.h>
|
|
|
|
#include <linux/pagemap.h>
|
2006-08-23 02:06:23 +02:00
|
|
|
#include <linux/pagevec.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/namei.h>
|
NFS: Share NFS superblocks per-protocol per-server per-FSID
The attached patch makes NFS share superblocks between mounts from the same
server and FSID over the same protocol.
It does this by creating each superblock with a false root and returning the
real root dentry in the vfsmount presented by get_sb(). The root dentry set
starts off as an anonymous dentry if we don't already have the dentry for its
inode, otherwise it simply returns the dentry we already have.
We may thus end up with several trees of dentries in the superblock, and if at
some later point one of anonymous tree roots is discovered by normal filesystem
activity to be located in another tree within the superblock, the anonymous
root is named and materialises attached to the second tree at the appropriate
point.
Why do it this way? Why not pass an extra argument to the mount() syscall to
indicate the subpath and then pathwalk from the server root to the desired
directory? You can't guarantee this will work for two reasons:
(1) The root and intervening nodes may not be accessible to the client.
With NFS2 and NFS3, for instance, mountd is called on the server to get
the filehandle for the tip of a path. mountd won't give us handles for
anything we don't have permission to access, and so we can't set up NFS
inodes for such nodes, and so can't easily set up dentries (we'd have to
have ghost inodes or something).
With this patch we don't actually create dentries until we get handles
from the server that we can use to set up their inodes, and we don't
actually bind them into the tree until we know for sure where they go.
(2) Inaccessible symbolic links.
If we're asked to mount two exports from the server, eg:
mount warthog:/warthog/aaa/xxx /mmm
mount warthog:/warthog/bbb/yyy /nnn
We may not be able to access anything nearer the root than xxx and yyy,
but we may find out later that /mmm/www/yyy, say, is actually the same
directory as the one mounted on /nnn. What we might then find out, for
example, is that /warthog/bbb was actually a symbolic link to
/warthog/aaa/xxx/www, but we can't actually determine that by talking to
the server until /warthog is made available by NFS.
This would lead to having constructed an errneous dentry tree which we
can't easily fix. We can end up with a dentry marked as a directory when
it should actually be a symlink, or we could end up with an apparently
hardlinked directory.
With this patch we need not make assumptions about the type of a dentry
for which we can't retrieve information, nor need we assume we know its
place in the grand scheme of things until we actually see that place.
This patch reduces the possibility of aliasing in the inode and page caches for
inodes that may be accessed by more than one NFS export. It also reduces the
number of superblocks required for NFS where there are many NFS exports being
used from a server (home directory server + autofs for example).
This in turn makes it simpler to do local caching of network filesystems, as it
can then be guaranteed that there won't be links from multiple inodes in
separate superblocks to the same cache file.
Obviously, cache aliasing between different levels of NFS protocol could still
be a problem, but at least that gives us another key to use when indexing the
cache.
This patch makes the following changes:
(1) The server record construction/destruction has been abstracted out into
its own set of functions to make things easier to get right. These have
been moved into fs/nfs/client.c.
All the code in fs/nfs/client.c has to do with the management of
connections to servers, and doesn't touch superblocks in any way; the
remaining code in fs/nfs/super.c has to do with VFS superblock management.
(2) The sequence of events undertaken by NFS mount is now reordered:
(a) A volume representation (struct nfs_server) is allocated.
(b) A server representation (struct nfs_client) is acquired. This may be
allocated or shared, and is keyed on server address, port and NFS
version.
(c) If allocated, the client representation is initialised. The state
member variable of nfs_client is used to prevent a race during
initialisation from two mounts.
(d) For NFS4 a simple pathwalk is performed, walking from FH to FH to find
the root filehandle for the mount (fs/nfs/getroot.c). For NFS2/3 we
are given the root FH in advance.
(e) The volume FSID is probed for on the root FH.
(f) The volume representation is initialised from the FSINFO record
retrieved on the root FH.
(g) sget() is called to acquire a superblock. This may be allocated or
shared, keyed on client pointer and FSID.
(h) If allocated, the superblock is initialised.
(i) If the superblock is shared, then the new nfs_server record is
discarded.
(j) The root dentry for this mount is looked up from the root FH.
(k) The root dentry for this mount is assigned to the vfsmount.
(3) nfs_readdir_lookup() creates dentries for each of the entries readdir()
returns; this function now attaches disconnected trees from alternate
roots that happen to be discovered attached to a directory being read (in
the same way nfs_lookup() is made to do for lookup ops).
The new d_materialise_unique() function is now used to do this, thus
permitting the whole thing to be done under one set of locks, and thus
avoiding any race between mount and lookup operations on the same
directory.
(4) The client management code uses a new debug facility: NFSDBG_CLIENT which
is set by echoing 1024 to /proc/net/sunrpc/nfs_debug.
(5) Clone mounts are now called xdev mounts.
(6) Use the dentry passed to the statfs() op as the handle for retrieving fs
statistics rather than the root dentry of the superblock (which is now a
dummy).
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2006-08-23 02:06:13 +02:00
|
|
|
#include <linux/mount.h>
|
Detach sched.h from mm.h
First thing mm.h does is including sched.h solely for can_do_mlock() inline
function which has "current" dereference inside. By dealing with can_do_mlock()
mm.h can be detached from sched.h which is good. See below, why.
This patch
a) removes unconditional inclusion of sched.h from mm.h
b) makes can_do_mlock() normal function in mm/mlock.c
c) exports can_do_mlock() to not break compilation
d) adds sched.h inclusions back to files that were getting it indirectly.
e) adds less bloated headers to some files (asm/signal.h, jiffies.h) that were
getting them indirectly
Net result is:
a) mm.h users would get less code to open, read, preprocess, parse, ... if
they don't need sched.h
b) sched.h stops being dependency for significant number of files:
on x86_64 allmodconfig touching sched.h results in recompile of 4083 files,
after patch it's only 3744 (-8.3%).
Cross-compile tested on
all arm defconfigs, all mips defconfigs, all powerpc defconfigs,
alpha alpha-up
arm
i386 i386-up i386-defconfig i386-allnoconfig
ia64 ia64-up
m68k
mips
parisc parisc-up
powerpc powerpc-up
s390 s390-up
sparc sparc-up
sparc64 sparc64-up
um-x86_64
x86_64 x86_64-up x86_64-defconfig x86_64-allnoconfig
as well as my two usual configs.
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-20 23:22:52 +02:00
|
|
|
#include <linux/sched.h>
|
2010-11-11 13:53:47 +01:00
|
|
|
#include <linux/kmemleak.h>
|
2010-12-09 12:35:25 +01:00
|
|
|
#include <linux/xattr.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include "delegation.h"
|
2006-03-20 19:44:14 +01:00
|
|
|
#include "iostat.h"
|
2007-11-22 00:04:31 +01:00
|
|
|
#include "internal.h"
|
2010-09-17 16:56:50 +02:00
|
|
|
#include "fscache.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* #define NFS_DEBUG_VERBOSE 1 */
|
|
|
|
|
|
|
|
static int nfs_opendir(struct inode *, struct file *);
|
2011-03-23 19:48:29 +01:00
|
|
|
static int nfs_closedir(struct inode *, struct file *);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_readdir(struct file *, void *, filldir_t);
|
|
|
|
static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
|
2011-07-26 07:42:34 +02:00
|
|
|
static int nfs_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
|
2011-07-26 07:41:39 +02:00
|
|
|
static int nfs_mkdir(struct inode *, struct dentry *, umode_t);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_rmdir(struct inode *, struct dentry *);
|
|
|
|
static int nfs_unlink(struct inode *, struct dentry *);
|
|
|
|
static int nfs_symlink(struct inode *, struct dentry *, const char *);
|
|
|
|
static int nfs_link(struct dentry *, struct inode *, struct dentry *);
|
2011-07-26 07:52:52 +02:00
|
|
|
static int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_rename(struct inode *, struct dentry *,
|
|
|
|
struct inode *, struct dentry *);
|
2011-07-17 02:44:56 +02:00
|
|
|
static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
|
2005-06-22 19:16:29 +02:00
|
|
|
static loff_t nfs_llseek_dir(struct file *, loff_t, int);
|
2010-12-01 20:17:06 +01:00
|
|
|
static void nfs_readdir_clear_array(struct page*);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-28 11:56:42 +02:00
|
|
|
const struct file_operations nfs_dir_operations = {
|
2005-06-22 19:16:29 +02:00
|
|
|
.llseek = nfs_llseek_dir,
|
2005-04-17 00:20:36 +02:00
|
|
|
.read = generic_read_dir,
|
|
|
|
.readdir = nfs_readdir,
|
|
|
|
.open = nfs_opendir,
|
2011-03-23 19:48:29 +01:00
|
|
|
.release = nfs_closedir,
|
2005-04-17 00:20:36 +02:00
|
|
|
.fsync = nfs_fsync_dir,
|
|
|
|
};
|
|
|
|
|
2007-02-12 09:55:39 +01:00
|
|
|
const struct inode_operations nfs_dir_inode_operations = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.create = nfs_create,
|
|
|
|
.lookup = nfs_lookup,
|
|
|
|
.link = nfs_link,
|
|
|
|
.unlink = nfs_unlink,
|
|
|
|
.symlink = nfs_symlink,
|
|
|
|
.mkdir = nfs_mkdir,
|
|
|
|
.rmdir = nfs_rmdir,
|
|
|
|
.mknod = nfs_mknod,
|
|
|
|
.rename = nfs_rename,
|
|
|
|
.permission = nfs_permission,
|
|
|
|
.getattr = nfs_getattr,
|
|
|
|
.setattr = nfs_setattr,
|
|
|
|
};
|
|
|
|
|
2010-12-01 20:17:06 +01:00
|
|
|
const struct address_space_operations nfs_dir_aops = {
|
|
|
|
.freepage = nfs_readdir_clear_array,
|
2010-09-24 20:48:42 +02:00
|
|
|
};
|
|
|
|
|
2005-06-22 19:16:27 +02:00
|
|
|
#ifdef CONFIG_NFS_V3
|
2007-02-12 09:55:39 +01:00
|
|
|
const struct inode_operations nfs3_dir_inode_operations = {
|
2005-06-22 19:16:27 +02:00
|
|
|
.create = nfs_create,
|
|
|
|
.lookup = nfs_lookup,
|
|
|
|
.link = nfs_link,
|
|
|
|
.unlink = nfs_unlink,
|
|
|
|
.symlink = nfs_symlink,
|
|
|
|
.mkdir = nfs_mkdir,
|
|
|
|
.rmdir = nfs_rmdir,
|
|
|
|
.mknod = nfs_mknod,
|
|
|
|
.rename = nfs_rename,
|
|
|
|
.permission = nfs_permission,
|
|
|
|
.getattr = nfs_getattr,
|
|
|
|
.setattr = nfs_setattr,
|
|
|
|
.listxattr = nfs3_listxattr,
|
|
|
|
.getxattr = nfs3_getxattr,
|
|
|
|
.setxattr = nfs3_setxattr,
|
|
|
|
.removexattr = nfs3_removexattr,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_NFS_V3 */
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
|
|
|
|
static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
|
2011-07-26 07:42:34 +02:00
|
|
|
static int nfs_open_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd);
|
2007-02-12 09:55:39 +01:00
|
|
|
const struct inode_operations nfs4_dir_inode_operations = {
|
2010-09-17 16:56:51 +02:00
|
|
|
.create = nfs_open_create,
|
2005-04-17 00:20:36 +02:00
|
|
|
.lookup = nfs_atomic_lookup,
|
|
|
|
.link = nfs_link,
|
|
|
|
.unlink = nfs_unlink,
|
|
|
|
.symlink = nfs_symlink,
|
|
|
|
.mkdir = nfs_mkdir,
|
|
|
|
.rmdir = nfs_rmdir,
|
|
|
|
.mknod = nfs_mknod,
|
|
|
|
.rename = nfs_rename,
|
|
|
|
.permission = nfs_permission,
|
|
|
|
.getattr = nfs_getattr,
|
|
|
|
.setattr = nfs_setattr,
|
2010-12-09 12:35:25 +01:00
|
|
|
.getxattr = generic_getxattr,
|
|
|
|
.setxattr = generic_setxattr,
|
|
|
|
.listxattr = generic_listxattr,
|
|
|
|
.removexattr = generic_removexattr,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* CONFIG_NFS_V4 */
|
|
|
|
|
2011-07-30 18:45:35 +02:00
|
|
|
static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
|
2011-03-23 19:48:29 +01:00
|
|
|
{
|
|
|
|
struct nfs_open_dir_context *ctx;
|
|
|
|
ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
|
|
|
|
if (ctx != NULL) {
|
2011-03-23 20:04:31 +01:00
|
|
|
ctx->duped = 0;
|
2011-07-30 18:45:35 +02:00
|
|
|
ctx->attr_gencount = NFS_I(dir)->attr_gencount;
|
2011-03-23 19:48:29 +01:00
|
|
|
ctx->dir_cookie = 0;
|
2011-03-23 20:04:31 +01:00
|
|
|
ctx->dup_cookie = 0;
|
2011-03-23 19:48:29 +01:00
|
|
|
ctx->cred = get_rpccred(cred);
|
2011-07-30 18:45:35 +02:00
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2011-03-23 19:48:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)
|
|
|
|
{
|
|
|
|
put_rpccred(ctx->cred);
|
|
|
|
kfree(ctx);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Open file
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_opendir(struct inode *inode, struct file *filp)
|
|
|
|
{
|
2011-03-23 19:48:29 +01:00
|
|
|
int res = 0;
|
|
|
|
struct nfs_open_dir_context *ctx;
|
|
|
|
struct rpc_cred *cred;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dfprintk(FILE, "NFS: open dir(%s/%s)\n",
|
2008-06-11 23:55:42 +02:00
|
|
|
filp->f_path.dentry->d_parent->d_name.name,
|
|
|
|
filp->f_path.dentry->d_name.name);
|
|
|
|
|
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSOPEN);
|
2006-03-20 19:44:24 +01:00
|
|
|
|
2011-03-23 19:48:29 +01:00
|
|
|
cred = rpc_lookup_cred();
|
|
|
|
if (IS_ERR(cred))
|
|
|
|
return PTR_ERR(cred);
|
2011-07-30 18:45:35 +02:00
|
|
|
ctx = alloc_nfs_open_dir_context(inode, cred);
|
2011-03-23 19:48:29 +01:00
|
|
|
if (IS_ERR(ctx)) {
|
|
|
|
res = PTR_ERR(ctx);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
filp->private_data = ctx;
|
2010-08-10 16:20:05 +02:00
|
|
|
if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
|
|
|
|
/* This is a mountpoint, so d_revalidate will never
|
|
|
|
* have been called, so we need to refresh the
|
|
|
|
* inode (for close-open consistency) ourselves.
|
|
|
|
*/
|
|
|
|
__nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
}
|
2011-03-23 19:48:29 +01:00
|
|
|
out:
|
|
|
|
put_rpccred(cred);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-03-23 19:48:29 +01:00
|
|
|
static int
|
|
|
|
nfs_closedir(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
put_nfs_open_dir_context(filp->private_data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
struct nfs_cache_array_entry {
|
|
|
|
u64 cookie;
|
|
|
|
u64 ino;
|
|
|
|
struct qstr string;
|
2010-11-20 20:26:44 +01:00
|
|
|
unsigned char d_type;
|
2010-09-24 20:48:42 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct nfs_cache_array {
|
|
|
|
unsigned int size;
|
|
|
|
int eof_index;
|
|
|
|
u64 last_cookie;
|
|
|
|
struct nfs_cache_array_entry array[0];
|
|
|
|
};
|
|
|
|
|
2010-12-14 15:58:11 +01:00
|
|
|
typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
|
2005-04-17 00:20:36 +02:00
|
|
|
typedef struct {
|
|
|
|
struct file *file;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long page_index;
|
2005-06-22 19:16:29 +02:00
|
|
|
u64 *dir_cookie;
|
2010-12-01 03:56:32 +01:00
|
|
|
u64 last_cookie;
|
2005-06-22 19:16:29 +02:00
|
|
|
loff_t current_index;
|
2005-04-17 00:20:36 +02:00
|
|
|
decode_dirent_t decode;
|
2010-09-24 20:48:42 +02:00
|
|
|
|
2007-04-16 01:35:27 +02:00
|
|
|
unsigned long timestamp;
|
2008-10-15 01:16:07 +02:00
|
|
|
unsigned long gencount;
|
2010-09-24 20:48:42 +02:00
|
|
|
unsigned int cache_entry_index;
|
|
|
|
unsigned int plus:1;
|
|
|
|
unsigned int eof:1;
|
2005-04-17 00:20:36 +02:00
|
|
|
} nfs_readdir_descriptor_t;
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
/*
|
|
|
|
* The caller is responsible for calling nfs_readdir_release_array(page)
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
static
|
2010-09-24 20:48:42 +02:00
|
|
|
struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
|
|
|
|
{
|
2010-11-16 02:26:22 +01:00
|
|
|
void *ptr;
|
2010-09-24 20:48:42 +02:00
|
|
|
if (page == NULL)
|
|
|
|
return ERR_PTR(-EIO);
|
2010-11-16 02:26:22 +01:00
|
|
|
ptr = kmap(page);
|
|
|
|
if (ptr == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
return ptr;
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void nfs_readdir_release_array(struct page *page)
|
|
|
|
{
|
|
|
|
kunmap(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we are freeing strings created by nfs_add_to_readdir_array()
|
|
|
|
*/
|
|
|
|
static
|
2010-12-01 20:17:06 +01:00
|
|
|
void nfs_readdir_clear_array(struct page *page)
|
2010-09-24 20:48:42 +02:00
|
|
|
{
|
2010-12-01 20:17:06 +01:00
|
|
|
struct nfs_cache_array *array;
|
2010-09-24 20:48:42 +02:00
|
|
|
int i;
|
2010-11-16 02:26:22 +01:00
|
|
|
|
2011-11-25 16:14:33 +01:00
|
|
|
array = kmap_atomic(page);
|
2010-09-24 20:48:42 +02:00
|
|
|
for (i = 0; i < array->size; i++)
|
|
|
|
kfree(array->array[i].string.name);
|
2011-11-25 16:14:33 +01:00
|
|
|
kunmap_atomic(array);
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the caller is responsible for freeing qstr.name
|
|
|
|
* when called by nfs_readdir_add_to_array, the strings will be freed in
|
|
|
|
* nfs_clear_readdir_array()
|
|
|
|
*/
|
|
|
|
static
|
2010-10-23 20:53:23 +02:00
|
|
|
int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
|
2010-09-24 20:48:42 +02:00
|
|
|
{
|
|
|
|
string->len = len;
|
|
|
|
string->name = kmemdup(name, len, GFP_KERNEL);
|
2010-10-23 20:53:23 +02:00
|
|
|
if (string->name == NULL)
|
|
|
|
return -ENOMEM;
|
2010-11-11 13:53:47 +01:00
|
|
|
/*
|
|
|
|
* Avoid a kmemleak false positive. The pointer to the name is stored
|
|
|
|
* in a page cache page which kmemleak does not scan.
|
|
|
|
*/
|
|
|
|
kmemleak_not_leak(string->name);
|
2010-10-23 20:53:23 +02:00
|
|
|
string->hash = full_name_hash(name, len);
|
|
|
|
return 0;
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_cache_array *array = nfs_readdir_get_array(page);
|
2010-10-23 20:53:23 +02:00
|
|
|
struct nfs_cache_array_entry *cache_entry;
|
|
|
|
int ret;
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
if (IS_ERR(array))
|
|
|
|
return PTR_ERR(array);
|
2010-11-20 21:18:22 +01:00
|
|
|
|
|
|
|
cache_entry = &array->array[array->size];
|
|
|
|
|
|
|
|
/* Check that this entry lies within the page bounds */
|
2010-11-16 02:26:22 +01:00
|
|
|
ret = -ENOSPC;
|
2010-11-20 21:18:22 +01:00
|
|
|
if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
|
2010-10-23 20:53:23 +02:00
|
|
|
goto out;
|
2010-09-24 20:48:42 +02:00
|
|
|
|
2010-10-23 20:53:23 +02:00
|
|
|
cache_entry->cookie = entry->prev_cookie;
|
|
|
|
cache_entry->ino = entry->ino;
|
2010-11-20 20:26:44 +01:00
|
|
|
cache_entry->d_type = entry->d_type;
|
2010-10-23 20:53:23 +02:00
|
|
|
ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2010-09-24 20:48:42 +02:00
|
|
|
array->last_cookie = entry->cookie;
|
2010-11-16 02:26:22 +01:00
|
|
|
array->size++;
|
2010-12-07 18:44:56 +01:00
|
|
|
if (entry->eof != 0)
|
2010-09-24 20:48:42 +02:00
|
|
|
array->eof_index = array->size;
|
2010-10-23 20:53:23 +02:00
|
|
|
out:
|
2010-09-24 20:48:42 +02:00
|
|
|
nfs_readdir_release_array(page);
|
2010-10-23 20:53:23 +02:00
|
|
|
return ret;
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
|
|
|
loff_t diff = desc->file->f_pos - desc->current_index;
|
|
|
|
unsigned int index;
|
|
|
|
|
|
|
|
if (diff < 0)
|
|
|
|
goto out_eof;
|
|
|
|
if (diff >= array->size) {
|
2010-11-16 02:26:22 +01:00
|
|
|
if (array->eof_index >= 0)
|
2010-09-24 20:48:42 +02:00
|
|
|
goto out_eof;
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = (unsigned int)diff;
|
|
|
|
*desc->dir_cookie = array->array[index].cookie;
|
|
|
|
desc->cache_entry_index = index;
|
|
|
|
return 0;
|
|
|
|
out_eof:
|
|
|
|
desc->eof = 1;
|
|
|
|
return -EBADCOOKIE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
|
|
|
int i;
|
2011-03-23 20:04:31 +01:00
|
|
|
loff_t new_pos;
|
2010-09-24 20:48:42 +02:00
|
|
|
int status = -EAGAIN;
|
|
|
|
|
|
|
|
for (i = 0; i < array->size; i++) {
|
|
|
|
if (array->array[i].cookie == *desc->dir_cookie) {
|
2011-07-30 18:45:35 +02:00
|
|
|
struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
|
|
|
|
struct nfs_open_dir_context *ctx = desc->file->private_data;
|
|
|
|
|
2011-03-23 20:04:31 +01:00
|
|
|
new_pos = desc->current_index + i;
|
2011-07-30 18:45:35 +02:00
|
|
|
if (ctx->attr_gencount != nfsi->attr_gencount
|
|
|
|
|| (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
|
|
|
|
ctx->duped = 0;
|
|
|
|
ctx->attr_gencount = nfsi->attr_gencount;
|
|
|
|
} else if (new_pos < desc->file->f_pos) {
|
|
|
|
if (ctx->duped > 0
|
|
|
|
&& ctx->dup_cookie == *desc->dir_cookie) {
|
|
|
|
if (printk_ratelimit()) {
|
|
|
|
pr_notice("NFS: directory %s/%s contains a readdir loop."
|
|
|
|
"Please contact your server vendor. "
|
2011-07-29 17:49:06 +02:00
|
|
|
"The file: %s has duplicate cookie %llu\n",
|
2011-07-30 18:45:35 +02:00
|
|
|
desc->file->f_dentry->d_parent->d_name.name,
|
|
|
|
desc->file->f_dentry->d_name.name,
|
2011-07-29 17:49:06 +02:00
|
|
|
array->array[i].string.name,
|
2011-07-30 18:45:35 +02:00
|
|
|
*desc->dir_cookie);
|
|
|
|
}
|
|
|
|
status = -ELOOP;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-03-23 20:04:31 +01:00
|
|
|
ctx->dup_cookie = *desc->dir_cookie;
|
2011-07-30 18:45:35 +02:00
|
|
|
ctx->duped = -1;
|
2011-03-23 20:04:31 +01:00
|
|
|
}
|
|
|
|
desc->file->f_pos = new_pos;
|
2010-09-24 20:48:42 +02:00
|
|
|
desc->cache_entry_index = i;
|
2010-12-07 18:44:56 +01:00
|
|
|
return 0;
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
|
|
|
}
|
2010-12-07 18:44:56 +01:00
|
|
|
if (array->eof_index >= 0) {
|
2010-11-16 02:26:22 +01:00
|
|
|
status = -EBADCOOKIE;
|
2010-12-07 18:41:58 +01:00
|
|
|
if (*desc->dir_cookie == array->last_cookie)
|
|
|
|
desc->eof = 1;
|
2010-11-16 02:26:22 +01:00
|
|
|
}
|
2011-07-30 18:45:35 +02:00
|
|
|
out:
|
2010-09-24 20:48:42 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
|
|
|
struct nfs_cache_array *array;
|
2010-12-07 18:44:56 +01:00
|
|
|
int status;
|
2010-09-24 20:48:42 +02:00
|
|
|
|
|
|
|
array = nfs_readdir_get_array(desc->page);
|
|
|
|
if (IS_ERR(array)) {
|
|
|
|
status = PTR_ERR(array);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*desc->dir_cookie == 0)
|
|
|
|
status = nfs_readdir_search_for_pos(array, desc);
|
|
|
|
else
|
|
|
|
status = nfs_readdir_search_for_cookie(array, desc);
|
|
|
|
|
2010-12-07 18:44:56 +01:00
|
|
|
if (status == -EAGAIN) {
|
2010-12-01 03:56:32 +01:00
|
|
|
desc->last_cookie = array->last_cookie;
|
2011-03-23 13:43:09 +01:00
|
|
|
desc->current_index += array->size;
|
2010-12-07 18:44:56 +01:00
|
|
|
desc->page_index++;
|
|
|
|
}
|
2010-09-24 20:48:42 +02:00
|
|
|
nfs_readdir_release_array(desc->page);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill a page with xdr information before transferring to the cache page */
|
|
|
|
static
|
2010-10-20 21:44:37 +02:00
|
|
|
int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
|
2010-09-24 20:48:42 +02:00
|
|
|
struct nfs_entry *entry, struct file *file, struct inode *inode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-03-23 19:48:29 +01:00
|
|
|
struct nfs_open_dir_context *ctx = file->private_data;
|
|
|
|
struct rpc_cred *cred = ctx->cred;
|
2008-10-15 01:16:07 +02:00
|
|
|
unsigned long timestamp, gencount;
|
2005-04-17 00:20:36 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
again:
|
|
|
|
timestamp = jiffies;
|
2008-10-15 01:16:07 +02:00
|
|
|
gencount = nfs_inc_attr_generation_counter();
|
2010-10-20 21:44:37 +02:00
|
|
|
error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
|
2005-04-17 00:20:36 +02:00
|
|
|
NFS_SERVER(inode)->dtsize, desc->plus);
|
|
|
|
if (error < 0) {
|
|
|
|
/* We requested READDIRPLUS, but the server doesn't grok it */
|
|
|
|
if (error == -ENOTSUPP && desc->plus) {
|
|
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
|
2008-01-23 07:58:59 +01:00
|
|
|
clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
desc->plus = 0;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
goto error;
|
|
|
|
}
|
2007-04-16 01:35:27 +02:00
|
|
|
desc->timestamp = timestamp;
|
2008-10-15 01:16:07 +02:00
|
|
|
desc->gencount = gencount;
|
2010-09-24 20:48:42 +02:00
|
|
|
error:
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-12-14 15:58:11 +01:00
|
|
|
static int xdr_decode(nfs_readdir_descriptor_t *desc,
|
|
|
|
struct nfs_entry *entry, struct xdr_stream *xdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-12-14 15:58:11 +01:00
|
|
|
int error;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-12-14 15:58:11 +01:00
|
|
|
error = desc->decode(xdr, entry, desc->plus);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2010-09-24 20:48:42 +02:00
|
|
|
entry->fattr->time_start = desc->timestamp;
|
|
|
|
entry->fattr->gencount = desc->gencount;
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-09-25 00:50:01 +02:00
|
|
|
static
|
|
|
|
int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
|
|
|
|
{
|
|
|
|
if (dentry->d_inode == NULL)
|
|
|
|
goto different;
|
2010-11-30 18:42:34 +01:00
|
|
|
if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
|
2010-09-25 00:50:01 +02:00
|
|
|
goto different;
|
|
|
|
return 1;
|
|
|
|
different:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
|
|
|
|
{
|
2010-10-23 20:53:23 +02:00
|
|
|
struct qstr filename = {
|
|
|
|
.len = entry->len,
|
|
|
|
.name = entry->name,
|
|
|
|
};
|
|
|
|
struct dentry *dentry;
|
|
|
|
struct dentry *alias;
|
2010-09-25 00:50:01 +02:00
|
|
|
struct inode *dir = parent->d_inode;
|
|
|
|
struct inode *inode;
|
|
|
|
|
2010-10-23 20:53:23 +02:00
|
|
|
if (filename.name[0] == '.') {
|
|
|
|
if (filename.len == 1)
|
|
|
|
return;
|
|
|
|
if (filename.len == 2 && filename.name[1] == '.')
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
filename.hash = full_name_hash(filename.name, filename.len);
|
2010-09-25 00:50:01 +02:00
|
|
|
|
2010-10-23 20:53:23 +02:00
|
|
|
dentry = d_lookup(parent, &filename);
|
2010-09-25 00:50:01 +02:00
|
|
|
if (dentry != NULL) {
|
|
|
|
if (nfs_same_file(dentry, entry)) {
|
|
|
|
nfs_refresh_inode(dentry->d_inode, entry->fattr);
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
d_drop(dentry);
|
|
|
|
dput(dentry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dentry = d_alloc(parent, &filename);
|
2010-10-23 20:53:23 +02:00
|
|
|
if (dentry == NULL)
|
|
|
|
return;
|
|
|
|
|
2010-09-25 00:50:01 +02:00
|
|
|
inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
alias = d_materialise_unique(dentry, inode);
|
|
|
|
if (IS_ERR(alias))
|
|
|
|
goto out;
|
|
|
|
else if (alias) {
|
|
|
|
nfs_set_verifier(alias, nfs_save_change_attribute(dir));
|
|
|
|
dput(alias);
|
|
|
|
} else
|
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
|
|
|
|
|
|
|
out:
|
|
|
|
dput(dentry);
|
|
|
|
}
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
/* Perform conversion from xdr to cache array */
|
|
|
|
static
|
2010-11-16 02:26:22 +01:00
|
|
|
int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
|
2011-01-08 23:45:38 +01:00
|
|
|
struct page **xdr_pages, struct page *page, unsigned int buflen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-10-20 21:44:29 +02:00
|
|
|
struct xdr_stream stream;
|
2011-05-19 20:16:47 +02:00
|
|
|
struct xdr_buf buf;
|
2011-01-08 23:45:38 +01:00
|
|
|
struct page *scratch;
|
2010-10-21 22:33:16 +02:00
|
|
|
struct nfs_cache_array *array;
|
2010-11-20 18:43:45 +01:00
|
|
|
unsigned int count = 0;
|
|
|
|
int status;
|
2010-10-20 21:44:29 +02:00
|
|
|
|
2011-01-08 23:45:38 +01:00
|
|
|
scratch = alloc_page(GFP_KERNEL);
|
|
|
|
if (scratch == NULL)
|
|
|
|
return -ENOMEM;
|
2010-10-20 21:44:29 +02:00
|
|
|
|
2011-05-19 20:16:47 +02:00
|
|
|
xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
|
2011-01-08 23:45:38 +01:00
|
|
|
xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
|
2010-10-21 22:33:16 +02:00
|
|
|
|
|
|
|
do {
|
|
|
|
status = xdr_decode(desc, entry, &stream);
|
2010-11-16 02:26:22 +01:00
|
|
|
if (status != 0) {
|
|
|
|
if (status == -EAGAIN)
|
|
|
|
status = 0;
|
2010-10-21 22:33:16 +02:00
|
|
|
break;
|
2010-11-16 02:26:22 +01:00
|
|
|
}
|
2010-10-21 22:33:16 +02:00
|
|
|
|
2010-11-20 18:43:45 +01:00
|
|
|
count++;
|
|
|
|
|
2010-12-07 18:44:56 +01:00
|
|
|
if (desc->plus != 0)
|
2010-09-25 00:50:01 +02:00
|
|
|
nfs_prime_dcache(desc->file->f_path.dentry, entry);
|
2010-11-16 02:26:22 +01:00
|
|
|
|
|
|
|
status = nfs_readdir_add_to_array(entry, page);
|
|
|
|
if (status != 0)
|
|
|
|
break;
|
2010-10-21 22:33:16 +02:00
|
|
|
} while (!entry->eof);
|
|
|
|
|
2010-12-07 18:44:56 +01:00
|
|
|
if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
|
2010-10-21 22:33:16 +02:00
|
|
|
array = nfs_readdir_get_array(page);
|
2010-11-16 02:26:22 +01:00
|
|
|
if (!IS_ERR(array)) {
|
|
|
|
array->eof_index = array->size;
|
|
|
|
status = 0;
|
|
|
|
nfs_readdir_release_array(page);
|
2010-11-20 18:43:45 +01:00
|
|
|
} else
|
|
|
|
status = PTR_ERR(array);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2011-01-08 23:45:38 +01:00
|
|
|
|
|
|
|
put_page(scratch);
|
2010-11-16 02:26:22 +01:00
|
|
|
return status;
|
2010-10-20 21:44:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < npages; i++)
|
|
|
|
put_page(pages[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void nfs_readdir_free_large_page(void *ptr, struct page **pages,
|
|
|
|
unsigned int npages)
|
|
|
|
{
|
|
|
|
nfs_readdir_free_pagearray(pages, npages);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs_readdir_large_page will allocate pages that must be freed with a call
|
|
|
|
* to nfs_readdir_free_large_page
|
|
|
|
*/
|
|
|
|
static
|
2011-01-08 23:45:38 +01:00
|
|
|
int nfs_readdir_large_page(struct page **pages, unsigned int npages)
|
2010-10-20 21:44:37 +02:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
struct page *page = alloc_page(GFP_KERNEL);
|
|
|
|
if (page == NULL)
|
|
|
|
goto out_freepages;
|
|
|
|
pages[i] = page;
|
|
|
|
}
|
2011-01-08 23:45:38 +01:00
|
|
|
return 0;
|
2010-10-20 21:44:37 +02:00
|
|
|
|
|
|
|
out_freepages:
|
|
|
|
nfs_readdir_free_pagearray(pages, i);
|
2011-01-08 23:45:38 +01:00
|
|
|
return -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
static
|
|
|
|
int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
|
2005-06-22 19:16:29 +02:00
|
|
|
{
|
2010-10-20 21:44:37 +02:00
|
|
|
struct page *pages[NFS_MAX_READDIR_PAGES];
|
|
|
|
void *pages_ptr = NULL;
|
2010-09-24 20:48:42 +02:00
|
|
|
struct nfs_entry entry;
|
|
|
|
struct file *file = desc->file;
|
|
|
|
struct nfs_cache_array *array;
|
2010-11-16 02:26:22 +01:00
|
|
|
int status = -ENOMEM;
|
2010-10-20 21:44:37 +02:00
|
|
|
unsigned int array_size = ARRAY_SIZE(pages);
|
2010-09-24 20:48:42 +02:00
|
|
|
|
|
|
|
entry.prev_cookie = 0;
|
2010-12-01 03:56:32 +01:00
|
|
|
entry.cookie = desc->last_cookie;
|
2010-09-24 20:48:42 +02:00
|
|
|
entry.eof = 0;
|
|
|
|
entry.fh = nfs_alloc_fhandle();
|
|
|
|
entry.fattr = nfs_alloc_fattr();
|
2010-12-14 15:58:11 +01:00
|
|
|
entry.server = NFS_SERVER(inode);
|
2010-09-24 20:48:42 +02:00
|
|
|
if (entry.fh == NULL || entry.fattr == NULL)
|
|
|
|
goto out;
|
2005-06-22 19:16:29 +02:00
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
array = nfs_readdir_get_array(page);
|
2010-11-16 02:26:22 +01:00
|
|
|
if (IS_ERR(array)) {
|
|
|
|
status = PTR_ERR(array);
|
|
|
|
goto out;
|
|
|
|
}
|
2010-09-24 20:48:42 +02:00
|
|
|
memset(array, 0, sizeof(struct nfs_cache_array));
|
|
|
|
array->eof_index = -1;
|
2005-06-22 19:16:29 +02:00
|
|
|
|
2011-01-08 23:45:38 +01:00
|
|
|
status = nfs_readdir_large_page(pages, array_size);
|
|
|
|
if (status < 0)
|
2010-09-24 20:48:42 +02:00
|
|
|
goto out_release_array;
|
|
|
|
do {
|
2010-11-16 02:26:22 +01:00
|
|
|
unsigned int pglen;
|
2010-10-20 21:44:37 +02:00
|
|
|
status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
|
2010-10-20 21:44:29 +02:00
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
if (status < 0)
|
2005-06-22 19:16:29 +02:00
|
|
|
break;
|
2010-11-16 02:26:22 +01:00
|
|
|
pglen = status;
|
2011-01-08 23:45:38 +01:00
|
|
|
status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
|
2010-11-16 02:26:22 +01:00
|
|
|
if (status < 0) {
|
|
|
|
if (status == -ENOSPC)
|
|
|
|
status = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (array->eof_index < 0);
|
2010-09-24 20:48:42 +02:00
|
|
|
|
2010-10-20 21:44:37 +02:00
|
|
|
nfs_readdir_free_large_page(pages_ptr, pages, array_size);
|
2010-09-24 20:48:42 +02:00
|
|
|
out_release_array:
|
|
|
|
nfs_readdir_release_array(page);
|
|
|
|
out:
|
|
|
|
nfs_free_fattr(entry.fattr);
|
|
|
|
nfs_free_fhandle(entry.fh);
|
2005-06-22 19:16:29 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-09-24 20:48:42 +02:00
|
|
|
* Now we cache directories properly, by converting xdr information
|
|
|
|
* to an array that can be used for lookups later. This results in
|
|
|
|
* fewer cache pages, since we can store more information on each page.
|
|
|
|
* We only need to convert from xdr once so future lookups are much simpler
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2010-09-24 20:48:42 +02:00
|
|
|
static
|
|
|
|
int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct inode *inode = desc->file->f_path.dentry->d_inode;
|
2010-11-16 02:26:22 +01:00
|
|
|
int ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-11-16 02:26:22 +01:00
|
|
|
ret = nfs_readdir_xdr_to_array(desc, page, inode);
|
|
|
|
if (ret < 0)
|
2010-09-24 20:48:42 +02:00
|
|
|
goto error;
|
|
|
|
SetPageUptodate(page);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
|
|
|
|
/* Should never happen */
|
|
|
|
nfs_zap_mapping(inode, inode->i_mapping);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-09-24 20:48:42 +02:00
|
|
|
unlock_page(page);
|
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
unlock_page(page);
|
2010-11-16 02:26:22 +01:00
|
|
|
return ret;
|
2010-09-24 20:48:42 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
static
|
|
|
|
void cache_page_release(nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
2010-12-01 20:17:06 +01:00
|
|
|
if (!desc->page->mapping)
|
|
|
|
nfs_readdir_clear_array(desc->page);
|
2010-09-24 20:48:42 +02:00
|
|
|
page_cache_release(desc->page);
|
|
|
|
desc->page = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
2010-11-16 02:26:22 +01:00
|
|
|
return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
|
2010-09-24 20:48:42 +02:00
|
|
|
desc->page_index, (filler_t *)nfs_readdir_filler, desc);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-09-24 20:48:42 +02:00
|
|
|
* Returns 0 if desc->dir_cookie was found on page desc->page_index
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2010-09-24 20:48:42 +02:00
|
|
|
static
|
|
|
|
int find_cache_page(nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
desc->page = get_cache_page(desc);
|
|
|
|
if (IS_ERR(desc->page))
|
|
|
|
return PTR_ERR(desc->page);
|
|
|
|
|
|
|
|
res = nfs_readdir_search_array(desc);
|
2010-12-07 18:44:56 +01:00
|
|
|
if (res != 0)
|
|
|
|
cache_page_release(desc);
|
2010-09-24 20:48:42 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search for desc->dir_cookie from the beginning of the page cache */
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline
|
|
|
|
int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
|
|
|
|
{
|
2010-11-16 02:26:22 +01:00
|
|
|
int res;
|
2010-09-24 20:48:42 +02:00
|
|
|
|
2010-12-01 03:56:32 +01:00
|
|
|
if (desc->page_index == 0) {
|
2010-11-16 02:26:22 +01:00
|
|
|
desc->current_index = 0;
|
2010-12-01 03:56:32 +01:00
|
|
|
desc->last_cookie = 0;
|
|
|
|
}
|
2010-12-07 18:44:56 +01:00
|
|
|
do {
|
2010-09-24 20:48:42 +02:00
|
|
|
res = find_cache_page(desc);
|
2010-12-07 18:44:56 +01:00
|
|
|
} while (res == -EAGAIN);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Once we've found the start of the dirent within a page: fill 'er up...
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
|
|
|
|
filldir_t filldir)
|
|
|
|
{
|
|
|
|
struct file *file = desc->file;
|
2010-09-24 20:48:42 +02:00
|
|
|
int i = 0;
|
|
|
|
int res = 0;
|
|
|
|
struct nfs_cache_array *array = NULL;
|
2011-03-23 20:04:31 +01:00
|
|
|
struct nfs_open_dir_context *ctx = file->private_data;
|
|
|
|
|
2010-09-24 20:48:42 +02:00
|
|
|
array = nfs_readdir_get_array(desc->page);
|
2010-11-20 19:22:24 +01:00
|
|
|
if (IS_ERR(array)) {
|
|
|
|
res = PTR_ERR(array);
|
|
|
|
goto out;
|
|
|
|
}
|
2010-09-24 20:48:42 +02:00
|
|
|
|
|
|
|
for (i = desc->cache_entry_index; i < array->size; i++) {
|
2010-11-20 19:55:33 +01:00
|
|
|
struct nfs_cache_array_entry *ent;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-11-20 19:55:33 +01:00
|
|
|
ent = &array->array[i];
|
|
|
|
if (filldir(dirent, ent->string.name, ent->string.len,
|
2010-11-20 20:26:44 +01:00
|
|
|
file->f_pos, nfs_compat_user_ino64(ent->ino),
|
|
|
|
ent->d_type) < 0) {
|
2010-11-20 19:55:33 +01:00
|
|
|
desc->eof = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2010-11-20 19:55:33 +01:00
|
|
|
}
|
2005-06-22 19:16:29 +02:00
|
|
|
file->f_pos++;
|
2010-09-24 20:48:42 +02:00
|
|
|
if (i < (array->size-1))
|
|
|
|
*desc->dir_cookie = array->array[i+1].cookie;
|
|
|
|
else
|
|
|
|
*desc->dir_cookie = array->last_cookie;
|
2011-07-30 18:45:35 +02:00
|
|
|
if (ctx->duped != 0)
|
|
|
|
ctx->duped = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-12-07 18:44:56 +01:00
|
|
|
if (array->eof_index >= 0)
|
2010-11-16 02:26:22 +01:00
|
|
|
desc->eof = 1;
|
2010-09-24 20:48:42 +02:00
|
|
|
|
|
|
|
nfs_readdir_release_array(desc->page);
|
2010-11-20 19:22:24 +01:00
|
|
|
out:
|
2010-09-24 20:48:42 +02:00
|
|
|
cache_page_release(desc);
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
|
|
|
|
(unsigned long long)*desc->dir_cookie, res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we cannot find a cookie in our cache, we suspect that this is
|
|
|
|
* because it points to a deleted file, so we ask the server to return
|
|
|
|
* whatever it thinks is the next entry. We then feed this to filldir.
|
|
|
|
* If all goes well, we should then be able to find our way round the
|
|
|
|
* cache on the next call to readdir_search_pagecache();
|
|
|
|
*
|
|
|
|
* NOTE: we cannot add the anonymous page to the pagecache because
|
|
|
|
* the data it contains might not be page aligned. Besides,
|
|
|
|
* we should already have a complete representation of the
|
|
|
|
* directory in the page cache by the time we get here.
|
|
|
|
*/
|
|
|
|
static inline
|
|
|
|
int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
|
|
|
|
filldir_t filldir)
|
|
|
|
{
|
|
|
|
struct page *page = NULL;
|
|
|
|
int status;
|
2010-09-24 20:48:42 +02:00
|
|
|
struct inode *inode = desc->file->f_path.dentry->d_inode;
|
2011-07-30 18:45:35 +02:00
|
|
|
struct nfs_open_dir_context *ctx = desc->file->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
|
|
|
|
(unsigned long long)*desc->dir_cookie);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
page = alloc_page(GFP_HIGHUSER);
|
|
|
|
if (!page) {
|
|
|
|
status = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-09-24 20:48:42 +02:00
|
|
|
|
2010-11-20 19:24:46 +01:00
|
|
|
desc->page_index = 0;
|
2010-12-01 03:56:32 +01:00
|
|
|
desc->last_cookie = *desc->dir_cookie;
|
2010-11-20 19:24:46 +01:00
|
|
|
desc->page = page;
|
2011-07-30 18:45:35 +02:00
|
|
|
ctx->duped = 0;
|
2010-11-20 19:24:46 +01:00
|
|
|
|
2010-11-20 19:24:49 +01:00
|
|
|
status = nfs_readdir_xdr_to_array(desc, page, inode);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_release;
|
|
|
|
|
|
|
|
status = nfs_do_filldir(desc, dirent, filldir);
|
|
|
|
|
|
|
|
out:
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
out_release:
|
2010-09-24 20:48:42 +02:00
|
|
|
cache_page_release(desc);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-06-22 19:16:29 +02:00
|
|
|
/* The file offset position represents the dirent entry number. A
|
|
|
|
last cookie cache takes care of the common case of reading the
|
|
|
|
whole directory.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
|
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
nfs_readdir_descriptor_t my_desc,
|
|
|
|
*desc = &my_desc;
|
2011-03-23 19:48:29 +01:00
|
|
|
struct nfs_open_dir_context *dir_ctx = filp->private_data;
|
2010-12-07 18:44:56 +01:00
|
|
|
int res;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
(long long)filp->f_pos);
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2005-06-22 19:16:29 +02:00
|
|
|
* filp->f_pos points to the dirent entry number.
|
2005-06-22 19:16:29 +02:00
|
|
|
* *desc->dir_cookie has the cookie for the next entry. We have
|
2005-06-22 19:16:29 +02:00
|
|
|
* to either find the entry with the appropriate number or
|
|
|
|
* revalidate the cookie.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
memset(desc, 0, sizeof(*desc));
|
|
|
|
|
|
|
|
desc->file = filp;
|
2011-03-23 19:48:29 +01:00
|
|
|
desc->dir_cookie = &dir_ctx->dir_cookie;
|
2005-04-17 00:20:36 +02:00
|
|
|
desc->decode = NFS_PROTO(inode)->decode_dirent;
|
|
|
|
desc->plus = NFS_USE_READDIRPLUS(inode);
|
|
|
|
|
2007-10-16 00:17:53 +02:00
|
|
|
nfs_block_sillyrename(dentry);
|
2010-02-20 02:03:30 +01:00
|
|
|
res = nfs_revalidate_mapping(inode, filp->f_mapping);
|
2008-01-26 23:37:47 +01:00
|
|
|
if (res < 0)
|
|
|
|
goto out;
|
|
|
|
|
2010-12-07 18:44:56 +01:00
|
|
|
do {
|
2005-04-17 00:20:36 +02:00
|
|
|
res = readdir_search_pagecache(desc);
|
2005-06-22 19:16:29 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (res == -EBADCOOKIE) {
|
2010-11-20 19:55:33 +01:00
|
|
|
res = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* This means either end of directory */
|
2010-09-24 20:48:42 +02:00
|
|
|
if (*desc->dir_cookie && desc->eof == 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Or that the server has 'lost' a cookie */
|
|
|
|
res = uncached_readdir(desc, dirent, filldir);
|
2010-11-20 19:55:33 +01:00
|
|
|
if (res == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (res == -ETOOSMALL && desc->plus) {
|
2008-01-23 07:58:59 +01:00
|
|
|
clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs_zap_caches(inode);
|
2010-09-25 00:49:43 +02:00
|
|
|
desc->page_index = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
desc->plus = 0;
|
2010-09-24 20:48:42 +02:00
|
|
|
desc->eof = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (res < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
res = nfs_do_filldir(desc, dirent, filldir);
|
2010-11-20 19:55:33 +01:00
|
|
|
if (res < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2010-12-07 18:44:56 +01:00
|
|
|
} while (!desc->eof);
|
2008-01-26 23:37:47 +01:00
|
|
|
out:
|
2007-10-16 00:17:53 +02:00
|
|
|
nfs_unblock_sillyrename(dentry);
|
2006-03-20 19:44:24 +01:00
|
|
|
if (res > 0)
|
|
|
|
res = 0;
|
2010-04-16 22:22:49 +02:00
|
|
|
dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
res);
|
|
|
|
return res;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-05-14 23:16:04 +02:00
|
|
|
static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
|
2005-06-22 19:16:29 +02:00
|
|
|
{
|
2008-06-11 23:55:34 +02:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
2011-03-23 19:48:29 +01:00
|
|
|
struct nfs_open_dir_context *dir_ctx = filp->private_data;
|
2008-06-11 23:55:34 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
|
2008-06-11 23:55:34 +02:00
|
|
|
dentry->d_parent->d_name.name,
|
|
|
|
dentry->d_name.name,
|
|
|
|
offset, origin);
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-06-22 19:16:29 +02:00
|
|
|
switch (origin) {
|
|
|
|
case 1:
|
|
|
|
offset += filp->f_pos;
|
|
|
|
case 0:
|
|
|
|
if (offset >= 0)
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
offset = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (offset != filp->f_pos) {
|
|
|
|
filp->f_pos = offset;
|
2011-03-23 19:48:29 +01:00
|
|
|
dir_ctx->dir_cookie = 0;
|
2011-03-23 20:04:31 +01:00
|
|
|
dir_ctx->duped = 0;
|
2005-06-22 19:16:29 +02:00
|
|
|
}
|
|
|
|
out:
|
2008-06-11 23:55:34 +02:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-06-22 19:16:29 +02:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* All directory operations under NFS are synchronous, so fsync()
|
|
|
|
* is a dummy operation.
|
|
|
|
*/
|
2011-07-17 02:44:56 +02:00
|
|
|
static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
|
|
|
|
int datasync)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-05-26 17:53:25 +02:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
2011-07-17 02:44:56 +02:00
|
|
|
struct inode *inode = dentry->d_inode;
|
2010-05-26 17:53:25 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
datasync);
|
|
|
|
|
2011-07-17 02:44:56 +02:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2008-05-27 22:29:07 +02:00
|
|
|
nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
|
2011-07-17 02:44:56 +02:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-16 00:18:29 +02:00
|
|
|
/**
|
|
|
|
* nfs_force_lookup_revalidate - Mark the directory as having changed
|
|
|
|
* @dir - pointer to directory inode
|
|
|
|
*
|
|
|
|
* This forces the revalidation code in nfs_lookup_revalidate() to do a
|
|
|
|
* full lookup on all child dentries of 'dir' whenever a change occurs
|
|
|
|
* on the server that might have invalidated our dcache.
|
|
|
|
*
|
|
|
|
* The caller should be holding dir->i_lock
|
|
|
|
*/
|
|
|
|
void nfs_force_lookup_revalidate(struct inode *dir)
|
|
|
|
{
|
2008-10-15 01:24:50 +02:00
|
|
|
NFS_I(dir)->cache_change_attribute++;
|
2007-10-16 00:18:29 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* A check for whether or not the parent directory has changed.
|
|
|
|
* In the case it has, we assume that the dentries are untrustworthy
|
|
|
|
* and may need to be looked up again.
|
|
|
|
*/
|
2007-01-31 14:16:24 +01:00
|
|
|
static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (IS_ROOT(dentry))
|
|
|
|
return 1;
|
2008-07-15 23:58:13 +02:00
|
|
|
if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
|
|
|
|
return 0;
|
2007-10-02 18:54:39 +02:00
|
|
|
if (!nfs_verify_change_attribute(dir, dentry->d_time))
|
|
|
|
return 0;
|
|
|
|
/* Revalidate nfsi->cache_change_attribute before we declare a match */
|
|
|
|
if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
|
|
|
|
return 0;
|
|
|
|
if (!nfs_verify_change_attribute(dir, dentry->d_time))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-08 00:37:01 +02:00
|
|
|
/*
|
|
|
|
* Return the intent data that applies to this particular path component
|
|
|
|
*
|
|
|
|
* Note that the current set of intents only apply to the very last
|
2011-06-26 03:48:43 +02:00
|
|
|
* component of the path and none of them is set before that last
|
|
|
|
* component.
|
2005-06-08 00:37:01 +02:00
|
|
|
*/
|
2011-01-07 07:49:57 +01:00
|
|
|
static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
|
|
|
|
unsigned int mask)
|
2005-06-08 00:37:01 +02:00
|
|
|
{
|
|
|
|
return nd->flags & mask;
|
|
|
|
}
|
|
|
|
|
2007-10-03 01:13:04 +02:00
|
|
|
/*
|
|
|
|
* Use intent information to check whether or not we're going to do
|
|
|
|
* an O_EXCL create using this path component.
|
|
|
|
*/
|
|
|
|
static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
|
|
|
|
{
|
|
|
|
if (NFS_PROTO(dir)->version == 2)
|
|
|
|
return 0;
|
2008-08-05 09:00:49 +02:00
|
|
|
return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);
|
2007-10-03 01:13:04 +02:00
|
|
|
}
|
|
|
|
|
2005-06-08 00:37:01 +02:00
|
|
|
/*
|
|
|
|
* Inode and filehandle revalidation for lookups.
|
|
|
|
*
|
|
|
|
* We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
|
|
|
|
* or if the intent information indicates that we're about to open this
|
|
|
|
* particular file and the "nocto" mount flag is not set.
|
|
|
|
*
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline
|
|
|
|
int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
|
|
|
|
{
|
|
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
|
|
|
2011-01-14 19:45:42 +01:00
|
|
|
if (IS_AUTOMOUNT(inode))
|
2008-03-06 18:34:59 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (nd != NULL) {
|
|
|
|
/* VFS wants an on-the-wire revalidation */
|
2005-06-08 00:37:01 +02:00
|
|
|
if (nd->flags & LOOKUP_REVAL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_force;
|
|
|
|
/* This is an open(2) */
|
2005-06-08 00:37:01 +02:00
|
|
|
if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
|
2006-07-05 19:05:13 +02:00
|
|
|
!(server->flags & NFS_MOUNT_NOCTO) &&
|
|
|
|
(S_ISREG(inode->i_mode) ||
|
|
|
|
S_ISDIR(inode->i_mode)))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_force;
|
2007-10-03 05:13:32 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return nfs_revalidate_inode(server, inode);
|
|
|
|
out_force:
|
|
|
|
return __nfs_revalidate_inode(server, inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We judge how long we want to trust negative
|
|
|
|
* dentries by looking at the parent inode mtime.
|
|
|
|
*
|
|
|
|
* If parent mtime has changed, we revalidate, else we wait for a
|
|
|
|
* period corresponding to the parent's attribute cache timeout value.
|
|
|
|
*/
|
|
|
|
static inline
|
|
|
|
int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
|
|
|
|
struct nameidata *nd)
|
|
|
|
{
|
|
|
|
/* Don't revalidate a negative dentry if we're creating a new file */
|
2005-06-08 00:37:01 +02:00
|
|
|
if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2008-07-15 23:58:13 +02:00
|
|
|
if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
|
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
return !nfs_check_verifier(dir, dentry);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called every time the dcache has a lookup hit,
|
|
|
|
* and we should check whether we can really trust that
|
|
|
|
* lookup.
|
|
|
|
*
|
|
|
|
* NOTE! The hit can be a negative hit too, don't assume
|
|
|
|
* we have an inode!
|
|
|
|
*
|
|
|
|
* If the parent directory is seen to have changed, we throw out the
|
|
|
|
* cached dentry and do a new lookup.
|
|
|
|
*/
|
2011-01-07 07:49:57 +01:00
|
|
|
static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inode *dir;
|
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *parent;
|
2010-04-16 22:22:47 +02:00
|
|
|
struct nfs_fh *fhandle = NULL;
|
|
|
|
struct nfs_fattr *fattr = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
int error;
|
|
|
|
|
2011-01-07 07:49:57 +01:00
|
|
|
if (nd->flags & LOOKUP_RCU)
|
|
|
|
return -ECHILD;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
parent = dget_parent(dentry);
|
|
|
|
dir = parent->d_inode;
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
|
2005-04-17 00:20:36 +02:00
|
|
|
inode = dentry->d_inode;
|
|
|
|
|
|
|
|
if (!inode) {
|
|
|
|
if (nfs_neg_need_reval(dir, dentry, nd))
|
|
|
|
goto out_bad;
|
|
|
|
goto out_valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_bad_inode(inode)) {
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, dentry->d_parent->d_name.name,
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_bad;
|
|
|
|
}
|
|
|
|
|
2008-12-23 21:21:54 +01:00
|
|
|
if (nfs_have_delegation(inode, FMODE_READ))
|
|
|
|
goto out_set_verifier;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Force a full look up iff the parent directory has changed */
|
2007-10-03 01:13:04 +02:00
|
|
|
if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (nfs_lookup_verify_inode(inode, nd))
|
|
|
|
goto out_zap_parent;
|
|
|
|
goto out_valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NFS_STALE(inode))
|
|
|
|
goto out_bad;
|
|
|
|
|
2010-04-16 22:22:47 +02:00
|
|
|
error = -ENOMEM;
|
|
|
|
fhandle = nfs_alloc_fhandle();
|
|
|
|
fattr = nfs_alloc_fattr();
|
|
|
|
if (fhandle == NULL || fattr == NULL)
|
|
|
|
goto out_error;
|
|
|
|
|
2011-03-24 18:12:24 +01:00
|
|
|
error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error)
|
|
|
|
goto out_bad;
|
2010-04-16 22:22:47 +02:00
|
|
|
if (nfs_compare_fh(NFS_FH(inode), fhandle))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_bad;
|
2010-04-16 22:22:47 +02:00
|
|
|
if ((error = nfs_refresh_inode(inode, fattr)) != 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_bad;
|
|
|
|
|
2010-04-16 22:22:47 +02:00
|
|
|
nfs_free_fattr(fattr);
|
|
|
|
nfs_free_fhandle(fhandle);
|
2008-12-23 21:21:54 +01:00
|
|
|
out_set_verifier:
|
2007-10-01 19:46:53 +02:00
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
2005-04-17 00:20:36 +02:00
|
|
|
out_valid:
|
|
|
|
dput(parent);
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, dentry->d_parent->d_name.name,
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
out_zap_parent:
|
|
|
|
nfs_zap_caches(dir);
|
|
|
|
out_bad:
|
2007-09-29 23:25:43 +02:00
|
|
|
nfs_mark_for_revalidate(dir);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (inode && S_ISDIR(inode->i_mode)) {
|
|
|
|
/* Purge readdir caches. */
|
|
|
|
nfs_zap_caches(inode);
|
|
|
|
/* If we have submounts, don't unhash ! */
|
|
|
|
if (have_submounts(dentry))
|
|
|
|
goto out_valid;
|
2010-04-29 04:10:43 +02:00
|
|
|
if (dentry->d_flags & DCACHE_DISCONNECTED)
|
|
|
|
goto out_valid;
|
2005-04-17 00:20:36 +02:00
|
|
|
shrink_dcache_parent(dentry);
|
|
|
|
}
|
|
|
|
d_drop(dentry);
|
2010-04-16 22:22:47 +02:00
|
|
|
nfs_free_fattr(fattr);
|
|
|
|
nfs_free_fhandle(fhandle);
|
2005-04-17 00:20:36 +02:00
|
|
|
dput(parent);
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, dentry->d_parent->d_name.name,
|
2006-03-20 19:44:24 +01:00
|
|
|
dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2010-04-16 22:22:47 +02:00
|
|
|
out_error:
|
|
|
|
nfs_free_fattr(fattr);
|
|
|
|
nfs_free_fhandle(fhandle);
|
|
|
|
dput(parent);
|
|
|
|
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
|
|
|
|
__func__, dentry->d_parent->d_name.name,
|
|
|
|
dentry->d_name.name, error);
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called from dput() when d_count is going to 0.
|
|
|
|
*/
|
2011-01-07 07:49:23 +01:00
|
|
|
static int nfs_dentry_delete(const struct dentry *dentry)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
dentry->d_flags);
|
|
|
|
|
2008-01-29 01:43:19 +01:00
|
|
|
/* Unhash any dentry with a stale inode */
|
|
|
|
if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
|
|
|
|
return 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
|
|
|
|
/* Unhash it, so that ->d_iput() would be called */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
|
|
|
|
/* Unhash it, so that ancestors of killed async unlink
|
|
|
|
* files will be cleaned up during umount */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-06-11 21:44:04 +02:00
|
|
|
static void nfs_drop_nlink(struct inode *inode)
|
|
|
|
{
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (inode->i_nlink > 0)
|
|
|
|
drop_nlink(inode);
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Called when the dentry loses inode.
|
|
|
|
* We use it to clean up silly-renamed files.
|
|
|
|
*/
|
|
|
|
static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
|
|
|
|
{
|
2007-02-26 02:48:25 +01:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
/* drop any readdir cache as it could easily be old */
|
|
|
|
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
|
2006-10-01 08:29:03 +02:00
|
|
|
drop_nlink(inode);
|
2007-07-14 21:39:58 +02:00
|
|
|
nfs_complete_unlink(dentry, inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
iput(inode);
|
|
|
|
}
|
|
|
|
|
2011-03-16 10:44:14 +01:00
|
|
|
static void nfs_d_release(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
/* free cached devname value, if it survived that far */
|
|
|
|
if (unlikely(dentry->d_fsdata)) {
|
|
|
|
if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
|
|
|
|
WARN_ON(1);
|
|
|
|
else
|
|
|
|
kfree(dentry->d_fsdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-20 06:51:22 +01:00
|
|
|
const struct dentry_operations nfs_dentry_operations = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.d_revalidate = nfs_lookup_revalidate,
|
|
|
|
.d_delete = nfs_dentry_delete,
|
|
|
|
.d_iput = nfs_dentry_iput,
|
2011-01-14 19:45:42 +01:00
|
|
|
.d_automount = nfs_d_automount,
|
2011-03-16 10:44:14 +01:00
|
|
|
.d_release = nfs_d_release,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
|
|
|
|
{
|
|
|
|
struct dentry *res;
|
2007-10-16 00:17:53 +02:00
|
|
|
struct dentry *parent;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode = NULL;
|
2010-04-16 22:22:47 +02:00
|
|
|
struct nfs_fh *fhandle = NULL;
|
|
|
|
struct nfs_fattr *fattr = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: lookup(%s/%s)\n",
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name);
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
res = ERR_PTR(-ENAMETOOLONG);
|
|
|
|
if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
|
|
|
|
goto out;
|
|
|
|
|
2006-09-05 18:27:44 +02:00
|
|
|
/*
|
|
|
|
* If we're doing an exclusive create, optimize away the lookup
|
|
|
|
* but don't hash the dentry.
|
|
|
|
*/
|
|
|
|
if (nfs_is_exclusive_create(dir, nd)) {
|
|
|
|
d_instantiate(dentry, NULL);
|
|
|
|
res = NULL;
|
2008-06-11 21:44:20 +02:00
|
|
|
goto out;
|
2006-09-05 18:27:44 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-04-16 22:22:47 +02:00
|
|
|
res = ERR_PTR(-ENOMEM);
|
|
|
|
fhandle = nfs_alloc_fhandle();
|
|
|
|
fattr = nfs_alloc_fattr();
|
|
|
|
if (fhandle == NULL || fattr == NULL)
|
|
|
|
goto out;
|
|
|
|
|
2007-10-16 00:17:53 +02:00
|
|
|
parent = dentry->d_parent;
|
|
|
|
/* Protect against concurrent sillydeletes */
|
|
|
|
nfs_block_sillyrename(parent);
|
2011-03-24 18:12:24 +01:00
|
|
|
error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error == -ENOENT)
|
|
|
|
goto no_entry;
|
|
|
|
if (error < 0) {
|
|
|
|
res = ERR_PTR(error);
|
2007-10-16 00:17:53 +02:00
|
|
|
goto out_unblock_sillyrename;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-04-16 22:22:47 +02:00
|
|
|
inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
|
2010-12-28 18:02:46 +01:00
|
|
|
res = ERR_CAST(inode);
|
2006-03-20 19:44:48 +01:00
|
|
|
if (IS_ERR(res))
|
2007-10-16 00:17:53 +02:00
|
|
|
goto out_unblock_sillyrename;
|
NFS: Share NFS superblocks per-protocol per-server per-FSID
The attached patch makes NFS share superblocks between mounts from the same
server and FSID over the same protocol.
It does this by creating each superblock with a false root and returning the
real root dentry in the vfsmount presented by get_sb(). The root dentry set
starts off as an anonymous dentry if we don't already have the dentry for its
inode, otherwise it simply returns the dentry we already have.
We may thus end up with several trees of dentries in the superblock, and if at
some later point one of anonymous tree roots is discovered by normal filesystem
activity to be located in another tree within the superblock, the anonymous
root is named and materialises attached to the second tree at the appropriate
point.
Why do it this way? Why not pass an extra argument to the mount() syscall to
indicate the subpath and then pathwalk from the server root to the desired
directory? You can't guarantee this will work for two reasons:
(1) The root and intervening nodes may not be accessible to the client.
With NFS2 and NFS3, for instance, mountd is called on the server to get
the filehandle for the tip of a path. mountd won't give us handles for
anything we don't have permission to access, and so we can't set up NFS
inodes for such nodes, and so can't easily set up dentries (we'd have to
have ghost inodes or something).
With this patch we don't actually create dentries until we get handles
from the server that we can use to set up their inodes, and we don't
actually bind them into the tree until we know for sure where they go.
(2) Inaccessible symbolic links.
If we're asked to mount two exports from the server, eg:
mount warthog:/warthog/aaa/xxx /mmm
mount warthog:/warthog/bbb/yyy /nnn
We may not be able to access anything nearer the root than xxx and yyy,
but we may find out later that /mmm/www/yyy, say, is actually the same
directory as the one mounted on /nnn. What we might then find out, for
example, is that /warthog/bbb was actually a symbolic link to
/warthog/aaa/xxx/www, but we can't actually determine that by talking to
the server until /warthog is made available by NFS.
This would lead to having constructed an errneous dentry tree which we
can't easily fix. We can end up with a dentry marked as a directory when
it should actually be a symlink, or we could end up with an apparently
hardlinked directory.
With this patch we need not make assumptions about the type of a dentry
for which we can't retrieve information, nor need we assume we know its
place in the grand scheme of things until we actually see that place.
This patch reduces the possibility of aliasing in the inode and page caches for
inodes that may be accessed by more than one NFS export. It also reduces the
number of superblocks required for NFS where there are many NFS exports being
used from a server (home directory server + autofs for example).
This in turn makes it simpler to do local caching of network filesystems, as it
can then be guaranteed that there won't be links from multiple inodes in
separate superblocks to the same cache file.
Obviously, cache aliasing between different levels of NFS protocol could still
be a problem, but at least that gives us another key to use when indexing the
cache.
This patch makes the following changes:
(1) The server record construction/destruction has been abstracted out into
its own set of functions to make things easier to get right. These have
been moved into fs/nfs/client.c.
All the code in fs/nfs/client.c has to do with the management of
connections to servers, and doesn't touch superblocks in any way; the
remaining code in fs/nfs/super.c has to do with VFS superblock management.
(2) The sequence of events undertaken by NFS mount is now reordered:
(a) A volume representation (struct nfs_server) is allocated.
(b) A server representation (struct nfs_client) is acquired. This may be
allocated or shared, and is keyed on server address, port and NFS
version.
(c) If allocated, the client representation is initialised. The state
member variable of nfs_client is used to prevent a race during
initialisation from two mounts.
(d) For NFS4 a simple pathwalk is performed, walking from FH to FH to find
the root filehandle for the mount (fs/nfs/getroot.c). For NFS2/3 we
are given the root FH in advance.
(e) The volume FSID is probed for on the root FH.
(f) The volume representation is initialised from the FSINFO record
retrieved on the root FH.
(g) sget() is called to acquire a superblock. This may be allocated or
shared, keyed on client pointer and FSID.
(h) If allocated, the superblock is initialised.
(i) If the superblock is shared, then the new nfs_server record is
discarded.
(j) The root dentry for this mount is looked up from the root FH.
(k) The root dentry for this mount is assigned to the vfsmount.
(3) nfs_readdir_lookup() creates dentries for each of the entries readdir()
returns; this function now attaches disconnected trees from alternate
roots that happen to be discovered attached to a directory being read (in
the same way nfs_lookup() is made to do for lookup ops).
The new d_materialise_unique() function is now used to do this, thus
permitting the whole thing to be done under one set of locks, and thus
avoiding any race between mount and lookup operations on the same
directory.
(4) The client management code uses a new debug facility: NFSDBG_CLIENT which
is set by echoing 1024 to /proc/net/sunrpc/nfs_debug.
(5) Clone mounts are now called xdev mounts.
(6) Use the dentry passed to the statfs() op as the handle for retrieving fs
statistics rather than the root dentry of the superblock (which is now a
dummy).
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2006-08-23 02:06:13 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
no_entry:
|
NFS: Share NFS superblocks per-protocol per-server per-FSID
The attached patch makes NFS share superblocks between mounts from the same
server and FSID over the same protocol.
It does this by creating each superblock with a false root and returning the
real root dentry in the vfsmount presented by get_sb(). The root dentry set
starts off as an anonymous dentry if we don't already have the dentry for its
inode, otherwise it simply returns the dentry we already have.
We may thus end up with several trees of dentries in the superblock, and if at
some later point one of anonymous tree roots is discovered by normal filesystem
activity to be located in another tree within the superblock, the anonymous
root is named and materialises attached to the second tree at the appropriate
point.
Why do it this way? Why not pass an extra argument to the mount() syscall to
indicate the subpath and then pathwalk from the server root to the desired
directory? You can't guarantee this will work for two reasons:
(1) The root and intervening nodes may not be accessible to the client.
With NFS2 and NFS3, for instance, mountd is called on the server to get
the filehandle for the tip of a path. mountd won't give us handles for
anything we don't have permission to access, and so we can't set up NFS
inodes for such nodes, and so can't easily set up dentries (we'd have to
have ghost inodes or something).
With this patch we don't actually create dentries until we get handles
from the server that we can use to set up their inodes, and we don't
actually bind them into the tree until we know for sure where they go.
(2) Inaccessible symbolic links.
If we're asked to mount two exports from the server, eg:
mount warthog:/warthog/aaa/xxx /mmm
mount warthog:/warthog/bbb/yyy /nnn
We may not be able to access anything nearer the root than xxx and yyy,
but we may find out later that /mmm/www/yyy, say, is actually the same
directory as the one mounted on /nnn. What we might then find out, for
example, is that /warthog/bbb was actually a symbolic link to
/warthog/aaa/xxx/www, but we can't actually determine that by talking to
the server until /warthog is made available by NFS.
This would lead to having constructed an errneous dentry tree which we
can't easily fix. We can end up with a dentry marked as a directory when
it should actually be a symlink, or we could end up with an apparently
hardlinked directory.
With this patch we need not make assumptions about the type of a dentry
for which we can't retrieve information, nor need we assume we know its
place in the grand scheme of things until we actually see that place.
This patch reduces the possibility of aliasing in the inode and page caches for
inodes that may be accessed by more than one NFS export. It also reduces the
number of superblocks required for NFS where there are many NFS exports being
used from a server (home directory server + autofs for example).
This in turn makes it simpler to do local caching of network filesystems, as it
can then be guaranteed that there won't be links from multiple inodes in
separate superblocks to the same cache file.
Obviously, cache aliasing between different levels of NFS protocol could still
be a problem, but at least that gives us another key to use when indexing the
cache.
This patch makes the following changes:
(1) The server record construction/destruction has been abstracted out into
its own set of functions to make things easier to get right. These have
been moved into fs/nfs/client.c.
All the code in fs/nfs/client.c has to do with the management of
connections to servers, and doesn't touch superblocks in any way; the
remaining code in fs/nfs/super.c has to do with VFS superblock management.
(2) The sequence of events undertaken by NFS mount is now reordered:
(a) A volume representation (struct nfs_server) is allocated.
(b) A server representation (struct nfs_client) is acquired. This may be
allocated or shared, and is keyed on server address, port and NFS
version.
(c) If allocated, the client representation is initialised. The state
member variable of nfs_client is used to prevent a race during
initialisation from two mounts.
(d) For NFS4 a simple pathwalk is performed, walking from FH to FH to find
the root filehandle for the mount (fs/nfs/getroot.c). For NFS2/3 we
are given the root FH in advance.
(e) The volume FSID is probed for on the root FH.
(f) The volume representation is initialised from the FSINFO record
retrieved on the root FH.
(g) sget() is called to acquire a superblock. This may be allocated or
shared, keyed on client pointer and FSID.
(h) If allocated, the superblock is initialised.
(i) If the superblock is shared, then the new nfs_server record is
discarded.
(j) The root dentry for this mount is looked up from the root FH.
(k) The root dentry for this mount is assigned to the vfsmount.
(3) nfs_readdir_lookup() creates dentries for each of the entries readdir()
returns; this function now attaches disconnected trees from alternate
roots that happen to be discovered attached to a directory being read (in
the same way nfs_lookup() is made to do for lookup ops).
The new d_materialise_unique() function is now used to do this, thus
permitting the whole thing to be done under one set of locks, and thus
avoiding any race between mount and lookup operations on the same
directory.
(4) The client management code uses a new debug facility: NFSDBG_CLIENT which
is set by echoing 1024 to /proc/net/sunrpc/nfs_debug.
(5) Clone mounts are now called xdev mounts.
(6) Use the dentry passed to the statfs() op as the handle for retrieving fs
statistics rather than the root dentry of the superblock (which is now a
dummy).
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2006-08-23 02:06:13 +02:00
|
|
|
res = d_materialise_unique(dentry, inode);
|
2006-10-21 19:24:20 +02:00
|
|
|
if (res != NULL) {
|
|
|
|
if (IS_ERR(res))
|
2007-10-16 00:17:53 +02:00
|
|
|
goto out_unblock_sillyrename;
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry = res;
|
2006-10-21 19:24:20 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
2007-10-16 00:17:53 +02:00
|
|
|
out_unblock_sillyrename:
|
|
|
|
nfs_unblock_sillyrename(parent);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2010-04-16 22:22:47 +02:00
|
|
|
nfs_free_fattr(fattr);
|
|
|
|
nfs_free_fhandle(fhandle);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
static int nfs_open_revalidate(struct dentry *, struct nameidata *);
|
|
|
|
|
2009-02-20 06:51:22 +01:00
|
|
|
const struct dentry_operations nfs4_dentry_operations = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.d_revalidate = nfs_open_revalidate,
|
|
|
|
.d_delete = nfs_dentry_delete,
|
|
|
|
.d_iput = nfs_dentry_iput,
|
2011-01-14 19:45:42 +01:00
|
|
|
.d_automount = nfs_d_automount,
|
2011-03-16 10:44:14 +01:00
|
|
|
.d_release = nfs_d_release,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2005-06-08 00:37:01 +02:00
|
|
|
/*
|
|
|
|
* Use intent information to determine whether we need to substitute
|
|
|
|
* the NFSv4-style stateful OPEN for the LOOKUP call
|
|
|
|
*/
|
2008-12-23 21:21:54 +01:00
|
|
|
static int is_atomic_open(struct nameidata *nd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-08 00:37:01 +02:00
|
|
|
if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
/* NFS does not (yet) have a stateful open for directories */
|
|
|
|
if (nd->flags & LOOKUP_DIRECTORY)
|
|
|
|
return 0;
|
|
|
|
/* Are we trying to write to a read only partition? */
|
2008-02-15 23:37:56 +01:00
|
|
|
if (__mnt_is_readonly(nd->path.mnt) &&
|
2011-06-26 01:15:54 +02:00
|
|
|
(nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-06-26 01:15:54 +02:00
|
|
|
static fmode_t flags_to_mode(int flags)
|
|
|
|
{
|
|
|
|
fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
|
|
|
|
if ((flags & O_ACCMODE) != O_WRONLY)
|
|
|
|
res |= FMODE_READ;
|
|
|
|
if ((flags & O_ACCMODE) != O_RDONLY)
|
|
|
|
res |= FMODE_WRITE;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-06-23 00:47:28 +02:00
|
|
|
static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
|
2010-09-17 16:56:50 +02:00
|
|
|
{
|
2011-10-24 00:49:54 +02:00
|
|
|
return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
|
2010-09-17 16:56:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
nfs_fscache_set_inode_cookie(inode, filp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx)
|
|
|
|
{
|
|
|
|
struct file *filp;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* If the open_intent is for execute, we have an extra check to make */
|
|
|
|
if (ctx->mode & FMODE_EXEC) {
|
2011-06-23 00:40:12 +02:00
|
|
|
ret = nfs_may_open(ctx->dentry->d_inode,
|
2010-09-17 16:56:50 +02:00
|
|
|
ctx->cred,
|
|
|
|
nd->intent.open.flags);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
2011-06-23 00:40:12 +02:00
|
|
|
filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
|
2010-09-17 16:56:50 +02:00
|
|
|
if (IS_ERR(filp))
|
|
|
|
ret = PTR_ERR(filp);
|
|
|
|
else
|
|
|
|
nfs_file_set_open_context(filp, ctx);
|
|
|
|
out:
|
|
|
|
put_nfs_open_context(ctx);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
|
|
|
|
{
|
2010-09-17 16:56:50 +02:00
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
struct iattr attr;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct dentry *res = NULL;
|
2010-09-17 16:56:50 +02:00
|
|
|
struct inode *inode;
|
2010-09-17 16:56:50 +02:00
|
|
|
int open_flags;
|
2010-10-23 17:24:25 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Check that we are indeed trying to open this file */
|
2008-12-23 21:21:54 +01:00
|
|
|
if (!is_atomic_open(nd))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto no_open;
|
|
|
|
|
|
|
|
if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
|
|
|
|
res = ERR_PTR(-ENAMETOOLONG);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-10-03 00:38:53 +02:00
|
|
|
/* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
|
|
|
|
* the dentry. */
|
2008-08-05 09:00:49 +02:00
|
|
|
if (nd->flags & LOOKUP_EXCL) {
|
2007-10-03 00:38:53 +02:00
|
|
|
d_instantiate(dentry, NULL);
|
2005-10-18 23:20:17 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-06-23 00:47:28 +02:00
|
|
|
open_flags = nd->intent.open.flags;
|
|
|
|
|
|
|
|
ctx = create_nfs_open_context(dentry, open_flags);
|
2010-09-17 16:56:50 +02:00
|
|
|
res = ERR_CAST(ctx);
|
|
|
|
if (IS_ERR(ctx))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (nd->flags & LOOKUP_CREATE) {
|
|
|
|
attr.ia_mode = nd->intent.open.create_mode;
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
2010-12-09 12:35:14 +01:00
|
|
|
attr.ia_mode &= ~current_umask();
|
2010-09-17 16:56:50 +02:00
|
|
|
} else {
|
2010-10-23 17:24:25 +02:00
|
|
|
open_flags &= ~(O_EXCL | O_CREAT);
|
2010-09-17 16:56:50 +02:00
|
|
|
attr.ia_valid = 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Open the file on the server */
|
2010-09-17 16:56:50 +02:00
|
|
|
nfs_block_sillyrename(dentry->d_parent);
|
2010-09-17 16:56:51 +02:00
|
|
|
inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
|
2010-09-17 16:56:50 +02:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
nfs_unblock_sillyrename(dentry->d_parent);
|
2010-09-17 16:56:50 +02:00
|
|
|
put_nfs_open_context(ctx);
|
2010-09-17 16:56:50 +02:00
|
|
|
switch (PTR_ERR(inode)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Make a negative dentry */
|
|
|
|
case -ENOENT:
|
2010-09-17 16:56:50 +02:00
|
|
|
d_add(dentry, NULL);
|
2005-10-18 23:20:17 +02:00
|
|
|
res = NULL;
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* This turned out not to be a regular file */
|
nfs: when attempting to open a directory, fall back on normal lookup (try #5)
commit d953126 changed how nfs_atomic_lookup handles an -EISDIR return
from an OPEN call. Prior to that patch, that caused the client to fall
back to doing a normal lookup. When that patch went in, the code began
returning that error to userspace. The d_revalidate codepath however
never had the corresponding change, so it was still possible to end up
with a NULL ctx->state pointer after that.
That patch caused a regression. When we attempt to open a directory that
does not have a cached dentry, that open now errors out with EISDIR. If
you attempt the same open with a cached dentry, it will succeed.
Fix this by reverting the change in nfs_atomic_lookup and allowing
attempts to open directories to fall back to a normal lookup
Also, add a NFSv4-specific f_ops->open routine that just returns
-ENOTDIR. This should never be called if things are working properly,
but if it ever is, then the dprintk may help in debugging.
To facilitate this, a new file_operations field is also added to the
nfs_rpc_ops struct.
Cc: stable@kernel.org
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2011-11-04 18:31:21 +01:00
|
|
|
case -EISDIR:
|
2005-10-18 23:20:18 +02:00
|
|
|
case -ENOTDIR:
|
|
|
|
goto no_open;
|
2005-04-17 00:20:36 +02:00
|
|
|
case -ELOOP:
|
|
|
|
if (!(nd->intent.open.flags & O_NOFOLLOW))
|
|
|
|
goto no_open;
|
|
|
|
/* case -EINVAL: */
|
|
|
|
default:
|
2010-09-17 16:56:50 +02:00
|
|
|
res = ERR_CAST(inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2010-09-17 16:56:50 +02:00
|
|
|
}
|
2010-09-17 16:56:50 +02:00
|
|
|
res = d_add_unique(dentry, inode);
|
2010-10-23 17:24:25 +02:00
|
|
|
nfs_unblock_sillyrename(dentry->d_parent);
|
2010-09-17 16:56:50 +02:00
|
|
|
if (res != NULL) {
|
2011-06-23 00:40:12 +02:00
|
|
|
dput(ctx->dentry);
|
|
|
|
ctx->dentry = dget(res);
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry = res;
|
2010-09-17 16:56:50 +02:00
|
|
|
}
|
2010-10-23 17:24:25 +02:00
|
|
|
err = nfs_intent_set_file(nd, ctx);
|
|
|
|
if (err < 0) {
|
|
|
|
if (res != NULL)
|
|
|
|
dput(res);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2010-09-17 16:56:50 +02:00
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
no_open:
|
|
|
|
return nfs_lookup(dir, dentry, nd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
|
|
|
|
{
|
|
|
|
struct dentry *parent = NULL;
|
2011-01-14 03:48:39 +01:00
|
|
|
struct inode *inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *dir;
|
2010-09-17 16:56:51 +02:00
|
|
|
struct nfs_open_context *ctx;
|
2005-04-17 00:20:36 +02:00
|
|
|
int openflags, ret = 0;
|
|
|
|
|
2011-01-14 03:48:39 +01:00
|
|
|
if (nd->flags & LOOKUP_RCU)
|
|
|
|
return -ECHILD;
|
|
|
|
|
|
|
|
inode = dentry->d_inode;
|
2010-04-22 21:35:55 +02:00
|
|
|
if (!is_atomic_open(nd) || d_mountpoint(dentry))
|
2008-12-23 21:21:54 +01:00
|
|
|
goto no_open;
|
2010-09-17 16:56:51 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
parent = dget_parent(dentry);
|
|
|
|
dir = parent->d_inode;
|
2010-09-17 16:56:51 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* We can't create new files in nfs_open_revalidate(), so we
|
|
|
|
* optimize away revalidation of negative dentries.
|
|
|
|
*/
|
2007-10-02 02:10:12 +02:00
|
|
|
if (inode == NULL) {
|
|
|
|
if (!nfs_neg_need_reval(dir, dentry, nd))
|
|
|
|
ret = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2007-10-02 02:10:12 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* NFS only supports OPEN on regular files */
|
|
|
|
if (!S_ISREG(inode->i_mode))
|
2008-12-23 21:21:54 +01:00
|
|
|
goto no_open_dput;
|
2005-04-17 00:20:36 +02:00
|
|
|
openflags = nd->intent.open.flags;
|
|
|
|
/* We cannot do exclusive creation on a positive dentry */
|
|
|
|
if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
|
2008-12-23 21:21:54 +01:00
|
|
|
goto no_open_dput;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* We can't create new files, or truncate existing ones here */
|
2010-08-18 15:25:42 +02:00
|
|
|
openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-06-23 00:47:28 +02:00
|
|
|
ctx = create_nfs_open_context(dentry, openflags);
|
2010-09-17 16:56:51 +02:00
|
|
|
ret = PTR_ERR(ctx);
|
|
|
|
if (IS_ERR(ctx))
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2006-01-10 00:59:24 +01:00
|
|
|
* Note: we're not holding inode->i_mutex and so may be racing with
|
2005-04-17 00:20:36 +02:00
|
|
|
* operations that change the directory. We therefore save the
|
|
|
|
* change attribute *before* we do the RPC call.
|
|
|
|
*/
|
2010-09-17 16:56:51 +02:00
|
|
|
inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL);
|
2010-09-17 16:56:51 +02:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
ret = PTR_ERR(inode);
|
|
|
|
switch (ret) {
|
|
|
|
case -EPERM:
|
|
|
|
case -EACCES:
|
|
|
|
case -EDQUOT:
|
|
|
|
case -ENOSPC:
|
|
|
|
case -EROFS:
|
|
|
|
goto out_put_ctx;
|
|
|
|
default:
|
|
|
|
goto out_drop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
iput(inode);
|
2010-10-23 17:24:25 +02:00
|
|
|
if (inode != dentry->d_inode)
|
2010-09-17 16:56:51 +02:00
|
|
|
goto out_drop;
|
2010-10-23 17:24:25 +02:00
|
|
|
|
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
|
|
|
ret = nfs_intent_set_file(nd, ctx);
|
|
|
|
if (ret >= 0)
|
|
|
|
ret = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
dput(parent);
|
|
|
|
return ret;
|
2010-09-17 16:56:51 +02:00
|
|
|
out_drop:
|
|
|
|
d_drop(dentry);
|
|
|
|
ret = 0;
|
|
|
|
out_put_ctx:
|
|
|
|
put_nfs_open_context(ctx);
|
|
|
|
goto out;
|
|
|
|
|
2008-12-23 21:21:54 +01:00
|
|
|
no_open_dput:
|
2005-04-17 00:20:36 +02:00
|
|
|
dput(parent);
|
2008-12-23 21:21:54 +01:00
|
|
|
no_open:
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfs_lookup_revalidate(dentry, nd);
|
|
|
|
}
|
2010-09-17 16:56:51 +02:00
|
|
|
|
2011-07-26 07:42:34 +02:00
|
|
|
static int nfs_open_create(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode, struct nameidata *nd)
|
2010-09-17 16:56:51 +02:00
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx = NULL;
|
|
|
|
struct iattr attr;
|
|
|
|
int error;
|
2011-06-26 01:15:54 +02:00
|
|
|
int open_flags = O_CREAT|O_EXCL;
|
2010-09-17 16:56:51 +02:00
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
|
|
|
|
|
|
|
attr.ia_mode = mode;
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
|
|
|
|
2011-06-26 03:17:17 +02:00
|
|
|
if (nd)
|
2010-09-17 16:56:51 +02:00
|
|
|
open_flags = nd->intent.open.flags;
|
|
|
|
|
2011-06-23 00:53:18 +02:00
|
|
|
ctx = create_nfs_open_context(dentry, open_flags);
|
|
|
|
error = PTR_ERR(ctx);
|
|
|
|
if (IS_ERR(ctx))
|
|
|
|
goto out_err_drop;
|
2010-09-17 16:56:51 +02:00
|
|
|
|
|
|
|
error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
|
|
|
|
if (error != 0)
|
|
|
|
goto out_put_ctx;
|
2011-06-26 03:17:17 +02:00
|
|
|
if (nd) {
|
2010-10-23 17:24:25 +02:00
|
|
|
error = nfs_intent_set_file(nd, ctx);
|
|
|
|
if (error < 0)
|
|
|
|
goto out_err;
|
2011-06-23 00:53:18 +02:00
|
|
|
} else {
|
|
|
|
put_nfs_open_context(ctx);
|
2010-10-23 17:24:25 +02:00
|
|
|
}
|
2010-09-17 16:56:51 +02:00
|
|
|
return 0;
|
|
|
|
out_put_ctx:
|
2011-06-23 00:53:18 +02:00
|
|
|
put_nfs_open_context(ctx);
|
2010-10-23 17:24:25 +02:00
|
|
|
out_err_drop:
|
2010-09-17 16:56:51 +02:00
|
|
|
d_drop(dentry);
|
2010-10-23 17:24:25 +02:00
|
|
|
out_err:
|
2010-09-17 16:56:51 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif /* CONFIG_NFSV4 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Code common to create, mkdir, and mknod.
|
|
|
|
*/
|
|
|
|
int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
|
|
|
|
struct nfs_fattr *fattr)
|
|
|
|
{
|
2007-09-29 23:41:33 +02:00
|
|
|
struct dentry *parent = dget_parent(dentry);
|
|
|
|
struct inode *dir = parent->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode;
|
|
|
|
int error = -EACCES;
|
|
|
|
|
2007-09-29 23:41:33 +02:00
|
|
|
d_drop(dentry);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* We may have been initialized further down */
|
|
|
|
if (dentry->d_inode)
|
2007-09-29 23:41:33 +02:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (fhandle->size == 0) {
|
2011-03-24 18:12:24 +01:00
|
|
|
error = NFS_PROTO(dir)->lookup(NFS_SERVER(dir)->client, dir, &dentry->d_name, fhandle, fattr);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error)
|
2007-09-29 23:41:33 +02:00
|
|
|
goto out_error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-10-02 03:51:38 +02:00
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!(fattr->valid & NFS_ATTR_FATTR)) {
|
|
|
|
struct nfs_server *server = NFS_SB(dentry->d_sb);
|
2006-08-23 02:06:12 +02:00
|
|
|
error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error < 0)
|
2007-09-29 23:41:33 +02:00
|
|
|
goto out_error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
|
2006-03-20 19:44:48 +01:00
|
|
|
error = PTR_ERR(inode);
|
|
|
|
if (IS_ERR(inode))
|
2007-09-29 23:41:33 +02:00
|
|
|
goto out_error;
|
|
|
|
d_add(dentry, inode);
|
|
|
|
out:
|
|
|
|
dput(parent);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2007-09-29 23:41:33 +02:00
|
|
|
out_error:
|
|
|
|
nfs_mark_for_revalidate(dir);
|
|
|
|
dput(parent);
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Following a failed create operation, we drop the dentry rather
|
|
|
|
* than retain a negative dentry. This avoids a problem in the event
|
|
|
|
* that the operation succeeded on the server, but an error in the
|
|
|
|
* reply path made it appear to have failed.
|
|
|
|
*/
|
2011-07-26 07:42:34 +02:00
|
|
|
static int nfs_create(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode, struct nameidata *nd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct iattr attr;
|
|
|
|
int error;
|
2011-06-26 01:15:54 +02:00
|
|
|
int open_flags = O_CREAT|O_EXCL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
attr.ia_mode = mode;
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
|
|
|
|
2011-06-26 03:17:17 +02:00
|
|
|
if (nd)
|
2011-01-13 20:15:50 +01:00
|
|
|
open_flags = nd->intent.open.flags;
|
|
|
|
|
|
|
|
error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error != 0)
|
|
|
|
goto out_err;
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
|
|
d_drop(dentry);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See comments for nfs_proc_create regarding failed operations.
|
|
|
|
*/
|
|
|
|
static int
|
2011-07-26 07:52:52 +02:00
|
|
|
nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct iattr attr;
|
|
|
|
int status;
|
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!new_valid_dev(rdev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
attr.ia_mode = mode;
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
|
|
|
|
|
|
|
status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
|
|
|
|
if (status != 0)
|
|
|
|
goto out_err;
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
|
|
d_drop(dentry);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See comments for nfs_proc_create regarding failed operations.
|
|
|
|
*/
|
2011-07-26 07:41:39 +02:00
|
|
|
static int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct iattr attr;
|
|
|
|
int error;
|
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
|
|
|
attr.ia_mode = mode | S_IFDIR;
|
|
|
|
|
|
|
|
error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
|
|
|
|
if (error != 0)
|
|
|
|
goto out_err;
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
|
|
d_drop(dentry);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-01-29 01:43:18 +01:00
|
|
|
static void nfs_dentry_handle_enoent(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
if (dentry->d_inode != NULL && !d_unhashed(dentry))
|
|
|
|
d_delete(dentry);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
|
|
|
|
/* Ensure the VFS deletes this inode */
|
|
|
|
if (error == 0 && dentry->d_inode != NULL)
|
2006-10-01 08:29:06 +02:00
|
|
|
clear_nlink(dentry->d_inode);
|
2008-01-29 01:43:18 +01:00
|
|
|
else if (error == -ENOENT)
|
|
|
|
nfs_dentry_handle_enoent(dentry);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a file after making sure there are no pending writes,
|
|
|
|
* and after checking that the file has only one user.
|
|
|
|
*
|
|
|
|
* We invalidate the attribute cache and free the inode prior to the operation
|
|
|
|
* to avoid possible races if the server reuses the inode.
|
|
|
|
*/
|
|
|
|
static int nfs_safe_remove(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct inode *dir = dentry->d_parent->d_inode;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
int error = -EBUSY;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name);
|
|
|
|
|
|
|
|
/* If the dentry was sillyrenamed, we simply call d_delete() */
|
|
|
|
if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
|
|
|
|
error = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inode != NULL) {
|
2005-10-18 23:20:19 +02:00
|
|
|
nfs_inode_return_delegation(inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
|
|
|
|
/* The VFS may want to delete this inode */
|
|
|
|
if (error == 0)
|
2008-06-11 21:44:04 +02:00
|
|
|
nfs_drop_nlink(inode);
|
2005-12-03 21:20:17 +01:00
|
|
|
nfs_mark_for_revalidate(inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
|
|
|
error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
|
2008-01-29 01:43:18 +01:00
|
|
|
if (error == -ENOENT)
|
|
|
|
nfs_dentry_handle_enoent(dentry);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We do silly rename. In case sillyrename() returns -EBUSY, the inode
|
|
|
|
* belongs to an active ".nfs..." file and we return -EBUSY.
|
|
|
|
*
|
|
|
|
* If sillyrename() returns 0, we do nothing, otherwise we unlink.
|
|
|
|
*/
|
|
|
|
static int nfs_unlink(struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
int need_rehash = 0;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
|
|
|
|
dir->i_ino, dentry->d_name.name);
|
|
|
|
|
|
|
|
spin_lock(&dentry->d_lock);
|
2011-01-07 07:49:32 +01:00
|
|
|
if (dentry->d_count > 1) {
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&dentry->d_lock);
|
2007-01-13 08:28:12 +01:00
|
|
|
/* Start asynchronous writeout of the inode */
|
|
|
|
write_inode_now(dentry->d_inode, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
error = nfs_sillyrename(dir, dentry);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
if (!d_unhashed(dentry)) {
|
|
|
|
__d_drop(dentry);
|
|
|
|
need_rehash = 1;
|
|
|
|
}
|
|
|
|
spin_unlock(&dentry->d_lock);
|
|
|
|
error = nfs_safe_remove(dentry);
|
2008-01-29 01:43:18 +01:00
|
|
|
if (!error || error == -ENOENT) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
|
|
|
|
} else if (need_rehash)
|
|
|
|
d_rehash(dentry);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-08-23 02:06:23 +02:00
|
|
|
/*
|
|
|
|
* To create a symbolic link, most file systems instantiate a new inode,
|
|
|
|
* add a page to it containing the path, then write it out to the disk
|
|
|
|
* using prepare_write/commit_write.
|
|
|
|
*
|
|
|
|
* Unfortunately the NFS client can't create the in-core inode first
|
|
|
|
* because it needs a file handle to create an in-core inode (see
|
|
|
|
* fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the
|
|
|
|
* symlink request has completed on the server.
|
|
|
|
*
|
|
|
|
* So instead we allocate a raw page, copy the symname into it, then do
|
|
|
|
* the SYMLINK request with the page as the buffer. If it succeeds, we
|
|
|
|
* now have a new file handle and can instantiate an in-core NFS inode
|
|
|
|
* and move the raw page into its mapping.
|
|
|
|
*/
|
|
|
|
static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-23 02:06:23 +02:00
|
|
|
struct pagevec lru_pvec;
|
|
|
|
struct page *page;
|
|
|
|
char *kaddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct iattr attr;
|
2006-08-23 02:06:23 +02:00
|
|
|
unsigned int pathlen = strlen(symname);
|
2005-04-17 00:20:36 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
|
|
|
|
dir->i_ino, dentry->d_name.name, symname);
|
|
|
|
|
2006-08-23 02:06:23 +02:00
|
|
|
if (pathlen > PAGE_SIZE)
|
|
|
|
return -ENAMETOOLONG;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-23 02:06:23 +02:00
|
|
|
attr.ia_mode = S_IFLNK | S_IRWXUGO;
|
|
|
|
attr.ia_valid = ATTR_MODE;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-06-07 15:58:08 +02:00
|
|
|
page = alloc_page(GFP_HIGHUSER);
|
2008-06-11 21:44:22 +02:00
|
|
|
if (!page)
|
2006-08-23 02:06:23 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-11-25 16:14:33 +01:00
|
|
|
kaddr = kmap_atomic(page);
|
2006-08-23 02:06:23 +02:00
|
|
|
memcpy(kaddr, symname, pathlen);
|
|
|
|
if (pathlen < PAGE_SIZE)
|
|
|
|
memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
|
2011-11-25 16:14:33 +01:00
|
|
|
kunmap_atomic(kaddr);
|
2006-08-23 02:06:23 +02:00
|
|
|
|
2006-08-23 02:06:23 +02:00
|
|
|
error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
|
2006-08-23 02:06:23 +02:00
|
|
|
if (error != 0) {
|
|
|
|
dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
|
|
|
|
dir->i_sb->s_id, dir->i_ino,
|
|
|
|
dentry->d_name.name, symname, error);
|
2005-04-17 00:20:36 +02:00
|
|
|
d_drop(dentry);
|
2006-08-23 02:06:23 +02:00
|
|
|
__free_page(page);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No big deal if we can't add this page to the page cache here.
|
|
|
|
* READLINK will get the missing page from the server if needed.
|
|
|
|
*/
|
|
|
|
pagevec_init(&lru_pvec, 0);
|
|
|
|
if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
|
|
|
|
GFP_KERNEL)) {
|
2006-10-20 08:28:41 +02:00
|
|
|
pagevec_add(&lru_pvec, page);
|
2008-10-19 05:26:32 +02:00
|
|
|
pagevec_lru_add_file(&lru_pvec);
|
2006-08-23 02:06:23 +02:00
|
|
|
SetPageUptodate(page);
|
|
|
|
unlock_page(page);
|
|
|
|
} else
|
|
|
|
__free_page(page);
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct inode *inode = old_dentry->d_inode;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
|
|
|
|
old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name);
|
|
|
|
|
2009-10-26 13:09:46 +01:00
|
|
|
nfs_inode_return_delegation(inode);
|
|
|
|
|
2007-10-03 03:58:05 +02:00
|
|
|
d_drop(dentry);
|
2005-04-17 00:20:36 +02:00
|
|
|
error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
|
2005-10-28 04:12:42 +02:00
|
|
|
if (error == 0) {
|
2010-10-23 17:11:40 +02:00
|
|
|
ihold(inode);
|
2007-10-03 03:58:05 +02:00
|
|
|
d_add(dentry, inode);
|
2005-10-28 04:12:42 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RENAME
|
|
|
|
* FIXME: Some nfsds, like the Linux user space nfsd, may generate a
|
|
|
|
* different file handle for the same inode after a rename (e.g. when
|
|
|
|
* moving to a different directory). A fail-safe method to do so would
|
|
|
|
* be to look up old_dir/old_name, create a link to new_dir/new_name and
|
|
|
|
* rename the old file using the sillyrename stuff. This way, the original
|
|
|
|
* file in old_dir will go away when the last process iput()s the inode.
|
|
|
|
*
|
|
|
|
* FIXED.
|
|
|
|
*
|
|
|
|
* It actually works quite well. One needs to have the possibility for
|
|
|
|
* at least one ".nfs..." file in each directory the file ever gets
|
|
|
|
* moved or linked to which happens automagically with the new
|
|
|
|
* implementation that only depends on the dcache stuff instead of
|
|
|
|
* using the inode layer
|
|
|
|
*
|
|
|
|
* Unfortunately, things are a little more complicated than indicated
|
|
|
|
* above. For a cross-directory move, we want to make sure we can get
|
|
|
|
* rid of the old inode after the operation. This means there must be
|
|
|
|
* no pending writes (if it's a file), and the use count must be 1.
|
|
|
|
* If these conditions are met, we can drop the dentries before doing
|
|
|
|
* the rename.
|
|
|
|
*/
|
|
|
|
static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
|
|
|
|
struct inode *new_dir, struct dentry *new_dentry)
|
|
|
|
{
|
|
|
|
struct inode *old_inode = old_dentry->d_inode;
|
|
|
|
struct inode *new_inode = new_dentry->d_inode;
|
|
|
|
struct dentry *dentry = NULL, *rehash = NULL;
|
|
|
|
int error = -EBUSY;
|
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
|
|
|
|
old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
|
|
|
|
new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
|
2011-01-07 07:49:32 +01:00
|
|
|
new_dentry->d_count);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2009-12-03 21:58:56 +01:00
|
|
|
* For non-directories, check whether the target is busy and if so,
|
|
|
|
* make a copy of the dentry and then do a silly-rename. If the
|
|
|
|
* silly-rename succeeds, the copied dentry is hashed and becomes
|
|
|
|
* the new target.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2009-12-03 21:58:56 +01:00
|
|
|
if (new_inode && !S_ISDIR(new_inode->i_mode)) {
|
|
|
|
/*
|
|
|
|
* To prevent any new references to the target during the
|
|
|
|
* rename, we unhash the dentry in advance.
|
|
|
|
*/
|
|
|
|
if (!d_unhashed(new_dentry)) {
|
|
|
|
d_drop(new_dentry);
|
|
|
|
rehash = new_dentry;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-07 07:49:32 +01:00
|
|
|
if (new_dentry->d_count > 2) {
|
2009-12-03 21:58:56 +01:00
|
|
|
int err;
|
|
|
|
|
|
|
|
/* copy the target dentry's name */
|
|
|
|
dentry = d_alloc(new_dentry->d_parent,
|
|
|
|
&new_dentry->d_name);
|
|
|
|
if (!dentry)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* silly-rename the existing target ... */
|
|
|
|
err = nfs_sillyrename(new_dir, new_dentry);
|
2009-12-03 21:58:56 +01:00
|
|
|
if (err)
|
2009-12-03 21:58:56 +01:00
|
|
|
goto out;
|
2009-12-03 21:58:56 +01:00
|
|
|
|
|
|
|
new_dentry = dentry;
|
2010-01-07 00:48:26 +01:00
|
|
|
rehash = NULL;
|
2009-12-03 21:58:56 +01:00
|
|
|
new_inode = NULL;
|
2009-12-03 21:58:56 +01:00
|
|
|
}
|
2009-03-19 20:35:49 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-18 23:20:19 +02:00
|
|
|
nfs_inode_return_delegation(old_inode);
|
2009-03-19 20:35:49 +01:00
|
|
|
if (new_inode != NULL)
|
2006-01-03 09:55:33 +01:00
|
|
|
nfs_inode_return_delegation(new_inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
|
|
|
|
new_dir, &new_dentry->d_name);
|
2005-12-03 21:20:17 +01:00
|
|
|
nfs_mark_for_revalidate(old_inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
if (rehash)
|
|
|
|
d_rehash(rehash);
|
|
|
|
if (!error) {
|
2009-03-19 20:35:49 +01:00
|
|
|
if (new_inode != NULL)
|
|
|
|
nfs_drop_nlink(new_inode);
|
2006-09-08 23:22:21 +02:00
|
|
|
d_move(old_dentry, new_dentry);
|
2007-09-24 21:40:16 +02:00
|
|
|
nfs_set_verifier(new_dentry,
|
|
|
|
nfs_save_change_attribute(new_dir));
|
2008-01-29 01:43:18 +01:00
|
|
|
} else if (error == -ENOENT)
|
|
|
|
nfs_dentry_handle_enoent(old_dentry);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* new dentry created? */
|
|
|
|
if (dentry)
|
|
|
|
dput(dentry);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-07-25 17:28:18 +02:00
|
|
|
static DEFINE_SPINLOCK(nfs_access_lru_lock);
|
|
|
|
static LIST_HEAD(nfs_access_lru_list);
|
|
|
|
static atomic_long_t nfs_access_nr_entries;
|
|
|
|
|
2006-07-25 17:28:18 +02:00
|
|
|
static void nfs_access_free_entry(struct nfs_access_entry *entry)
|
|
|
|
{
|
|
|
|
put_rpccred(entry->cred);
|
|
|
|
kfree(entry);
|
2006-07-25 17:28:18 +02:00
|
|
|
smp_mb__before_atomic_dec();
|
|
|
|
atomic_long_dec(&nfs_access_nr_entries);
|
|
|
|
smp_mb__after_atomic_dec();
|
2006-07-25 17:28:18 +02:00
|
|
|
}
|
|
|
|
|
2010-05-13 18:51:06 +02:00
|
|
|
static void nfs_access_free_list(struct list_head *head)
|
|
|
|
{
|
|
|
|
struct nfs_access_entry *cache;
|
|
|
|
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
cache = list_entry(head->next, struct nfs_access_entry, lru);
|
|
|
|
list_del(&cache->lru);
|
|
|
|
nfs_access_free_entry(cache);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-25 02:12:27 +02:00
|
|
|
int nfs_access_cache_shrinker(struct shrinker *shrink,
|
|
|
|
struct shrink_control *sc)
|
2006-07-25 17:28:19 +02:00
|
|
|
{
|
|
|
|
LIST_HEAD(head);
|
2010-09-29 21:11:56 +02:00
|
|
|
struct nfs_inode *nfsi, *next;
|
2006-07-25 17:28:19 +02:00
|
|
|
struct nfs_access_entry *cache;
|
2011-05-25 02:12:27 +02:00
|
|
|
int nr_to_scan = sc->nr_to_scan;
|
|
|
|
gfp_t gfp_mask = sc->gfp_mask;
|
2006-07-25 17:28:19 +02:00
|
|
|
|
2010-05-13 18:51:06 +02:00
|
|
|
if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
|
|
|
|
return (nr_to_scan == 0) ? 0 : -1;
|
2010-05-13 18:51:06 +02:00
|
|
|
|
2007-06-06 01:23:43 +02:00
|
|
|
spin_lock(&nfs_access_lru_lock);
|
2010-09-29 21:11:56 +02:00
|
|
|
list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
|
2006-07-25 17:28:19 +02:00
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
if (nr_to_scan-- == 0)
|
|
|
|
break;
|
2010-05-13 18:51:06 +02:00
|
|
|
inode = &nfsi->vfs_inode;
|
2006-07-25 17:28:19 +02:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (list_empty(&nfsi->access_cache_entry_lru))
|
|
|
|
goto remove_lru_entry;
|
|
|
|
cache = list_entry(nfsi->access_cache_entry_lru.next,
|
|
|
|
struct nfs_access_entry, lru);
|
|
|
|
list_move(&cache->lru, &head);
|
|
|
|
rb_erase(&cache->rb_node, &nfsi->access_cache);
|
|
|
|
if (!list_empty(&nfsi->access_cache_entry_lru))
|
|
|
|
list_move_tail(&nfsi->access_cache_inode_lru,
|
|
|
|
&nfs_access_lru_list);
|
|
|
|
else {
|
|
|
|
remove_lru_entry:
|
|
|
|
list_del_init(&nfsi->access_cache_inode_lru);
|
2010-05-13 18:51:06 +02:00
|
|
|
smp_mb__before_clear_bit();
|
2006-07-25 17:28:19 +02:00
|
|
|
clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
|
2010-05-13 18:51:06 +02:00
|
|
|
smp_mb__after_clear_bit();
|
2006-07-25 17:28:19 +02:00
|
|
|
}
|
2010-05-26 14:42:24 +02:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-07-25 17:28:19 +02:00
|
|
|
}
|
|
|
|
spin_unlock(&nfs_access_lru_lock);
|
2010-05-13 18:51:06 +02:00
|
|
|
nfs_access_free_list(&head);
|
2006-07-25 17:28:19 +02:00
|
|
|
return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
|
|
|
|
}
|
|
|
|
|
2010-05-13 18:51:06 +02:00
|
|
|
static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-07-25 17:28:18 +02:00
|
|
|
struct rb_root *root_node = &nfsi->access_cache;
|
2010-05-13 18:51:06 +02:00
|
|
|
struct rb_node *n;
|
2006-07-25 17:28:18 +02:00
|
|
|
struct nfs_access_entry *entry;
|
|
|
|
|
|
|
|
/* Unhook entries from the cache */
|
|
|
|
while ((n = rb_first(root_node)) != NULL) {
|
|
|
|
entry = rb_entry(n, struct nfs_access_entry, rb_node);
|
|
|
|
rb_erase(n, root_node);
|
2010-05-13 18:51:06 +02:00
|
|
|
list_move(&entry->lru, head);
|
2006-07-25 17:28:18 +02:00
|
|
|
}
|
|
|
|
nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-07-25 17:28:18 +02:00
|
|
|
void nfs_access_zap_cache(struct inode *inode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-05-13 18:51:06 +02:00
|
|
|
LIST_HEAD(head);
|
|
|
|
|
|
|
|
if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
|
|
|
|
return;
|
2006-07-25 17:28:18 +02:00
|
|
|
/* Remove from global LRU init */
|
2010-05-13 18:51:06 +02:00
|
|
|
spin_lock(&nfs_access_lru_lock);
|
|
|
|
if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
|
2006-07-25 17:28:18 +02:00
|
|
|
list_del_init(&NFS_I(inode)->access_cache_inode_lru);
|
|
|
|
|
2006-07-25 17:28:18 +02:00
|
|
|
spin_lock(&inode->i_lock);
|
2010-05-13 18:51:06 +02:00
|
|
|
__nfs_access_zap_cache(NFS_I(inode), &head);
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
spin_unlock(&nfs_access_lru_lock);
|
|
|
|
nfs_access_free_list(&head);
|
2006-07-25 17:28:18 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-25 17:28:18 +02:00
|
|
|
static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
|
|
|
|
{
|
|
|
|
struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
|
|
|
|
struct nfs_access_entry *entry;
|
|
|
|
|
|
|
|
while (n != NULL) {
|
|
|
|
entry = rb_entry(n, struct nfs_access_entry, rb_node);
|
|
|
|
|
|
|
|
if (cred < entry->cred)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (cred > entry->cred)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return entry;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-07-25 17:28:18 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-08-10 23:45:10 +02:00
|
|
|
static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
|
2006-07-25 17:28:18 +02:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_access_entry *cache;
|
|
|
|
int err = -ENOENT;
|
|
|
|
|
2005-08-18 20:24:12 +02:00
|
|
|
spin_lock(&inode->i_lock);
|
2006-07-25 17:28:18 +02:00
|
|
|
if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
|
|
|
|
goto out_zap;
|
|
|
|
cache = nfs_access_search_rbtree(inode, cred);
|
|
|
|
if (cache == NULL)
|
|
|
|
goto out;
|
2010-03-10 21:21:44 +01:00
|
|
|
if (!nfs_have_delegated_attributes(inode) &&
|
optimize attribute timeouts for "noac" and "actimeo=0"
Hi.
I've been looking at a bugzilla which describes a problem where
a customer was advised to use either the "noac" or "actimeo=0"
mount options to solve a consistency problem that they were
seeing in the file attributes. It turned out that this solution
did not work reliably for them because sometimes, the local
attribute cache was believed to be valid and not timed out.
(With an attribute cache timeout of 0, the cache should always
appear to be timed out.)
In looking at this situation, it appears to me that the problem
is that the attribute cache timeout code has an off-by-one
error in it. It is assuming that the cache is valid in the
region, [read_cache_jiffies, read_cache_jiffies + attrtimeo]. The
cache should be considered valid only in the region,
[read_cache_jiffies, read_cache_jiffies + attrtimeo). With this
change, the options, "noac" and "actimeo=0", work as originally
expected.
This problem was previously addressed by special casing the
attrtimeo == 0 case. However, since the problem is only an off-
by-one error, the cleaner solution is address the off-by-one
error and thus, not require the special case.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-12-23 21:21:56 +01:00
|
|
|
!time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
|
2006-07-25 17:28:18 +02:00
|
|
|
goto out_stale;
|
|
|
|
res->jiffies = cache->jiffies;
|
|
|
|
res->cred = cache->cred;
|
|
|
|
res->mask = cache->mask;
|
2006-07-25 17:28:18 +02:00
|
|
|
list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
|
2006-07-25 17:28:18 +02:00
|
|
|
err = 0;
|
|
|
|
out:
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return err;
|
|
|
|
out_stale:
|
|
|
|
rb_erase(&cache->rb_node, &nfsi->access_cache);
|
2006-07-25 17:28:18 +02:00
|
|
|
list_del(&cache->lru);
|
2006-07-25 17:28:18 +02:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
nfs_access_free_entry(cache);
|
|
|
|
return -ENOENT;
|
|
|
|
out_zap:
|
2010-05-13 18:51:06 +02:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
nfs_access_zap_cache(inode);
|
2006-07-25 17:28:18 +02:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
|
|
|
|
{
|
2006-07-25 17:28:18 +02:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct rb_root *root_node = &nfsi->access_cache;
|
2006-07-25 17:28:18 +02:00
|
|
|
struct rb_node **p = &root_node->rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct nfs_access_entry *entry;
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
entry = rb_entry(parent, struct nfs_access_entry, rb_node);
|
|
|
|
|
|
|
|
if (set->cred < entry->cred)
|
|
|
|
p = &parent->rb_left;
|
|
|
|
else if (set->cred > entry->cred)
|
|
|
|
p = &parent->rb_right;
|
|
|
|
else
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
rb_link_node(&set->rb_node, parent, p);
|
|
|
|
rb_insert_color(&set->rb_node, root_node);
|
2006-07-25 17:28:18 +02:00
|
|
|
list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
|
2005-08-18 20:24:12 +02:00
|
|
|
spin_unlock(&inode->i_lock);
|
2006-07-25 17:28:18 +02:00
|
|
|
return;
|
|
|
|
found:
|
|
|
|
rb_replace_node(parent, &set->rb_node, root_node);
|
2006-07-25 17:28:18 +02:00
|
|
|
list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
|
|
|
|
list_del(&entry->lru);
|
2006-07-25 17:28:18 +02:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
nfs_access_free_entry(entry);
|
|
|
|
}
|
|
|
|
|
2007-08-10 23:45:10 +02:00
|
|
|
static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
|
2006-07-25 17:28:18 +02:00
|
|
|
{
|
|
|
|
struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
|
|
|
|
if (cache == NULL)
|
|
|
|
return;
|
|
|
|
RB_CLEAR_NODE(&cache->rb_node);
|
2005-04-17 00:20:36 +02:00
|
|
|
cache->jiffies = set->jiffies;
|
2006-07-25 17:28:18 +02:00
|
|
|
cache->cred = get_rpccred(set->cred);
|
2005-04-17 00:20:36 +02:00
|
|
|
cache->mask = set->mask;
|
2006-07-25 17:28:18 +02:00
|
|
|
|
|
|
|
nfs_access_add_rbtree(inode, cache);
|
2006-07-25 17:28:18 +02:00
|
|
|
|
|
|
|
/* Update accounting */
|
|
|
|
smp_mb__before_atomic_inc();
|
|
|
|
atomic_long_inc(&nfs_access_nr_entries);
|
|
|
|
smp_mb__after_atomic_inc();
|
|
|
|
|
|
|
|
/* Add inode to global LRU list */
|
2010-05-13 18:51:06 +02:00
|
|
|
if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
|
2006-07-25 17:28:18 +02:00
|
|
|
spin_lock(&nfs_access_lru_lock);
|
2010-05-13 18:51:06 +02:00
|
|
|
if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
|
|
|
|
list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
|
|
|
|
&nfs_access_lru_list);
|
2006-07-25 17:28:18 +02:00
|
|
|
spin_unlock(&nfs_access_lru_lock);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
|
|
|
|
{
|
|
|
|
struct nfs_access_entry cache;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = nfs_access_get_cached(inode, cred, &cache);
|
|
|
|
if (status == 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Be clever: ask server to check for all possible rights */
|
|
|
|
cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
|
|
|
|
cache.cred = cred;
|
|
|
|
cache.jiffies = jiffies;
|
|
|
|
status = NFS_PROTO(inode)->access(inode, &cache);
|
2009-03-11 01:33:21 +01:00
|
|
|
if (status != 0) {
|
|
|
|
if (status == -ESTALE) {
|
|
|
|
nfs_zap_caches(inode);
|
|
|
|
if (!S_ISDIR(inode->i_mode))
|
|
|
|
set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
2009-03-11 01:33:21 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs_access_add_cache(inode, &cache);
|
|
|
|
out:
|
2008-07-16 03:03:57 +02:00
|
|
|
if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
return -EACCES;
|
|
|
|
}
|
|
|
|
|
2007-08-10 23:45:10 +02:00
|
|
|
static int nfs_open_permission_mask(int openflags)
|
|
|
|
{
|
|
|
|
int mask = 0;
|
|
|
|
|
2011-06-26 01:15:54 +02:00
|
|
|
if ((openflags & O_ACCMODE) != O_WRONLY)
|
2007-08-10 23:45:10 +02:00
|
|
|
mask |= MAY_READ;
|
2011-06-26 01:15:54 +02:00
|
|
|
if ((openflags & O_ACCMODE) != O_RDONLY)
|
2007-08-10 23:45:10 +02:00
|
|
|
mask |= MAY_WRITE;
|
2011-06-26 01:15:54 +02:00
|
|
|
if (openflags & __FMODE_EXEC)
|
2007-08-10 23:45:10 +02:00
|
|
|
mask |= MAY_EXEC;
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
|
|
|
|
{
|
|
|
|
return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
|
|
|
|
}
|
|
|
|
|
2011-06-21 01:28:19 +02:00
|
|
|
int nfs_permission(struct inode *inode, int mask)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct rpc_cred *cred;
|
|
|
|
int res = 0;
|
|
|
|
|
2011-06-21 01:28:19 +02:00
|
|
|
if (mask & MAY_NOT_BLOCK)
|
2011-01-07 07:49:58 +01:00
|
|
|
return -ECHILD;
|
|
|
|
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSACCESS);
|
|
|
|
|
2008-07-16 03:03:57 +02:00
|
|
|
if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
/* Is this sys_access() ? */
|
2010-07-23 17:43:51 +02:00
|
|
|
if (mask & (MAY_ACCESS | MAY_CHDIR))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto force_lookup;
|
|
|
|
|
|
|
|
switch (inode->i_mode & S_IFMT) {
|
|
|
|
case S_IFLNK:
|
|
|
|
goto out;
|
|
|
|
case S_IFREG:
|
|
|
|
/* NFSv4 has atomic_open... */
|
|
|
|
if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
|
2009-05-18 23:41:40 +02:00
|
|
|
&& (mask & MAY_OPEN)
|
|
|
|
&& !(mask & MAY_EXEC))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case S_IFDIR:
|
|
|
|
/*
|
|
|
|
* Optimize away all write operations, since the server
|
|
|
|
* will check permissions when we perform the op.
|
|
|
|
*/
|
|
|
|
if ((mask & MAY_WRITE) && !(mask & MAY_READ))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
force_lookup:
|
|
|
|
if (!NFS_PROTO(inode)->access)
|
|
|
|
goto out_notsup;
|
|
|
|
|
2008-03-12 17:25:28 +01:00
|
|
|
cred = rpc_lookup_cred();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!IS_ERR(cred)) {
|
|
|
|
res = nfs_do_access(inode, cred, mask);
|
|
|
|
put_rpccred(cred);
|
|
|
|
} else
|
|
|
|
res = PTR_ERR(cred);
|
|
|
|
out:
|
2008-07-31 13:41:58 +02:00
|
|
|
if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
|
|
|
|
res = -EACCES;
|
|
|
|
|
2006-03-20 19:44:24 +01:00
|
|
|
dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
|
|
|
|
inode->i_sb->s_id, inode->i_ino, mask, res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
out_notsup:
|
|
|
|
res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
if (res == 0)
|
2011-06-21 01:16:29 +02:00
|
|
|
res = generic_permission(inode, mask);
|
2006-03-20 19:44:24 +01:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* version-control: t
|
|
|
|
* kept-new-versions: 5
|
|
|
|
* End:
|
|
|
|
*/
|