mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 16:29:59 +00:00
![Nick Piggin](/assets/img/avatar_default.png)
fs: scale files_lock Improve scalability of files_lock by adding per-cpu, per-sb files lists, protected with an lglock. The lglock provides fast access to the per-cpu lists to add and remove files. It also provides a snapshot of all the per-cpu lists (although this is very slow). One difficulty with this approach is that a file can be removed from the list by another CPU. We must track which per-cpu list the file is on with a new variale in the file struct (packed into a hole on 64-bit archs). Scalability could suffer if files are frequently removed from different cpu's list. However loads with frequent removal of files imply short interval between adding and removing the files, and the scheduler attempts to avoid moving processes too far away. Also, even in the case of cross-CPU removal, the hardware has much more opportunity to parallelise cacheline transfers with N cachelines than with 1. A worst-case test of 1 CPU allocating files subsequently being freed by N CPUs degenerates to contending on a single lock, which is no worse than before. When more than one CPU are allocating files, even if they are always freed by different CPUs, there will be more parallelism than the single-lock case. Testing results: On a 2 socket, 8 core opteron, I measure the number of times the lock is taken to remove the file, the number of times it is removed by the same CPU that added it, and the number of times it is removed by the same node that added it. Booting: locks= 25049 cpu-hits= 23174 (92.5%) node-hits= 23945 (95.6%) kbuild -j16 locks=2281913 cpu-hits=2208126 (96.8%) node-hits=2252674 (98.7%) dbench 64 locks=4306582 cpu-hits=4287247 (99.6%) node-hits=4299527 (99.8%) So a file is removed from the same CPU it was added by over 90% of the time. It remains within the same node 95% of the time. Tim Chen ran some numbers for a 64 thread Nehalem system performing a compile. throughput 2.6.34-rc2 24.5 +patch 24.9 us sys idle IO wait (in %) 2.6.34-rc2 51.25 28.25 17.25 3.25 +patch 53.75 18.5 19 8.75 So significantly less CPU time spent in kernel code, higher idle time and slightly higher throughput. Single threaded performance difference was within the noise of microbenchmarks. That is not to say penalty does not exist, the code is larger and more memory accesses required so it will be slightly slower. Cc: linux-kernel@vger.kernel.org Cc: Tim Chen <tim.c.chen@linux.intel.com> Cc: Andi Kleen <ak@linux.intel.com> Signed-off-by: Nick Piggin <npiggin@kernel.dk> Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
1118 lines
26 KiB
C
1118 lines
26 KiB
C
/*
|
|
* 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:
|
|
* Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
|
|
* 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/acct.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/security.h>
|
|
#include <linux/writeback.h> /* for the emergency remount stuff */
|
|
#include <linux/idr.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/backing-dev.h>
|
|
#include "internal.h"
|
|
|
|
|
|
LIST_HEAD(super_blocks);
|
|
DEFINE_SPINLOCK(sb_lock);
|
|
|
|
/**
|
|
* alloc_super - create new superblock
|
|
* @type: filesystem type superblock should belong to
|
|
*
|
|
* Allocates and initializes a new &struct super_block. alloc_super()
|
|
* returns a pointer new superblock or %NULL if allocation had failed.
|
|
*/
|
|
static struct super_block *alloc_super(struct file_system_type *type)
|
|
{
|
|
struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
|
|
static const struct super_operations default_op;
|
|
|
|
if (s) {
|
|
if (security_sb_alloc(s)) {
|
|
kfree(s);
|
|
s = NULL;
|
|
goto out;
|
|
}
|
|
#ifdef CONFIG_SMP
|
|
s->s_files = alloc_percpu(struct list_head);
|
|
if (!s->s_files) {
|
|
security_sb_free(s);
|
|
kfree(s);
|
|
s = NULL;
|
|
goto out;
|
|
} else {
|
|
int i;
|
|
|
|
for_each_possible_cpu(i)
|
|
INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));
|
|
}
|
|
#else
|
|
INIT_LIST_HEAD(&s->s_files);
|
|
#endif
|
|
INIT_LIST_HEAD(&s->s_instances);
|
|
INIT_HLIST_HEAD(&s->s_anon);
|
|
INIT_LIST_HEAD(&s->s_inodes);
|
|
INIT_LIST_HEAD(&s->s_dentry_lru);
|
|
init_rwsem(&s->s_umount);
|
|
mutex_init(&s->s_lock);
|
|
lockdep_set_class(&s->s_umount, &type->s_umount_key);
|
|
/*
|
|
* 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);
|
|
/*
|
|
* sget() can have s_umount recursion.
|
|
*
|
|
* When it cannot find a suitable sb, it allocates a new
|
|
* one (this one), and tries again to find a suitable old
|
|
* one.
|
|
*
|
|
* In case that succeeds, it will acquire the s_umount
|
|
* lock of the old one. Since these are clearly distrinct
|
|
* locks, and this object isn't exposed yet, there's no
|
|
* risk of deadlocks.
|
|
*
|
|
* Annotate this by putting this lock in a different
|
|
* subclass.
|
|
*/
|
|
down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
|
|
s->s_count = 1;
|
|
atomic_set(&s->s_active, 1);
|
|
mutex_init(&s->s_vfs_rename_mutex);
|
|
lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
|
|
mutex_init(&s->s_dquot.dqio_mutex);
|
|
mutex_init(&s->s_dquot.dqonoff_mutex);
|
|
init_rwsem(&s->s_dquot.dqptr_sem);
|
|
init_waitqueue_head(&s->s_wait_unfrozen);
|
|
s->s_maxbytes = MAX_NON_LFS;
|
|
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)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
free_percpu(s->s_files);
|
|
#endif
|
|
security_sb_free(s);
|
|
kfree(s->s_subtype);
|
|
kfree(s->s_options);
|
|
kfree(s);
|
|
}
|
|
|
|
/* Superblock refcounting */
|
|
|
|
/*
|
|
* Drop a superblock's refcount. The caller must hold sb_lock.
|
|
*/
|
|
void __put_super(struct super_block *sb)
|
|
{
|
|
if (!--sb->s_count) {
|
|
list_del_init(&sb->s_list);
|
|
destroy_super(sb);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* put_super - drop a temporary reference to superblock
|
|
* @sb: superblock in question
|
|
*
|
|
* Drops a temporary reference, frees superblock if there's no
|
|
* references left.
|
|
*/
|
|
void put_super(struct super_block *sb)
|
|
{
|
|
spin_lock(&sb_lock);
|
|
__put_super(sb);
|
|
spin_unlock(&sb_lock);
|
|
}
|
|
|
|
|
|
/**
|
|
* deactivate_locked_super - drop an active reference to superblock
|
|
* @s: superblock to deactivate
|
|
*
|
|
* Drops an active reference to superblock, converting it into a temprory
|
|
* one if there is no other active references left. In that case we
|
|
* tell fs driver to shut it down and drop the temporary reference we
|
|
* had just acquired.
|
|
*
|
|
* Caller holds exclusive lock on superblock; that lock is released.
|
|
*/
|
|
void deactivate_locked_super(struct super_block *s)
|
|
{
|
|
struct file_system_type *fs = s->s_type;
|
|
if (atomic_dec_and_test(&s->s_active)) {
|
|
fs->kill_sb(s);
|
|
put_filesystem(fs);
|
|
put_super(s);
|
|
} else {
|
|
up_write(&s->s_umount);
|
|
}
|
|
}
|
|
|
|
EXPORT_SYMBOL(deactivate_locked_super);
|
|
|
|
/**
|
|
* deactivate_super - drop an active reference to superblock
|
|
* @s: superblock to deactivate
|
|
*
|
|
* Variant of deactivate_locked_super(), except that superblock is *not*
|
|
* locked by caller. If we are going to drop the final active reference,
|
|
* lock will be acquired prior to that.
|
|
*/
|
|
void deactivate_super(struct super_block *s)
|
|
{
|
|
if (!atomic_add_unless(&s->s_active, -1, 1)) {
|
|
down_write(&s->s_umount);
|
|
deactivate_locked_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).
|
|
*/
|
|
static int grab_super(struct super_block *s) __releases(sb_lock)
|
|
{
|
|
if (atomic_inc_not_zero(&s->s_active)) {
|
|
spin_unlock(&sb_lock);
|
|
return 1;
|
|
}
|
|
/* it's going away */
|
|
s->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
/* wait for it to die */
|
|
down_write(&s->s_umount);
|
|
up_write(&s->s_umount);
|
|
put_super(s);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
void generic_shutdown_super(struct super_block *sb)
|
|
{
|
|
const struct super_operations *sop = sb->s_op;
|
|
|
|
|
|
if (sb->s_root) {
|
|
shrink_dcache_for_umount(sb);
|
|
sync_filesystem(sb);
|
|
get_fs_excl();
|
|
sb->s_flags &= ~MS_ACTIVE;
|
|
|
|
/* bad name - it should be evict_inodes() */
|
|
invalidate_inodes(sb);
|
|
|
|
if (sop->put_super)
|
|
sop->put_super(sb);
|
|
|
|
/* Forget any remaining inodes */
|
|
if (invalidate_inodes(sb)) {
|
|
printk("VFS: Busy inodes after unmount of %s. "
|
|
"Self-destruct in 5 seconds. Have a nice day...\n",
|
|
sb->s_id);
|
|
}
|
|
put_fs_excl();
|
|
}
|
|
spin_lock(&sb_lock);
|
|
/* should be initialized for __put_super_and_need_restart() */
|
|
list_del_init(&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;
|
|
struct super_block *old;
|
|
int err;
|
|
|
|
retry:
|
|
spin_lock(&sb_lock);
|
|
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) {
|
|
up_write(&s->s_umount);
|
|
destroy_super(s);
|
|
s = NULL;
|
|
}
|
|
down_write(&old->s_umount);
|
|
if (unlikely(!(old->s_flags & MS_BORN))) {
|
|
deactivate_locked_super(old);
|
|
goto retry;
|
|
}
|
|
return old;
|
|
}
|
|
}
|
|
if (!s) {
|
|
spin_unlock(&sb_lock);
|
|
s = alloc_super(type);
|
|
if (!s)
|
|
return ERR_PTR(-ENOMEM);
|
|
goto retry;
|
|
}
|
|
|
|
err = set(s, data);
|
|
if (err) {
|
|
spin_unlock(&sb_lock);
|
|
up_write(&s->s_umount);
|
|
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);
|
|
|
|
/**
|
|
* sync_supers - helper for periodic superblock writeback
|
|
*
|
|
* Call the write_super method if present on all dirty superblocks in
|
|
* the system. This is for the periodic writeback used by most older
|
|
* filesystems. For data integrity superblock writeback use
|
|
* sync_filesystems() instead.
|
|
*
|
|
* 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)
|
|
{
|
|
struct super_block *sb, *p = NULL;
|
|
|
|
spin_lock(&sb_lock);
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
if (sb->s_op->write_super && sb->s_dirt) {
|
|
sb->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_read(&sb->s_umount);
|
|
if (sb->s_root && sb->s_dirt)
|
|
sb->s_op->write_super(sb);
|
|
up_read(&sb->s_umount);
|
|
|
|
spin_lock(&sb_lock);
|
|
if (p)
|
|
__put_super(p);
|
|
p = sb;
|
|
}
|
|
}
|
|
if (p)
|
|
__put_super(p);
|
|
spin_unlock(&sb_lock);
|
|
}
|
|
|
|
/**
|
|
* iterate_supers - call function for all active superblocks
|
|
* @f: function to call
|
|
* @arg: argument to pass to it
|
|
*
|
|
* Scans the superblock list and calls given function, passing it
|
|
* locked superblock and given argument.
|
|
*/
|
|
void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
|
|
{
|
|
struct super_block *sb, *p = NULL;
|
|
|
|
spin_lock(&sb_lock);
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
sb->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
|
|
down_read(&sb->s_umount);
|
|
if (sb->s_root)
|
|
f(sb, arg);
|
|
up_read(&sb->s_umount);
|
|
|
|
spin_lock(&sb_lock);
|
|
if (p)
|
|
__put_super(p);
|
|
p = sb;
|
|
}
|
|
if (p)
|
|
__put_super(p);
|
|
spin_unlock(&sb_lock);
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
struct super_block *sb;
|
|
|
|
if (!bdev)
|
|
return NULL;
|
|
|
|
spin_lock(&sb_lock);
|
|
rescan:
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
if (sb->s_bdev == bdev) {
|
|
sb->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
down_read(&sb->s_umount);
|
|
/* still alive? */
|
|
if (sb->s_root)
|
|
return sb;
|
|
up_read(&sb->s_umount);
|
|
/* nope, got unmounted */
|
|
spin_lock(&sb_lock);
|
|
__put_super(sb);
|
|
goto rescan;
|
|
}
|
|
}
|
|
spin_unlock(&sb_lock);
|
|
return NULL;
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_super);
|
|
|
|
/**
|
|
* get_active_super - get an active reference to 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. Returns the superblock with an active
|
|
* reference or %NULL if none was found.
|
|
*/
|
|
struct super_block *get_active_super(struct block_device *bdev)
|
|
{
|
|
struct super_block *sb;
|
|
|
|
if (!bdev)
|
|
return NULL;
|
|
|
|
restart:
|
|
spin_lock(&sb_lock);
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
if (sb->s_bdev == bdev) {
|
|
if (grab_super(sb)) /* drops sb_lock */
|
|
return sb;
|
|
else
|
|
goto restart;
|
|
}
|
|
}
|
|
spin_unlock(&sb_lock);
|
|
return NULL;
|
|
}
|
|
|
|
struct super_block *user_get_super(dev_t dev)
|
|
{
|
|
struct super_block *sb;
|
|
|
|
spin_lock(&sb_lock);
|
|
rescan:
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
if (sb->s_dev == dev) {
|
|
sb->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
down_read(&sb->s_umount);
|
|
/* still alive? */
|
|
if (sb->s_root)
|
|
return sb;
|
|
up_read(&sb->s_umount);
|
|
/* nope, got unmounted */
|
|
spin_lock(&sb_lock);
|
|
__put_super(sb);
|
|
goto rescan;
|
|
}
|
|
}
|
|
spin_unlock(&sb_lock);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
int remount_ro;
|
|
|
|
if (sb->s_frozen != SB_UNFROZEN)
|
|
return -EBUSY;
|
|
|
|
#ifdef CONFIG_BLOCK
|
|
if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
|
|
return -EACCES;
|
|
#endif
|
|
|
|
if (flags & MS_RDONLY)
|
|
acct_auto_close(sb);
|
|
shrink_dcache_sb(sb);
|
|
sync_filesystem(sb);
|
|
|
|
remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
|
|
|
|
/* If we are remounting RDONLY and current sb is read/write,
|
|
make sure there are no rw files opened */
|
|
if (remount_ro) {
|
|
if (force)
|
|
mark_files_ro(sb);
|
|
else if (!fs_may_remount_ro(sb))
|
|
return -EBUSY;
|
|
}
|
|
|
|
if (sb->s_op->remount_fs) {
|
|
retval = sb->s_op->remount_fs(sb, &flags, data);
|
|
if (retval)
|
|
return retval;
|
|
}
|
|
sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
|
|
|
|
/*
|
|
* Some filesystems modify their metadata via some other path than the
|
|
* bdev buffer cache (eg. use a private mapping, or directories in
|
|
* pagecache, etc). Also file data modifications go via their own
|
|
* mappings. So If we try to mount readonly then copy the filesystem
|
|
* from bdev, we could get stale data, so invalidate it to give a best
|
|
* effort at coherency.
|
|
*/
|
|
if (remount_ro && sb->s_bdev)
|
|
invalidate_bdev(sb->s_bdev);
|
|
return 0;
|
|
}
|
|
|
|
static void do_emergency_remount(struct work_struct *work)
|
|
{
|
|
struct super_block *sb, *p = NULL;
|
|
|
|
spin_lock(&sb_lock);
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
|
if (list_empty(&sb->s_instances))
|
|
continue;
|
|
sb->s_count++;
|
|
spin_unlock(&sb_lock);
|
|
down_write(&sb->s_umount);
|
|
if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
|
|
/*
|
|
* What lock protects sb->s_flags??
|
|
*/
|
|
do_remount_sb(sb, MS_RDONLY, NULL, 1);
|
|
}
|
|
up_write(&sb->s_umount);
|
|
spin_lock(&sb_lock);
|
|
if (p)
|
|
__put_super(p);
|
|
p = sb;
|
|
}
|
|
if (p)
|
|
__put_super(p);
|
|
spin_unlock(&sb_lock);
|
|
kfree(work);
|
|
printk("Emergency Remount complete\n");
|
|
}
|
|
|
|
void emergency_remount(void)
|
|
{
|
|
struct work_struct *work;
|
|
|
|
work = kmalloc(sizeof(*work), GFP_ATOMIC);
|
|
if (work) {
|
|
INIT_WORK(work, do_emergency_remount);
|
|
schedule_work(work);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unnamed block devices are dummy devices used by virtual
|
|
* filesystems which don't use real block-devices. -- jrs
|
|
*/
|
|
|
|
static DEFINE_IDA(unnamed_dev_ida);
|
|
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
|
|
static int unnamed_dev_start = 0; /* don't bother trying below it */
|
|
|
|
int set_anon_super(struct super_block *s, void *data)
|
|
{
|
|
int dev;
|
|
int error;
|
|
|
|
retry:
|
|
if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
|
|
return -ENOMEM;
|
|
spin_lock(&unnamed_dev_lock);
|
|
error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
|
|
if (!error)
|
|
unnamed_dev_start = dev + 1;
|
|
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);
|
|
ida_remove(&unnamed_dev_ida, dev);
|
|
if (unnamed_dev_start > dev)
|
|
unnamed_dev_start = dev;
|
|
spin_unlock(&unnamed_dev_lock);
|
|
return -EMFILE;
|
|
}
|
|
s->s_dev = MKDEV(0, dev & MINORMASK);
|
|
s->s_bdi = &noop_backing_dev_info;
|
|
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);
|
|
ida_remove(&unnamed_dev_ida, slot);
|
|
if (slot < unnamed_dev_start)
|
|
unnamed_dev_start = 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);
|
|
|
|
static int ns_test_super(struct super_block *sb, void *data)
|
|
{
|
|
return sb->s_fs_info == data;
|
|
}
|
|
|
|
static int ns_set_super(struct super_block *sb, void *data)
|
|
{
|
|
sb->s_fs_info = data;
|
|
return set_anon_super(sb, NULL);
|
|
}
|
|
|
|
int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
struct vfsmount *mnt)
|
|
{
|
|
struct super_block *sb;
|
|
|
|
sb = sget(fs_type, ns_test_super, ns_set_super, data);
|
|
if (IS_ERR(sb))
|
|
return PTR_ERR(sb);
|
|
|
|
if (!sb->s_root) {
|
|
int err;
|
|
sb->s_flags = flags;
|
|
err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
|
|
if (err) {
|
|
deactivate_locked_super(sb);
|
|
return err;
|
|
}
|
|
|
|
sb->s_flags |= MS_ACTIVE;
|
|
}
|
|
|
|
simple_set_mnt(mnt, sb);
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_sb_ns);
|
|
|
|
#ifdef CONFIG_BLOCK
|
|
static int set_bdev_super(struct super_block *s, void *data)
|
|
{
|
|
s->s_bdev = data;
|
|
s->s_dev = s->s_bdev->bd_dev;
|
|
|
|
/*
|
|
* We set the bdi here to the queue backing, file systems can
|
|
* overwrite this in ->fill_super()
|
|
*/
|
|
s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
|
|
return 0;
|
|
}
|
|
|
|
static int test_bdev_super(struct super_block *s, void *data)
|
|
{
|
|
return (void *)s->s_bdev == data;
|
|
}
|
|
|
|
int get_sb_bdev(struct file_system_type *fs_type,
|
|
int flags, const char *dev_name, void *data,
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
struct vfsmount *mnt)
|
|
{
|
|
struct block_device *bdev;
|
|
struct super_block *s;
|
|
fmode_t mode = FMODE_READ;
|
|
int error = 0;
|
|
|
|
if (!(flags & MS_RDONLY))
|
|
mode |= FMODE_WRITE;
|
|
|
|
bdev = open_bdev_exclusive(dev_name, mode, fs_type);
|
|
if (IS_ERR(bdev))
|
|
return PTR_ERR(bdev);
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
mutex_lock(&bdev->bd_fsfreeze_mutex);
|
|
if (bdev->bd_fsfreeze_count > 0) {
|
|
mutex_unlock(&bdev->bd_fsfreeze_mutex);
|
|
error = -EBUSY;
|
|
goto error_bdev;
|
|
}
|
|
s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
|
|
mutex_unlock(&bdev->bd_fsfreeze_mutex);
|
|
if (IS_ERR(s))
|
|
goto error_s;
|
|
|
|
if (s->s_root) {
|
|
if ((flags ^ s->s_flags) & MS_RDONLY) {
|
|
deactivate_locked_super(s);
|
|
error = -EBUSY;
|
|
goto error_bdev;
|
|
}
|
|
|
|
/*
|
|
* s_umount nests inside bd_mutex during
|
|
* __invalidate_device(). close_bdev_exclusive()
|
|
* acquires bd_mutex and can't be called under
|
|
* s_umount. Drop s_umount temporarily. This is safe
|
|
* as we're holding an active reference.
|
|
*/
|
|
up_write(&s->s_umount);
|
|
close_bdev_exclusive(bdev, mode);
|
|
down_write(&s->s_umount);
|
|
} else {
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
s->s_flags = flags;
|
|
s->s_mode = mode;
|
|
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
|
|
sb_set_blocksize(s, block_size(bdev));
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
|
if (error) {
|
|
deactivate_locked_super(s);
|
|
goto error;
|
|
}
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
|
bdev->bd_super = s;
|
|
}
|
|
|
|
simple_set_mnt(mnt, s);
|
|
return 0;
|
|
|
|
error_s:
|
|
error = PTR_ERR(s);
|
|
error_bdev:
|
|
close_bdev_exclusive(bdev, mode);
|
|
error:
|
|
return error;
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_sb_bdev);
|
|
|
|
void kill_block_super(struct super_block *sb)
|
|
{
|
|
struct block_device *bdev = sb->s_bdev;
|
|
fmode_t mode = sb->s_mode;
|
|
|
|
bdev->bd_super = NULL;
|
|
generic_shutdown_super(sb);
|
|
sync_blockdev(bdev);
|
|
close_bdev_exclusive(bdev, mode);
|
|
}
|
|
|
|
EXPORT_SYMBOL(kill_block_super);
|
|
#endif
|
|
|
|
int get_sb_nodev(struct file_system_type *fs_type,
|
|
int flags, void *data,
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
struct vfsmount *mnt)
|
|
{
|
|
int error;
|
|
struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
|
|
|
|
if (IS_ERR(s))
|
|
return PTR_ERR(s);
|
|
|
|
s->s_flags = flags;
|
|
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
|
if (error) {
|
|
deactivate_locked_super(s);
|
|
return error;
|
|
}
|
|
s->s_flags |= MS_ACTIVE;
|
|
simple_set_mnt(mnt, s);
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_sb_nodev);
|
|
|
|
static int compare_single(struct super_block *s, void *p)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int get_sb_single(struct file_system_type *fs_type,
|
|
int flags, void *data,
|
|
int (*fill_super)(struct super_block *, void *, int),
|
|
struct vfsmount *mnt)
|
|
{
|
|
struct super_block *s;
|
|
int error;
|
|
|
|
s = sget(fs_type, compare_single, set_anon_super, NULL);
|
|
if (IS_ERR(s))
|
|
return PTR_ERR(s);
|
|
if (!s->s_root) {
|
|
s->s_flags = flags;
|
|
error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
|
|
if (error) {
|
|
deactivate_locked_super(s);
|
|
return error;
|
|
}
|
|
s->s_flags |= MS_ACTIVE;
|
|
} else {
|
|
do_remount_sb(s, flags, data, 0);
|
|
}
|
|
simple_set_mnt(mnt, s);
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_sb_single);
|
|
|
|
struct vfsmount *
|
|
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
|
|
{
|
|
struct vfsmount *mnt;
|
|
char *secdata = NULL;
|
|
int error;
|
|
|
|
if (!type)
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
error = -ENOMEM;
|
|
mnt = alloc_vfsmnt(name);
|
|
if (!mnt)
|
|
goto out;
|
|
|
|
if (flags & MS_KERNMOUNT)
|
|
mnt->mnt_flags = MNT_INTERNAL;
|
|
|
|
if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
|
|
secdata = alloc_secdata();
|
|
if (!secdata)
|
|
goto out_mnt;
|
|
|
|
error = security_sb_copy_data(data, secdata);
|
|
if (error)
|
|
goto out_free_secdata;
|
|
}
|
|
|
|
error = type->get_sb(type, flags, name, data, mnt);
|
|
if (error < 0)
|
|
goto out_free_secdata;
|
|
BUG_ON(!mnt->mnt_sb);
|
|
WARN_ON(!mnt->mnt_sb->s_bdi);
|
|
mnt->mnt_sb->s_flags |= MS_BORN;
|
|
|
|
error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
|
|
if (error)
|
|
goto out_sb;
|
|
|
|
/*
|
|
* filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
|
|
* but s_maxbytes was an unsigned long long for many releases. Throw
|
|
* this warning for a little while to try and catch filesystems that
|
|
* violate this rule. This warning should be either removed or
|
|
* converted to a BUG() in 2.6.34.
|
|
*/
|
|
WARN((mnt->mnt_sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
|
|
"negative value (%lld)\n", type->name, mnt->mnt_sb->s_maxbytes);
|
|
|
|
mnt->mnt_mountpoint = mnt->mnt_root;
|
|
mnt->mnt_parent = mnt;
|
|
up_write(&mnt->mnt_sb->s_umount);
|
|
free_secdata(secdata);
|
|
return mnt;
|
|
out_sb:
|
|
dput(mnt->mnt_root);
|
|
deactivate_locked_super(mnt->mnt_sb);
|
|
out_free_secdata:
|
|
free_secdata(secdata);
|
|
out_mnt:
|
|
free_vfsmnt(mnt);
|
|
out:
|
|
return ERR_PTR(error);
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(vfs_kern_mount);
|
|
|
|
/**
|
|
* freeze_super - lock the filesystem and force it into a consistent state
|
|
* @sb: the super to lock
|
|
*
|
|
* Syncs the super to make sure the filesystem is consistent and calls the fs's
|
|
* freeze_fs. Subsequent calls to this without first thawing the fs will return
|
|
* -EBUSY.
|
|
*/
|
|
int freeze_super(struct super_block *sb)
|
|
{
|
|
int ret;
|
|
|
|
atomic_inc(&sb->s_active);
|
|
down_write(&sb->s_umount);
|
|
if (sb->s_frozen) {
|
|
deactivate_locked_super(sb);
|
|
return -EBUSY;
|
|
}
|
|
|
|
if (sb->s_flags & MS_RDONLY) {
|
|
sb->s_frozen = SB_FREEZE_TRANS;
|
|
smp_wmb();
|
|
up_write(&sb->s_umount);
|
|
return 0;
|
|
}
|
|
|
|
sb->s_frozen = SB_FREEZE_WRITE;
|
|
smp_wmb();
|
|
|
|
sync_filesystem(sb);
|
|
|
|
sb->s_frozen = SB_FREEZE_TRANS;
|
|
smp_wmb();
|
|
|
|
sync_blockdev(sb->s_bdev);
|
|
if (sb->s_op->freeze_fs) {
|
|
ret = sb->s_op->freeze_fs(sb);
|
|
if (ret) {
|
|
printk(KERN_ERR
|
|
"VFS:Filesystem freeze failed\n");
|
|
sb->s_frozen = SB_UNFROZEN;
|
|
deactivate_locked_super(sb);
|
|
return ret;
|
|
}
|
|
}
|
|
up_write(&sb->s_umount);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(freeze_super);
|
|
|
|
/**
|
|
* thaw_super -- unlock filesystem
|
|
* @sb: the super to thaw
|
|
*
|
|
* Unlocks the filesystem and marks it writeable again after freeze_super().
|
|
*/
|
|
int thaw_super(struct super_block *sb)
|
|
{
|
|
int error;
|
|
|
|
down_write(&sb->s_umount);
|
|
if (sb->s_frozen == SB_UNFROZEN) {
|
|
up_write(&sb->s_umount);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (sb->s_flags & MS_RDONLY)
|
|
goto out;
|
|
|
|
if (sb->s_op->unfreeze_fs) {
|
|
error = sb->s_op->unfreeze_fs(sb);
|
|
if (error) {
|
|
printk(KERN_ERR
|
|
"VFS:Filesystem thaw failed\n");
|
|
sb->s_frozen = SB_FREEZE_TRANS;
|
|
up_write(&sb->s_umount);
|
|
return error;
|
|
}
|
|
}
|
|
|
|
out:
|
|
sb->s_frozen = SB_UNFROZEN;
|
|
smp_wmb();
|
|
wake_up(&sb->s_wait_unfrozen);
|
|
deactivate_locked_super(sb);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(thaw_super);
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
|
|
!mnt->mnt_sb->s_subtype)
|
|
mnt = fs_set_subtype(mnt, fstype);
|
|
put_filesystem(type);
|
|
return mnt;
|
|
}
|
|
EXPORT_SYMBOL_GPL(do_kern_mount);
|
|
|
|
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
|
|
{
|
|
return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(kern_mount_data);
|