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
|
|
|
|
*/
|
|
|
|
|
2011-11-17 05:57:37 +01:00
|
|
|
#include <linux/export.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#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>
|
2006-03-26 11:37:12 +02:00
|
|
|
#include <linux/mutex.h>
|
2010-04-29 20:33:35 +02:00
|
|
|
#include <linux/backing-dev.h>
|
2011-01-07 07:50:05 +01:00
|
|
|
#include <linux/rculist_bl.h>
|
2011-05-26 18:01:43 +02:00
|
|
|
#include <linux/cleancache.h>
|
2012-02-13 04:58:52 +01:00
|
|
|
#include <linux/fsnotify.h>
|
2012-06-12 16:20:34 +02:00
|
|
|
#include <linux/lockdep.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);
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
static char *sb_writers_name[SB_FREEZE_LEVELS] = {
|
|
|
|
"sb_writers",
|
|
|
|
"sb_pagefaults",
|
|
|
|
"sb_internal",
|
|
|
|
};
|
|
|
|
|
2011-07-08 06:14:42 +02:00
|
|
|
/*
|
|
|
|
* One thing we have to be careful of with a per-sb shrinker is that we don't
|
|
|
|
* drop the last active reference to the superblock from within the shrinker.
|
|
|
|
* If that happens we could trigger unregistering the shrinker from within the
|
|
|
|
* shrinker path and that leads to deadlock on the shrinker_rwsem. Hence we
|
|
|
|
* take a passive reference to the superblock to avoid this from occurring.
|
|
|
|
*/
|
|
|
|
static int prune_super(struct shrinker *shrink, struct shrink_control *sc)
|
|
|
|
{
|
|
|
|
struct super_block *sb;
|
2011-07-08 06:14:44 +02:00
|
|
|
int fs_objects = 0;
|
|
|
|
int total_objects;
|
2011-07-08 06:14:42 +02:00
|
|
|
|
|
|
|
sb = container_of(shrink, struct super_block, s_shrink);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deadlock avoidance. We may hold various FS locks, and we don't want
|
|
|
|
* to recurse into the FS that called us in clear_inode() and friends..
|
|
|
|
*/
|
|
|
|
if (sc->nr_to_scan && !(sc->gfp_mask & __GFP_FS))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!grab_super_passive(sb))
|
2012-08-01 01:43:16 +02:00
|
|
|
return -1;
|
2011-07-08 06:14:42 +02:00
|
|
|
|
2011-07-08 06:14:44 +02:00
|
|
|
if (sb->s_op && sb->s_op->nr_cached_objects)
|
|
|
|
fs_objects = sb->s_op->nr_cached_objects(sb);
|
|
|
|
|
|
|
|
total_objects = sb->s_nr_dentry_unused +
|
|
|
|
sb->s_nr_inodes_unused + fs_objects + 1;
|
|
|
|
|
2011-07-08 06:14:42 +02:00
|
|
|
if (sc->nr_to_scan) {
|
2011-07-08 06:14:44 +02:00
|
|
|
int dentries;
|
|
|
|
int inodes;
|
2011-07-08 06:14:42 +02:00
|
|
|
|
2011-07-08 06:14:44 +02:00
|
|
|
/* proportion the scan between the caches */
|
|
|
|
dentries = (sc->nr_to_scan * sb->s_nr_dentry_unused) /
|
|
|
|
total_objects;
|
|
|
|
inodes = (sc->nr_to_scan * sb->s_nr_inodes_unused) /
|
|
|
|
total_objects;
|
|
|
|
if (fs_objects)
|
|
|
|
fs_objects = (sc->nr_to_scan * fs_objects) /
|
|
|
|
total_objects;
|
|
|
|
/*
|
|
|
|
* prune the dcache first as the icache is pinned by it, then
|
|
|
|
* prune the icache, followed by the filesystem specific caches
|
|
|
|
*/
|
|
|
|
prune_dcache_sb(sb, dentries);
|
|
|
|
prune_icache_sb(sb, inodes);
|
2011-07-08 06:14:42 +02:00
|
|
|
|
2011-07-08 06:14:44 +02:00
|
|
|
if (fs_objects && sb->s_op->free_cached_objects) {
|
|
|
|
sb->s_op->free_cached_objects(sb, fs_objects);
|
|
|
|
fs_objects = sb->s_op->nr_cached_objects(sb);
|
|
|
|
}
|
|
|
|
total_objects = sb->s_nr_dentry_unused +
|
|
|
|
sb->s_nr_inodes_unused + fs_objects;
|
2011-07-08 06:14:42 +02:00
|
|
|
}
|
|
|
|
|
2011-07-08 06:14:44 +02:00
|
|
|
total_objects = (total_objects / 100) * sysctl_vfs_cache_pressure;
|
2011-07-08 06:14:42 +02:00
|
|
|
drop_super(sb);
|
2011-07-08 06:14:44 +02:00
|
|
|
return total_objects;
|
2011-07-08 06:14:42 +02:00
|
|
|
}
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
static int init_sb_writers(struct super_block *s, struct file_system_type *type)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < SB_FREEZE_LEVELS; i++) {
|
|
|
|
err = percpu_counter_init(&s->s_writers.counter[i], 0);
|
|
|
|
if (err < 0)
|
|
|
|
goto err_out;
|
|
|
|
lockdep_init_map(&s->s_writers.lock_map[i], sb_writers_name[i],
|
|
|
|
&type->s_writers_key[i], 0);
|
|
|
|
}
|
|
|
|
init_waitqueue_head(&s->s_writers.wait);
|
|
|
|
init_waitqueue_head(&s->s_writers.wait_unfrozen);
|
|
|
|
return 0;
|
|
|
|
err_out:
|
|
|
|
while (--i >= 0)
|
|
|
|
percpu_counter_destroy(&s->s_writers.counter[i]);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_sb_writers(struct super_block *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < SB_FREEZE_LEVELS; i++)
|
|
|
|
percpu_counter_destroy(&s->s_writers.counter[i]);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* alloc_super - create new superblock
|
2006-09-06 09:03:41 +02:00
|
|
|
* @type: filesystem type superblock should belong to
|
2012-06-25 13:55:37 +02:00
|
|
|
* @flags: the mount flags
|
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.
|
|
|
|
*/
|
2012-06-25 13:55:37 +02:00
|
|
|
static struct super_block *alloc_super(struct file_system_type *type, int flags)
|
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);
|
2009-09-22 02:01:09 +02:00
|
|
|
static const struct super_operations default_op;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (s) {
|
|
|
|
if (security_sb_alloc(s)) {
|
2012-06-12 16:20:34 +02:00
|
|
|
/*
|
|
|
|
* We cannot call security_sb_free() without
|
|
|
|
* security_sb_alloc() succeeding. So bail out manually
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(s);
|
|
|
|
s = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
fs: scale files_lock
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>
2010-08-17 20:37:38 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
s->s_files = alloc_percpu(struct list_head);
|
2012-06-12 16:20:34 +02:00
|
|
|
if (!s->s_files)
|
|
|
|
goto err_out;
|
|
|
|
else {
|
fs: scale files_lock
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>
2010-08-17 20:37:38 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i)
|
|
|
|
INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));
|
|
|
|
}
|
|
|
|
#else
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&s->s_files);
|
fs: scale files_lock
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>
2010-08-17 20:37:38 +02:00
|
|
|
#endif
|
2012-06-12 16:20:34 +02:00
|
|
|
if (init_sb_writers(s, type))
|
|
|
|
goto err_out;
|
2012-06-25 13:55:37 +02:00
|
|
|
s->s_flags = flags;
|
2011-03-17 11:13:12 +01:00
|
|
|
s->s_bdi = &default_backing_dev_info;
|
2011-12-13 04:53:00 +01:00
|
|
|
INIT_HLIST_NODE(&s->s_instances);
|
2011-01-07 07:50:05 +01:00
|
|
|
INIT_HLIST_BL_HEAD(&s->s_anon);
|
2005-04-17 00:20:36 +02:00
|
|
|
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);
|
2011-07-08 06:14:39 +02:00
|
|
|
INIT_LIST_HEAD(&s->s_inode_lru);
|
2011-07-08 06:14:40 +02:00
|
|
|
spin_lock_init(&s->s_inode_lru_lock);
|
2011-11-21 12:11:30 +01:00
|
|
|
INIT_LIST_HEAD(&s->s_mounts);
|
2005-04-17 00:20:36 +02:00
|
|
|
init_rwsem(&s->s_umount);
|
2006-07-03 09:25:28 +02:00
|
|
|
lockdep_set_class(&s->s_umount, &type->s_umount_key);
|
fs/super.c: add lockdep annotation to s_umount
Li Zefan said:
Thread 1:
for ((; ;))
{
mount -t cpuset xxx /mnt > /dev/null 2>&1
cat /mnt/cpus > /dev/null 2>&1
umount /mnt > /dev/null 2>&1
}
Thread 2:
for ((; ;))
{
mount -t cpuset xxx /mnt > /dev/null 2>&1
umount /mnt > /dev/null 2>&1
}
(Note: It is irrelevant which cgroup subsys is used.)
After a while a lockdep warning showed up:
=============================================
[ INFO: possible recursive locking detected ]
2.6.28 #479
---------------------------------------------
mount/13554 is trying to acquire lock:
(&type->s_umount_key#19){--..}, at: [<c049d888>] sget+0x5e/0x321
but task is already holding lock:
(&type->s_umount_key#19){--..}, at: [<c049da0c>] sget+0x1e2/0x321
other info that might help us debug this:
1 lock held by mount/13554:
#0: (&type->s_umount_key#19){--..}, at: [<c049da0c>] sget+0x1e2/0x321
stack backtrace:
Pid: 13554, comm: mount Not tainted 2.6.28-mc #479
Call Trace:
[<c044ad2e>] validate_chain+0x4c6/0xbbd
[<c044ba9b>] __lock_acquire+0x676/0x700
[<c044bb82>] lock_acquire+0x5d/0x7a
[<c049d888>] ? sget+0x5e/0x321
[<c061b9b8>] down_write+0x34/0x50
[<c049d888>] ? sget+0x5e/0x321
[<c049d888>] sget+0x5e/0x321
[<c045a2e7>] ? cgroup_set_super+0x0/0x3e
[<c045959f>] ? cgroup_test_super+0x0/0x2f
[<c045bcea>] cgroup_get_sb+0x98/0x2e7
[<c045cfb6>] cpuset_get_sb+0x4a/0x5f
[<c049dfa4>] vfs_kern_mount+0x40/0x7b
[<c049e02d>] do_kern_mount+0x37/0xbf
[<c04af4a0>] do_mount+0x5c3/0x61a
[<c04addd2>] ? copy_mount_options+0x2c/0x111
[<c04af560>] sys_mount+0x69/0xa0
[<c0403251>] sysenter_do_call+0x12/0x31
The cause is after alloc_super() and then retry, an old entry in list
fs_supers is found, so grab_super(old) is called, but both functions hold
s_umount lock:
struct super_block *sget(...)
{
...
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)) <--- 2nd: down_write(&old->s_umount);
goto retry;
if (s)
destroy_super(s);
return old;
}
}
if (!s) {
spin_unlock(&sb_lock);
s = alloc_super(type); <--- 1th: down_write(&s->s_umount)
if (!s)
return ERR_PTR(-ENOMEM);
goto retry;
}
...
}
It seems like a false positive, and seems like VFS but not cgroup needs to
be fixed.
Peter said:
We can simply put the new s_umount instance in a but lockdep doesn't
particularly cares about subclass order.
If there's any issue with the callers of sget() assuming the s_umount lock
being of sublcass 0, then there is another annotation we can use to fix
that, but lets not bother with that if this is sufficient.
Addresses http://bugzilla.kernel.org/show_bug.cgi?id=12673
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Tested-by: Li Zefan <lizf@cn.fujitsu.com>
Reported-by: Li Zefan <lizf@cn.fujitsu.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Paul Menage <menage@google.com>
Cc: Arjan van de Ven <arjan@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-02-18 23:48:30 +01:00
|
|
|
/*
|
|
|
|
* 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);
|
2010-03-22 13:53:19 +01:00
|
|
|
s->s_count = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
atomic_set(&s->s_active, 1);
|
2006-03-23 12:00:33 +01:00
|
|
|
mutex_init(&s->s_vfs_rename_mutex);
|
2010-04-27 23:23:57 +02:00
|
|
|
lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
|
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);
|
|
|
|
s->s_maxbytes = MAX_NON_LFS;
|
|
|
|
s->s_op = &default_op;
|
|
|
|
s->s_time_gran = 1000000000;
|
2011-05-26 18:01:43 +02:00
|
|
|
s->cleancache_poolid = -1;
|
2011-07-08 06:14:42 +02:00
|
|
|
|
|
|
|
s->s_shrink.seeks = DEFAULT_SEEKS;
|
|
|
|
s->s_shrink.shrink = prune_super;
|
2011-07-08 06:14:45 +02:00
|
|
|
s->s_shrink.batch = 1024;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return s;
|
2012-06-12 16:20:34 +02:00
|
|
|
err_out:
|
|
|
|
security_sb_free(s);
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (s->s_files)
|
|
|
|
free_percpu(s->s_files);
|
|
|
|
#endif
|
|
|
|
destroy_sb_writers(s);
|
|
|
|
kfree(s);
|
|
|
|
s = NULL;
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* destroy_super - frees a superblock
|
|
|
|
* @s: superblock to free
|
|
|
|
*
|
|
|
|
* Frees a superblock.
|
|
|
|
*/
|
|
|
|
static inline void destroy_super(struct super_block *s)
|
|
|
|
{
|
fs: scale files_lock
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>
2010-08-17 20:37:38 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
free_percpu(s->s_files);
|
|
|
|
#endif
|
2012-06-12 16:20:34 +02:00
|
|
|
destroy_sb_writers(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
security_sb_free(s);
|
2011-11-21 12:11:30 +01:00
|
|
|
WARN_ON(!list_empty(&s->s_mounts));
|
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 */
|
|
|
|
|
|
|
|
/*
|
2010-03-23 02:13:53 +01:00
|
|
|
* Drop a superblock's refcount. The caller must hold sb_lock.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2011-11-22 03:15:42 +01:00
|
|
|
static void __put_super(struct super_block *sb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (!--sb->s_count) {
|
2010-03-23 00:36:35 +01:00
|
|
|
list_del_init(&sb->s_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
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.
|
|
|
|
*/
|
2011-11-22 03:15:42 +01:00
|
|
|
static void put_super(struct super_block *sb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
__put_super(sb);
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2010-03-22 20:22:31 +01:00
|
|
|
* deactivate_locked_super - drop an active reference to superblock
|
2005-04-17 00:20:36 +02:00
|
|
|
* @s: superblock to deactivate
|
|
|
|
*
|
2010-03-22 20:22:31 +01:00
|
|
|
* Drops an active reference to superblock, converting it into a temprory
|
|
|
|
* one if there is no other active references left. In that case we
|
2005-04-17 00:20:36 +02:00
|
|
|
* tell fs driver to shut it down and drop the temporary reference we
|
|
|
|
* had just acquired.
|
2010-03-22 20:22:31 +01:00
|
|
|
*
|
|
|
|
* Caller holds exclusive lock on superblock; that lock is released.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2010-03-22 20:22:31 +01:00
|
|
|
void deactivate_locked_super(struct super_block *s)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct file_system_type *fs = s->s_type;
|
2010-03-22 13:53:19 +01:00
|
|
|
if (atomic_dec_and_test(&s->s_active)) {
|
2011-09-21 17:56:28 +02:00
|
|
|
cleancache_invalidate_fs(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
fs->kill_sb(s);
|
2011-07-08 06:14:42 +02:00
|
|
|
|
|
|
|
/* caches are now gone, we can safely kill the shrinker now */
|
|
|
|
unregister_shrinker(&s->s_shrink);
|
2005-04-17 00:20:36 +02:00
|
|
|
put_filesystem(fs);
|
|
|
|
put_super(s);
|
2010-03-22 20:22:31 +01:00
|
|
|
} else {
|
|
|
|
up_write(&s->s_umount);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:22:31 +01:00
|
|
|
EXPORT_SYMBOL(deactivate_locked_super);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-05-06 07:07:50 +02:00
|
|
|
/**
|
2010-03-22 20:22:31 +01:00
|
|
|
* deactivate_super - drop an active reference to superblock
|
2009-05-06 07:07:50 +02:00
|
|
|
* @s: superblock to deactivate
|
|
|
|
*
|
2010-03-22 20:22:31 +01:00
|
|
|
* 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.
|
2009-05-06 07:07:50 +02:00
|
|
|
*/
|
2010-03-22 20:22:31 +01:00
|
|
|
void deactivate_super(struct super_block *s)
|
2009-05-06 07:07:50 +02:00
|
|
|
{
|
2010-03-22 20:22:31 +01:00
|
|
|
if (!atomic_add_unless(&s->s_active, -1, 1)) {
|
|
|
|
down_write(&s->s_umount);
|
|
|
|
deactivate_locked_super(s);
|
2009-05-06 07:07:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:22:31 +01:00
|
|
|
EXPORT_SYMBOL(deactivate_super);
|
2009-05-06 07:07:50 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
{
|
2010-03-22 13:53:19 +01:00
|
|
|
if (atomic_inc_not_zero(&s->s_active)) {
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* it's going away */
|
2005-04-17 00:20:36 +02:00
|
|
|
s->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
2010-03-22 20:22:31 +01:00
|
|
|
/* wait for it to die */
|
2005-04-17 00:20:36 +02:00
|
|
|
down_write(&s->s_umount);
|
|
|
|
up_write(&s->s_umount);
|
|
|
|
put_super(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-08 06:14:41 +02:00
|
|
|
/*
|
|
|
|
* grab_super_passive - acquire a passive reference
|
2012-06-09 05:10:55 +02:00
|
|
|
* @sb: reference we are trying to grab
|
2011-07-08 06:14:41 +02:00
|
|
|
*
|
|
|
|
* Tries to acquire a passive reference. This is used in places where we
|
|
|
|
* cannot take an active reference but we need to ensure that the
|
|
|
|
* superblock does not go away while we are working on it. It returns
|
|
|
|
* false if a reference was not gained, and returns true with the s_umount
|
|
|
|
* lock held in read mode if a reference is gained. On successful return,
|
|
|
|
* the caller must drop the s_umount lock and the passive reference when
|
|
|
|
* done.
|
|
|
|
*/
|
|
|
|
bool grab_super_passive(struct super_block *sb)
|
|
|
|
{
|
|
|
|
spin_lock(&sb_lock);
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances)) {
|
2011-07-08 06:14:41 +02:00
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
|
|
|
|
if (down_read_trylock(&sb->s_umount)) {
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && (sb->s_flags & MS_BORN))
|
2011-07-08 06:14:41 +02:00
|
|
|
return true;
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
}
|
|
|
|
|
|
|
|
put_super(sb);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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);
|
2009-04-27 16:43:53 +02:00
|
|
|
sync_filesystem(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
sb->s_flags &= ~MS_ACTIVE;
|
2009-01-06 16:20:54 +01:00
|
|
|
|
2010-10-26 02:49:35 +02:00
|
|
|
fsnotify_unmount_inodes(&sb->s_inodes);
|
|
|
|
|
|
|
|
evict_inodes(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (sop->put_super)
|
|
|
|
sop->put_super(sb);
|
|
|
|
|
2010-10-26 02:49:35 +02:00
|
|
|
if (!list_empty(&sb->s_inodes)) {
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_lock(&sb_lock);
|
|
|
|
/* should be initialized for __put_super_and_need_restart() */
|
2011-12-13 04:53:00 +01:00
|
|
|
hlist_del_init(&sb->s_instances);
|
2005-04-17 00:20:36 +02:00
|
|
|
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
|
2012-06-25 13:55:37 +02:00
|
|
|
* @flags: mount flags
|
2005-04-17 00:20:36 +02:00
|
|
|
* @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 *),
|
2012-06-25 13:55:37 +02:00
|
|
|
int flags,
|
2005-04-17 00:20:36 +02:00
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct super_block *s = NULL;
|
2011-12-13 04:53:00 +01:00
|
|
|
struct hlist_node *node;
|
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) {
|
2011-12-13 04:53:00 +01:00
|
|
|
hlist_for_each_entry(old, node, &type->fs_supers, s_instances) {
|
2007-10-19 08:39:57 +02:00
|
|
|
if (!test(old, data))
|
|
|
|
continue;
|
|
|
|
if (!grab_super(old))
|
|
|
|
goto retry;
|
2009-03-12 22:31:29 +01:00
|
|
|
if (s) {
|
|
|
|
up_write(&s->s_umount);
|
2007-10-19 08:39:57 +02:00
|
|
|
destroy_super(s);
|
2010-08-09 18:05:43 +02:00
|
|
|
s = NULL;
|
2009-03-12 22:31:29 +01:00
|
|
|
}
|
2010-03-23 16:11:05 +01:00
|
|
|
down_write(&old->s_umount);
|
2010-08-09 18:05:43 +02:00
|
|
|
if (unlikely(!(old->s_flags & MS_BORN))) {
|
|
|
|
deactivate_locked_super(old);
|
|
|
|
goto retry;
|
|
|
|
}
|
2007-10-19 08:39:57 +02:00
|
|
|
return old;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (!s) {
|
|
|
|
spin_unlock(&sb_lock);
|
2012-06-25 13:55:37 +02:00
|
|
|
s = alloc_super(type, flags);
|
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);
|
2009-03-12 22:31:29 +01:00
|
|
|
up_write(&s->s_umount);
|
2005-04-17 00:20:36 +02:00
|
|
|
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);
|
2011-12-13 04:53:00 +01:00
|
|
|
hlist_add_head(&s->s_instances, &type->fs_supers);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
get_filesystem(type);
|
2011-07-08 06:14:42 +02:00
|
|
|
register_shrinker(&s->s_shrink);
|
2005-04-17 00:20:36 +02:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(sget);
|
|
|
|
|
|
|
|
void drop_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
put_super(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(drop_super);
|
|
|
|
|
2010-03-23 11:06:58 +01:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2010-07-25 00:31:46 +02:00
|
|
|
struct super_block *sb, *p = NULL;
|
2010-03-23 11:06:58 +01:00
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
2010-07-25 00:31:46 +02:00
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances))
|
2010-03-23 11:06:58 +01:00
|
|
|
continue;
|
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
|
|
|
|
down_read(&sb->s_umount);
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && (sb->s_flags & MS_BORN))
|
2010-03-23 11:06:58 +01:00
|
|
|
f(sb, arg);
|
|
|
|
up_read(&sb->s_umount);
|
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
2010-07-25 00:31:46 +02:00
|
|
|
if (p)
|
|
|
|
__put_super(p);
|
|
|
|
p = sb;
|
2010-03-23 11:06:58 +01:00
|
|
|
}
|
2010-07-25 00:31:46 +02:00
|
|
|
if (p)
|
|
|
|
__put_super(p);
|
2010-03-23 11:06:58 +01:00
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
}
|
|
|
|
|
2011-06-04 02:16:57 +02:00
|
|
|
/**
|
|
|
|
* iterate_supers_type - call function for superblocks of given type
|
|
|
|
* @type: fs type
|
|
|
|
* @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_type(struct file_system_type *type,
|
|
|
|
void (*f)(struct super_block *, void *), void *arg)
|
|
|
|
{
|
|
|
|
struct super_block *sb, *p = NULL;
|
2011-12-13 04:53:00 +01:00
|
|
|
struct hlist_node *node;
|
2011-06-04 02:16:57 +02:00
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
2011-12-13 04:53:00 +01:00
|
|
|
hlist_for_each_entry(sb, node, &type->fs_supers, s_instances) {
|
2011-06-04 02:16:57 +02:00
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
|
|
|
|
down_read(&sb->s_umount);
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && (sb->s_flags & MS_BORN))
|
2011-06-04 02:16:57 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(iterate_supers_type);
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2010-03-23 01:23:25 +01:00
|
|
|
struct super_block *get_super(struct block_device *bdev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
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) {
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances))
|
2010-03-23 00:36:35 +01:00
|
|
|
continue;
|
2005-06-23 09:09:54 +02:00
|
|
|
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);
|
2010-03-23 01:23:25 +01:00
|
|
|
/* still alive? */
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && (sb->s_flags & MS_BORN))
|
2005-06-23 09:09:54 +02:00
|
|
|
return sb;
|
|
|
|
up_read(&sb->s_umount);
|
2010-03-23 01:23:25 +01:00
|
|
|
/* nope, got unmounted */
|
2005-06-23 09:09:54 +02:00
|
|
|
spin_lock(&sb_lock);
|
2010-03-23 01:23:25 +01:00
|
|
|
__put_super(sb);
|
|
|
|
goto rescan;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(get_super);
|
2009-08-03 23:28:35 +02:00
|
|
|
|
2012-02-10 11:03:00 +01:00
|
|
|
/**
|
|
|
|
* get_super_thawed - get thawed 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. The superblock is returned once it is thawed
|
|
|
|
* (or immediately if it was not frozen). %NULL is returned if no match
|
|
|
|
* is found.
|
|
|
|
*/
|
|
|
|
struct super_block *get_super_thawed(struct block_device *bdev)
|
|
|
|
{
|
|
|
|
while (1) {
|
|
|
|
struct super_block *s = get_super(bdev);
|
2012-06-12 16:20:34 +02:00
|
|
|
if (!s || s->s_writers.frozen == SB_UNFROZEN)
|
2012-02-10 11:03:00 +01:00
|
|
|
return s;
|
|
|
|
up_read(&s->s_umount);
|
2012-06-12 16:20:34 +02:00
|
|
|
wait_event(s->s_writers.wait_unfrozen,
|
|
|
|
s->s_writers.frozen == SB_UNFROZEN);
|
2012-02-10 11:03:00 +01:00
|
|
|
put_super(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(get_super_thawed);
|
|
|
|
|
2009-08-03 23:28:35 +02:00
|
|
|
/**
|
|
|
|
* 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
|
2010-03-23 16:11:05 +01:00
|
|
|
* reference or %NULL if none was found.
|
2009-08-03 23:28:35 +02:00
|
|
|
*/
|
|
|
|
struct super_block *get_active_super(struct block_device *bdev)
|
|
|
|
{
|
|
|
|
struct super_block *sb;
|
|
|
|
|
|
|
|
if (!bdev)
|
|
|
|
return NULL;
|
|
|
|
|
2010-03-23 01:15:33 +01:00
|
|
|
restart:
|
2009-08-03 23:28:35 +02:00
|
|
|
spin_lock(&sb_lock);
|
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances))
|
2010-03-23 00:36:35 +01:00
|
|
|
continue;
|
2010-03-23 01:15:33 +01:00
|
|
|
if (sb->s_bdev == bdev) {
|
|
|
|
if (grab_super(sb)) /* drops sb_lock */
|
|
|
|
return sb;
|
|
|
|
else
|
|
|
|
goto restart;
|
|
|
|
}
|
2009-08-03 23:28:35 +02:00
|
|
|
}
|
|
|
|
spin_unlock(&sb_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-03-23 01:23:25 +01:00
|
|
|
struct super_block *user_get_super(dev_t dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
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) {
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances))
|
2010-03-23 00:36:35 +01:00
|
|
|
continue;
|
2005-06-23 09:09:54 +02:00
|
|
|
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);
|
2010-03-23 01:23:25 +01:00
|
|
|
/* still alive? */
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && (sb->s_flags & MS_BORN))
|
2005-06-23 09:09:54 +02:00
|
|
|
return sb;
|
|
|
|
up_read(&sb->s_umount);
|
2010-03-23 01:23:25 +01:00
|
|
|
/* nope, got unmounted */
|
2005-06-23 09:09:54 +02:00
|
|
|
spin_lock(&sb_lock);
|
2010-03-23 01:23:25 +01:00
|
|
|
__put_super(sb);
|
|
|
|
goto rescan;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
2010-05-19 13:16:40 +02:00
|
|
|
int remount_ro;
|
2009-08-03 23:28:35 +02:00
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
if (sb->s_writers.frozen != SB_UNFROZEN)
|
2009-08-03 23:28:35 +02:00
|
|
|
return -EBUSY;
|
|
|
|
|
[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
|
2009-08-03 23:28:35 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (flags & MS_RDONLY)
|
|
|
|
acct_auto_close(sb);
|
|
|
|
shrink_dcache_sb(sb);
|
2009-04-27 16:43:53 +02:00
|
|
|
sync_filesystem(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-12-22 01:28:53 +01:00
|
|
|
remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* If we are remounting RDONLY and current sb is read/write,
|
|
|
|
make sure there are no rw files opened */
|
2009-12-22 01:28:53 +01:00
|
|
|
if (remount_ro) {
|
2011-11-21 12:11:31 +01:00
|
|
|
if (force) {
|
2005-04-17 00:20:36 +02:00
|
|
|
mark_files_ro(sb);
|
2011-11-21 12:11:31 +01:00
|
|
|
} else {
|
|
|
|
retval = sb_prepare_remount_readonly(sb);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sb->s_op->remount_fs) {
|
|
|
|
retval = sb->s_op->remount_fs(sb, &flags, data);
|
2011-10-28 14:13:20 +02:00
|
|
|
if (retval) {
|
|
|
|
if (!force)
|
2011-11-21 12:11:31 +01:00
|
|
|
goto cancel_readonly;
|
2011-10-28 14:13:20 +02:00
|
|
|
/* If forced remount, go ahead despite any errors */
|
|
|
|
WARN(1, "forced remount of a %s fs returned %i\n",
|
|
|
|
sb->s_type->name, retval);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
|
2011-11-21 12:11:31 +01:00
|
|
|
/* Needs to be ordered wrt mnt_is_readonly() */
|
|
|
|
smp_wmb();
|
|
|
|
sb->s_readonly_remount = 0;
|
2010-05-19 13:16:40 +02:00
|
|
|
|
2009-12-22 01:28:53 +01:00
|
|
|
/*
|
|
|
|
* 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);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2011-11-21 12:11:31 +01:00
|
|
|
|
|
|
|
cancel_readonly:
|
|
|
|
sb->s_readonly_remount = 0;
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-03-17 09:38:40 +01:00
|
|
|
static void do_emergency_remount(struct work_struct *work)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-07-25 00:31:46 +02:00
|
|
|
struct super_block *sb, *p = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
spin_lock(&sb_lock);
|
2010-07-25 00:31:46 +02:00
|
|
|
list_for_each_entry(sb, &super_blocks, s_list) {
|
2011-12-13 04:53:00 +01:00
|
|
|
if (hlist_unhashed(&sb->s_instances))
|
2010-03-23 00:36:35 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
sb->s_count++;
|
|
|
|
spin_unlock(&sb_lock);
|
2009-05-06 05:48:50 +02:00
|
|
|
down_write(&sb->s_umount);
|
2012-01-04 03:01:29 +01:00
|
|
|
if (sb->s_root && sb->s_bdev && (sb->s_flags & MS_BORN) &&
|
|
|
|
!(sb->s_flags & MS_RDONLY)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* What lock protects sb->s_flags??
|
|
|
|
*/
|
|
|
|
do_remount_sb(sb, MS_RDONLY, NULL, 1);
|
|
|
|
}
|
2009-05-06 05:48:50 +02:00
|
|
|
up_write(&sb->s_umount);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&sb_lock);
|
2010-07-25 00:31:46 +02:00
|
|
|
if (p)
|
|
|
|
__put_super(p);
|
|
|
|
p = sb;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-07-25 00:31:46 +02:00
|
|
|
if (p)
|
|
|
|
__put_super(p);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&sb_lock);
|
2009-03-17 09:38:40 +01:00
|
|
|
kfree(work);
|
2005-04-17 00:20:36 +02:00
|
|
|
printk("Emergency Remount complete\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void emergency_remount(void)
|
|
|
|
{
|
2009-03-17 09:38:40 +01:00
|
|
|
struct work_struct *work;
|
|
|
|
|
|
|
|
work = kmalloc(sizeof(*work), GFP_ATOMIC);
|
|
|
|
if (work) {
|
|
|
|
INIT_WORK(work, do_emergency_remount);
|
|
|
|
schedule_work(work);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unnamed block devices are dummy devices used by virtual
|
|
|
|
* filesystems which don't use real block-devices. -- jrs
|
|
|
|
*/
|
|
|
|
|
2008-08-28 04:26:23 +02:00
|
|
|
static DEFINE_IDA(unnamed_dev_ida);
|
2005-04-17 00:20:36 +02:00
|
|
|
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
|
2009-06-24 08:05:18 +02:00
|
|
|
static int unnamed_dev_start = 0; /* don't bother trying below it */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-07-07 21:44:25 +02:00
|
|
|
int get_anon_bdev(dev_t *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int dev;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
retry:
|
2008-08-28 04:26:23 +02:00
|
|
|
if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
spin_lock(&unnamed_dev_lock);
|
2009-06-24 08:05:18 +02:00
|
|
|
error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
|
2009-06-24 09:12:00 +02:00
|
|
|
if (!error)
|
|
|
|
unnamed_dev_start = dev + 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
if (error == -EAGAIN)
|
|
|
|
/* We raced and lost with another CPU. */
|
|
|
|
goto retry;
|
|
|
|
else if (error)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
idr: remove MAX_IDR_MASK and move left MAX_IDR_* into idr.c
MAX_IDR_MASK is another weirdness in the idr interface. As idr covers
whole positive integer range, it's defined as 0x7fffffff or INT_MAX.
Its usage in idr_find(), idr_replace() and idr_remove() is bizarre.
They basically mask off the sign bit and operate on the rest, so if
the caller, by accident, passes in a negative number, the sign bit
will be masked off and the remaining part will be used as if that was
the input, which is worse than crashing.
The constant is visible in idr.h and there are several users in the
kernel.
* drivers/i2c/i2c-core.c:i2c_add_numbered_adapter()
Basically used to test if adap->nr is a negative number which isn't
-1 and returns -EINVAL if so. idr_alloc() already has negative
@start checking (w/ WARN_ON_ONCE), so this can go away.
* drivers/infiniband/core/cm.c:cm_alloc_id()
drivers/infiniband/hw/mlx4/cm.c:id_map_alloc()
Used to wrap cyclic @start. Can be replaced with max(next, 0).
Note that this type of cyclic allocation using idr is buggy. These
are prone to spurious -ENOSPC failure after the first wraparound.
* fs/super.c:get_anon_bdev()
The ID allocated from ida is masked off before being tested whether
it's inside valid range. ida allocated ID can never be a negative
number and the masking is unnecessary.
Update idr_*() functions to fail with -EINVAL when negative @id is
specified and update other MAX_IDR_MASK users as described above.
This leaves MAX_IDR_MASK without any user, remove it and relocate
other MAX_IDR_* constants to lib/idr.c.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Jean Delvare <khali@linux-fr.org>
Cc: Roland Dreier <roland@kernel.org>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
Cc: "Marciniszyn, Mike" <mike.marciniszyn@intel.com>
Cc: Jack Morgenstein <jackm@dev.mellanox.co.il>
Cc: Or Gerlitz <ogerlitz@mellanox.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Acked-by: Wolfram Sang <wolfram@the-dreams.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 02:05:04 +01:00
|
|
|
if (dev == (1 << MINORBITS)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&unnamed_dev_lock);
|
2008-08-28 04:26:23 +02:00
|
|
|
ida_remove(&unnamed_dev_ida, dev);
|
2009-06-24 09:12:00 +02:00
|
|
|
if (unnamed_dev_start > dev)
|
|
|
|
unnamed_dev_start = dev;
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
return -EMFILE;
|
|
|
|
}
|
2011-07-07 21:44:25 +02:00
|
|
|
*p = MKDEV(0, dev & MINORMASK);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2011-07-07 21:44:25 +02:00
|
|
|
EXPORT_SYMBOL(get_anon_bdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-07-07 21:44:25 +02:00
|
|
|
void free_anon_bdev(dev_t dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-07-07 21:44:25 +02:00
|
|
|
int slot = MINOR(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&unnamed_dev_lock);
|
2008-08-28 04:26:23 +02:00
|
|
|
ida_remove(&unnamed_dev_ida, slot);
|
2009-06-24 08:05:18 +02:00
|
|
|
if (slot < unnamed_dev_start)
|
|
|
|
unnamed_dev_start = slot;
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&unnamed_dev_lock);
|
|
|
|
}
|
2011-07-07 21:44:25 +02:00
|
|
|
EXPORT_SYMBOL(free_anon_bdev);
|
|
|
|
|
|
|
|
int set_anon_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
int error = get_anon_bdev(&s->s_dev);
|
|
|
|
if (!error)
|
|
|
|
s->s_bdi = &noop_backing_dev_info;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(set_anon_super);
|
|
|
|
|
|
|
|
void kill_anon_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
dev_t dev = sb->s_dev;
|
|
|
|
generic_shutdown_super(sb);
|
|
|
|
free_anon_bdev(dev);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2009-04-07 04:01:07 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-07-26 11:16:50 +02:00
|
|
|
struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
|
|
|
|
void *data, int (*fill_super)(struct super_block *, void *, int))
|
2009-04-07 04:01:07 +02:00
|
|
|
{
|
|
|
|
struct super_block *sb;
|
|
|
|
|
2012-06-25 13:55:37 +02:00
|
|
|
sb = sget(fs_type, ns_test_super, ns_set_super, flags, data);
|
2009-04-07 04:01:07 +02:00
|
|
|
if (IS_ERR(sb))
|
2010-07-26 11:16:50 +02:00
|
|
|
return ERR_CAST(sb);
|
2009-04-07 04:01:07 +02:00
|
|
|
|
|
|
|
if (!sb->s_root) {
|
|
|
|
int err;
|
|
|
|
err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
|
|
|
|
if (err) {
|
2009-05-06 07:07:50 +02:00
|
|
|
deactivate_locked_super(sb);
|
2010-07-26 11:16:50 +02:00
|
|
|
return ERR_PTR(err);
|
2009-04-07 04:01:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
sb->s_flags |= MS_ACTIVE;
|
|
|
|
}
|
|
|
|
|
2010-07-26 11:16:50 +02:00
|
|
|
return dget(sb->s_root);
|
2009-04-07 04:01:07 +02:00
|
|
|
}
|
|
|
|
|
2010-07-26 11:16:50 +02:00
|
|
|
EXPORT_SYMBOL(mount_ns);
|
2009-04-07 04:01:07 +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
|
|
|
static int set_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
s->s_bdev = data;
|
|
|
|
s->s_dev = s->s_bdev->bd_dev;
|
2009-09-16 15:02:33 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int test_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
return (void *)s->s_bdev == data;
|
|
|
|
}
|
|
|
|
|
2010-07-24 22:46:55 +02:00
|
|
|
struct dentry *mount_bdev(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, const char *dev_name, void *data,
|
2010-07-24 22:46:55 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int))
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct block_device *bdev;
|
|
|
|
struct super_block *s;
|
2010-11-13 11:55:18 +01:00
|
|
|
fmode_t mode = FMODE_READ | FMODE_EXCL;
|
2005-04-17 00:20:36 +02:00
|
|
|
int error = 0;
|
|
|
|
|
2008-02-23 01:50:45 +01:00
|
|
|
if (!(flags & MS_RDONLY))
|
|
|
|
mode |= FMODE_WRITE;
|
|
|
|
|
2010-11-13 11:55:18 +01:00
|
|
|
bdev = blkdev_get_by_path(dev_name, mode, fs_type);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (IS_ERR(bdev))
|
2010-07-24 22:46:55 +02:00
|
|
|
return ERR_CAST(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
|
|
|
|
*/
|
2009-08-03 23:28:06 +02:00
|
|
|
mutex_lock(&bdev->bd_fsfreeze_mutex);
|
|
|
|
if (bdev->bd_fsfreeze_count > 0) {
|
|
|
|
mutex_unlock(&bdev->bd_fsfreeze_mutex);
|
|
|
|
error = -EBUSY;
|
|
|
|
goto error_bdev;
|
|
|
|
}
|
2012-06-25 13:55:37 +02:00
|
|
|
s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
|
|
|
|
bdev);
|
2009-08-03 23:28:06 +02:00
|
|
|
mutex_unlock(&bdev->bd_fsfreeze_mutex);
|
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) {
|
2009-05-06 07:07:50 +02:00
|
|
|
deactivate_locked_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
|
|
|
|
2010-07-21 00:18:07 +02:00
|
|
|
/*
|
|
|
|
* s_umount nests inside bd_mutex during
|
block: make blkdev_get/put() handle exclusive access
Over time, block layer has accumulated a set of APIs dealing with bdev
open, close, claim and release.
* blkdev_get/put() are the primary open and close functions.
* bd_claim/release() deal with exclusive open.
* open/close_bdev_exclusive() are combination of open and claim and
the other way around, respectively.
* bd_link/unlink_disk_holder() to create and remove holder/slave
symlinks.
* open_by_devnum() wraps bdget() + blkdev_get().
The interface is a bit confusing and the decoupling of open and claim
makes it impossible to properly guarantee exclusive access as
in-kernel open + claim sequence can disturb the existing exclusive
open even before the block layer knows the current open if for another
exclusive access. Reorganize the interface such that,
* blkdev_get() is extended to include exclusive access management.
@holder argument is added and, if is @FMODE_EXCL specified, it will
gain exclusive access atomically w.r.t. other exclusive accesses.
* blkdev_put() is similarly extended. It now takes @mode argument and
if @FMODE_EXCL is set, it releases an exclusive access. Also, when
the last exclusive claim is released, the holder/slave symlinks are
removed automatically.
* bd_claim/release() and close_bdev_exclusive() are no longer
necessary and either made static or removed.
* bd_link_disk_holder() remains the same but bd_unlink_disk_holder()
is no longer necessary and removed.
* open_bdev_exclusive() becomes a simple wrapper around lookup_bdev()
and blkdev_get(). It also has an unexpected extra bdev_read_only()
test which probably should be moved into blkdev_get().
* open_by_devnum() is modified to take @holder argument and pass it to
blkdev_get().
Most of bdev open/close operations are unified into blkdev_get/put()
and most exclusive accesses are tested atomically at the open time (as
it should). This cleans up code and removes some, both valid and
invalid, but unnecessary all the same, corner cases.
open_bdev_exclusive() and open_by_devnum() can use further cleanup -
rename to blkdev_get_by_path() and blkdev_get_by_devt() and drop
special features. Well, let's leave them for another day.
Most conversions are straight-forward. drbd conversion is a bit more
involved as there was some reordering, but the logic should stay the
same.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Neil Brown <neilb@suse.de>
Acked-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Acked-by: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Peter Osterlund <petero2@telia.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Cc: Alex Elder <aelder@sgi.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: dm-devel@redhat.com
Cc: drbd-dev@lists.linbit.com
Cc: Leo Chen <leochen@broadcom.com>
Cc: Scott Branden <sbranden@broadcom.com>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Cc: Joern Engel <joern@logfs.org>
Cc: reiserfs-devel@vger.kernel.org
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
2010-11-13 11:55:17 +01:00
|
|
|
* __invalidate_device(). blkdev_put() 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.
|
2010-07-21 00:18:07 +02:00
|
|
|
*/
|
|
|
|
up_write(&s->s_umount);
|
2010-11-13 11:55:18 +01:00
|
|
|
blkdev_put(bdev, mode);
|
2010-07-21 00:18:07 +02:00
|
|
|
down_write(&s->s_umount);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
|
2008-02-23 01:50:45 +01:00
|
|
|
s->s_mode = mode;
|
2005-04-17 00:20:36 +02:00
|
|
|
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) {
|
2009-05-06 07:07:50 +02:00
|
|
|
deactivate_locked_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;
|
2009-01-03 15:47:09 +01:00
|
|
|
bdev->bd_super = s;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-07-24 22:46:55 +02:00
|
|
|
return dget(s->s_root);
|
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:
|
2010-11-13 11:55:18 +01:00
|
|
|
blkdev_put(bdev, mode);
|
[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:
|
2010-07-24 22:46:55 +02:00
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mount_bdev);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void kill_block_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct block_device *bdev = sb->s_bdev;
|
2008-02-23 01:50:45 +01:00
|
|
|
fmode_t mode = sb->s_mode;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-04-30 02:14:57 +02:00
|
|
|
bdev->bd_super = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
generic_shutdown_super(sb);
|
|
|
|
sync_blockdev(bdev);
|
2010-11-13 11:55:18 +01:00
|
|
|
WARN_ON_ONCE(!(mode & FMODE_EXCL));
|
block: make blkdev_get/put() handle exclusive access
Over time, block layer has accumulated a set of APIs dealing with bdev
open, close, claim and release.
* blkdev_get/put() are the primary open and close functions.
* bd_claim/release() deal with exclusive open.
* open/close_bdev_exclusive() are combination of open and claim and
the other way around, respectively.
* bd_link/unlink_disk_holder() to create and remove holder/slave
symlinks.
* open_by_devnum() wraps bdget() + blkdev_get().
The interface is a bit confusing and the decoupling of open and claim
makes it impossible to properly guarantee exclusive access as
in-kernel open + claim sequence can disturb the existing exclusive
open even before the block layer knows the current open if for another
exclusive access. Reorganize the interface such that,
* blkdev_get() is extended to include exclusive access management.
@holder argument is added and, if is @FMODE_EXCL specified, it will
gain exclusive access atomically w.r.t. other exclusive accesses.
* blkdev_put() is similarly extended. It now takes @mode argument and
if @FMODE_EXCL is set, it releases an exclusive access. Also, when
the last exclusive claim is released, the holder/slave symlinks are
removed automatically.
* bd_claim/release() and close_bdev_exclusive() are no longer
necessary and either made static or removed.
* bd_link_disk_holder() remains the same but bd_unlink_disk_holder()
is no longer necessary and removed.
* open_bdev_exclusive() becomes a simple wrapper around lookup_bdev()
and blkdev_get(). It also has an unexpected extra bdev_read_only()
test which probably should be moved into blkdev_get().
* open_by_devnum() is modified to take @holder argument and pass it to
blkdev_get().
Most of bdev open/close operations are unified into blkdev_get/put()
and most exclusive accesses are tested atomically at the open time (as
it should). This cleans up code and removes some, both valid and
invalid, but unnecessary all the same, corner cases.
open_bdev_exclusive() and open_by_devnum() can use further cleanup -
rename to blkdev_get_by_path() and blkdev_get_by_devt() and drop
special features. Well, let's leave them for another day.
Most conversions are straight-forward. drbd conversion is a bit more
involved as there was some reordering, but the logic should stay the
same.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Neil Brown <neilb@suse.de>
Acked-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Acked-by: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Peter Osterlund <petero2@telia.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Cc: Alex Elder <aelder@sgi.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: dm-devel@redhat.com
Cc: drbd-dev@lists.linbit.com
Cc: Leo Chen <leochen@broadcom.com>
Cc: Scott Branden <sbranden@broadcom.com>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Cc: Joern Engel <joern@logfs.org>
Cc: reiserfs-devel@vger.kernel.org
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
2010-11-13 11:55:17 +01:00
|
|
|
blkdev_put(bdev, mode | FMODE_EXCL);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
2010-07-25 09:46:36 +02:00
|
|
|
struct dentry *mount_nodev(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, void *data,
|
2010-07-25 09:46:36 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int))
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int error;
|
2012-06-25 13:55:37 +02:00
|
|
|
struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (IS_ERR(s))
|
2010-07-25 09:46:36 +02:00
|
|
|
return ERR_CAST(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[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) {
|
2009-05-06 07:07:50 +02:00
|
|
|
deactivate_locked_super(s);
|
2010-07-25 09:46:36 +02:00
|
|
|
return ERR_PTR(error);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
2010-07-25 09:46:36 +02:00
|
|
|
return dget(s->s_root);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-07-25 09:46:36 +02:00
|
|
|
EXPORT_SYMBOL(mount_nodev);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int compare_single(struct super_block *s, void *p)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-07-24 23:48:30 +02:00
|
|
|
struct dentry *mount_single(struct file_system_type *fs_type,
|
2005-04-17 00:20:36 +02:00
|
|
|
int flags, void *data,
|
2010-07-24 23:48:30 +02:00
|
|
|
int (*fill_super)(struct super_block *, void *, int))
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct super_block *s;
|
|
|
|
int error;
|
|
|
|
|
2012-06-25 13:55:37 +02:00
|
|
|
s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (IS_ERR(s))
|
2010-07-24 23:48:30 +02:00
|
|
|
return ERR_CAST(s);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!s->s_root) {
|
[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) {
|
2009-05-06 07:07:50 +02:00
|
|
|
deactivate_locked_super(s);
|
2010-07-24 23:48:30 +02:00
|
|
|
return ERR_PTR(error);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
s->s_flags |= MS_ACTIVE;
|
2009-12-18 21:18:15 +01:00
|
|
|
} else {
|
|
|
|
do_remount_sb(s, flags, data, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-07-24 23:48:30 +02:00
|
|
|
return dget(s->s_root);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mount_single);
|
|
|
|
|
2011-03-18 03:08:28 +01:00
|
|
|
struct dentry *
|
|
|
|
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-07-24 22:17:56 +02:00
|
|
|
struct dentry *root;
|
2011-03-18 03:08:28 +01:00
|
|
|
struct super_block *sb;
|
2005-04-17 00:20:36 +02:00
|
|
|
char *secdata = NULL;
|
2011-03-18 03:08:28 +01:00
|
|
|
int error = -ENOMEM;
|
2010-02-05 15:30:46 +01:00
|
|
|
|
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)
|
2011-03-18 03:08:28 +01:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-03-16 14:07:58 +01:00
|
|
|
root = type->mount(type, flags, name, data);
|
|
|
|
if (IS_ERR(root)) {
|
|
|
|
error = PTR_ERR(root);
|
|
|
|
goto out_free_secdata;
|
2010-07-24 22:17:56 +02:00
|
|
|
}
|
2011-03-18 03:08:28 +01:00
|
|
|
sb = root->d_sb;
|
|
|
|
BUG_ON(!sb);
|
|
|
|
WARN_ON(!sb->s_bdi);
|
2011-03-24 18:16:26 +01:00
|
|
|
WARN_ON(sb->s_bdi == &default_backing_dev_info);
|
2011-03-18 03:08:28 +01:00
|
|
|
sb->s_flags |= MS_BORN;
|
[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
|
|
|
|
2011-03-18 03:08:28 +01:00
|
|
|
error = security_sb_kern_mount(sb, flags, secdata);
|
2010-04-25 08:54:42 +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
|
|
|
|
2009-09-18 22:05:53 +02:00
|
|
|
/*
|
|
|
|
* 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
|
2011-03-29 15:33:31 +02:00
|
|
|
* violate this rule.
|
2009-09-18 22:05:53 +02:00
|
|
|
*/
|
2011-03-18 03:08:28 +01:00
|
|
|
WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
|
|
|
|
"negative value (%lld)\n", type->name, sb->s_maxbytes);
|
2009-09-18 22:05:53 +02:00
|
|
|
|
2011-03-18 03:08:28 +01:00
|
|
|
up_write(&sb->s_umount);
|
2005-06-22 02:15:16 +02:00
|
|
|
free_secdata(secdata);
|
2011-03-18 03:08:28 +01:00
|
|
|
return root;
|
2005-04-17 00:20:36 +02:00
|
|
|
out_sb:
|
2011-03-18 03:08:28 +01:00
|
|
|
dput(root);
|
|
|
|
deactivate_locked_super(sb);
|
2005-04-17 00:20:36 +02:00
|
|
|
out_free_secdata:
|
|
|
|
free_secdata(secdata);
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
/*
|
|
|
|
* This is an internal function, please use sb_end_{write,pagefault,intwrite}
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
void __sb_end_write(struct super_block *sb, int level)
|
|
|
|
{
|
|
|
|
percpu_counter_dec(&sb->s_writers.counter[level-1]);
|
|
|
|
/*
|
|
|
|
* Make sure s_writers are updated before we wake up waiters in
|
|
|
|
* freeze_super().
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
if (waitqueue_active(&sb->s_writers.wait))
|
|
|
|
wake_up(&sb->s_writers.wait);
|
|
|
|
rwsem_release(&sb->s_writers.lock_map[level-1], 1, _RET_IP_);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__sb_end_write);
|
|
|
|
|
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
|
|
/*
|
|
|
|
* We want lockdep to tell us about possible deadlocks with freezing but
|
|
|
|
* it's it bit tricky to properly instrument it. Getting a freeze protection
|
|
|
|
* works as getting a read lock but there are subtle problems. XFS for example
|
|
|
|
* gets freeze protection on internal level twice in some cases, which is OK
|
|
|
|
* only because we already hold a freeze protection also on higher level. Due
|
|
|
|
* to these cases we have to tell lockdep we are doing trylock when we
|
|
|
|
* already hold a freeze protection for a higher freeze level.
|
|
|
|
*/
|
|
|
|
static void acquire_freeze_lock(struct super_block *sb, int level, bool trylock,
|
|
|
|
unsigned long ip)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!trylock) {
|
|
|
|
for (i = 0; i < level - 1; i++)
|
|
|
|
if (lock_is_held(&sb->s_writers.lock_map[i])) {
|
|
|
|
trylock = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rwsem_acquire_read(&sb->s_writers.lock_map[level-1], 0, trylock, ip);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is an internal function, please use sb_start_{write,pagefault,intwrite}
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
int __sb_start_write(struct super_block *sb, int level, bool wait)
|
|
|
|
{
|
|
|
|
retry:
|
|
|
|
if (unlikely(sb->s_writers.frozen >= level)) {
|
|
|
|
if (!wait)
|
|
|
|
return 0;
|
|
|
|
wait_event(sb->s_writers.wait_unfrozen,
|
|
|
|
sb->s_writers.frozen < level);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
|
|
acquire_freeze_lock(sb, level, !wait, _RET_IP_);
|
|
|
|
#endif
|
|
|
|
percpu_counter_inc(&sb->s_writers.counter[level-1]);
|
|
|
|
/*
|
|
|
|
* Make sure counter is updated before we check for frozen.
|
|
|
|
* freeze_super() first sets frozen and then checks the counter.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
if (unlikely(sb->s_writers.frozen >= level)) {
|
|
|
|
__sb_end_write(sb, level);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__sb_start_write);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sb_wait_write - wait until all writers to given file system finish
|
|
|
|
* @sb: the super for which we wait
|
|
|
|
* @level: type of writers we wait for (normal vs page fault)
|
|
|
|
*
|
|
|
|
* This function waits until there are no writers of given type to given file
|
|
|
|
* system. Caller of this function should make sure there can be no new writers
|
|
|
|
* of type @level before calling this function. Otherwise this function can
|
|
|
|
* livelock.
|
|
|
|
*/
|
|
|
|
static void sb_wait_write(struct super_block *sb, int level)
|
|
|
|
{
|
|
|
|
s64 writers;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We just cycle-through lockdep here so that it does not complain
|
|
|
|
* about returning with lock to userspace
|
|
|
|
*/
|
|
|
|
rwsem_acquire(&sb->s_writers.lock_map[level-1], 0, 0, _THIS_IP_);
|
|
|
|
rwsem_release(&sb->s_writers.lock_map[level-1], 1, _THIS_IP_);
|
|
|
|
|
|
|
|
do {
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We use a barrier in prepare_to_wait() to separate setting
|
|
|
|
* of frozen and checking of the counter
|
|
|
|
*/
|
|
|
|
prepare_to_wait(&sb->s_writers.wait, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
|
|
|
|
writers = percpu_counter_sum(&sb->s_writers.counter[level-1]);
|
|
|
|
if (writers)
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
finish_wait(&sb->s_writers.wait, &wait);
|
|
|
|
} while (writers);
|
|
|
|
}
|
|
|
|
|
2010-03-23 15:34:56 +01:00
|
|
|
/**
|
2010-05-25 07:22:34 +02:00
|
|
|
* freeze_super - lock the filesystem and force it into a consistent state
|
|
|
|
* @sb: the super to lock
|
2010-03-23 15:34:56 +01:00
|
|
|
*
|
|
|
|
* 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.
|
2012-06-12 16:20:34 +02:00
|
|
|
*
|
|
|
|
* During this function, sb->s_writers.frozen goes through these values:
|
|
|
|
*
|
|
|
|
* SB_UNFROZEN: File system is normal, all writes progress as usual.
|
|
|
|
*
|
|
|
|
* SB_FREEZE_WRITE: The file system is in the process of being frozen. New
|
|
|
|
* writes should be blocked, though page faults are still allowed. We wait for
|
|
|
|
* all writes to complete and then proceed to the next stage.
|
|
|
|
*
|
|
|
|
* SB_FREEZE_PAGEFAULT: Freezing continues. Now also page faults are blocked
|
|
|
|
* but internal fs threads can still modify the filesystem (although they
|
|
|
|
* should not dirty new pages or inodes), writeback can run etc. After waiting
|
|
|
|
* for all running page faults we sync the filesystem which will clean all
|
|
|
|
* dirty pages and inodes (no new dirty pages or inodes can be created when
|
|
|
|
* sync is running).
|
|
|
|
*
|
|
|
|
* SB_FREEZE_FS: The file system is frozen. Now all internal sources of fs
|
|
|
|
* modification are blocked (e.g. XFS preallocation truncation on inode
|
|
|
|
* reclaim). This is usually implemented by blocking new transactions for
|
|
|
|
* filesystems that have them and need this additional guard. After all
|
|
|
|
* internal writers are finished we call ->freeze_fs() to finish filesystem
|
|
|
|
* freezing. Then we transition to SB_FREEZE_COMPLETE state. This state is
|
|
|
|
* mostly auxiliary for filesystems to verify they do not modify frozen fs.
|
|
|
|
*
|
|
|
|
* sb->s_writers.frozen is protected by sb->s_umount.
|
2010-03-23 15:34:56 +01:00
|
|
|
*/
|
|
|
|
int freeze_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
atomic_inc(&sb->s_active);
|
|
|
|
down_write(&sb->s_umount);
|
2012-06-12 16:20:34 +02:00
|
|
|
if (sb->s_writers.frozen != SB_UNFROZEN) {
|
2010-03-23 15:34:56 +01:00
|
|
|
deactivate_locked_super(sb);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2012-01-04 03:01:29 +01:00
|
|
|
if (!(sb->s_flags & MS_BORN)) {
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
return 0; /* sic - it's "nothing to do" */
|
|
|
|
}
|
|
|
|
|
2010-03-23 15:34:56 +01:00
|
|
|
if (sb->s_flags & MS_RDONLY) {
|
2012-06-12 16:20:34 +02:00
|
|
|
/* Nothing to do really... */
|
|
|
|
sb->s_writers.frozen = SB_FREEZE_COMPLETE;
|
2010-03-23 15:34:56 +01:00
|
|
|
up_write(&sb->s_umount);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
/* From now on, no new normal writers can start */
|
|
|
|
sb->s_writers.frozen = SB_FREEZE_WRITE;
|
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
/* Release s_umount to preserve sb_start_write -> s_umount ordering */
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
|
|
|
|
sb_wait_write(sb, SB_FREEZE_WRITE);
|
|
|
|
|
|
|
|
/* Now we go and block page faults... */
|
|
|
|
down_write(&sb->s_umount);
|
|
|
|
sb->s_writers.frozen = SB_FREEZE_PAGEFAULT;
|
2010-03-23 15:34:56 +01:00
|
|
|
smp_wmb();
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
|
|
|
|
|
|
|
|
/* All writers are done so after syncing there won't be dirty data */
|
2010-03-23 15:34:56 +01:00
|
|
|
sync_filesystem(sb);
|
|
|
|
|
2012-06-12 16:20:34 +02:00
|
|
|
/* Now wait for internal filesystem counter */
|
|
|
|
sb->s_writers.frozen = SB_FREEZE_FS;
|
2010-03-23 15:34:56 +01:00
|
|
|
smp_wmb();
|
2012-06-12 16:20:34 +02:00
|
|
|
sb_wait_write(sb, SB_FREEZE_FS);
|
2010-03-23 15:34:56 +01:00
|
|
|
|
|
|
|
if (sb->s_op->freeze_fs) {
|
|
|
|
ret = sb->s_op->freeze_fs(sb);
|
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"VFS:Filesystem freeze failed\n");
|
2012-06-12 16:20:34 +02:00
|
|
|
sb->s_writers.frozen = SB_UNFROZEN;
|
2011-12-01 08:51:07 +01:00
|
|
|
smp_wmb();
|
2012-06-12 16:20:34 +02:00
|
|
|
wake_up(&sb->s_writers.wait_unfrozen);
|
2010-03-23 15:34:56 +01:00
|
|
|
deactivate_locked_super(sb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2012-06-12 16:20:34 +02:00
|
|
|
/*
|
|
|
|
* This is just for debugging purposes so that fs can warn if it
|
|
|
|
* sees write activity when frozen is set to SB_FREEZE_COMPLETE.
|
|
|
|
*/
|
|
|
|
sb->s_writers.frozen = SB_FREEZE_COMPLETE;
|
2010-03-23 15:34:56 +01:00
|
|
|
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);
|
2012-06-12 16:20:34 +02:00
|
|
|
if (sb->s_writers.frozen == SB_UNFROZEN) {
|
2010-03-23 15:34:56 +01:00
|
|
|
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");
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2012-06-12 16:20:34 +02:00
|
|
|
sb->s_writers.frozen = SB_UNFROZEN;
|
2010-03-23 15:34:56 +01:00
|
|
|
smp_wmb();
|
2012-06-12 16:20:34 +02:00
|
|
|
wake_up(&sb->s_writers.wait_unfrozen);
|
2010-03-23 15:34:56 +01:00
|
|
|
deactivate_locked_super(sb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(thaw_super);
|