2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* linux/fs/super.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
|
|
|
* super.c contains code to handle: - mount structures
|
|
|
|
* - super-block tables
|
|
|
|
* - filesystem drivers list
|
|
|
|
* - mount system call
|
|
|
|
* - umount system call
|
|
|
|
* - ustat system call
|
|
|
|
*
|
|
|
|
* GK 2/5/95 - Changed to support mounting the root fs via NFS
|
|
|
|
*
|
|
|
|
* Added kerneld support: Jacques Gelinas and Bjorn Ekwall
|
|
|
|
* Added change_root: Werner Almesberger & Hans Lermen, Feb '96
|
|
|
|
* Added options to /proc/mounts:
|
2007-10-19 23:21:04 +02:00
|
|
|
* Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
|
2005-04-17 00:20:36 +02:00
|
|
|
* Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
|
|
|
|
* Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <linux/acct.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/quotaops.h>
|
|
|
|
#include <linux/namei.h>
|
|
|
|
#include <linux/buffer_head.h> /* for fsync_super() */
|
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/vfs.h>
|
|
|
|
#include <linux/writeback.h> /* for the emergency remount stuff */
|
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/kobject.h>
|
2006-03-26 11:37:12 +02:00
|
|
|
#include <linux/mutex.h>
|
2008-02-15 23:37:32 +01:00
|
|
|
#include <linux/file.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/uaccess.h>
|
2008-03-22 20:48:17 +01:00
|
|
|
#include "internal.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
LIST_HEAD(super_blocks);
|
|
|
|
DEFINE_SPINLOCK(sb_lock);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* alloc_super - create new superblock
|
2006-09-06 09:03:41 +02:00
|
|
|
* @type: filesystem type superblock should belong to
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Allocates and initializes a new &struct super_block. alloc_super()
|
|
|
|
* returns a pointer new superblock or %NULL if allocation had failed.
|
|
|
|
*/
|
2006-07-03 09:25:27 +02:00
|
|
|
static struct super_block *alloc_super(struct file_system_type *type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-25 12:08:13 +01:00
|
|
|
struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct super_operations default_op;
|
|
|
|
|
|
|
|
if (s) {
|
|
|
|
if (security_sb_alloc(s)) {
|
|
|
|
kfree(s);
|
|
|
|
s = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
INIT_LIST_HEAD(&s->s_dirty);
|
|
|
|
INIT_LIST_HEAD(&s->s_io);
|
2007-10-17 08:30:38 +02:00
|
|
|
INIT_LIST_HEAD(&s->s_more_io);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&s->s_files);
|
|
|
|
INIT_LIST_HEAD(&s->s_instances);
|
|
|
|
INIT_HLIST_HEAD(&s->s_anon);
|
|
|
|
INIT_LIST_HEAD(&s->s_inodes);
|
fix soft lock up at NFS mount via per-SB LRU-list of unused dentries
[Summary]
Split LRU-list of unused dentries to one per superblock to avoid soft
lock up during NFS mounts and remounting of any filesystem.
Previously I posted here:
http://lkml.org/lkml/2008/3/5/590
[Descriptions]
- background
dentry_unused is a list of dentries which are not referenced.
dentry_unused grows up when references on directories or files are
released. This list can be very long if there is huge free memory.
- the problem
When shrink_dcache_sb() is called, it scans all dentry_unused linearly
under spin_lock(), and if dentry->d_sb is differnt from given
superblock, scan next dentry. This scan costs very much if there are
many entries, and very ineffective if there are many superblocks.
IOW, When we need to shrink unused dentries on one dentry, but scans
unused dentries on all superblocks in the system. For example, we scan
500 dentries to unmount a filesystem, but scans 1,000,000 or more unused
dentries on other superblocks.
In our case , At mounting NFS*, shrink_dcache_sb() is called to shrink
unused dentries on NFS, but scans 100,000,000 unused dentries on
superblocks in the system such as local ext3 filesystems. I hear NFS
mounting took 1 min on some system in use.
* : NFS uses virtual filesystem in rpc layer, so NFS is affected by
this problem.
100,000,000 is possible number on large systems.
Per-superblock LRU of unused dentried can reduce the cost in
reasonable manner.
- How to fix
I found this problem is solved by David Chinner's "Per-superblock
unused dentry LRU lists V3"(1), so I rebase it and add some fix to
reclaim with fairness, which is in Andrew Morton's comments(2).
1) http://lkml.org/lkml/2006/5/25/318
2) http://lkml.org/lkml/2006/5/25/320
Split LRU-list of unused dentries to each superblocks. Then, NFS
mounting will check dentries under a superblock instead of all. But
this spliting will break LRU of dentry-unused. So, I've attempted to
make reclaim unused dentrins with fairness by calculate number of
dentries to scan on this sb based on following way
number of dentries to scan on this sb =
count * (number of dentries on this sb / number of dentries in the machine)
- ToDo
- I have to measuring performance number and do stress tests.
- When unmount occurs during prune_dcache(), scanning on same
superblock, It is unable to reach next superblock because it is gone
away. We restart scannig superblock from first one, it causes
unfairness of reclaim unused dentries on first superblock. But I think
this happens very rarely.
- Test Results
Result on 6GB boxes with excessive unused dentries.
Without patch:
$ cat /proc/sys/fs/dentry-state
10181835 10180203 45 0 0 0
# mount -t nfs 10.124.60.70:/work/kernel-src nfs
real 0m1.830s
user 0m0.001s
sys 0m1.653s
With this patch:
$ cat /proc/sys/fs/dentry-state
10236610 10234751 45 0 0 0
# mount -t nfs 10.124.60.70:/work/kernel-src nfs
real 0m0.106s
user 0m0.002s
sys 0m0.032s
[akpm@linux-foundation.org: fix comments]
Signed-off-by: Kentaro Makita <k-makita@np.css.fujitsu.com>
Cc: Neil Brown <neilb@suse.de>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Cc: David Chinner <dgc@sgi.com>
Cc: "J. Bruce Fields" <bfields@fieldses.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:27:13 +02:00
|
|
|
INIT_LIST_HEAD(&s->s_dentry_lru);
|
2005-04-17 00:20:36 +02:00
|
|
|
init_rwsem(&s->s_umount);
|
2006-01-10 00:59:25 +01:00
|
|
|
mutex_init(&s->s_lock);
|
2006-07-03 09:25:28 +02:00
|
|
|
lockdep_set_class(&s->s_umount, &type->s_umount_key);
|
2006-07-03 09:25:27 +02:00
|
|
|
/*
|
|
|
|
* The locking rules for s_lock are up to the
|
|
|
|
* filesystem. For example ext3fs has different
|
|
|
|
* lock ordering than usbfs:
|
|
|
|
*/
|
|
|
|
lockdep_set_class(&s->s_lock, &type->s_lock_key);
|
2005-04-17 00:20:36 +02:00
|
|
|
down_write(&s->s_umount);
|
|
|
|
s->s_count = S_BIAS;
|
|
|
|
atomic_set(&s->s_active, 1);
|
2006-03-23 12:00:33 +01:00
|
|
|
mutex_init(&s->s_vfs_rename_mutex);
|
2006-03-23 12:00:29 +01:00
|
|
|
mutex_init(&s->s_dquot.dqio_mutex);
|
|
|
|
mutex_init(&s->s_dquot.dqonoff_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
init_rwsem(&s->s_dquot.dqptr_sem);
|
|
|
|
init_waitqueue_head(&s->s_wait_unfrozen);
|
|
|
|
s->s_maxbytes = MAX_NON_LFS;
|
|
|
|
s->dq_op = sb_dquot_ops;
|
|
|
|
s->s_qcop = sb_quotactl_ops;
|
|
|
|
s->s_op = &default_op;
|
|
|
|
s->s_time_gran = 1000000000;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* destroy_super - frees a superblock
|
|
|
|
* @s: superblock to free
|
|
|
|
*
|
|
|
|
* Frees a superblock.
|
|
|
|
*/
|
|
|
|
static inline void destroy_super(struct super_block *s)
|
|
|
|
{
|
|
|
|
security_sb_free(s);
|
add filesystem subtype support
There's a slight problem with filesystem type representation in fuse
based filesystems.
From the kernel's view, there are just two filesystem types: fuse and
fuseblk. From the user's view there are lots of different filesystem
types. The user is not even much concerned if the filesystem is fuse based
or not. So there's a conflict of interest in how this should be
represented in fstab, mtab and /proc/mounts.
The current scheme is to encode the real filesystem type in the mount
source. So an sshfs mount looks like this:
sshfs#user@server:/ /mnt/server fuse rw,nosuid,nodev,...
This url-ish syntax works OK for sshfs and similar filesystems. However
for block device based filesystems (ntfs-3g, zfs) it doesn't work, since
the kernel expects the mount source to be a real device name.
A possibly better scheme would be to encode the real type in the type
field as "type.subtype". So fuse mounts would look like this:
/dev/hda1 /mnt/windows fuseblk.ntfs-3g rw,...
user@server:/ /mnt/server fuse.sshfs rw,nosuid,nodev,...
This patch adds the necessary code to the kernel so that this can be
correctly displayed in /proc/mounts.
Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 09:25:43 +02:00
|
|
|
kfree(s->s_subtype);
|
2008-02-08 13:21:35 +01:00
|
|
|
kfree(s->s_options);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Superblock refcounting */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop a superblock's refcount. Returns non-zero if the superblock was
|
|
|
|
* destroyed. The caller must hold sb_lock.
|
|
|
|
*/
|
2008-04-29 09:58:54 +02:00
|
|
|
static int __put_super(struct super_block *sb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!--sb->s_count) {
|
|
|
|
destroy_super(sb);
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop a superblock's refcount.
|
|
|
|
* Returns non-zero if the superblock is about to be destroyed and
|
|
|
|
* at least is already removed from super_blocks list, so if we are
|
|
|
|
* making a loop through super blocks then we need to restart.
|
|
|
|
* The caller must hold sb_lock.
|
|
|
|
*/
|
|
|
|
int __put_super_and_need_restart(struct super_block *sb)
|
|
|
|
{
|
|
|
|
/* check for race with generic_shutdown_super() */
|
|
|
|
if (list_empty(&sb->s_list)) {
|
|
|
|
/* super block is removed, need to restart... */
|
|
|
|
__put_super(sb);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* can't be the last, since s_list is still in use */
|
|
|
|
sb->s_count--;
|
|
|
|
BUG_ON(sb->s_count == 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* put_super - drop a temporary reference to superblock
|
|
|
|
* @sb: superblock in question
|
|
|
|
*
|
|
|
|
* Drops a temporary reference, frees superblock if there's no
|
|
|
|
* references left.
|
|
|
|
*/
|
|
|
|
static void put_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
__put_super(sb);
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* deactivate_super - drop an active reference to superblock
|
|
|
|
* @s: superblock to deactivate
|
|
|
|
*
|
|
|
|
* Drops an active reference to superblock, acquiring a temprory one if
|
|
|
|
* there is no active references left. In that case we lock superblock,
|
|
|
|
* tell fs driver to shut it down and drop the temporary reference we
|
|
|
|
* had just acquired.
|
|
|
|
*/
|
|
|
|
void deactivate_super(struct super_block *s)
|
|
|
|
{
|
|
|
|
struct file_system_type *fs = s->s_type;
|
|
|
|
if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
|
|
|
|
s->s_count -= S_BIAS-1;
|
|
|
|
spin_unlock(&sb_lock);
|
2008-04-28 11:14:33 +02:00
|
|
|
DQUOT_OFF(s, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
down_write(&s->s_umount);
|
|
|
|
fs->kill_sb(s);
|
|
|
|
put_filesystem(fs);
|
|
|
|
put_super(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(deactivate_super);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* grab_super - acquire an active reference
|
|
|
|
* @s: reference we are trying to make active
|
|
|
|
*
|
|
|
|
* Tries to acquire an active reference. grab_super() is used when we
|
|
|
|
* had just found a superblock in super_blocks or fs_type->fs_supers
|
|
|
|
* and want to turn it into a full-blown active reference. grab_super()
|
|
|
|
* is called with sb_lock held and drops it. Returns 1 in case of
|
|
|
|
* success, 0 if we had failed (superblock contents was already dead or
|
|
|
|
* dying when grab_super() had been called).
|
|
|
|
*/
|
2006-09-29 10:59:29 +02:00
|
|
|
static int grab_super(struct super_block *s) __releases(sb_lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
s->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_write(&s->s_umount);
|
|
|
|
if (s->s_root) {
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
if (s->s_count > S_BIAS) {
|
|
|
|
atomic_inc(&s->s_active);
|
|
|
|
s->s_count--;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
}
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
put_super(s);
|
|
|
|
yield();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-18 19:55:46 +02:00
|
|
|
/*
|
|
|
|
* Superblock locking. We really ought to get rid of these two.
|
|
|
|
*/
|
|
|
|
void lock_super(struct super_block * sb)
|
|
|
|
{
|
|
|
|
get_fs_excl();
|
|
|
|
mutex_lock(&sb->s_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void unlock_super(struct super_block * sb)
|
|
|
|
{
|
|
|
|
put_fs_excl();
|
|
|
|
mutex_unlock(&sb->s_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(lock_super);
|
|
|
|
EXPORT_SYMBOL(unlock_super);
|
|
|
|
|
2006-08-29 20:05:54 +02:00
|
|
|
/*
|
|
|
|
* Write out and wait upon all dirty data associated with this
|
|
|
|
* superblock. Filesystem data as well as the underlying block
|
|
|
|
* device. Takes the superblock lock. Requires a second blkdev
|
|
|
|
* flush by the caller to complete the operation.
|
|
|
|
*/
|
|
|
|
void __fsync_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
sync_inodes_sb(sb, 0);
|
|
|
|
DQUOT_SYNC(sb);
|
|
|
|
lock_super(sb);
|
|
|
|
if (sb->s_dirt && sb->s_op->write_super)
|
|
|
|
sb->s_op->write_super(sb);
|
|
|
|
unlock_super(sb);
|
|
|
|
if (sb->s_op->sync_fs)
|
|
|
|
sb->s_op->sync_fs(sb, 1);
|
|
|
|
sync_blockdev(sb->s_bdev);
|
|
|
|
sync_inodes_sb(sb, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write out and wait upon all dirty data associated with this
|
|
|
|
* superblock. Filesystem data as well as the underlying block
|
|
|
|
* device. Takes the superblock lock.
|
|
|
|
*/
|
|
|
|
int fsync_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
__fsync_super(sb);
|
|
|
|
return sync_blockdev(sb->s_bdev);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* generic_shutdown_super - common helper for ->kill_sb()
|
|
|
|
* @sb: superblock to kill
|
|
|
|
*
|
|
|
|
* generic_shutdown_super() does all fs-independent work on superblock
|
|
|
|
* shutdown. Typical ->kill_sb() should pick all fs-specific objects
|
|
|
|
* that need destruction out of superblock, call generic_shutdown_super()
|
|
|
|
* and release aforementioned objects. Note: dentries and inodes _are_
|
|
|
|
* taken care of and do not need specific handling.
|
2006-10-11 10:22:19 +02:00
|
|
|
*
|
|
|
|
* Upon calling this function, the filesystem may no longer alter or
|
|
|
|
* rearrange the set of dentries belonging to this super_block, nor may it
|
|
|
|
* change the attachments of dentries to inodes.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
void generic_shutdown_super(struct super_block *sb)
|
|
|
|
{
|
2007-02-12 09:55:41 +01:00
|
|
|
const struct super_operations *sop = sb->s_op;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-10-11 10:22:19 +02:00
|
|
|
if (sb->s_root) {
|
|
|
|
shrink_dcache_for_umount(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
fsync_super(sb);
|
|
|
|
lock_super(sb);
|
|
|
|
sb->s_flags &= ~MS_ACTIVE;
|
|
|
|
/* bad name - it should be evict_inodes() */
|
|
|
|
invalidate_inodes(sb);
|
|
|
|
lock_kernel();
|
|
|
|
|
|
|
|
if (sop->write_super && sb->s_dirt)
|
|
|
|
sop->write_super(sb);
|
|
|
|
if (sop->put_super)
|
|
|
|
sop->put_super(sb);
|
|
|
|
|
|
|
|
/* Forget any remaining inodes */
|
|
|
|
if (invalidate_inodes(sb)) {
|
2006-02-07 21:58:48 +01:00
|
|
|
printk("VFS: Busy inodes after unmount of %s. "
|
|
|
|
"Self-destruct in 5 seconds. Have a nice day...\n",
|
|
|
|
sb->s_id);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
unlock_kernel();
|
|
|
|
unlock_super(sb);
|
|
|
|
}
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
/* should be initialized for __put_super_and_need_restart() */
|
|
|
|
list_del_init(&sb->s_list);
|
|
|
|
list_del(&sb->s_instances);
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(generic_shutdown_super);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sget - find or create a superblock
|
|
|
|
* @type: filesystem type superblock should belong to
|
|
|
|
* @test: comparison callback
|
|
|
|
* @set: setup callback
|
|
|
|
* @data: argument to each of them
|
|
|
|
*/
|
|
|
|
struct super_block *sget(struct file_system_type *type,
|
|
|
|
int (*test)(struct super_block *,void *),
|
|
|
|
int (*set)(struct super_block *,void *),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct super_block *s = NULL;
|
2007-10-19 08:39:57 +02:00
|
|
|
struct super_block *old;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
spin_lock(&sb_lock);
|
2007-10-19 08:39:57 +02:00
|
|
|
if (test) {
|
|
|
|
list_for_each_entry(old, &type->fs_supers, s_instances) {
|
|
|
|
if (!test(old, data))
|
|
|
|
continue;
|
|
|
|
if (!grab_super(old))
|
|
|
|
goto retry;
|
|
|
|
if (s)
|
|
|
|
destroy_super(s);
|
|
|
|
return old;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (!s) {
|
|
|
|
spin_unlock(&sb_lock);
|
2006-07-03 09:25:27 +02:00
|
|
|
s = alloc_super(type);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!s)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = set(s, data);
|
|
|
|
if (err) {
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
destroy_super(s);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
s->s_type = type;
|
|
|
|
strlcpy(s->s_id, type->name, sizeof(s->s_id));
|
|
|
|
list_add_tail(&s->s_list, &super_blocks);
|
|
|
|
list_add(&s->s_instances, &type->fs_supers);
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
get_filesystem(type);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(sget);
|
|
|
|
|
|
|
|
void drop_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
put_super(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(drop_super);
|
|
|
|
|
|
|
|
static inline void write_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
lock_super(sb);
|
|
|
|
if (sb->s_root && sb->s_dirt)
|
|
|
|
if (sb->s_op->write_super)
|
|
|
|
sb->s_op->write_super(sb);
|
|
|
|
unlock_super(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: check the dirty flag before waiting, so we don't
|
|
|
|
* hold up the sync while mounting a device. (The newly
|
|
|
|
* mounted device won't need syncing.)
|
|
|
|
*/
|
|
|
|
void sync_supers(void)
|
|
|
|
{
|
2005-06-23 09:09:54 +02:00
|
|
|
struct super_block *sb;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
restart:
|
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (sb->s_dirt) {
|
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_read(&sb->s_umount);
|
|
|
|
write_super(sb);
|
2005-06-23 09:09:54 +02:00
|
|
|
up_read(&sb->s_umount);
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
if (__put_super_and_need_restart(sb))
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-10-19 23:10:43 +02:00
|
|
|
* Call the ->sync_fs super_op against all filesystems which are r/w and
|
2005-04-17 00:20:36 +02:00
|
|
|
* which implement it.
|
|
|
|
*
|
|
|
|
* This operation is careful to avoid the livelock which could easily happen
|
|
|
|
* if two or more filesystems are being continuously dirtied. s_need_sync_fs
|
|
|
|
* is used only here. We set it against all filesystems and then clear it as
|
|
|
|
* we sync them. So redirtied filesystems are skipped.
|
|
|
|
*
|
2007-10-19 23:10:43 +02:00
|
|
|
* But if process A is currently running sync_filesystems and then process B
|
2005-04-17 00:20:36 +02:00
|
|
|
* calls sync_filesystems as well, process B will set all the s_need_sync_fs
|
|
|
|
* flags again, which will cause process A to resync everything. Fix that with
|
|
|
|
* a local mutex.
|
|
|
|
*
|
|
|
|
* (Fabian) Avoid sync_fs with clean fs & wait mode 0
|
|
|
|
*/
|
|
|
|
void sync_filesystems(int wait)
|
|
|
|
{
|
|
|
|
struct super_block *sb;
|
2006-03-26 11:37:12 +02:00
|
|
|
static DEFINE_MUTEX(mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-26 11:37:12 +02:00
|
|
|
mutex_lock(&mutex); /* Could be down_interruptible */
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!sb->s_op->sync_fs)
|
|
|
|
continue;
|
|
|
|
if (sb->s_flags & MS_RDONLY)
|
|
|
|
continue;
|
|
|
|
sb->s_need_sync_fs = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
restart:
|
2005-06-23 09:09:54 +02:00
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!sb->s_need_sync_fs)
|
|
|
|
continue;
|
|
|
|
sb->s_need_sync_fs = 0;
|
|
|
|
if (sb->s_flags & MS_RDONLY)
|
|
|
|
continue; /* hm. Was remounted r/o meanwhile */
|
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_read(&sb->s_umount);
|
|
|
|
if (sb->s_root && (wait || sb->s_dirt))
|
|
|
|
sb->s_op->sync_fs(sb, wait);
|
2005-06-23 09:09:54 +02:00
|
|
|
up_read(&sb->s_umount);
|
|
|
|
/* restart only when sb is no longer on the list */
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
if (__put_super_and_need_restart(sb))
|
|
|
|
goto restart;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
2006-03-26 11:37:12 +02:00
|
|
|
mutex_unlock(&mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_super - get the superblock of a device
|
|
|
|
* @bdev: device to get the superblock for
|
|
|
|
*
|
|
|
|
* Scans the superblock list and finds the superblock of the file system
|
|
|
|
* mounted on the device given. %NULL is returned if no match is found.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct super_block * get_super(struct block_device *bdev)
|
|
|
|
{
|
2005-06-23 09:09:54 +02:00
|
|
|
struct super_block *sb;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!bdev)
|
|
|
|
return NULL;
|
2005-06-23 09:09:54 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
rescan:
|
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
|
|
if (sb->s_bdev == bdev) {
|
|
|
|
sb->s_count++;
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
down_read(&sb->s_umount);
|
|
|
|
if (sb->s_root)
|
|
|
|
return sb;
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
/* restart only when sb is no longer on the list */
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
if (__put_super_and_need_restart(sb))
|
|
|
|
goto rescan;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(get_super);
|
|
|
|
|
|
|
|
struct super_block * user_get_super(dev_t dev)
|
|
|
|
{
|
2005-06-23 09:09:54 +02:00
|
|
|
struct super_block *sb;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
rescan:
|
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
|
|
if (sb->s_dev == dev) {
|
|
|
|
sb->s_count++;
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&sb_lock);
|
2005-06-23 09:09:54 +02:00
|
|
|
down_read(&sb->s_umount);
|
|
|
|
if (sb->s_root)
|
|
|
|
return sb;
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
/* restart only when sb is no longer on the list */
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
if (__put_super_and_need_restart(sb))
|
|
|
|
goto rescan;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage long sys_ustat(unsigned dev, struct ustat __user * ubuf)
|
|
|
|
{
|
|
|
|
struct super_block *s;
|
|
|
|
struct ustat tmp;
|
|
|
|
struct kstatfs sbuf;
|
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
|
|
s = user_get_super(new_decode_dev(dev));
|
|
|
|
if (s == NULL)
|
|
|
|
goto out;
|
2006-06-23 11:02:58 +02:00
|
|
|
err = vfs_statfs(s->s_root, &sbuf);
|
2005-04-17 00:20:36 +02:00
|
|
|
drop_super(s);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
memset(&tmp,0,sizeof(struct ustat));
|
|
|
|
tmp.f_tfree = sbuf.f_bfree;
|
|
|
|
tmp.f_tinode = sbuf.f_ffree;
|
|
|
|
|
|
|
|
err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-03-20 01:01:00 +01:00
|
|
|
* mark_files_ro - mark all files read-only
|
2005-04-17 00:20:36 +02:00
|
|
|
* @sb: superblock in question
|
|
|
|
*
|
2008-03-20 01:01:00 +01:00
|
|
|
* All files are marked read-only. We don't care about pending
|
|
|
|
* delete files so this should be used in 'force' mode only.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void mark_files_ro(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct file *f;
|
|
|
|
|
2008-02-15 23:37:32 +01:00
|
|
|
retry:
|
2005-04-17 00:20:36 +02:00
|
|
|
file_list_lock();
|
2005-10-31 00:02:16 +01:00
|
|
|
list_for_each_entry(f, &sb->s_files, f_u.fu_list) {
|
2008-02-15 23:37:32 +01:00
|
|
|
struct vfsmount *mnt;
|
|
|
|
if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
|
|
|
|
continue;
|
|
|
|
if (!file_count(f))
|
|
|
|
continue;
|
|
|
|
if (!(f->f_mode & FMODE_WRITE))
|
|
|
|
continue;
|
|
|
|
f->f_mode &= ~FMODE_WRITE;
|
2008-02-15 23:38:01 +01:00
|
|
|
if (file_check_writeable(f) != 0)
|
|
|
|
continue;
|
|
|
|
file_release_write(f);
|
2008-02-15 23:37:32 +01:00
|
|
|
mnt = mntget(f->f_path.mnt);
|
|
|
|
file_list_unlock();
|
|
|
|
/*
|
|
|
|
* This can sleep, so we can't hold
|
|
|
|
* the file_list_lock() spinlock.
|
|
|
|
*/
|
|
|
|
mnt_drop_write(mnt);
|
|
|
|
mntput(mnt);
|
|
|
|
goto retry;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
file_list_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* do_remount_sb - asks filesystem to change mount options.
|
|
|
|
* @sb: superblock in question
|
|
|
|
* @flags: numeric part of options
|
|
|
|
* @data: the rest of options
|
|
|
|
* @force: whether or not to force the change
|
|
|
|
*
|
|
|
|
* Alters the mount options of a mounted file system.
|
|
|
|
*/
|
|
|
|
int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
|
|
|
|
{
|
|
|
|
int retval;
|
2008-04-28 11:14:33 +02:00
|
|
|
int remount_rw;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 20:45:40 +02:00
|
|
|
#ifdef CONFIG_BLOCK
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
|
|
|
|
return -EACCES;
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 20:45:40 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
if (flags & MS_RDONLY)
|
|
|
|
acct_auto_close(sb);
|
|
|
|
shrink_dcache_sb(sb);
|
|
|
|
fsync_super(sb);
|
|
|
|
|
|
|
|
/* If we are remounting RDONLY and current sb is read/write,
|
|
|
|
make sure there are no rw files opened */
|
|
|
|
if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {
|
|
|
|
if (force)
|
|
|
|
mark_files_ro(sb);
|
|
|
|
else if (!fs_may_remount_ro(sb))
|
|
|
|
return -EBUSY;
|
2008-04-28 11:14:33 +02:00
|
|
|
retval = DQUOT_OFF(sb, 1);
|
|
|
|
if (retval < 0 && retval != -ENOSYS)
|
|
|
|
return -EBUSY;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-28 11:14:33 +02:00
|
|
|
remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (sb->s_op->remount_fs) {
|
|
|
|
lock_super(sb);
|
|
|
|
retval = sb->s_op->remount_fs(sb, &flags, data);
|
|
|
|
unlock_super(sb);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
|
2008-04-28 11:14:33 +02:00
|
|
|
if (remount_rw)
|
|
|
|
DQUOT_ON_REMOUNT(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_emergency_remount(unsigned long foo)
|
|
|
|
{
|
|
|
|
struct super_block *sb;
|
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_read(&sb->s_umount);
|
|
|
|
if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
|
|
|
|
/*
|
|
|
|
* ->remount_fs needs lock_kernel().
|
|
|
|
*
|
|
|
|
* What lock protects sb->s_flags??
|
|
|
|
*/
|
|
|
|
lock_kernel();
|
|
|
|
do_remount_sb(sb, MS_RDONLY, NULL, 1);
|
|
|
|
unlock_kernel();
|
|
|
|
}
|
|
|
|
drop_super(sb);
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
printk("Emergency Remount complete\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void emergency_remount(void)
|
|
|
|
{
|
|
|
|
pdflush_operation(do_emergency_remount, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unnamed block devices are dummy devices used by virtual
|
|
|
|
* filesystems which don't use real block-devices. -- jrs
|
|
|
|
*/
|
|
|
|
|
2008-08-28 04:25:49 +02:00
|
|
|
static DEFINE_IDR(unnamed_dev_idr);
|
2005-04-17 00:20:36 +02:00
|
|
|
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
|
|
|
|
|
|
|
|
int set_anon_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
int dev;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
if (idr_pre_get(&unnamed_dev_idr, GFP_ATOMIC) == 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
spin_lock(&unnamed_dev_lock);
|
|
|
|
error = idr_get_new(&unnamed_dev_idr, NULL, &dev);
|
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
if (error == -EAGAIN)
|
|
|
|
/* We raced and lost with another CPU. */
|
|
|
|
goto retry;
|
|
|
|
else if (error)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
|
|
|
|
spin_lock(&unnamed_dev_lock);
|
|
|
|
idr_remove(&unnamed_dev_idr, dev);
|
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
return -EMFILE;
|
|
|
|
}
|
|
|
|
s->s_dev = MKDEV(0, dev & MINORMASK);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(set_anon_super);
|
|
|
|
|
|
|
|
void kill_anon_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
int slot = MINOR(sb->s_dev);
|
|
|
|
|
|
|
|
generic_shutdown_super(sb);
|
|
|
|
spin_lock(&unnamed_dev_lock);
|
|
|
|
idr_remove(&unnamed_dev_idr, slot);
|
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(kill_anon_super);
|
|
|
|
|
|
|
|
void kill_litter_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
if (sb->s_root)
|
|
|
|
d_genocide(sb->s_root);
|
|
|
|
kill_anon_super(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(kill_litter_super);
|
|
|
|
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 20:45:40 +02:00
|
|
|
#ifdef CONFIG_BLOCK
|
2005-04-17 00:20:36 +02:00
|
|
|
static int set_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
s->s_bdev = data;
|
|
|
|
s->s_dev = s->s_bdev->bd_dev;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int test_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
return (void *)s->s_bdev == data;
|
|
|
|
}
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int get_sb_bdev(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, const char *dev_name, void *data,
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
|
|
struct vfsmount *mnt)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct block_device *bdev;
|
|
|
|
struct super_block *s;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
bdev = open_bdev_excl(dev_name, flags, fs_type);
|
|
|
|
if (IS_ERR(bdev))
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return PTR_ERR(bdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* once the super is inserted into the list by sget, s_umount
|
|
|
|
* will protect the lockfs code from trying to start a snapshot
|
|
|
|
* while we are mounting
|
|
|
|
*/
|
2007-01-11 08:15:41 +01:00
|
|
|
down(&bdev->bd_mount_sem);
|
2005-04-17 00:20:36 +02:00
|
|
|
s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
|
2007-01-11 08:15:41 +01:00
|
|
|
up(&bdev->bd_mount_sem);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (IS_ERR(s))
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
goto error_s;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (s->s_root) {
|
|
|
|
if ((flags ^ s->s_flags) & MS_RDONLY) {
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
deactivate_super(s);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
error = -EBUSY;
|
|
|
|
goto error_bdev;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
|
|
|
|
close_bdev_excl(bdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
|
|
|
|
s->s_flags = flags;
|
|
|
|
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
|
2006-01-08 10:03:39 +01:00
|
|
|
sb_set_blocksize(s, block_size(bdev));
|
[PATCH] vfs: MS_VERBOSE should be MS_SILENT
The meaning of MS_VERBOSE is backwards; if the bit is set, it really means,
"don't be verbose". This is confusing and counter-intuitive.
In addition, there is also no way to set the MS_VERBOSE flag in the
mount(8) program in util-linux, but interesting, it does define options
which would do the right thing if MS_SILENT were defined, which
unfortunately we do not:
#ifdef MS_SILENT
{ "quiet", 0, 0, MS_SILENT }, /* be quiet */
{ "loud", 0, 1, MS_SILENT }, /* print out messages. */
#endif
So the obvious fix is to deprecate the use of MS_VERBOSE and replace it
with MS_SILENT.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-24 12:15:10 +01:00
|
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error) {
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
deactivate_super(s);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
goto error;
|
2006-02-22 18:39:02 +01:00
|
|
|
}
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return simple_set_mnt(mnt, s);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
error_s:
|
|
|
|
error = PTR_ERR(s);
|
|
|
|
error_bdev:
|
2005-04-17 00:20:36 +02:00
|
|
|
close_bdev_excl(bdev);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
error:
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(get_sb_bdev);
|
|
|
|
|
|
|
|
void kill_block_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct block_device *bdev = sb->s_bdev;
|
|
|
|
|
|
|
|
generic_shutdown_super(sb);
|
|
|
|
sync_blockdev(bdev);
|
|
|
|
close_bdev_excl(bdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(kill_block_super);
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 20:45:40 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int get_sb_nodev(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, void *data,
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
|
|
struct vfsmount *mnt)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
|
|
|
|
|
|
|
|
if (IS_ERR(s))
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return PTR_ERR(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
s->s_flags = flags;
|
|
|
|
|
[PATCH] vfs: MS_VERBOSE should be MS_SILENT
The meaning of MS_VERBOSE is backwards; if the bit is set, it really means,
"don't be verbose". This is confusing and counter-intuitive.
In addition, there is also no way to set the MS_VERBOSE flag in the
mount(8) program in util-linux, but interesting, it does define options
which would do the right thing if MS_SILENT were defined, which
unfortunately we do not:
#ifdef MS_SILENT
{ "quiet", 0, 0, MS_SILENT }, /* be quiet */
{ "loud", 0, 1, MS_SILENT }, /* print out messages. */
#endif
So the obvious fix is to deprecate the use of MS_VERBOSE and replace it
with MS_SILENT.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-24 12:15:10 +01:00
|
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error) {
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
deactivate_super(s);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return simple_set_mnt(mnt, s);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(get_sb_nodev);
|
|
|
|
|
|
|
|
static int compare_single(struct super_block *s, void *p)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int get_sb_single(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, void *data,
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
|
|
struct vfsmount *mnt)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct super_block *s;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
s = sget(fs_type, compare_single, set_anon_super, NULL);
|
|
|
|
if (IS_ERR(s))
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return PTR_ERR(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!s->s_root) {
|
|
|
|
s->s_flags = flags;
|
[PATCH] vfs: MS_VERBOSE should be MS_SILENT
The meaning of MS_VERBOSE is backwards; if the bit is set, it really means,
"don't be verbose". This is confusing and counter-intuitive.
In addition, there is also no way to set the MS_VERBOSE flag in the
mount(8) program in util-linux, but interesting, it does define options
which would do the right thing if MS_SILENT were defined, which
unfortunately we do not:
#ifdef MS_SILENT
{ "quiet", 0, 0, MS_SILENT }, /* be quiet */
{ "loud", 0, 1, MS_SILENT }, /* print out messages. */
#endif
So the obvious fix is to deprecate the use of MS_VERBOSE and replace it
with MS_SILENT.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-24 12:15:10 +01:00
|
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error) {
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
deactivate_super(s);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
|
|
|
}
|
|
|
|
do_remount_sb(s, flags, data, 0);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return simple_set_mnt(mnt, s);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(get_sb_single);
|
|
|
|
|
|
|
|
struct vfsmount *
|
2006-06-09 15:34:15 +02:00
|
|
|
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct vfsmount *mnt;
|
|
|
|
char *secdata = NULL;
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
int error;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!type)
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
error = -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
mnt = alloc_vfsmnt(name);
|
|
|
|
if (!mnt)
|
|
|
|
goto out;
|
|
|
|
|
2008-03-05 16:31:54 +01:00
|
|
|
if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
secdata = alloc_secdata();
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
if (!secdata)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_mnt;
|
|
|
|
|
2008-03-05 16:31:54 +01:00
|
|
|
error = security_sb_copy_data(data, secdata);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
if (error)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_free_secdata;
|
|
|
|
}
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
error = type->get_sb(type, flags, name, data, mnt);
|
|
|
|
if (error < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_free_secdata;
|
2007-07-16 08:40:54 +02:00
|
|
|
BUG_ON(!mnt->mnt_sb);
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
|
|
|
|
error = security_sb_kern_mount(mnt->mnt_sb, secdata);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (error)
|
|
|
|
goto out_sb;
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
|
|
|
|
mnt->mnt_mountpoint = mnt->mnt_root;
|
2005-04-17 00:20:36 +02:00
|
|
|
mnt->mnt_parent = mnt;
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
up_write(&mnt->mnt_sb->s_umount);
|
2005-06-22 02:15:16 +02:00
|
|
|
free_secdata(secdata);
|
2005-04-17 00:20:36 +02:00
|
|
|
return mnt;
|
|
|
|
out_sb:
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
dput(mnt->mnt_root);
|
|
|
|
up_write(&mnt->mnt_sb->s_umount);
|
|
|
|
deactivate_super(mnt->mnt_sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
out_free_secdata:
|
|
|
|
free_secdata(secdata);
|
|
|
|
out_mnt:
|
|
|
|
free_vfsmnt(mnt);
|
|
|
|
out:
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 11:02:57 +02:00
|
|
|
return ERR_PTR(error);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:15 +02:00
|
|
|
EXPORT_SYMBOL_GPL(vfs_kern_mount);
|
|
|
|
|
add filesystem subtype support
There's a slight problem with filesystem type representation in fuse
based filesystems.
From the kernel's view, there are just two filesystem types: fuse and
fuseblk. From the user's view there are lots of different filesystem
types. The user is not even much concerned if the filesystem is fuse based
or not. So there's a conflict of interest in how this should be
represented in fstab, mtab and /proc/mounts.
The current scheme is to encode the real filesystem type in the mount
source. So an sshfs mount looks like this:
sshfs#user@server:/ /mnt/server fuse rw,nosuid,nodev,...
This url-ish syntax works OK for sshfs and similar filesystems. However
for block device based filesystems (ntfs-3g, zfs) it doesn't work, since
the kernel expects the mount source to be a real device name.
A possibly better scheme would be to encode the real type in the type
field as "type.subtype". So fuse mounts would look like this:
/dev/hda1 /mnt/windows fuseblk.ntfs-3g rw,...
user@server:/ /mnt/server fuse.sshfs rw,nosuid,nodev,...
This patch adds the necessary code to the kernel so that this can be
correctly displayed in /proc/mounts.
Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 09:25:43 +02:00
|
|
|
static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
const char *subtype = strchr(fstype, '.');
|
|
|
|
if (subtype) {
|
|
|
|
subtype++;
|
|
|
|
err = -EINVAL;
|
|
|
|
if (!subtype[0])
|
|
|
|
goto err;
|
|
|
|
} else
|
|
|
|
subtype = "";
|
|
|
|
|
|
|
|
mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
|
|
|
|
err = -ENOMEM;
|
|
|
|
if (!mnt->mnt_sb->s_subtype)
|
|
|
|
goto err;
|
|
|
|
return mnt;
|
|
|
|
|
|
|
|
err:
|
|
|
|
mntput(mnt);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:15 +02:00
|
|
|
struct vfsmount *
|
|
|
|
do_kern_mount(const char *fstype, int flags, const char *name, void *data)
|
|
|
|
{
|
|
|
|
struct file_system_type *type = get_fs_type(fstype);
|
|
|
|
struct vfsmount *mnt;
|
|
|
|
if (!type)
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
mnt = vfs_kern_mount(type, flags, name, data);
|
add filesystem subtype support
There's a slight problem with filesystem type representation in fuse
based filesystems.
From the kernel's view, there are just two filesystem types: fuse and
fuseblk. From the user's view there are lots of different filesystem
types. The user is not even much concerned if the filesystem is fuse based
or not. So there's a conflict of interest in how this should be
represented in fstab, mtab and /proc/mounts.
The current scheme is to encode the real filesystem type in the mount
source. So an sshfs mount looks like this:
sshfs#user@server:/ /mnt/server fuse rw,nosuid,nodev,...
This url-ish syntax works OK for sshfs and similar filesystems. However
for block device based filesystems (ntfs-3g, zfs) it doesn't work, since
the kernel expects the mount source to be a real device name.
A possibly better scheme would be to encode the real type in the type
field as "type.subtype". So fuse mounts would look like this:
/dev/hda1 /mnt/windows fuseblk.ntfs-3g rw,...
user@server:/ /mnt/server fuse.sshfs rw,nosuid,nodev,...
This patch adds the necessary code to the kernel so that this can be
correctly displayed in /proc/mounts.
Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 09:25:43 +02:00
|
|
|
if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
|
|
|
|
!mnt->mnt_sb->s_subtype)
|
|
|
|
mnt = fs_set_subtype(mnt, fstype);
|
2006-06-09 15:34:15 +02:00
|
|
|
put_filesystem(type);
|
|
|
|
return mnt;
|
|
|
|
}
|
2008-02-24 07:43:03 +01:00
|
|
|
EXPORT_SYMBOL_GPL(do_kern_mount);
|
2006-06-09 15:34:15 +02:00
|
|
|
|
2007-10-19 08:40:02 +02:00
|
|
|
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-10-19 08:40:02 +02:00
|
|
|
return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-19 08:40:02 +02:00
|
|
|
EXPORT_SYMBOL_GPL(kern_mount_data);
|