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

	void (*kill_sb) (struct super_block *);

locking rules:

		may block

get_sb		yes

mount		yes

kill_sb		yes

->get_sb() returns error or 0 with locked superblock attached to the vfsmount

(exclusive on ->s_umount).

->mount() returns ERR_PTR or the root dentry.

->mount() returns ERR_PTR or the root dentry; its superblock should be locked

on return.

->kill_sb() takes a write-locked superblock, does all shutdown work on it,

unlocks and drops the reference.

Currently you can only have FALLOC_FL_PUNCH_HOLE with FALLOC_FL_KEEP_SIZE set,

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

a file off.

--

[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(...).

   extern int unregister_filesystem(struct file_system_type *);

The passed struct file_system_type describes your filesystem. When a

request is made to mount a device onto a directory in your filespace,

the VFS will call the appropriate get_sb() method for the specific

filesystem. The dentry for the mount point will then be updated to

point to the root inode for the new filesystem.

request is made to mount a filesystem onto a directory in your namespace,

the VFS will call the appropriate mount() method for the specific

filesystem.  New vfsmount refering to the tree returned by ->mount()

will be attached to the mountpoint, so that when pathname resolution

reaches the mountpoint it will jump into the root of that vfsmount.

You can see all filesystems that are registered to the kernel in the

file /proc/filesystems.

struct file_system_type

-----------------------

This describes the filesystem. As of kernel 2.6.22, the following

This describes the filesystem. As of kernel 2.6.39, the following

members are defined:

struct file_system_type {

	const char *name;

	int fs_flags;

        int (*get_sb) (struct file_system_type *, int,

                       const char *, void *, struct vfsmount *);

        struct dentry (*mount) (struct file_system_type *, int,

                       const char *, void *);

        void (*kill_sb) (struct super_block *);

        struct module *owner;

        struct file_system_type * next;

  fs_flags: various flags (i.e. FS_REQUIRES_DEV, FS_NO_DCACHE, etc.)

  get_sb: the method to call when a new instance of this

  mount: the method to call when a new instance of this

	filesystem should be mounted

  kill_sb: the method to call when an instance of this filesystem

	should be unmounted

	should be shut down

  owner: for internal VFS use: you should initialize this to THIS_MODULE in

  	most cases.

  s_lock_key, s_umount_key: lockdep-specific

The get_sb() method has the following arguments:

The mount() method has the following arguments:

  struct file_system_type *fs_type: describes the filesystem, partly initialized

  	by the specific filesystem code

  void *data: arbitrary mount options, usually comes as an ASCII

	string (see "Mount Options" section)

  struct vfsmount *mnt: a vfs-internal representation of a mount point

The mount() method must return the root dentry of the tree requested by

caller.  An active reference to its superblock must be grabbed and the

superblock must be locked.  On failure it should return ERR_PTR(error).

The get_sb() method must determine if the block device specified

in the dev_name and fs_type contains a filesystem of the type the method

supports. If it succeeds in opening the named block device, it initializes a

struct super_block descriptor for the filesystem contained by the block device.

On failure it returns an error.

The arguments match those of mount(2) and their interpretation

depends on filesystem type.  E.g. for block filesystems, dev_name is

interpreted as block device name, that device is opened and if it

contains a suitable filesystem image the method creates and initializes

struct super_block accordingly, returning its root dentry to caller.

->mount() may choose to return a subtree of existing filesystem - it

doesn't have to create a new one.  The main result from the caller's

point of view is a reference to dentry at the root of (sub)tree to

be attached; creation of new superblock is a common side effect.

The most interesting member of the superblock structure that the

get_sb() method fills in is the "s_op" field. This is a pointer to

mount() method fills in is the "s_op" field. This is a pointer to

a "struct super_operations" which describes the next level of the

filesystem implementation.

Usually, a filesystem uses one of the generic get_sb() implementations

and provides a fill_super() method instead. The generic methods are:

Usually, a filesystem uses one of the generic mount() implementations

and provides a fill_super() callback instead. The generic variants are:

  get_sb_bdev: mount a filesystem residing on a block device

  mount_bdev: mount a filesystem residing on a block device

  get_sb_nodev: mount a filesystem that is not backed by a device

  mount_nodev: mount a filesystem that is not backed by a device

  get_sb_single: mount a filesystem which shares the instance between

  mount_single: mount a filesystem which shares the instance between

  	all mounts

A fill_super() method implementation has the following arguments:

A fill_super() callback implementation has the following arguments:

  struct super_block *sb: the superblock structure. The method fill_super()

  struct super_block *sb: the superblock structure. The callback

  	must initialize this properly.

  void *data: arbitrary mount options, usually comes as an ASCII

	int err = 0;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };

	if (mnt->mnt_sb->s_op->show_devname) {

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

		if (err)

			goto out;

	} else {

		mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");

	}

	seq_putc(m, ' ');

	seq_path(m, &mnt_path, " \t\n\\");

	seq_putc(m, ' ');

	seq_printf(m, "%i %i %u:%u ", mnt->mnt_id, mnt->mnt_parent->mnt_id,

		   MAJOR(sb->s_dev), MINOR(sb->s_dev));

	if (sb->s_op->show_path)

		err = sb->s_op->show_path(m, mnt);

	else

		seq_dentry(m, mnt->mnt_root, " \t\n\\");

	if (err)

		goto out;

	seq_putc(m, ' ');

	seq_path_root(m, &mnt_path, &root, " \t\n\\");

	if (root.mnt != p->root.mnt || root.dentry != p->root.dentry) {

	seq_puts(m, " - ");

	show_type(m, sb);

	seq_putc(m, ' ');

	if (sb->s_op->show_devname)

		err = sb->s_op->show_devname(m, mnt);

	else

		mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");

	if (err)

		goto out;

	seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");

	err = show_sb_opts(m, sb);

	if (err)

	int err = 0;

	/* device */

	if (mnt->mnt_sb->s_op->show_devname) {

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

	} else {

		if (mnt->mnt_devname) {

			seq_puts(m, "device ");

			mangle(m, mnt->mnt_devname);

		} else

			seq_puts(m, "no device");

	}

	/* mount point */

	seq_puts(m, " mounted on ");

	/* optional statistics */

	if (mnt->mnt_sb->s_op->show_stats) {

		seq_putc(m, ' ');

		if (!err)

			err = mnt->mnt_sb->s_op->show_stats(m, mnt);

	}

	iput(inode);

}

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);

	}

}

const struct dentry_operations nfs_dentry_operations = {

	.d_revalidate	= nfs_lookup_revalidate,

	.d_delete	= nfs_dentry_delete,

	.d_iput		= nfs_dentry_iput,

	.d_automount	= nfs_d_automount,

	.d_release	= nfs_d_release,

};

static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)

	.d_delete	= nfs_dentry_delete,

	.d_iput		= nfs_dentry_iput,

	.d_automount	= nfs_d_automount,

	.d_release	= nfs_d_release,

};

/*