Blame view
fs/super.c
48 KB
b24413180 License cleanup: ... |
1 |
// SPDX-License-Identifier: GPL-2.0 |
1da177e4c Linux-2.6.12-rc2 |
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/* * 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: |
96de0e252 Convert files to ... |
19 |
* Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996. |
1da177e4c Linux-2.6.12-rc2 |
20 21 22 |
* Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998 * Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000 */ |
630d9c472 fs: reduce the us... |
23 |
#include <linux/export.h> |
1da177e4c Linux-2.6.12-rc2 |
24 |
#include <linux/slab.h> |
1da177e4c Linux-2.6.12-rc2 |
25 |
#include <linux/blkdev.h> |
1da177e4c Linux-2.6.12-rc2 |
26 27 |
#include <linux/mount.h> #include <linux/security.h> |
1da177e4c Linux-2.6.12-rc2 |
28 29 |
#include <linux/writeback.h> /* for the emergency remount stuff */ #include <linux/idr.h> |
353ab6e97 [PATCH] sem2mutex... |
30 |
#include <linux/mutex.h> |
5477d0fac fs: fs/super.c ne... |
31 |
#include <linux/backing-dev.h> |
ceb5bdc2d fs: dcache per-bu... |
32 |
#include <linux/rculist_bl.h> |
c515e1fd3 mm/fs: add hooks ... |
33 |
#include <linux/cleancache.h> |
22d94f493 fscrypt: add FS_I... |
34 |
#include <linux/fscrypt.h> |
404015308 security: trim se... |
35 |
#include <linux/fsnotify.h> |
5accdf82b fs: Improve files... |
36 |
#include <linux/lockdep.h> |
6e4eab577 fs: Add user name... |
37 |
#include <linux/user_namespace.h> |
9bc61ab18 vfs: Introduce fs... |
38 |
#include <linux/fs_context.h> |
e262e32d6 vfs: Suppress MS_... |
39 |
#include <uapi/linux/mount.h> |
6d59e7f58 [PATCH] move a bu... |
40 |
#include "internal.h" |
1da177e4c Linux-2.6.12-rc2 |
41 |
|
08fdc8a01 buffer.c: call th... |
42 |
static int thaw_super_locked(struct super_block *sb); |
1da177e4c Linux-2.6.12-rc2 |
43 |
|
15d0f5ea3 Make super_blocks... |
44 45 |
static LIST_HEAD(super_blocks); static DEFINE_SPINLOCK(sb_lock); |
1da177e4c Linux-2.6.12-rc2 |
46 |
|
5accdf82b fs: Improve files... |
47 48 49 50 51 |
static char *sb_writers_name[SB_FREEZE_LEVELS] = { "sb_writers", "sb_pagefaults", "sb_internal", }; |
b0d40c92a superblock: intro... |
52 53 54 55 56 57 58 |
/* * 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. */ |
0a234c6dc shrinker: convert... |
59 60 |
static unsigned long super_cache_scan(struct shrinker *shrink, struct shrink_control *sc) |
b0d40c92a superblock: intro... |
61 62 |
{ struct super_block *sb; |
0a234c6dc shrinker: convert... |
63 64 65 66 67 |
long fs_objects = 0; long total_objects; long freed = 0; long dentries; long inodes; |
b0d40c92a superblock: intro... |
68 69 70 71 72 73 74 |
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.. */ |
0a234c6dc shrinker: convert... |
75 76 |
if (!(sc->gfp_mask & __GFP_FS)) return SHRINK_STOP; |
b0d40c92a superblock: intro... |
77 |
|
eb6ef3df4 trylock_super(): ... |
78 |
if (!trylock_super(sb)) |
0a234c6dc shrinker: convert... |
79 |
return SHRINK_STOP; |
b0d40c92a superblock: intro... |
80 |
|
d04079039 prune_super(): sb... |
81 |
if (sb->s_op->nr_cached_objects) |
4101b6243 fs: consolidate {... |
82 |
fs_objects = sb->s_op->nr_cached_objects(sb, sc); |
0e1fdafd9 superblock: add f... |
83 |
|
503c358cf list_lru: introdu... |
84 85 |
inodes = list_lru_shrink_count(&sb->s_inode_lru, sc); dentries = list_lru_shrink_count(&sb->s_dentry_lru, sc); |
f60415675 dcache: convert t... |
86 |
total_objects = dentries + inodes + fs_objects + 1; |
475d0db74 fs: Fix theoretic... |
87 88 |
if (!total_objects) total_objects = 1; |
0e1fdafd9 superblock: add f... |
89 |
|
0a234c6dc shrinker: convert... |
90 |
/* proportion the scan between the caches */ |
f60415675 dcache: convert t... |
91 |
dentries = mult_frac(sc->nr_to_scan, dentries, total_objects); |
bc3b14cb2 inode: convert in... |
92 |
inodes = mult_frac(sc->nr_to_scan, inodes, total_objects); |
503c358cf list_lru: introdu... |
93 |
fs_objects = mult_frac(sc->nr_to_scan, fs_objects, total_objects); |
b0d40c92a superblock: intro... |
94 |
|
0a234c6dc shrinker: convert... |
95 96 97 |
/* * prune the dcache first as the icache is pinned by it, then * prune the icache, followed by the filesystem specific caches |
49e7e7ff8 fs: shrinker: alw... |
98 99 100 |
* * Ensure that we always scan at least one object - memcg kmem * accounting uses this to fully empty the caches. |
0a234c6dc shrinker: convert... |
101 |
*/ |
49e7e7ff8 fs: shrinker: alw... |
102 |
sc->nr_to_scan = dentries + 1; |
503c358cf list_lru: introdu... |
103 |
freed = prune_dcache_sb(sb, sc); |
49e7e7ff8 fs: shrinker: alw... |
104 |
sc->nr_to_scan = inodes + 1; |
503c358cf list_lru: introdu... |
105 |
freed += prune_icache_sb(sb, sc); |
0a234c6dc shrinker: convert... |
106 107 |
if (fs_objects) { |
49e7e7ff8 fs: shrinker: alw... |
108 |
sc->nr_to_scan = fs_objects + 1; |
4101b6243 fs: consolidate {... |
109 |
freed += sb->s_op->free_cached_objects(sb, sc); |
b0d40c92a superblock: intro... |
110 |
} |
eb6ef3df4 trylock_super(): ... |
111 |
up_read(&sb->s_umount); |
0a234c6dc shrinker: convert... |
112 113 114 115 116 117 118 119 120 121 |
return freed; } static unsigned long super_cache_count(struct shrinker *shrink, struct shrink_control *sc) { struct super_block *sb; long total_objects = 0; sb = container_of(shrink, struct super_block, s_shrink); |
d23da150a fs/superblock: av... |
122 |
/* |
79f546a69 fs: don't scan th... |
123 124 125 126 127 128 129 130 131 132 133 134 |
* We don't call trylock_super() here as it is a scalability bottleneck, * so we're exposed to partial setup state. The shrinker rwsem does not * protect filesystem operations backing list_lru_shrink_count() or * s_op->nr_cached_objects(). Counts can change between * super_cache_count and super_cache_scan, so we really don't need locks * here. * * However, if we are currently mounting the superblock, the underlying * filesystem might be in a state of partial construction and hence it * is dangerous to access it. trylock_super() uses a SB_BORN check to * avoid this situation, so do the same here. The memory barrier is * matched with the one in mount_fs() as we don't hold locks here. |
d23da150a fs/superblock: av... |
135 |
*/ |
79f546a69 fs: don't scan th... |
136 137 138 |
if (!(sb->s_flags & SB_BORN)) return 0; smp_rmb(); |
0a234c6dc shrinker: convert... |
139 |
if (sb->s_op && sb->s_op->nr_cached_objects) |
4101b6243 fs: consolidate {... |
140 |
total_objects = sb->s_op->nr_cached_objects(sb, sc); |
0a234c6dc shrinker: convert... |
141 |
|
503c358cf list_lru: introdu... |
142 143 |
total_objects += list_lru_shrink_count(&sb->s_dentry_lru, sc); total_objects += list_lru_shrink_count(&sb->s_inode_lru, sc); |
0a234c6dc shrinker: convert... |
144 |
|
9b996468c mm: add SHRINK_EM... |
145 146 |
if (!total_objects) return SHRINK_EMPTY; |
55f841ce9 super: fix calcul... |
147 |
total_objects = vfs_pressure_ratio(total_objects); |
0e1fdafd9 superblock: add f... |
148 |
return total_objects; |
b0d40c92a superblock: intro... |
149 |
} |
853b39a7c shift percpu_coun... |
150 151 152 153 154 155 156 |
static void destroy_super_work(struct work_struct *work) { struct super_block *s = container_of(work, struct super_block, destroy_work); int i; for (i = 0; i < SB_FREEZE_LEVELS; i++) |
8129ed296 change sb_writers... |
157 |
percpu_free_rwsem(&s->s_writers.rw_sem[i]); |
853b39a7c shift percpu_coun... |
158 159 160 161 162 163 164 165 166 |
kfree(s); } static void destroy_super_rcu(struct rcu_head *head) { struct super_block *s = container_of(head, struct super_block, rcu); INIT_WORK(&s->destroy_work, destroy_super_work); schedule_work(&s->destroy_work); } |
0200894d1 new helper: destr... |
167 168 |
/* Free a superblock that has never been seen by anyone */ static void destroy_unused_super(struct super_block *s) |
5accdf82b fs: Improve files... |
169 |
{ |
0200894d1 new helper: destr... |
170 171 172 |
if (!s) return; up_write(&s->s_umount); |
7eb5e8826 uninline destroy_... |
173 174 |
list_lru_destroy(&s->s_dentry_lru); list_lru_destroy(&s->s_inode_lru); |
7eb5e8826 uninline destroy_... |
175 |
security_sb_free(s); |
6e4eab577 fs: Add user name... |
176 |
put_user_ns(s->s_user_ns); |
7eb5e8826 uninline destroy_... |
177 |
kfree(s->s_subtype); |
8e04944f0 mm,vmscan: Allow ... |
178 |
free_prealloced_shrinker(&s->s_shrink); |
0200894d1 new helper: destr... |
179 180 |
/* no delays needed */ destroy_super_work(&s->destroy_work); |
5accdf82b fs: Improve files... |
181 |
} |
1da177e4c Linux-2.6.12-rc2 |
182 183 |
/** * alloc_super - create new superblock |
fe2bbc483 [PATCH] add missi... |
184 |
* @type: filesystem type superblock should belong to |
9249e17fe VFS: Pass mount f... |
185 |
* @flags: the mount flags |
6e4eab577 fs: Add user name... |
186 |
* @user_ns: User namespace for the super_block |
1da177e4c Linux-2.6.12-rc2 |
187 188 189 190 |
* * Allocates and initializes a new &struct super_block. alloc_super() * returns a pointer new superblock or %NULL if allocation had failed. */ |
6e4eab577 fs: Add user name... |
191 192 |
static struct super_block *alloc_super(struct file_system_type *type, int flags, struct user_namespace *user_ns) |
1da177e4c Linux-2.6.12-rc2 |
193 |
{ |
11b0b5abb [PATCH] use kzall... |
194 |
struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER); |
b87221de6 const: mark remai... |
195 |
static const struct super_operations default_op; |
7eb5e8826 uninline destroy_... |
196 197 198 199 |
int i; if (!s) return NULL; |
1da177e4c Linux-2.6.12-rc2 |
200 |
|
b5bd856a0 fs/super.c: fix W... |
201 |
INIT_LIST_HEAD(&s->s_mounts); |
6e4eab577 fs: Add user name... |
202 |
s->s_user_ns = get_user_ns(user_ns); |
ca0168e8a alloc_super(): do... |
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 |
init_rwsem(&s->s_umount); lockdep_set_class(&s->s_umount, &type->s_umount_key); /* * sget() can have s_umount recursion. * * When it cannot find a suitable sb, it allocates a new * one (this one), and tries again to find a suitable old * one. * * In case that succeeds, it will acquire the s_umount * lock of the old one. Since these are clearly distrinct * locks, and this object isn't exposed yet, there's no * risk of deadlocks. * * Annotate this by putting this lock in a different * subclass. */ down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING); |
b5bd856a0 fs/super.c: fix W... |
221 |
|
7eb5e8826 uninline destroy_... |
222 223 |
if (security_sb_alloc(s)) goto fail; |
7b7a8665e direct-io: Implem... |
224 |
|
7eb5e8826 uninline destroy_... |
225 |
for (i = 0; i < SB_FREEZE_LEVELS; i++) { |
8129ed296 change sb_writers... |
226 227 228 |
if (__percpu_init_rwsem(&s->s_writers.rw_sem[i], sb_writers_name[i], &type->s_writers_key[i])) |
7eb5e8826 uninline destroy_... |
229 |
goto fail; |
1da177e4c Linux-2.6.12-rc2 |
230 |
} |
7eb5e8826 uninline destroy_... |
231 |
init_waitqueue_head(&s->s_writers.wait_unfrozen); |
df0ce26cb fs: remove defaul... |
232 |
s->s_bdi = &noop_backing_dev_info; |
7eb5e8826 uninline destroy_... |
233 |
s->s_flags = flags; |
cc50a07a2 userns: Remove th... |
234 |
if (s->s_user_ns != &init_user_ns) |
67690f937 userns: Remove im... |
235 |
s->s_iflags |= SB_I_NODEV; |
7eb5e8826 uninline destroy_... |
236 |
INIT_HLIST_NODE(&s->s_instances); |
f1ee61621 VFS: don't keep d... |
237 |
INIT_HLIST_BL_HEAD(&s->s_roots); |
e97fedb9e sync: serialise p... |
238 |
mutex_init(&s->s_sync_lock); |
7eb5e8826 uninline destroy_... |
239 |
INIT_LIST_HEAD(&s->s_inodes); |
74278da9f inode: convert in... |
240 |
spin_lock_init(&s->s_inode_list_lock); |
6c60d2b57 fs/fs-writeback.c... |
241 242 |
INIT_LIST_HEAD(&s->s_inodes_wb); spin_lock_init(&s->s_inode_wblist_lock); |
7eb5e8826 uninline destroy_... |
243 |
|
7eb5e8826 uninline destroy_... |
244 245 246 247 |
s->s_count = 1; atomic_set(&s->s_active, 1); mutex_init(&s->s_vfs_rename_mutex); lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key); |
bc8230ee8 quota: Convert dq... |
248 |
init_rwsem(&s->s_dquot.dqio_sem); |
7eb5e8826 uninline destroy_... |
249 250 251 |
s->s_maxbytes = MAX_NON_LFS; s->s_op = &default_op; s->s_time_gran = 1000000000; |
188d20bcd vfs: Add file tim... |
252 253 |
s->s_time_min = TIME64_MIN; s->s_time_max = TIME64_MAX; |
3cb29d111 cleancache: remov... |
254 |
s->cleancache_poolid = CLEANCACHE_NO_POOL; |
7eb5e8826 uninline destroy_... |
255 256 257 258 259 |
s->s_shrink.seeks = DEFAULT_SEEKS; s->s_shrink.scan_objects = super_cache_scan; s->s_shrink.count_objects = super_cache_count; s->s_shrink.batch = 1024; |
2acb60a04 fs: make shrinker... |
260 |
s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE; |
8e04944f0 mm,vmscan: Allow ... |
261 262 |
if (prealloc_shrinker(&s->s_shrink)) goto fail; |
c92e8e10c fs: propagate shr... |
263 |
if (list_lru_init_memcg(&s->s_dentry_lru, &s->s_shrink)) |
2b3648a6f fs/super.c: refac... |
264 |
goto fail; |
c92e8e10c fs: propagate shr... |
265 |
if (list_lru_init_memcg(&s->s_inode_lru, &s->s_shrink)) |
2b3648a6f fs/super.c: refac... |
266 |
goto fail; |
1da177e4c Linux-2.6.12-rc2 |
267 |
return s; |
5ca302c8e list_lru: dynamic... |
268 |
|
7eb5e8826 uninline destroy_... |
269 |
fail: |
0200894d1 new helper: destr... |
270 |
destroy_unused_super(s); |
7eb5e8826 uninline destroy_... |
271 |
return NULL; |
1da177e4c Linux-2.6.12-rc2 |
272 273 274 275 276 |
} /* Superblock refcounting */ /* |
35cf7ba0b Bury __put_super_... |
277 |
* Drop a superblock's refcount. The caller must hold sb_lock. |
1da177e4c Linux-2.6.12-rc2 |
278 |
*/ |
c645b9309 fold destroy_supe... |
279 |
static void __put_super(struct super_block *s) |
1da177e4c Linux-2.6.12-rc2 |
280 |
{ |
c645b9309 fold destroy_supe... |
281 282 283 284 285 286 |
if (!--s->s_count) { list_del_init(&s->s_list); WARN_ON(s->s_dentry_lru.node); WARN_ON(s->s_inode_lru.node); WARN_ON(!list_empty(&s->s_mounts)); security_sb_free(s); |
22d94f493 fscrypt: add FS_I... |
287 |
fscrypt_sb_free(s); |
c645b9309 fold destroy_supe... |
288 289 290 |
put_user_ns(s->s_user_ns); kfree(s->s_subtype); call_rcu(&s->rcu, destroy_super_rcu); |
1da177e4c Linux-2.6.12-rc2 |
291 |
} |
1da177e4c Linux-2.6.12-rc2 |
292 293 294 295 296 297 298 299 300 |
} /** * put_super - drop a temporary reference to superblock * @sb: superblock in question * * Drops a temporary reference, frees superblock if there's no * references left. */ |
f47ec3f28 trim fs/internal.h |
301 |
static void put_super(struct super_block *sb) |
1da177e4c Linux-2.6.12-rc2 |
302 303 304 305 306 307 308 309 |
{ spin_lock(&sb_lock); __put_super(sb); spin_unlock(&sb_lock); } /** |
1712ac8fd Saner locking aro... |
310 |
* deactivate_locked_super - drop an active reference to superblock |
1da177e4c Linux-2.6.12-rc2 |
311 312 |
* @s: superblock to deactivate * |
bd7ced988 Doc: treewide : F... |
313 |
* Drops an active reference to superblock, converting it into a temporary |
1712ac8fd Saner locking aro... |
314 |
* one if there is no other active references left. In that case we |
1da177e4c Linux-2.6.12-rc2 |
315 316 |
* tell fs driver to shut it down and drop the temporary reference we * had just acquired. |
1712ac8fd Saner locking aro... |
317 318 |
* * Caller holds exclusive lock on superblock; that lock is released. |
1da177e4c Linux-2.6.12-rc2 |
319 |
*/ |
1712ac8fd Saner locking aro... |
320 |
void deactivate_locked_super(struct super_block *s) |
1da177e4c Linux-2.6.12-rc2 |
321 322 |
{ struct file_system_type *fs = s->s_type; |
b20bd1a5e get rid of S_BIAS |
323 |
if (atomic_dec_and_test(&s->s_active)) { |
3167760f8 mm: cleancache: s... |
324 |
cleancache_invalidate_fs(s); |
b0d40c92a superblock: intro... |
325 |
unregister_shrinker(&s->s_shrink); |
28f2cd4f6 fs/superblock: un... |
326 |
fs->kill_sb(s); |
f5e1dd345 super: fix for de... |
327 |
|
c0a5b5609 list_lru: organiz... |
328 329 330 331 332 333 334 |
/* * Since list_lru_destroy() may sleep, we cannot call it from * put_super(), where we hold the sb_lock. Therefore we destroy * the lru lists right now. */ list_lru_destroy(&s->s_dentry_lru); list_lru_destroy(&s->s_inode_lru); |
1da177e4c Linux-2.6.12-rc2 |
335 336 |
put_filesystem(fs); put_super(s); |
1712ac8fd Saner locking aro... |
337 338 |
} else { up_write(&s->s_umount); |
1da177e4c Linux-2.6.12-rc2 |
339 340 |
} } |
1712ac8fd Saner locking aro... |
341 |
EXPORT_SYMBOL(deactivate_locked_super); |
1da177e4c Linux-2.6.12-rc2 |
342 343 |
/** |
1712ac8fd Saner locking aro... |
344 |
* deactivate_super - drop an active reference to superblock |
74dbbdd7f New helper: deact... |
345 346 |
* @s: superblock to deactivate * |
1712ac8fd Saner locking aro... |
347 348 349 |
* 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. |
74dbbdd7f New helper: deact... |
350 |
*/ |
1712ac8fd Saner locking aro... |
351 |
void deactivate_super(struct super_block *s) |
74dbbdd7f New helper: deact... |
352 |
{ |
1712ac8fd Saner locking aro... |
353 354 355 |
if (!atomic_add_unless(&s->s_active, -1, 1)) { down_write(&s->s_umount); deactivate_locked_super(s); |
74dbbdd7f New helper: deact... |
356 357 |
} } |
1712ac8fd Saner locking aro... |
358 |
EXPORT_SYMBOL(deactivate_super); |
74dbbdd7f New helper: deact... |
359 360 |
/** |
1da177e4c Linux-2.6.12-rc2 |
361 362 363 364 365 366 367 368 |
* 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 |
acfec9a5a livelock avoidanc... |
369 370 371 |
* dying when grab_super() had been called). Note that this is only * called for superblocks not in rundown mode (== ones still on ->fs_supers * of their type), so increment of ->s_count is OK here. |
1da177e4c Linux-2.6.12-rc2 |
372 |
*/ |
9c4dbee79 [PATCH] fs: add l... |
373 |
static int grab_super(struct super_block *s) __releases(sb_lock) |
1da177e4c Linux-2.6.12-rc2 |
374 375 376 377 |
{ s->s_count++; spin_unlock(&sb_lock); down_write(&s->s_umount); |
e462ec50c VFS: Differentiat... |
378 |
if ((s->s_flags & SB_BORN) && atomic_inc_not_zero(&s->s_active)) { |
acfec9a5a livelock avoidanc... |
379 380 381 |
put_super(s); return 1; } |
1da177e4c Linux-2.6.12-rc2 |
382 383 |
up_write(&s->s_umount); put_super(s); |
1da177e4c Linux-2.6.12-rc2 |
384 385 |
return 0; } |
cf9a2ae8d [PATCH] BLOCK: Mo... |
386 |
/* |
eb6ef3df4 trylock_super(): ... |
387 |
* trylock_super - try to grab ->s_umount shared |
331cbdeed writeback: Fix so... |
388 |
* @sb: reference we are trying to grab |
12ad3ab66 superblock: move ... |
389 |
* |
eb6ef3df4 trylock_super(): ... |
390 |
* Try to prevent fs shutdown. This is used in places where we |
12ad3ab66 superblock: move ... |
391 |
* cannot take an active reference but we need to ensure that the |
eb6ef3df4 trylock_super(): ... |
392 393 394 395 396 397 398 399 400 401 |
* filesystem is not shut down while we are working on it. It returns * false if we cannot acquire s_umount or if we lose the race and * filesystem already got into shutdown, and returns true with the s_umount * lock held in read mode in case of success. On successful return, * the caller must drop the s_umount lock when done. * * Note that unlike get_super() et.al. this one does *not* bump ->s_count. * The reason why it's safe is that we are OK with doing trylock instead * of down_read(). There's a couple of places that are OK with that, but * it's very much not a general-purpose interface. |
12ad3ab66 superblock: move ... |
402 |
*/ |
eb6ef3df4 trylock_super(): ... |
403 |
bool trylock_super(struct super_block *sb) |
12ad3ab66 superblock: move ... |
404 |
{ |
12ad3ab66 superblock: move ... |
405 |
if (down_read_trylock(&sb->s_umount)) { |
eb6ef3df4 trylock_super(): ... |
406 |
if (!hlist_unhashed(&sb->s_instances) && |
e462ec50c VFS: Differentiat... |
407 |
sb->s_root && (sb->s_flags & SB_BORN)) |
12ad3ab66 superblock: move ... |
408 409 410 |
return true; up_read(&sb->s_umount); } |
12ad3ab66 superblock: move ... |
411 412 |
return false; } |
1da177e4c Linux-2.6.12-rc2 |
413 414 415 416 417 418 419 420 421 |
/** * 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. |
c636ebdb1 [PATCH] VFS: Dest... |
422 423 424 425 |
* * 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. |
1da177e4c Linux-2.6.12-rc2 |
426 427 428 |
*/ void generic_shutdown_super(struct super_block *sb) { |
ee9b6d61a [PATCH] Mark stru... |
429 |
const struct super_operations *sop = sb->s_op; |
1da177e4c Linux-2.6.12-rc2 |
430 |
|
c636ebdb1 [PATCH] VFS: Dest... |
431 432 |
if (sb->s_root) { shrink_dcache_for_umount(sb); |
60b0680fa vfs: Rename fsync... |
433 |
sync_filesystem(sb); |
e462ec50c VFS: Differentiat... |
434 |
sb->s_flags &= ~SB_ACTIVE; |
efaee1920 async: make the f... |
435 |
|
a1a0e23e4 writeback: flush ... |
436 |
cgroup_writeback_umount(); |
63997e98a split invalidate_... |
437 |
|
2d300cb3b fs: call fsnotify... |
438 |
/* evict all inodes with zero refcount */ |
63997e98a split invalidate_... |
439 |
evict_inodes(sb); |
2d300cb3b fs: call fsnotify... |
440 441 |
/* only nonzero refcount inodes can have marks */ fsnotify_sb_delete(sb); |
1da177e4c Linux-2.6.12-rc2 |
442 |
|
7b7a8665e direct-io: Implem... |
443 444 445 446 |
if (sb->s_dio_done_wq) { destroy_workqueue(sb->s_dio_done_wq); sb->s_dio_done_wq = NULL; } |
1da177e4c Linux-2.6.12-rc2 |
447 448 |
if (sop->put_super) sop->put_super(sb); |
63997e98a split invalidate_... |
449 |
if (!list_empty(&sb->s_inodes)) { |
7b4fe29e0 [PATCH] More info... |
450 451 452 453 |
printk("VFS: Busy inodes after unmount of %s. " "Self-destruct in 5 seconds. Have a nice day... ", sb->s_id); |
1da177e4c Linux-2.6.12-rc2 |
454 |
} |
1da177e4c Linux-2.6.12-rc2 |
455 456 457 |
} spin_lock(&sb_lock); /* should be initialized for __put_super_and_need_restart() */ |
a5166169f vfs: convert fs_s... |
458 |
hlist_del_init(&sb->s_instances); |
1da177e4c Linux-2.6.12-rc2 |
459 460 |
spin_unlock(&sb_lock); up_write(&sb->s_umount); |
c1844d536 fs: Remove SB_I_D... |
461 |
if (sb->s_bdi != &noop_backing_dev_info) { |
fca39346a fs: Provide infra... |
462 463 |
bdi_put(sb->s_bdi); sb->s_bdi = &noop_backing_dev_info; |
fca39346a fs: Provide infra... |
464 |
} |
1da177e4c Linux-2.6.12-rc2 |
465 466 467 |
} EXPORT_SYMBOL(generic_shutdown_super); |
20284ab74 switch mount_capa... |
468 |
bool mount_capable(struct fs_context *fc) |
0ce0cf12f consolidate the c... |
469 |
{ |
20284ab74 switch mount_capa... |
470 |
if (!(fc->fs_type->fs_flags & FS_USERNS_MOUNT)) |
0ce0cf12f consolidate the c... |
471 472 |
return capable(CAP_SYS_ADMIN); else |
c2c44ec20 Unbreak mount_cap... |
473 |
return ns_capable(fc->user_ns, CAP_SYS_ADMIN); |
0ce0cf12f consolidate the c... |
474 |
} |
1da177e4c Linux-2.6.12-rc2 |
475 |
/** |
cb50b348c convenience helpe... |
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 |
* sget_fc - Find or create a superblock * @fc: Filesystem context. * @test: Comparison callback * @set: Setup callback * * Find or create a superblock using the parameters stored in the filesystem * context and the two callback functions. * * If an extant superblock is matched, then that will be returned with an * elevated reference count that the caller must transfer or discard. * * If no match is made, a new superblock will be allocated and basic * initialisation will be performed (s_type, s_fs_info and s_id will be set and * the set() callback will be invoked), the superblock will be published and it * will be returned in a partially constructed state with SB_BORN and SB_ACTIVE * as yet unset. */ struct super_block *sget_fc(struct fs_context *fc, int (*test)(struct super_block *, struct fs_context *), int (*set)(struct super_block *, struct fs_context *)) { struct super_block *s = NULL; struct super_block *old; struct user_namespace *user_ns = fc->global ? &init_user_ns : fc->user_ns; int err; |
cb50b348c convenience helpe... |
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 |
retry: spin_lock(&sb_lock); if (test) { hlist_for_each_entry(old, &fc->fs_type->fs_supers, s_instances) { if (test(old, fc)) goto share_extant_sb; } } if (!s) { spin_unlock(&sb_lock); s = alloc_super(fc->fs_type, fc->sb_flags, user_ns); if (!s) return ERR_PTR(-ENOMEM); goto retry; } s->s_fs_info = fc->s_fs_info; err = set(s, fc); if (err) { s->s_fs_info = NULL; spin_unlock(&sb_lock); destroy_unused_super(s); return ERR_PTR(err); } fc->s_fs_info = NULL; s->s_type = fc->fs_type; |
c80fa7c83 vfs: Provide sb->... |
527 |
s->s_iflags |= fc->s_iflags; |
cb50b348c convenience helpe... |
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 |
strlcpy(s->s_id, s->s_type->name, sizeof(s->s_id)); list_add_tail(&s->s_list, &super_blocks); hlist_add_head(&s->s_instances, &s->s_type->fs_supers); spin_unlock(&sb_lock); get_filesystem(s->s_type); register_shrinker_prepared(&s->s_shrink); return s; share_extant_sb: if (user_ns != old->s_user_ns) { spin_unlock(&sb_lock); destroy_unused_super(s); return ERR_PTR(-EBUSY); } if (!grab_super(old)) goto retry; destroy_unused_super(s); return old; } EXPORT_SYMBOL(sget_fc); /** |
023d066a0 vfs: Kill sget_us... |
550 551 552 553 554 555 |
* sget - find or create a superblock * @type: filesystem type superblock should belong to * @test: comparison callback * @set: setup callback * @flags: mount flags * @data: argument to each of them |
1da177e4c Linux-2.6.12-rc2 |
556 |
*/ |
023d066a0 vfs: Kill sget_us... |
557 |
struct super_block *sget(struct file_system_type *type, |
1da177e4c Linux-2.6.12-rc2 |
558 559 |
int (*test)(struct super_block *,void *), int (*set)(struct super_block *,void *), |
023d066a0 vfs: Kill sget_us... |
560 |
int flags, |
1da177e4c Linux-2.6.12-rc2 |
561 562 |
void *data) { |
023d066a0 vfs: Kill sget_us... |
563 |
struct user_namespace *user_ns = current_user_ns(); |
1da177e4c Linux-2.6.12-rc2 |
564 |
struct super_block *s = NULL; |
d47301271 fs/super.c: use l... |
565 |
struct super_block *old; |
1da177e4c Linux-2.6.12-rc2 |
566 |
int err; |
023d066a0 vfs: Kill sget_us... |
567 568 569 570 571 572 |
/* We don't yet pass the user namespace of the parent * mount through to here so always use &init_user_ns * until that changes. */ if (flags & SB_SUBMOUNT) user_ns = &init_user_ns; |
1da177e4c Linux-2.6.12-rc2 |
573 574 |
retry: spin_lock(&sb_lock); |
d47301271 fs/super.c: use l... |
575 |
if (test) { |
b67bfe0d4 hlist: drop the n... |
576 |
hlist_for_each_entry(old, &type->fs_supers, s_instances) { |
d47301271 fs/super.c: use l... |
577 578 |
if (!test(old, data)) continue; |
6e4eab577 fs: Add user name... |
579 580 |
if (user_ns != old->s_user_ns) { spin_unlock(&sb_lock); |
0200894d1 new helper: destr... |
581 |
destroy_unused_super(s); |
6e4eab577 fs: Add user name... |
582 583 |
return ERR_PTR(-EBUSY); } |
d47301271 fs/super.c: use l... |
584 585 |
if (!grab_super(old)) goto retry; |
0200894d1 new helper: destr... |
586 |
destroy_unused_super(s); |
d47301271 fs/super.c: use l... |
587 588 |
return old; } |
1da177e4c Linux-2.6.12-rc2 |
589 590 591 |
} if (!s) { spin_unlock(&sb_lock); |
e462ec50c VFS: Differentiat... |
592 |
s = alloc_super(type, (flags & ~SB_SUBMOUNT), user_ns); |
1da177e4c Linux-2.6.12-rc2 |
593 594 595 596 |
if (!s) return ERR_PTR(-ENOMEM); goto retry; } |
dd111b31e VFS: Clean up whi... |
597 |
|
1da177e4c Linux-2.6.12-rc2 |
598 599 600 |
err = set(s, data); if (err) { spin_unlock(&sb_lock); |
0200894d1 new helper: destr... |
601 |
destroy_unused_super(s); |
1da177e4c Linux-2.6.12-rc2 |
602 603 604 605 606 |
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); |
a5166169f vfs: convert fs_s... |
607 |
hlist_add_head(&s->s_instances, &type->fs_supers); |
1da177e4c Linux-2.6.12-rc2 |
608 609 |
spin_unlock(&sb_lock); get_filesystem(type); |
8e04944f0 mm,vmscan: Allow ... |
610 |
register_shrinker_prepared(&s->s_shrink); |
1da177e4c Linux-2.6.12-rc2 |
611 612 |
return s; } |
1da177e4c Linux-2.6.12-rc2 |
613 614 615 616 617 618 619 620 621 |
EXPORT_SYMBOL(sget); void drop_super(struct super_block *sb) { up_read(&sb->s_umount); put_super(sb); } EXPORT_SYMBOL(drop_super); |
ba6379f7e fs: Provide funct... |
622 623 624 625 626 627 |
void drop_super_exclusive(struct super_block *sb) { up_write(&sb->s_umount); put_super(sb); } EXPORT_SYMBOL(drop_super_exclusive); |
fa7c1d508 vfs: factor sb it... |
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 |
static void __iterate_supers(void (*f)(struct super_block *)) { struct super_block *sb, *p = NULL; spin_lock(&sb_lock); list_for_each_entry(sb, &super_blocks, s_list) { if (hlist_unhashed(&sb->s_instances)) continue; sb->s_count++; spin_unlock(&sb_lock); f(sb); spin_lock(&sb_lock); if (p) __put_super(p); p = sb; } if (p) __put_super(p); spin_unlock(&sb_lock); } |
e50047533 cleanup sync_supers |
650 |
/** |
01a05b337 new helper: itera... |
651 652 653 654 655 656 657 658 659 |
* 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) { |
dca332528 no need for list_... |
660 |
struct super_block *sb, *p = NULL; |
01a05b337 new helper: itera... |
661 662 |
spin_lock(&sb_lock); |
dca332528 no need for list_... |
663 |
list_for_each_entry(sb, &super_blocks, s_list) { |
a5166169f vfs: convert fs_s... |
664 |
if (hlist_unhashed(&sb->s_instances)) |
01a05b337 new helper: itera... |
665 666 667 668 669 |
continue; sb->s_count++; spin_unlock(&sb_lock); down_read(&sb->s_umount); |
e462ec50c VFS: Differentiat... |
670 |
if (sb->s_root && (sb->s_flags & SB_BORN)) |
01a05b337 new helper: itera... |
671 672 673 674 |
f(sb, arg); up_read(&sb->s_umount); spin_lock(&sb_lock); |
dca332528 no need for list_... |
675 676 677 |
if (p) __put_super(p); p = sb; |
01a05b337 new helper: itera... |
678 |
} |
dca332528 no need for list_... |
679 680 |
if (p) __put_super(p); |
01a05b337 new helper: itera... |
681 682 683 684 |
spin_unlock(&sb_lock); } /** |
43e15cdbe new helper: itera... |
685 686 687 688 689 690 691 692 693 694 695 696 697 698 |
* 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; spin_lock(&sb_lock); |
b67bfe0d4 hlist: drop the n... |
699 |
hlist_for_each_entry(sb, &type->fs_supers, s_instances) { |
43e15cdbe new helper: itera... |
700 701 702 703 |
sb->s_count++; spin_unlock(&sb_lock); down_read(&sb->s_umount); |
e462ec50c VFS: Differentiat... |
704 |
if (sb->s_root && (sb->s_flags & SB_BORN)) |
43e15cdbe new helper: itera... |
705 706 707 708 709 710 711 712 713 714 715 716 717 718 |
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); |
ba6379f7e fs: Provide funct... |
719 |
static struct super_block *__get_super(struct block_device *bdev, bool excl) |
1da177e4c Linux-2.6.12-rc2 |
720 |
{ |
618f06362 [PATCH] O(1) sb l... |
721 |
struct super_block *sb; |
1da177e4c Linux-2.6.12-rc2 |
722 723 |
if (!bdev) return NULL; |
618f06362 [PATCH] O(1) sb l... |
724 |
|
1da177e4c Linux-2.6.12-rc2 |
725 |
spin_lock(&sb_lock); |
618f06362 [PATCH] O(1) sb l... |
726 727 |
rescan: list_for_each_entry(sb, &super_blocks, s_list) { |
a5166169f vfs: convert fs_s... |
728 |
if (hlist_unhashed(&sb->s_instances)) |
551de6f34 Leave superblocks... |
729 |
continue; |
618f06362 [PATCH] O(1) sb l... |
730 731 |
if (sb->s_bdev == bdev) { sb->s_count++; |
1da177e4c Linux-2.6.12-rc2 |
732 |
spin_unlock(&sb_lock); |
ba6379f7e fs: Provide funct... |
733 734 735 736 |
if (!excl) down_read(&sb->s_umount); else down_write(&sb->s_umount); |
df40c01a9 In get_super() an... |
737 |
/* still alive? */ |
e462ec50c VFS: Differentiat... |
738 |
if (sb->s_root && (sb->s_flags & SB_BORN)) |
618f06362 [PATCH] O(1) sb l... |
739 |
return sb; |
ba6379f7e fs: Provide funct... |
740 741 742 743 |
if (!excl) up_read(&sb->s_umount); else up_write(&sb->s_umount); |
df40c01a9 In get_super() an... |
744 |
/* nope, got unmounted */ |
618f06362 [PATCH] O(1) sb l... |
745 |
spin_lock(&sb_lock); |
df40c01a9 In get_super() an... |
746 747 |
__put_super(sb); goto rescan; |
1da177e4c Linux-2.6.12-rc2 |
748 749 750 751 752 |
} } spin_unlock(&sb_lock); return NULL; } |
4504230a7 freeze_bdev: grab... |
753 |
/** |
ba6379f7e fs: Provide funct... |
754 |
* get_super - get the superblock of a device |
6b6dc836a vfs: Provide func... |
755 756 757 |
* @bdev: device to get the superblock for * * Scans the superblock list and finds the superblock of the file system |
ba6379f7e fs: Provide funct... |
758 |
* mounted on the device given. %NULL is returned if no match is found. |
6b6dc836a vfs: Provide func... |
759 |
*/ |
ba6379f7e fs: Provide funct... |
760 761 762 763 764 765 766 767 |
struct super_block *get_super(struct block_device *bdev) { return __get_super(bdev, false); } EXPORT_SYMBOL(get_super); static struct super_block *__get_super_thawed(struct block_device *bdev, bool excl) |
6b6dc836a vfs: Provide func... |
768 769 |
{ while (1) { |
ba6379f7e fs: Provide funct... |
770 |
struct super_block *s = __get_super(bdev, excl); |
5accdf82b fs: Improve files... |
771 |
if (!s || s->s_writers.frozen == SB_UNFROZEN) |
6b6dc836a vfs: Provide func... |
772 |
return s; |
ba6379f7e fs: Provide funct... |
773 774 775 776 |
if (!excl) up_read(&s->s_umount); else up_write(&s->s_umount); |
5accdf82b fs: Improve files... |
777 778 |
wait_event(s->s_writers.wait_unfrozen, s->s_writers.frozen == SB_UNFROZEN); |
6b6dc836a vfs: Provide func... |
779 780 781 |
put_super(s); } } |
ba6379f7e fs: Provide funct... |
782 783 784 785 786 787 788 789 790 791 792 793 794 795 |
/** * 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) { return __get_super_thawed(bdev, false); } |
6b6dc836a vfs: Provide func... |
796 797 798 |
EXPORT_SYMBOL(get_super_thawed); /** |
ba6379f7e fs: Provide funct... |
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 |
* get_super_exclusive_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) and s_umount semaphore is held * in exclusive mode. %NULL is returned if no match is found. */ struct super_block *get_super_exclusive_thawed(struct block_device *bdev) { return __get_super_thawed(bdev, true); } EXPORT_SYMBOL(get_super_exclusive_thawed); /** |
4504230a7 freeze_bdev: grab... |
814 815 816 817 818 |
* 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 |
d3f214730 Move grabbing s_u... |
819 |
* reference or %NULL if none was found. |
4504230a7 freeze_bdev: grab... |
820 821 822 823 824 825 826 |
*/ struct super_block *get_active_super(struct block_device *bdev) { struct super_block *sb; if (!bdev) return NULL; |
1494583de fix get_active_su... |
827 |
restart: |
4504230a7 freeze_bdev: grab... |
828 829 |
spin_lock(&sb_lock); list_for_each_entry(sb, &super_blocks, s_list) { |
a5166169f vfs: convert fs_s... |
830 |
if (hlist_unhashed(&sb->s_instances)) |
551de6f34 Leave superblocks... |
831 |
continue; |
1494583de fix get_active_su... |
832 |
if (sb->s_bdev == bdev) { |
acfec9a5a livelock avoidanc... |
833 |
if (!grab_super(sb)) |
1494583de fix get_active_su... |
834 |
goto restart; |
acfec9a5a livelock avoidanc... |
835 836 |
up_write(&sb->s_umount); return sb; |
1494583de fix get_active_su... |
837 |
} |
4504230a7 freeze_bdev: grab... |
838 839 840 841 |
} spin_unlock(&sb_lock); return NULL; } |
dd111b31e VFS: Clean up whi... |
842 |
|
df40c01a9 In get_super() an... |
843 |
struct super_block *user_get_super(dev_t dev) |
1da177e4c Linux-2.6.12-rc2 |
844 |
{ |
618f06362 [PATCH] O(1) sb l... |
845 |
struct super_block *sb; |
1da177e4c Linux-2.6.12-rc2 |
846 |
|
1da177e4c Linux-2.6.12-rc2 |
847 |
spin_lock(&sb_lock); |
618f06362 [PATCH] O(1) sb l... |
848 849 |
rescan: list_for_each_entry(sb, &super_blocks, s_list) { |
a5166169f vfs: convert fs_s... |
850 |
if (hlist_unhashed(&sb->s_instances)) |
551de6f34 Leave superblocks... |
851 |
continue; |
618f06362 [PATCH] O(1) sb l... |
852 853 |
if (sb->s_dev == dev) { sb->s_count++; |
1da177e4c Linux-2.6.12-rc2 |
854 |
spin_unlock(&sb_lock); |
618f06362 [PATCH] O(1) sb l... |
855 |
down_read(&sb->s_umount); |
df40c01a9 In get_super() an... |
856 |
/* still alive? */ |
e462ec50c VFS: Differentiat... |
857 |
if (sb->s_root && (sb->s_flags & SB_BORN)) |
618f06362 [PATCH] O(1) sb l... |
858 859 |
return sb; up_read(&sb->s_umount); |
df40c01a9 In get_super() an... |
860 |
/* nope, got unmounted */ |
618f06362 [PATCH] O(1) sb l... |
861 |
spin_lock(&sb_lock); |
df40c01a9 In get_super() an... |
862 863 |
__put_super(sb); goto rescan; |
1da177e4c Linux-2.6.12-rc2 |
864 865 866 867 868 |
} } spin_unlock(&sb_lock); return NULL; } |
1da177e4c Linux-2.6.12-rc2 |
869 |
/** |
8d0347f6c convert do_remoun... |
870 871 |
* reconfigure_super - asks filesystem to change superblock parameters * @fc: The superblock and configuration |
1da177e4c Linux-2.6.12-rc2 |
872 |
* |
8d0347f6c convert do_remoun... |
873 |
* Alters the configuration parameters of a live superblock. |
1da177e4c Linux-2.6.12-rc2 |
874 |
*/ |
8d0347f6c convert do_remoun... |
875 |
int reconfigure_super(struct fs_context *fc) |
1da177e4c Linux-2.6.12-rc2 |
876 |
{ |
8d0347f6c convert do_remoun... |
877 |
struct super_block *sb = fc->root->d_sb; |
1da177e4c Linux-2.6.12-rc2 |
878 |
int retval; |
8d0347f6c convert do_remoun... |
879 880 |
bool remount_ro = false; bool force = fc->sb_flags & SB_FORCE; |
4504230a7 freeze_bdev: grab... |
881 |
|
8d0347f6c convert do_remoun... |
882 883 |
if (fc->sb_flags_mask & ~MS_RMT_MASK) return -EINVAL; |
5accdf82b fs: Improve files... |
884 |
if (sb->s_writers.frozen != SB_UNFROZEN) |
4504230a7 freeze_bdev: grab... |
885 |
return -EBUSY; |
8d0347f6c convert do_remoun... |
886 887 888 889 890 |
retval = security_sb_remount(sb, fc->security); if (retval) return retval; if (fc->sb_flags_mask & SB_RDONLY) { |
9361401eb [PATCH] BLOCK: Ma... |
891 |
#ifdef CONFIG_BLOCK |
8d0347f6c convert do_remoun... |
892 893 |
if (!(fc->sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev)) return -EACCES; |
9361401eb [PATCH] BLOCK: Ma... |
894 |
#endif |
4504230a7 freeze_bdev: grab... |
895 |
|
8d0347f6c convert do_remoun... |
896 897 |
remount_ro = (fc->sb_flags & SB_RDONLY) && !sb_rdonly(sb); } |
d208bbdda fs: improve remou... |
898 |
|
0aec09d04 drop ->s_umount a... |
899 |
if (remount_ro) { |
fdab684d7 allow attaching f... |
900 |
if (!hlist_empty(&sb->s_pins)) { |
0aec09d04 drop ->s_umount a... |
901 |
up_write(&sb->s_umount); |
fdab684d7 allow attaching f... |
902 |
group_pin_kill(&sb->s_pins); |
0aec09d04 drop ->s_umount a... |
903 904 905 906 907 |
down_write(&sb->s_umount); if (!sb->s_root) return 0; if (sb->s_writers.frozen != SB_UNFROZEN) return -EBUSY; |
8d0347f6c convert do_remoun... |
908 |
remount_ro = !sb_rdonly(sb); |
0aec09d04 drop ->s_umount a... |
909 910 911 |
} } shrink_dcache_sb(sb); |
8d0347f6c convert do_remoun... |
912 913 914 |
/* If we are reconfiguring to RDONLY and current sb is read/write, * make sure there are no files open for writing. */ |
d208bbdda fs: improve remou... |
915 |
if (remount_ro) { |
4ed5e82fe vfs: protect remo... |
916 |
if (force) { |
eee5cc270 get rid of s_file... |
917 918 |
sb->s_readonly_remount = 1; smp_wmb(); |
4ed5e82fe vfs: protect remo... |
919 920 921 922 |
} else { retval = sb_prepare_remount_readonly(sb); if (retval) return retval; |
4ed5e82fe vfs: protect remo... |
923 |
} |
1da177e4c Linux-2.6.12-rc2 |
924 |
} |
f3a09c920 introduce fs_cont... |
925 926 927 928 929 930 931 932 933 934 |
if (fc->ops->reconfigure) { retval = fc->ops->reconfigure(fc); if (retval) { if (!force) goto cancel_readonly; /* If forced remount, go ahead despite any errors */ WARN(1, "forced remount of a %s fs returned %i ", sb->s_type->name, retval); } |
1da177e4c Linux-2.6.12-rc2 |
935 |
} |
8d0347f6c convert do_remoun... |
936 937 938 |
WRITE_ONCE(sb->s_flags, ((sb->s_flags & ~fc->sb_flags_mask) | (fc->sb_flags & fc->sb_flags_mask))); |
4ed5e82fe vfs: protect remo... |
939 940 941 |
/* Needs to be ordered wrt mnt_is_readonly() */ smp_wmb(); sb->s_readonly_remount = 0; |
c79d967de quota: move remou... |
942 |
|
d208bbdda fs: improve remou... |
943 944 945 946 947 948 949 950 951 952 |
/* * 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); |
1da177e4c Linux-2.6.12-rc2 |
953 |
return 0; |
4ed5e82fe vfs: protect remo... |
954 955 956 957 |
cancel_readonly: sb->s_readonly_remount = 0; return retval; |
1da177e4c Linux-2.6.12-rc2 |
958 |
} |
fa7c1d508 vfs: factor sb it... |
959 |
static void do_emergency_remount_callback(struct super_block *sb) |
1da177e4c Linux-2.6.12-rc2 |
960 |
{ |
fa7c1d508 vfs: factor sb it... |
961 962 963 |
down_write(&sb->s_umount); if (sb->s_root && sb->s_bdev && (sb->s_flags & SB_BORN) && !sb_rdonly(sb)) { |
8d0347f6c convert do_remoun... |
964 965 966 967 968 969 970 971 972 |
struct fs_context *fc; fc = fs_context_for_reconfigure(sb->s_root, SB_RDONLY | SB_FORCE, SB_RDONLY); if (!IS_ERR(fc)) { if (parse_monolithic_mount_data(fc, NULL) == 0) (void)reconfigure_super(fc); put_fs_context(fc); } |
1da177e4c Linux-2.6.12-rc2 |
973 |
} |
fa7c1d508 vfs: factor sb it... |
974 975 976 977 978 979 |
up_write(&sb->s_umount); } static void do_emergency_remount(struct work_struct *work) { __iterate_supers(do_emergency_remount_callback); |
a2a9537ac Get rid of pdflus... |
980 |
kfree(work); |
1da177e4c Linux-2.6.12-rc2 |
981 982 983 984 985 986 |
printk("Emergency Remount complete "); } void emergency_remount(void) { |
a2a9537ac Get rid of pdflus... |
987 988 989 990 991 992 993 |
struct work_struct *work; work = kmalloc(sizeof(*work), GFP_ATOMIC); if (work) { INIT_WORK(work, do_emergency_remount); schedule_work(work); } |
1da177e4c Linux-2.6.12-rc2 |
994 |
} |
08fdc8a01 buffer.c: call th... |
995 996 997 |
static void do_thaw_all_callback(struct super_block *sb) { down_write(&sb->s_umount); |
1c18d2a15 it's SB_BORN, not... |
998 |
if (sb->s_root && sb->s_flags & SB_BORN) { |
08fdc8a01 buffer.c: call th... |
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 |
emergency_thaw_bdev(sb); thaw_super_locked(sb); } else { up_write(&sb->s_umount); } } static void do_thaw_all(struct work_struct *work) { __iterate_supers(do_thaw_all_callback); kfree(work); printk(KERN_WARNING "Emergency Thaw complete "); } /** * emergency_thaw_all -- forcibly thaw every frozen filesystem * * Used for emergency unfreeze of all filesystems via SysRq */ void emergency_thaw_all(void) { struct work_struct *work; work = kmalloc(sizeof(*work), GFP_ATOMIC); if (work) { INIT_WORK(work, do_thaw_all); schedule_work(work); } } |
ad76cbc63 [PATCH 2/2] anond... |
1029 |
static DEFINE_IDA(unnamed_dev_ida); |
1da177e4c Linux-2.6.12-rc2 |
1030 |
|
5a66847e4 fs: Convert unnam... |
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 |
/** * get_anon_bdev - Allocate a block device for filesystems which don't have one. * @p: Pointer to a dev_t. * * Filesystems which don't use real block devices can call this function * to allocate a virtual block device. * * Context: Any context. Frequently called while holding sb_lock. * Return: 0 on success, -EMFILE if there are no anonymous bdevs left * or -ENOMEM if memory allocation failed. */ |
0ee5dc676 btrfs: kill magic... |
1042 |
int get_anon_bdev(dev_t *p) |
1da177e4c Linux-2.6.12-rc2 |
1043 1044 |
{ int dev; |
5a66847e4 fs: Convert unnam... |
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 |
/* * Many userspace utilities consider an FSID of 0 invalid. * Always return at least 1 from get_anon_bdev. */ dev = ida_alloc_range(&unnamed_dev_ida, 1, (1 << MINORBITS) - 1, GFP_ATOMIC); if (dev == -ENOSPC) dev = -EMFILE; if (dev < 0) return dev; *p = MKDEV(0, dev); |
1da177e4c Linux-2.6.12-rc2 |
1058 1059 |
return 0; } |
0ee5dc676 btrfs: kill magic... |
1060 |
EXPORT_SYMBOL(get_anon_bdev); |
1da177e4c Linux-2.6.12-rc2 |
1061 |
|
0ee5dc676 btrfs: kill magic... |
1062 |
void free_anon_bdev(dev_t dev) |
1da177e4c Linux-2.6.12-rc2 |
1063 |
{ |
5a66847e4 fs: Convert unnam... |
1064 |
ida_free(&unnamed_dev_ida, MINOR(dev)); |
1da177e4c Linux-2.6.12-rc2 |
1065 |
} |
0ee5dc676 btrfs: kill magic... |
1066 1067 1068 1069 |
EXPORT_SYMBOL(free_anon_bdev); int set_anon_super(struct super_block *s, void *data) { |
df0ce26cb fs: remove defaul... |
1070 |
return get_anon_bdev(&s->s_dev); |
0ee5dc676 btrfs: kill magic... |
1071 |
} |
0ee5dc676 btrfs: kill magic... |
1072 1073 1074 1075 1076 1077 1078 1079 |
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); } |
1da177e4c Linux-2.6.12-rc2 |
1080 |
EXPORT_SYMBOL(kill_anon_super); |
1da177e4c Linux-2.6.12-rc2 |
1081 1082 1083 1084 1085 1086 |
void kill_litter_super(struct super_block *sb) { if (sb->s_root) d_genocide(sb->s_root); kill_anon_super(sb); } |
1da177e4c Linux-2.6.12-rc2 |
1087 |
EXPORT_SYMBOL(kill_litter_super); |
cb50b348c convenience helpe... |
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 |
int set_anon_super_fc(struct super_block *sb, struct fs_context *fc) { return set_anon_super(sb, NULL); } EXPORT_SYMBOL(set_anon_super_fc); static int test_keyed_super(struct super_block *sb, struct fs_context *fc) { return sb->s_fs_info == fc->s_fs_info; } static int test_single_super(struct super_block *s, struct fs_context *fc) { return 1; } /** * vfs_get_super - Get a superblock with a search key set in s_fs_info. * @fc: The filesystem context holding the parameters * @keying: How to distinguish superblocks * @fill_super: Helper to initialise a new superblock * * Search for a superblock and create a new one if not found. The search * criterion is controlled by @keying. If the search fails, a new superblock * is created and @fill_super() is called to initialise it. * * @keying can take one of a number of values: * * (1) vfs_get_single_super - Only one superblock of this type may exist on the * system. This is typically used for special system filesystems. * * (2) vfs_get_keyed_super - Multiple superblocks may exist, but they must have * distinct keys (where the key is in s_fs_info). Searching for the same * key again will turn up the superblock for that key. * * (3) vfs_get_independent_super - Multiple superblocks may exist and are * unkeyed. Each call will get a new superblock. * * A permissions check is made by sget_fc() unless we're getting a superblock * for a kernel-internal mount or a submount. */ int vfs_get_super(struct fs_context *fc, enum vfs_get_super_keying keying, int (*fill_super)(struct super_block *sb, struct fs_context *fc)) { int (*test)(struct super_block *, struct fs_context *); struct super_block *sb; |
43ce4c1fe vfs: Add a single... |
1136 |
int err; |
cb50b348c convenience helpe... |
1137 1138 1139 |
switch (keying) { case vfs_get_single_super: |
43ce4c1fe vfs: Add a single... |
1140 |
case vfs_get_single_reconf_super: |
cb50b348c convenience helpe... |
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 |
test = test_single_super; break; case vfs_get_keyed_super: test = test_keyed_super; break; case vfs_get_independent_super: test = NULL; break; default: BUG(); } sb = sget_fc(fc, test, set_anon_super_fc); if (IS_ERR(sb)) return PTR_ERR(sb); if (!sb->s_root) { |
43ce4c1fe vfs: Add a single... |
1158 1159 1160 |
err = fill_super(sb, fc); if (err) goto error; |
cb50b348c convenience helpe... |
1161 1162 |
sb->s_flags |= SB_ACTIVE; |
43ce4c1fe vfs: Add a single... |
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 |
fc->root = dget(sb->s_root); } else { fc->root = dget(sb->s_root); if (keying == vfs_get_single_reconf_super) { err = reconfigure_super(fc); if (err < 0) { dput(fc->root); fc->root = NULL; goto error; } } |
cb50b348c convenience helpe... |
1174 |
} |
cb50b348c convenience helpe... |
1175 |
return 0; |
43ce4c1fe vfs: Add a single... |
1176 1177 1178 1179 |
error: deactivate_locked_super(sb); return err; |
cb50b348c convenience helpe... |
1180 1181 |
} EXPORT_SYMBOL(vfs_get_super); |
2ac295d4f convenience helpe... |
1182 1183 1184 1185 1186 1187 1188 |
int get_tree_nodev(struct fs_context *fc, int (*fill_super)(struct super_block *sb, struct fs_context *fc)) { return vfs_get_super(fc, vfs_get_independent_super, fill_super); } EXPORT_SYMBOL(get_tree_nodev); |
c23a0bbab convenience helpe... |
1189 1190 1191 1192 1193 1194 1195 |
int get_tree_single(struct fs_context *fc, int (*fill_super)(struct super_block *sb, struct fs_context *fc)) { return vfs_get_super(fc, vfs_get_single_super, fill_super); } EXPORT_SYMBOL(get_tree_single); |
43ce4c1fe vfs: Add a single... |
1196 1197 1198 1199 1200 1201 1202 |
int get_tree_single_reconf(struct fs_context *fc, int (*fill_super)(struct super_block *sb, struct fs_context *fc)) { return vfs_get_super(fc, vfs_get_single_reconf_super, fill_super); } EXPORT_SYMBOL(get_tree_single_reconf); |
533770cc0 new helper: get_t... |
1203 1204 1205 1206 1207 1208 1209 1210 1211 |
int get_tree_keyed(struct fs_context *fc, int (*fill_super)(struct super_block *sb, struct fs_context *fc), void *key) { fc->s_fs_info = key; return vfs_get_super(fc, vfs_get_keyed_super, fill_super); } EXPORT_SYMBOL(get_tree_keyed); |
9361401eb [PATCH] BLOCK: Ma... |
1212 |
#ifdef CONFIG_BLOCK |
fe62c3a4e vfs: Create fs_co... |
1213 |
|
1da177e4c Linux-2.6.12-rc2 |
1214 1215 1216 1217 |
static int set_bdev_super(struct super_block *s, void *data) { s->s_bdev = data; s->s_dev = s->s_bdev->bd_dev; |
13eec2363 fs: Get proper re... |
1218 |
s->s_bdi = bdi_get(s->s_bdev->bd_bdi); |
32a88aa1b fs: Assign bdi in... |
1219 |
|
1da177e4c Linux-2.6.12-rc2 |
1220 1221 |
return 0; } |
fe62c3a4e vfs: Create fs_co... |
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 |
static int set_bdev_super_fc(struct super_block *s, struct fs_context *fc) { return set_bdev_super(s, fc->sget_key); } static int test_bdev_super_fc(struct super_block *s, struct fs_context *fc) { return s->s_bdev == fc->sget_key; } /** * get_tree_bdev - Get a superblock based on a single block device * @fc: The filesystem context holding the parameters * @fill_super: Helper to initialise a new superblock */ int get_tree_bdev(struct fs_context *fc, int (*fill_super)(struct super_block *, struct fs_context *)) { struct block_device *bdev; struct super_block *s; fmode_t mode = FMODE_READ | FMODE_EXCL; int error = 0; if (!(fc->sb_flags & SB_RDONLY)) mode |= FMODE_WRITE; if (!fc->source) return invalf(fc, "No source specified"); bdev = blkdev_get_by_path(fc->source, mode, fc->fs_type); if (IS_ERR(bdev)) { errorf(fc, "%s: Can't open blockdev", fc->source); return PTR_ERR(bdev); } /* Once the superblock is inserted into the list by sget_fc(), s_umount * will protect the lockfs code from trying to start a snapshot while * we are mounting */ mutex_lock(&bdev->bd_fsfreeze_mutex); if (bdev->bd_fsfreeze_count > 0) { mutex_unlock(&bdev->bd_fsfreeze_mutex); |
6fcf0c72e vfs: add missing ... |
1265 |
blkdev_put(bdev, mode); |
fe62c3a4e vfs: Create fs_co... |
1266 1267 1268 1269 1270 1271 1272 1273 |
warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev); return -EBUSY; } fc->sb_flags |= SB_NOSEC; fc->sget_key = bdev; s = sget_fc(fc, test_bdev_super_fc, set_bdev_super_fc); mutex_unlock(&bdev->bd_fsfreeze_mutex); |
6fcf0c72e vfs: add missing ... |
1274 1275 |
if (IS_ERR(s)) { blkdev_put(bdev, mode); |
fe62c3a4e vfs: Create fs_co... |
1276 |
return PTR_ERR(s); |
6fcf0c72e vfs: add missing ... |
1277 |
} |
fe62c3a4e vfs: Create fs_co... |
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 |
if (s->s_root) { /* Don't summarily change the RO/RW state. */ if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) { warnf(fc, "%pg: Can't mount, would change RO state", bdev); deactivate_locked_super(s); blkdev_put(bdev, mode); return -EBUSY; } /* * s_umount nests inside bd_mutex during * __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. */ up_write(&s->s_umount); blkdev_put(bdev, mode); down_write(&s->s_umount); } else { s->s_mode = mode; snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); sb_set_blocksize(s, block_size(bdev)); error = fill_super(s, fc); if (error) { deactivate_locked_super(s); return error; } s->s_flags |= SB_ACTIVE; bdev->bd_super = s; } BUG_ON(fc->root); fc->root = dget(s->s_root); return 0; } EXPORT_SYMBOL(get_tree_bdev); |
1da177e4c Linux-2.6.12-rc2 |
1317 1318 1319 1320 |
static int test_bdev_super(struct super_block *s, void *data) { return (void *)s->s_bdev == data; } |
152a08366 new helper: mount... |
1321 |
struct dentry *mount_bdev(struct file_system_type *fs_type, |
1da177e4c Linux-2.6.12-rc2 |
1322 |
int flags, const char *dev_name, void *data, |
152a08366 new helper: mount... |
1323 |
int (*fill_super)(struct super_block *, void *, int)) |
1da177e4c Linux-2.6.12-rc2 |
1324 1325 1326 |
{ struct block_device *bdev; struct super_block *s; |
d4d776299 block: clean up b... |
1327 |
fmode_t mode = FMODE_READ | FMODE_EXCL; |
1da177e4c Linux-2.6.12-rc2 |
1328 |
int error = 0; |
e462ec50c VFS: Differentiat... |
1329 |
if (!(flags & SB_RDONLY)) |
30c40d2c0 [PATCH] propagate... |
1330 |
mode |= FMODE_WRITE; |
d4d776299 block: clean up b... |
1331 |
bdev = blkdev_get_by_path(dev_name, mode, fs_type); |
1da177e4c Linux-2.6.12-rc2 |
1332 |
if (IS_ERR(bdev)) |
152a08366 new helper: mount... |
1333 |
return ERR_CAST(bdev); |
1da177e4c Linux-2.6.12-rc2 |
1334 1335 1336 1337 1338 1339 |
/* * 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 */ |
4fadd7bb2 freeze_bdev: kill... |
1340 1341 1342 1343 1344 1345 |
mutex_lock(&bdev->bd_fsfreeze_mutex); if (bdev->bd_fsfreeze_count > 0) { mutex_unlock(&bdev->bd_fsfreeze_mutex); error = -EBUSY; goto error_bdev; } |
e462ec50c VFS: Differentiat... |
1346 |
s = sget(fs_type, test_bdev_super, set_bdev_super, flags | SB_NOSEC, |
9249e17fe VFS: Pass mount f... |
1347 |
bdev); |
4fadd7bb2 freeze_bdev: kill... |
1348 |
mutex_unlock(&bdev->bd_fsfreeze_mutex); |
1da177e4c Linux-2.6.12-rc2 |
1349 |
if (IS_ERR(s)) |
454e2398b [PATCH] VFS: Perm... |
1350 |
goto error_s; |
1da177e4c Linux-2.6.12-rc2 |
1351 1352 |
if (s->s_root) { |
e462ec50c VFS: Differentiat... |
1353 |
if ((flags ^ s->s_flags) & SB_RDONLY) { |
74dbbdd7f New helper: deact... |
1354 |
deactivate_locked_super(s); |
454e2398b [PATCH] VFS: Perm... |
1355 1356 |
error = -EBUSY; goto error_bdev; |
1da177e4c Linux-2.6.12-rc2 |
1357 |
} |
454e2398b [PATCH] VFS: Perm... |
1358 |
|
4f331f01b vfs: don't hold s... |
1359 1360 |
/* * s_umount nests inside bd_mutex during |
e525fd89d block: make blkde... |
1361 1362 1363 1364 |
* __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. |
4f331f01b vfs: don't hold s... |
1365 1366 |
*/ up_write(&s->s_umount); |
d4d776299 block: clean up b... |
1367 |
blkdev_put(bdev, mode); |
4f331f01b vfs: don't hold s... |
1368 |
down_write(&s->s_umount); |
1da177e4c Linux-2.6.12-rc2 |
1369 |
} else { |
30c40d2c0 [PATCH] propagate... |
1370 |
s->s_mode = mode; |
a1c6f0573 fs: use block_dev... |
1371 |
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); |
e78c9a004 [PATCH] fs: remov... |
1372 |
sb_set_blocksize(s, block_size(bdev)); |
e462ec50c VFS: Differentiat... |
1373 |
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0); |
1da177e4c Linux-2.6.12-rc2 |
1374 |
if (error) { |
74dbbdd7f New helper: deact... |
1375 |
deactivate_locked_super(s); |
454e2398b [PATCH] VFS: Perm... |
1376 |
goto error; |
fa675765a Revert mount/umou... |
1377 |
} |
454e2398b [PATCH] VFS: Perm... |
1378 |
|
e462ec50c VFS: Differentiat... |
1379 |
s->s_flags |= SB_ACTIVE; |
87d8fe1ee add releasepage h... |
1380 |
bdev->bd_super = s; |
1da177e4c Linux-2.6.12-rc2 |
1381 |
} |
152a08366 new helper: mount... |
1382 |
return dget(s->s_root); |
1da177e4c Linux-2.6.12-rc2 |
1383 |
|
454e2398b [PATCH] VFS: Perm... |
1384 1385 1386 |
error_s: error = PTR_ERR(s); error_bdev: |
d4d776299 block: clean up b... |
1387 |
blkdev_put(bdev, mode); |
454e2398b [PATCH] VFS: Perm... |
1388 |
error: |
152a08366 new helper: mount... |
1389 1390 1391 |
return ERR_PTR(error); } EXPORT_SYMBOL(mount_bdev); |
1da177e4c Linux-2.6.12-rc2 |
1392 1393 1394 |
void kill_block_super(struct super_block *sb) { struct block_device *bdev = sb->s_bdev; |
30c40d2c0 [PATCH] propagate... |
1395 |
fmode_t mode = sb->s_mode; |
1da177e4c Linux-2.6.12-rc2 |
1396 |
|
ddbaaf302 NULL noise in fs/... |
1397 |
bdev->bd_super = NULL; |
1da177e4c Linux-2.6.12-rc2 |
1398 1399 |
generic_shutdown_super(sb); sync_blockdev(bdev); |
d4d776299 block: clean up b... |
1400 |
WARN_ON_ONCE(!(mode & FMODE_EXCL)); |
e525fd89d block: make blkde... |
1401 |
blkdev_put(bdev, mode | FMODE_EXCL); |
1da177e4c Linux-2.6.12-rc2 |
1402 1403 1404 |
} EXPORT_SYMBOL(kill_block_super); |
9361401eb [PATCH] BLOCK: Ma... |
1405 |
#endif |
1da177e4c Linux-2.6.12-rc2 |
1406 |
|
3c26ff6e4 convert get_sb_no... |
1407 |
struct dentry *mount_nodev(struct file_system_type *fs_type, |
1da177e4c Linux-2.6.12-rc2 |
1408 |
int flags, void *data, |
3c26ff6e4 convert get_sb_no... |
1409 |
int (*fill_super)(struct super_block *, void *, int)) |
1da177e4c Linux-2.6.12-rc2 |
1410 1411 |
{ int error; |
9249e17fe VFS: Pass mount f... |
1412 |
struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL); |
1da177e4c Linux-2.6.12-rc2 |
1413 1414 |
if (IS_ERR(s)) |
3c26ff6e4 convert get_sb_no... |
1415 |
return ERR_CAST(s); |
1da177e4c Linux-2.6.12-rc2 |
1416 |
|
e462ec50c VFS: Differentiat... |
1417 |
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0); |
1da177e4c Linux-2.6.12-rc2 |
1418 |
if (error) { |
74dbbdd7f New helper: deact... |
1419 |
deactivate_locked_super(s); |
3c26ff6e4 convert get_sb_no... |
1420 |
return ERR_PTR(error); |
1da177e4c Linux-2.6.12-rc2 |
1421 |
} |
e462ec50c VFS: Differentiat... |
1422 |
s->s_flags |= SB_ACTIVE; |
3c26ff6e4 convert get_sb_no... |
1423 |
return dget(s->s_root); |
1da177e4c Linux-2.6.12-rc2 |
1424 |
} |
3c26ff6e4 convert get_sb_no... |
1425 |
EXPORT_SYMBOL(mount_nodev); |
8d0347f6c convert do_remoun... |
1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 |
static int reconfigure_single(struct super_block *s, int flags, void *data) { struct fs_context *fc; int ret; /* The caller really need to be passing fc down into mount_single(), * then a chunk of this can be removed. [Bollocks -- AV] * Better yet, reconfiguration shouldn't happen, but rather the second * mount should be rejected if the parameters are not compatible. */ fc = fs_context_for_reconfigure(s->s_root, flags, MS_RMT_MASK); if (IS_ERR(fc)) return PTR_ERR(fc); ret = parse_monolithic_mount_data(fc, data); if (ret < 0) goto out; ret = reconfigure_super(fc); out: put_fs_context(fc); return ret; } |
1da177e4c Linux-2.6.12-rc2 |
1450 1451 1452 1453 |
static int compare_single(struct super_block *s, void *p) { return 1; } |
fc14f2fef convert get_sb_si... |
1454 |
struct dentry *mount_single(struct file_system_type *fs_type, |
1da177e4c Linux-2.6.12-rc2 |
1455 |
int flags, void *data, |
fc14f2fef convert get_sb_si... |
1456 |
int (*fill_super)(struct super_block *, void *, int)) |
1da177e4c Linux-2.6.12-rc2 |
1457 1458 1459 |
{ struct super_block *s; int error; |
9249e17fe VFS: Pass mount f... |
1460 |
s = sget(fs_type, compare_single, set_anon_super, flags, NULL); |
1da177e4c Linux-2.6.12-rc2 |
1461 |
if (IS_ERR(s)) |
fc14f2fef convert get_sb_si... |
1462 |
return ERR_CAST(s); |
1da177e4c Linux-2.6.12-rc2 |
1463 |
if (!s->s_root) { |
e462ec50c VFS: Differentiat... |
1464 |
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0); |
8d0347f6c convert do_remoun... |
1465 1466 |
if (!error) s->s_flags |= SB_ACTIVE; |
9329d1bea vfs: get_sb_singl... |
1467 |
} else { |
8d0347f6c convert do_remoun... |
1468 1469 1470 1471 1472 |
error = reconfigure_single(s, flags, data); } if (unlikely(error)) { deactivate_locked_super(s); return ERR_PTR(error); |
1da177e4c Linux-2.6.12-rc2 |
1473 |
} |
fc14f2fef convert get_sb_si... |
1474 1475 1476 |
return dget(s->s_root); } EXPORT_SYMBOL(mount_single); |
9bc61ab18 vfs: Introduce fs... |
1477 1478 1479 1480 1481 1482 1483 1484 1485 |
/** * vfs_get_tree - Get the mountable root * @fc: The superblock configuration context. * * The filesystem is invoked to get or create a superblock which can then later * be used for mounting. The filesystem places a pointer to the root to be * used for mounting in @fc->root. */ int vfs_get_tree(struct fs_context *fc) |
1da177e4c Linux-2.6.12-rc2 |
1486 |
{ |
9d412a43c vfs: split off vf... |
1487 |
struct super_block *sb; |
9bc61ab18 vfs: Introduce fs... |
1488 |
int error; |
8089352a1 Mirror MS_KERNMOU... |
1489 |
|
f3a09c920 introduce fs_cont... |
1490 1491 1492 1493 1494 1495 1496 |
if (fc->root) return -EBUSY; /* Get the mountable root in fc->root, with a ref on the root and a ref * on the superblock. */ error = fc->ops->get_tree(fc); |
9bc61ab18 vfs: Introduce fs... |
1497 1498 |
if (error < 0) return error; |
1da177e4c Linux-2.6.12-rc2 |
1499 |
|
f3a09c920 introduce fs_cont... |
1500 1501 1502 1503 1504 1505 1506 1507 1508 |
if (!fc->root) { pr_err("Filesystem %s get_tree() didn't set fc->root ", fc->fs_type->name); /* We don't know what the locking state of the superblock is - * if there is a superblock. */ BUG(); } |
9bc61ab18 vfs: Introduce fs... |
1509 |
sb = fc->root->d_sb; |
9d412a43c vfs: split off vf... |
1510 |
WARN_ON(!sb->s_bdi); |
79f546a69 fs: don't scan th... |
1511 1512 1513 1514 1515 1516 1517 1518 |
/* * Write barrier is for super_cache_count(). We place it before setting * SB_BORN as the data dependency between the two functions is the * superblock structure contents that we just set up, not the SB_BORN * flag. */ smp_wmb(); |
e462ec50c VFS: Differentiat... |
1519 |
sb->s_flags |= SB_BORN; |
454e2398b [PATCH] VFS: Perm... |
1520 |
|
9bc61ab18 vfs: Introduce fs... |
1521 |
error = security_sb_set_mnt_opts(sb, fc->security, 0, NULL); |
c9ce29ed7 vfs_get_tree(): e... |
1522 1523 1524 |
if (unlikely(error)) { fc_drop_locked(fc); return error; |
a10d7c22b LSM: split ->sb_s... |
1525 |
} |
42cb56ae2 vfs: change sb->s... |
1526 1527 1528 1529 |
/* * 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 |
4358b5678 VFS: trivial: fix... |
1530 |
* violate this rule. |
42cb56ae2 vfs: change sb->s... |
1531 |
*/ |
9d412a43c vfs: split off vf... |
1532 |
WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to " |
9bc61ab18 vfs: Introduce fs... |
1533 1534 |
"negative value (%lld) ", fc->fs_type->name, sb->s_maxbytes); |
42cb56ae2 vfs: change sb->s... |
1535 |
|
9bc61ab18 vfs: Introduce fs... |
1536 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
1537 |
} |
9bc61ab18 vfs: Introduce fs... |
1538 |
EXPORT_SYMBOL(vfs_get_tree); |
1da177e4c Linux-2.6.12-rc2 |
1539 |
|
5accdf82b fs: Improve files... |
1540 |
/* |
fca39346a fs: Provide infra... |
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 |
* Setup private BDI for given superblock. It gets automatically cleaned up * in generic_shutdown_super(). */ int super_setup_bdi_name(struct super_block *sb, char *fmt, ...) { struct backing_dev_info *bdi; int err; va_list args; bdi = bdi_alloc(GFP_KERNEL); if (!bdi) return -ENOMEM; bdi->name = sb->s_type->name; va_start(args, fmt); |
7c4cc3002 bdi: Drop 'parent... |
1557 |
err = bdi_register_va(bdi, fmt, args); |
fca39346a fs: Provide infra... |
1558 1559 1560 1561 1562 1563 1564 |
va_end(args); if (err) { bdi_put(bdi); return err; } WARN_ON(sb->s_bdi != &noop_backing_dev_info); sb->s_bdi = bdi; |
fca39346a fs: Provide infra... |
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 |
return 0; } EXPORT_SYMBOL(super_setup_bdi_name); /* * Setup private BDI for given superblock. I gets automatically cleaned up * in generic_shutdown_super(). */ int super_setup_bdi(struct super_block *sb) { static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0); return super_setup_bdi_name(sb, "%.28s-%ld", sb->s_type->name, atomic_long_inc_return(&bdi_seq)); } EXPORT_SYMBOL(super_setup_bdi); /* |
5accdf82b fs: Improve files... |
1584 1585 1586 1587 1588 |
* This is an internal function, please use sb_end_{write,pagefault,intwrite} * instead. */ void __sb_end_write(struct super_block *sb, int level) { |
8129ed296 change sb_writers... |
1589 |
percpu_up_read(sb->s_writers.rw_sem + level-1); |
5accdf82b fs: Improve files... |
1590 1591 |
} EXPORT_SYMBOL(__sb_end_write); |
f4b554af9 fix the broken lo... |
1592 1593 1594 1595 1596 1597 1598 |
/* * 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) { bool force_trylock = false; |
8129ed296 change sb_writers... |
1599 |
int ret = 1; |
f4b554af9 fix the broken lo... |
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 |
#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 use wait == F (trylock mode) which must not fail. */ if (wait) { int i; for (i = 0; i < level - 1; i++) |
8129ed296 change sb_writers... |
1615 |
if (percpu_rwsem_is_held(sb->s_writers.rw_sem + i)) { |
f4b554af9 fix the broken lo... |
1616 1617 1618 1619 1620 |
force_trylock = true; break; } } #endif |
8129ed296 change sb_writers... |
1621 1622 1623 1624 |
if (wait && !force_trylock) percpu_down_read(sb->s_writers.rw_sem + level-1); else ret = percpu_down_read_trylock(sb->s_writers.rw_sem + level-1); |
22224a175 fs/super.c: use &... |
1625 |
WARN_ON(force_trylock && !ret); |
f4b554af9 fix the broken lo... |
1626 1627 |
return ret; } |
5accdf82b fs: Improve files... |
1628 1629 1630 1631 1632 1633 1634 1635 |
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 |
8129ed296 change sb_writers... |
1636 |
* system. |
5accdf82b fs: Improve files... |
1637 1638 1639 |
*/ static void sb_wait_write(struct super_block *sb, int level) { |
8129ed296 change sb_writers... |
1640 |
percpu_down_write(sb->s_writers.rw_sem + level-1); |
8129ed296 change sb_writers... |
1641 |
} |
5accdf82b fs: Improve files... |
1642 |
|
f1a962203 fs/super.c: don't... |
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 |
/* * We are going to return to userspace and forget about these locks, the * ownership goes to the caller of thaw_super() which does unlock(). */ static void lockdep_sb_freeze_release(struct super_block *sb) { int level; for (level = SB_FREEZE_LEVELS - 1; level >= 0; level--) percpu_rwsem_release(sb->s_writers.rw_sem + level, 0, _THIS_IP_); } /* * Tell lockdep we are holding these locks before we call ->unfreeze_fs(sb). */ static void lockdep_sb_freeze_acquire(struct super_block *sb) |
8129ed296 change sb_writers... |
1659 1660 |
{ int level; |
5accdf82b fs: Improve files... |
1661 |
|
8129ed296 change sb_writers... |
1662 1663 |
for (level = 0; level < SB_FREEZE_LEVELS; ++level) percpu_rwsem_acquire(sb->s_writers.rw_sem + level, 0, _THIS_IP_); |
f1a962203 fs/super.c: don't... |
1664 1665 1666 1667 1668 |
} static void sb_freeze_unlock(struct super_block *sb) { int level; |
5accdf82b fs: Improve files... |
1669 |
|
8129ed296 change sb_writers... |
1670 1671 |
for (level = SB_FREEZE_LEVELS - 1; level >= 0; level--) percpu_up_write(sb->s_writers.rw_sem + level); |
5accdf82b fs: Improve files... |
1672 |
} |
18e9e5104 Introduce freeze_... |
1673 |
/** |
7000d3c42 fs/super: fix ker... |
1674 1675 |
* freeze_super - lock the filesystem and force it into a consistent state * @sb: the super to lock |
18e9e5104 Introduce freeze_... |
1676 1677 1678 1679 |
* * 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. |
5accdf82b fs: Improve files... |
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 |
* * 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. |
18e9e5104 Introduce freeze_... |
1705 1706 1707 1708 1709 1710 1711 |
*/ int freeze_super(struct super_block *sb) { int ret; atomic_inc(&sb->s_active); down_write(&sb->s_umount); |
5accdf82b fs: Improve files... |
1712 |
if (sb->s_writers.frozen != SB_UNFROZEN) { |
18e9e5104 Introduce freeze_... |
1713 1714 1715 |
deactivate_locked_super(sb); return -EBUSY; } |
e462ec50c VFS: Differentiat... |
1716 |
if (!(sb->s_flags & SB_BORN)) { |
dabe0dc19 vfs: fix the rest... |
1717 1718 1719 |
up_write(&sb->s_umount); return 0; /* sic - it's "nothing to do" */ } |
bc98a42c1 VFS: Convert sb->... |
1720 |
if (sb_rdonly(sb)) { |
5accdf82b fs: Improve files... |
1721 1722 |
/* Nothing to do really... */ sb->s_writers.frozen = SB_FREEZE_COMPLETE; |
18e9e5104 Introduce freeze_... |
1723 1724 1725 |
up_write(&sb->s_umount); return 0; } |
5accdf82b fs: Improve files... |
1726 |
sb->s_writers.frozen = SB_FREEZE_WRITE; |
5accdf82b fs: Improve files... |
1727 1728 |
/* Release s_umount to preserve sb_start_write -> s_umount ordering */ up_write(&sb->s_umount); |
5accdf82b fs: Improve files... |
1729 |
sb_wait_write(sb, SB_FREEZE_WRITE); |
8129ed296 change sb_writers... |
1730 |
down_write(&sb->s_umount); |
5accdf82b fs: Improve files... |
1731 1732 |
/* Now we go and block page faults... */ |
5accdf82b fs: Improve files... |
1733 |
sb->s_writers.frozen = SB_FREEZE_PAGEFAULT; |
5accdf82b fs: Improve files... |
1734 1735 1736 |
sb_wait_write(sb, SB_FREEZE_PAGEFAULT); /* All writers are done so after syncing there won't be dirty data */ |
18e9e5104 Introduce freeze_... |
1737 |
sync_filesystem(sb); |
5accdf82b fs: Improve files... |
1738 1739 |
/* Now wait for internal filesystem counter */ sb->s_writers.frozen = SB_FREEZE_FS; |
5accdf82b fs: Improve files... |
1740 |
sb_wait_write(sb, SB_FREEZE_FS); |
18e9e5104 Introduce freeze_... |
1741 |
|
18e9e5104 Introduce freeze_... |
1742 1743 1744 1745 1746 1747 |
if (sb->s_op->freeze_fs) { ret = sb->s_op->freeze_fs(sb); if (ret) { printk(KERN_ERR "VFS:Filesystem freeze failed "); |
5accdf82b fs: Improve files... |
1748 |
sb->s_writers.frozen = SB_UNFROZEN; |
8129ed296 change sb_writers... |
1749 |
sb_freeze_unlock(sb); |
5accdf82b fs: Improve files... |
1750 |
wake_up(&sb->s_writers.wait_unfrozen); |
18e9e5104 Introduce freeze_... |
1751 1752 1753 1754 |
deactivate_locked_super(sb); return ret; } } |
5accdf82b fs: Improve files... |
1755 |
/* |
89f39af12 fs/super.c: fix r... |
1756 1757 |
* For debugging purposes so that fs can warn if it sees write activity * when frozen is set to SB_FREEZE_COMPLETE, and for thaw_super(). |
5accdf82b fs: Improve files... |
1758 1759 |
*/ sb->s_writers.frozen = SB_FREEZE_COMPLETE; |
f1a962203 fs/super.c: don't... |
1760 |
lockdep_sb_freeze_release(sb); |
18e9e5104 Introduce freeze_... |
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 |
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(). */ |
08fdc8a01 buffer.c: call th... |
1772 |
static int thaw_super_locked(struct super_block *sb) |
18e9e5104 Introduce freeze_... |
1773 1774 |
{ int error; |
89f39af12 fs/super.c: fix r... |
1775 |
if (sb->s_writers.frozen != SB_FREEZE_COMPLETE) { |
18e9e5104 Introduce freeze_... |
1776 1777 1778 |
up_write(&sb->s_umount); return -EINVAL; } |
bc98a42c1 VFS: Convert sb->... |
1779 |
if (sb_rdonly(sb)) { |
8129ed296 change sb_writers... |
1780 |
sb->s_writers.frozen = SB_UNFROZEN; |
18e9e5104 Introduce freeze_... |
1781 |
goto out; |
8129ed296 change sb_writers... |
1782 |
} |
18e9e5104 Introduce freeze_... |
1783 |
|
f1a962203 fs/super.c: don't... |
1784 |
lockdep_sb_freeze_acquire(sb); |
18e9e5104 Introduce freeze_... |
1785 1786 1787 1788 1789 1790 |
if (sb->s_op->unfreeze_fs) { error = sb->s_op->unfreeze_fs(sb); if (error) { printk(KERN_ERR "VFS:Filesystem thaw failed "); |
f1a962203 fs/super.c: don't... |
1791 |
lockdep_sb_freeze_release(sb); |
18e9e5104 Introduce freeze_... |
1792 1793 1794 1795 |
up_write(&sb->s_umount); return error; } } |
5accdf82b fs: Improve files... |
1796 |
sb->s_writers.frozen = SB_UNFROZEN; |
8129ed296 change sb_writers... |
1797 1798 |
sb_freeze_unlock(sb); out: |
5accdf82b fs: Improve files... |
1799 |
wake_up(&sb->s_writers.wait_unfrozen); |
18e9e5104 Introduce freeze_... |
1800 |
deactivate_locked_super(sb); |
18e9e5104 Introduce freeze_... |
1801 1802 |
return 0; } |
08fdc8a01 buffer.c: call th... |
1803 1804 1805 1806 1807 1808 |
int thaw_super(struct super_block *sb) { down_write(&sb->s_umount); return thaw_super_locked(sb); } |
18e9e5104 Introduce freeze_... |
1809 |
EXPORT_SYMBOL(thaw_super); |