Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6

	void (*put_link) (struct dentry *, struct nameidata *, void *);

	void (*truncate) (struct inode *);

	int (*permission) (struct inode *, int, unsigned int);

	int (*check_acl)(struct inode *, int, unsigned int);

	int (*check_acl)(struct inode *, int);

	int (*setattr) (struct dentry *, struct iattr *);

	int (*getattr) (struct vfsmount *, struct dentry *, struct kstat *);

	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);

	int (*open) (struct inode *, struct file *);

	int (*flush) (struct file *);

	int (*release) (struct inode *, struct file *);

	int (*fsync) (struct file *, int datasync);

	int (*fsync) (struct file *, loff_t start, loff_t end, int datasync);

	int (*aio_fsync) (struct kiocb *, int datasync);

	int (*fasync) (int, struct file *, int);

	int (*lock) (struct file *, int, struct file_lock *);

locking rules:

	All may block except for ->setlease.

	No VFS locks held on entry except for ->fsync and ->setlease.

->fsync() has i_mutex on inode.

	No VFS locks held on entry except for ->setlease.

->setlease has the file_list_lock held and must not sleep.

so the i_size should not change when hole punching, even when puching the end of

a file off.

--

[mandatory]

--

[mandatory]

	->get_sb() is gone.  Switch to use of ->mount().  Typically it's just

a matter of switching from calling get_sb_... to mount_... and changing the

function type.  If you were doing it manually, just switch from setting ->mnt_root

to some pointer to returning that pointer.  On errors return ERR_PTR(...).

--

[mandatory]

	->permission(), generic_permission() and ->check_acl() have lost flags

argument; instead of passing IPERM_FLAG_RCU we add MAY_NOT_BLOCK into mask.

	generic_permission() has also lost the check_acl argument; if you want

non-NULL to be used for that inode, put it into ->i_op->check_acl.

--

[mandatory]

	If you implement your own ->llseek() you must handle SEEK_HOLE and

SEEK_DATA.  You can hanle this by returning -EINVAL, but it would be nicer to

support it in some way.  The generic handler assumes that the entire file is

data and there is a virtual hole at the end of the file.  So if the provided

offset is less than i_size and SEEK_DATA is specified, return the same offset.

If the above is true for the offset and you are given SEEK_HOLE, return the end

of the file.  If the offset is i_size or greater return -ENXIO in either case.

[mandatory]

	If you have your own ->fsync() you must make sure to call

filemap_write_and_wait_range() so that all dirty pages are synced out properly.

You must also keep in mind that ->fsync() is not called with i_mutex held

anymore, so if you require i_mutex locking you must make sure to take it and

release it yourself.

        ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);

        ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);

	int (*nr_cached_objects)(struct super_block *);

	void (*free_cached_objects)(struct super_block *, int);

};

All methods are called without any locks being held, unless otherwise

  quota_write: called by the VFS to write to filesystem quota file.

  nr_cached_objects: called by the sb cache shrinking function for the

	filesystem to return the number of freeable cached objects it contains.

	Optional.

  free_cache_objects: called by the sb cache shrinking function for the

	filesystem to scan the number of objects indicated to try to free them.

	Optional, but any filesystem implementing this method needs to also

	implement ->nr_cached_objects for it to be called correctly.

	We can't do anything with any errors that the filesystem might

	encountered, hence the void return type. This will never be called if

	the VM is trying to reclaim under GFP_NOFS conditions, hence this

	method does not need to handle that situation itself.

	Implementations must include conditional reschedule calls inside any

	scanning loop that is done. This allows the VFS to determine

	appropriate scan batch sizes without having to worry about whether

	implementations will cause holdoff problems due to large scan batch

	sizes.

Whoever sets up the inode is responsible for filling in the "i_op" field. This

is a pointer to a "struct inode_operations" which describes the methods that

can be performed on individual inodes.

        void * (*follow_link) (struct dentry *, struct nameidata *);

        void (*put_link) (struct dentry *, struct nameidata *, void *);

	void (*truncate) (struct inode *);

	int (*permission) (struct inode *, int, unsigned int);

	int (*check_acl)(struct inode *, int, unsigned int);

	int (*permission) (struct inode *, int);

	int (*check_acl)(struct inode *, int);

	int (*setattr) (struct dentry *, struct iattr *);

	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);

	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);

  permission: called by the VFS to check for access rights on a POSIX-like

  	filesystem.

	May be called in rcu-walk mode (flags & IPERM_FLAG_RCU). If in rcu-walk

	May be called in rcu-walk mode (mask & MAY_NOT_BLOCK). If in rcu-walk

        mode, the filesystem must check the permission without blocking or

	storing to the inode.

	int (*open) (struct inode *, struct file *);

	int (*flush) (struct file *);

	int (*release) (struct inode *, struct file *);

	int (*fsync) (struct file *, int datasync);

	int (*fsync) (struct file *, loff_t, loff_t, int datasync);

	int (*aio_fsync) (struct kiocb *, int datasync);

	int (*fasync) (int, struct file *, int);

	int (*lock) (struct file *, int, struct file_lock *);

static int clk_debugfs_register_one(struct clk *c)

{

	struct dentry *d, *child, *child_tmp;

	struct dentry *d;

	d = debugfs_create_dir(c->name, clk_debugfs_root);

	if (!d)

	return 0;

err_out:

	d = c->dent;

	list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)

		debugfs_remove(child);

	debugfs_remove(c->dent);

	debugfs_remove_recursive(c->dent);

	return -ENOMEM;

}

static struct dentry *clk_debugfs_register_dir(struct clk *c,

						struct dentry *p_dentry)

{

	struct dentry *d, *clk_d, *child, *child_tmp;

	char s[255];

	char *p = s;

	struct dentry *d, *clk_d;

	const char *p = c->name;

	if (c->name == NULL)

		p += sprintf(p, "BUG");

	else

		p += sprintf(p, "%s", c->name);

	if (!p)

		p = "BUG";

	clk_d = debugfs_create_dir(s, p_dentry);

	clk_d = debugfs_create_dir(p, p_dentry);

	if (!clk_d)

		return NULL;

	return clk_d;

err_out:

	d = clk_d;

	list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)

		debugfs_remove(child);

	debugfs_remove(clk_d);

	debugfs_remove_recursive(clk_d);

	return NULL;

}

static void clk_debugfs_remove_dir(struct dentry *cdentry)

{

	struct dentry *d, *child, *child_tmp;

	d = cdentry;

	list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)

		debugfs_remove(child);

	debugfs_remove(cdentry);

	return ;

}

static int clk_debugfs_register_one(struct clk *c)

{

	struct clk *pa = c->parent_periph;

		c->dent_bus = clk_debugfs_register_dir(c,

				bpa->dent_bus ? bpa->dent_bus : bpa->dent);

		if ((!c->dent_bus) &&  (c->dent)) {

			clk_debugfs_remove_dir(c->dent);

			debugfs_remove_recursive(c->dent);

			c->dent = NULL;

			return -ENOMEM;

		}