Branch data Line data Source code
1 : : /*
2 : : * linux/fs/super.c
3 : : *
4 : : * Copyright (C) 1991, 1992 Linus Torvalds
5 : : *
6 : : * super.c contains code to handle: - mount structures
7 : : * - super-block tables
8 : : * - filesystem drivers list
9 : : * - mount system call
10 : : * - umount system call
11 : : * - ustat system call
12 : : *
13 : : * GK 2/5/95 - Changed to support mounting the root fs via NFS
14 : : *
15 : : * Added kerneld support: Jacques Gelinas and Bjorn Ekwall
16 : : * Added change_root: Werner Almesberger & Hans Lermen, Feb '96
17 : : * Added options to /proc/mounts:
18 : : * Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
19 : : * Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
20 : : * Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
21 : : */
22 : :
23 : : #include <linux/export.h>
24 : : #include <linux/slab.h>
25 : : #include <linux/acct.h>
26 : : #include <linux/blkdev.h>
27 : : #include <linux/mount.h>
28 : : #include <linux/security.h>
29 : : #include <linux/writeback.h> /* for the emergency remount stuff */
30 : : #include <linux/idr.h>
31 : : #include <linux/mutex.h>
32 : : #include <linux/backing-dev.h>
33 : : #include <linux/rculist_bl.h>
34 : : #include <linux/cleancache.h>
35 : : #include <linux/fsnotify.h>
36 : : #include <linux/lockdep.h>
37 : : #include "internal.h"
38 : :
39 : :
40 : : LIST_HEAD(super_blocks);
41 : : DEFINE_SPINLOCK(sb_lock);
42 : :
43 : : static char *sb_writers_name[SB_FREEZE_LEVELS] = {
44 : : "sb_writers",
45 : : "sb_pagefaults",
46 : : "sb_internal",
47 : : };
48 : :
49 : : /*
50 : : * One thing we have to be careful of with a per-sb shrinker is that we don't
51 : : * drop the last active reference to the superblock from within the shrinker.
52 : : * If that happens we could trigger unregistering the shrinker from within the
53 : : * shrinker path and that leads to deadlock on the shrinker_rwsem. Hence we
54 : : * take a passive reference to the superblock to avoid this from occurring.
55 : : */
56 : 0 : static unsigned long super_cache_scan(struct shrinker *shrink,
57 : : struct shrink_control *sc)
58 : : {
59 : : struct super_block *sb;
60 : : long fs_objects = 0;
61 : : long total_objects;
62 : : long freed = 0;
63 : : long dentries;
64 : : long inodes;
65 : :
66 : 65 : sb = container_of(shrink, struct super_block, s_shrink);
67 : :
68 : : /*
69 : : * Deadlock avoidance. We may hold various FS locks, and we don't want
70 : : * to recurse into the FS that called us in clear_inode() and friends..
71 : : */
72 [ + - ]: 65 : if (!(sc->gfp_mask & __GFP_FS))
73 : : return SHRINK_STOP;
74 : :
75 [ + - ]: 65 : if (!grab_super_passive(sb))
76 : : return SHRINK_STOP;
77 : :
78 [ - + ]: 65 : if (sb->s_op->nr_cached_objects)
79 : 0 : fs_objects = sb->s_op->nr_cached_objects(sb, sc->nid);
80 : :
81 : 65 : inodes = list_lru_count_node(&sb->s_inode_lru, sc->nid);
82 : 65 : dentries = list_lru_count_node(&sb->s_dentry_lru, sc->nid);
83 : 65 : total_objects = dentries + inodes + fs_objects + 1;
84 : :
85 : : /* proportion the scan between the caches */
86 : 65 : dentries = mult_frac(sc->nr_to_scan, dentries, total_objects);
87 : 65 : inodes = mult_frac(sc->nr_to_scan, inodes, total_objects);
88 : :
89 : : /*
90 : : * prune the dcache first as the icache is pinned by it, then
91 : : * prune the icache, followed by the filesystem specific caches
92 : : */
93 : 65 : freed = prune_dcache_sb(sb, dentries, sc->nid);
94 : 65 : freed += prune_icache_sb(sb, inodes, sc->nid);
95 : :
96 [ - + ]: 65 : if (fs_objects) {
97 : 0 : fs_objects = mult_frac(sc->nr_to_scan, fs_objects,
98 : : total_objects);
99 : 0 : freed += sb->s_op->free_cached_objects(sb, fs_objects,
100 : : sc->nid);
101 : : }
102 : :
103 : : drop_super(sb);
104 : 65 : return freed;
105 : : }
106 : :
107 : 0 : static unsigned long super_cache_count(struct shrinker *shrink,
108 : : struct shrink_control *sc)
109 : : {
110 : : struct super_block *sb;
111 : : long total_objects = 0;
112 : :
113 : 16237547 : sb = container_of(shrink, struct super_block, s_shrink);
114 : :
115 [ + ]: 16237547 : if (!grab_super_passive(sb))
116 : : return 0;
117 : :
118 [ + ][ - + ]: 16272194 : if (sb->s_op && sb->s_op->nr_cached_objects)
119 : 0 : total_objects = sb->s_op->nr_cached_objects(sb,
120 : : sc->nid);
121 : :
122 : 16272194 : total_objects += list_lru_count_node(&sb->s_dentry_lru,
123 : : sc->nid);
124 : 16281628 : total_objects += list_lru_count_node(&sb->s_inode_lru,
125 : : sc->nid);
126 : :
127 : : total_objects = vfs_pressure_ratio(total_objects);
128 : : drop_super(sb);
129 : 16282661 : return total_objects;
130 : : }
131 : :
132 : : /**
133 : : * destroy_super - frees a superblock
134 : : * @s: superblock to free
135 : : *
136 : : * Frees a superblock.
137 : : */
138 : 0 : static void destroy_super(struct super_block *s)
139 : : {
140 : : int i;
141 : 3 : list_lru_destroy(&s->s_dentry_lru);
142 : 3 : list_lru_destroy(&s->s_inode_lru);
143 [ + + ]: 12 : for (i = 0; i < SB_FREEZE_LEVELS; i++)
144 : 9 : percpu_counter_destroy(&s->s_writers.counter[i]);
145 : 3 : security_sb_free(s);
146 [ - + ]: 3 : WARN_ON(!list_empty(&s->s_mounts));
147 : 3 : kfree(s->s_subtype);
148 : 3 : kfree(s->s_options);
149 : 3 : kfree_rcu(s, rcu);
150 : 3 : }
151 : :
152 : : /**
153 : : * alloc_super - create new superblock
154 : : * @type: filesystem type superblock should belong to
155 : : * @flags: the mount flags
156 : : *
157 : : * Allocates and initializes a new &struct super_block. alloc_super()
158 : : * returns a pointer new superblock or %NULL if allocation had failed.
159 : : */
160 : 3 : static struct super_block *alloc_super(struct file_system_type *type, int flags)
161 : : {
162 : : struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
163 : : static const struct super_operations default_op;
164 : : int i;
165 : :
166 [ + - ]: 3 : if (!s)
167 : : return NULL;
168 : :
169 [ + - ]: 3 : if (security_sb_alloc(s))
170 : : goto fail;
171 : :
172 [ + + ]: 12 : for (i = 0; i < SB_FREEZE_LEVELS; i++) {
173 [ + - ]: 9 : if (percpu_counter_init(&s->s_writers.counter[i], 0) < 0)
174 : : goto fail;
175 : : lockdep_init_map(&s->s_writers.lock_map[i], sb_writers_name[i],
176 : : &type->s_writers_key[i], 0);
177 : : }
178 : 3 : init_waitqueue_head(&s->s_writers.wait);
179 : 3 : init_waitqueue_head(&s->s_writers.wait_unfrozen);
180 : 3 : s->s_flags = flags;
181 : 3 : s->s_bdi = &default_backing_dev_info;
182 : : INIT_HLIST_NODE(&s->s_instances);
183 : 3 : INIT_HLIST_BL_HEAD(&s->s_anon);
184 : 3 : INIT_LIST_HEAD(&s->s_inodes);
185 : :
186 [ + - ]: 3 : if (list_lru_init(&s->s_dentry_lru))
187 : : goto fail;
188 [ + - ]: 3 : if (list_lru_init(&s->s_inode_lru))
189 : : goto fail;
190 : :
191 : 3 : INIT_LIST_HEAD(&s->s_mounts);
192 : 3 : init_rwsem(&s->s_umount);
193 : : lockdep_set_class(&s->s_umount, &type->s_umount_key);
194 : : /*
195 : : * sget() can have s_umount recursion.
196 : : *
197 : : * When it cannot find a suitable sb, it allocates a new
198 : : * one (this one), and tries again to find a suitable old
199 : : * one.
200 : : *
201 : : * In case that succeeds, it will acquire the s_umount
202 : : * lock of the old one. Since these are clearly distrinct
203 : : * locks, and this object isn't exposed yet, there's no
204 : : * risk of deadlocks.
205 : : *
206 : : * Annotate this by putting this lock in a different
207 : : * subclass.
208 : : */
209 : 3 : down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
210 : 3 : s->s_count = 1;
211 : 3 : atomic_set(&s->s_active, 1);
212 : 3 : mutex_init(&s->s_vfs_rename_mutex);
213 : : lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
214 : 3 : mutex_init(&s->s_dquot.dqio_mutex);
215 : 3 : mutex_init(&s->s_dquot.dqonoff_mutex);
216 : 3 : init_rwsem(&s->s_dquot.dqptr_sem);
217 : 3 : s->s_maxbytes = MAX_NON_LFS;
218 : 3 : s->s_op = &default_op;
219 : 3 : s->s_time_gran = 1000000000;
220 : 3 : s->cleancache_poolid = -1;
221 : :
222 : 3 : s->s_shrink.seeks = DEFAULT_SEEKS;
223 : 3 : s->s_shrink.scan_objects = super_cache_scan;
224 : 3 : s->s_shrink.count_objects = super_cache_count;
225 : 3 : s->s_shrink.batch = 1024;
226 : 3 : s->s_shrink.flags = SHRINKER_NUMA_AWARE;
227 : : return s;
228 : :
229 : : fail:
230 : 0 : destroy_super(s);
231 : : return NULL;
232 : : }
233 : :
234 : : /* Superblock refcounting */
235 : :
236 : : /*
237 : : * Drop a superblock's refcount. The caller must hold sb_lock.
238 : : */
239 : 0 : static void __put_super(struct super_block *sb)
240 : : {
241 [ + + ]: 16483137 : if (!--sb->s_count) {
242 : 3 : list_del_init(&sb->s_list);
243 : 3 : destroy_super(sb);
244 : : }
245 : 0 : }
246 : :
247 : : /**
248 : : * put_super - drop a temporary reference to superblock
249 : : * @sb: superblock in question
250 : : *
251 : : * Drops a temporary reference, frees superblock if there's no
252 : : * references left.
253 : : */
254 : 0 : static void put_super(struct super_block *sb)
255 : : {
256 : : spin_lock(&sb_lock);
257 : 16288129 : __put_super(sb);
258 : : spin_unlock(&sb_lock);
259 : 16288129 : }
260 : :
261 : :
262 : : /**
263 : : * deactivate_locked_super - drop an active reference to superblock
264 : : * @s: superblock to deactivate
265 : : *
266 : : * Drops an active reference to superblock, converting it into a temprory
267 : : * one if there is no other active references left. In that case we
268 : : * tell fs driver to shut it down and drop the temporary reference we
269 : : * had just acquired.
270 : : *
271 : : * Caller holds exclusive lock on superblock; that lock is released.
272 : : */
273 : 0 : void deactivate_locked_super(struct super_block *s)
274 : : {
275 : 3 : struct file_system_type *fs = s->s_type;
276 [ + - ]: 3 : if (atomic_dec_and_test(&s->s_active)) {
277 : : cleancache_invalidate_fs(s);
278 : 3 : fs->kill_sb(s);
279 : :
280 : : /* caches are now gone, we can safely kill the shrinker now */
281 : 3 : unregister_shrinker(&s->s_shrink);
282 : :
283 : 3 : put_filesystem(fs);
284 : 3 : put_super(s);
285 : : } else {
286 : 0 : up_write(&s->s_umount);
287 : : }
288 : 3 : }
289 : :
290 : : EXPORT_SYMBOL(deactivate_locked_super);
291 : :
292 : : /**
293 : : * deactivate_super - drop an active reference to superblock
294 : : * @s: superblock to deactivate
295 : : *
296 : : * Variant of deactivate_locked_super(), except that superblock is *not*
297 : : * locked by caller. If we are going to drop the final active reference,
298 : : * lock will be acquired prior to that.
299 : : */
300 : 0 : void deactivate_super(struct super_block *s)
301 : : {
302 [ + + ]: 1291 : if (!atomic_add_unless(&s->s_active, -1, 1)) {
303 : 3 : down_write(&s->s_umount);
304 : 3 : deactivate_locked_super(s);
305 : : }
306 : 0 : }
307 : :
308 : : EXPORT_SYMBOL(deactivate_super);
309 : :
310 : : /**
311 : : * grab_super - acquire an active reference
312 : : * @s: reference we are trying to make active
313 : : *
314 : : * Tries to acquire an active reference. grab_super() is used when we
315 : : * had just found a superblock in super_blocks or fs_type->fs_supers
316 : : * and want to turn it into a full-blown active reference. grab_super()
317 : : * is called with sb_lock held and drops it. Returns 1 in case of
318 : : * success, 0 if we had failed (superblock contents was already dead or
319 : : * dying when grab_super() had been called). Note that this is only
320 : : * called for superblocks not in rundown mode (== ones still on ->fs_supers
321 : : * of their type), so increment of ->s_count is OK here.
322 : : */
323 : 0 : static int grab_super(struct super_block *s) __releases(sb_lock)
324 : : {
325 : 0 : s->s_count++;
326 : : spin_unlock(&sb_lock);
327 : 0 : down_write(&s->s_umount);
328 [ # # ][ # # ]: 0 : if ((s->s_flags & MS_BORN) && atomic_inc_not_zero(&s->s_active)) {
329 : 0 : put_super(s);
330 : 0 : return 1;
331 : : }
332 : 0 : up_write(&s->s_umount);
333 : 0 : put_super(s);
334 : 0 : return 0;
335 : : }
336 : :
337 : : /*
338 : : * grab_super_passive - acquire a passive reference
339 : : * @sb: reference we are trying to grab
340 : : *
341 : : * Tries to acquire a passive reference. This is used in places where we
342 : : * cannot take an active reference but we need to ensure that the
343 : : * superblock does not go away while we are working on it. It returns
344 : : * false if a reference was not gained, and returns true with the s_umount
345 : : * lock held in read mode if a reference is gained. On successful return,
346 : : * the caller must drop the s_umount lock and the passive reference when
347 : : * done.
348 : : */
349 : 0 : bool grab_super_passive(struct super_block *sb)
350 : : {
351 : : spin_lock(&sb_lock);
352 [ - + ]: 16288124 : if (hlist_unhashed(&sb->s_instances)) {
353 : : spin_unlock(&sb_lock);
354 : 0 : return false;
355 : : }
356 : :
357 : 16288124 : sb->s_count++;
358 : : spin_unlock(&sb_lock);
359 : :
360 [ + ]: 16288105 : if (down_read_trylock(&sb->s_umount)) {
361 [ + + ][ - + ]: 16287864 : if (sb->s_root && (sb->s_flags & MS_BORN))
362 : : return true;
363 : 1 : up_read(&sb->s_umount);
364 : : }
365 : :
366 : 0 : put_super(sb);
367 : 0 : return false;
368 : : }
369 : :
370 : : /**
371 : : * generic_shutdown_super - common helper for ->kill_sb()
372 : : * @sb: superblock to kill
373 : : *
374 : : * generic_shutdown_super() does all fs-independent work on superblock
375 : : * shutdown. Typical ->kill_sb() should pick all fs-specific objects
376 : : * that need destruction out of superblock, call generic_shutdown_super()
377 : : * and release aforementioned objects. Note: dentries and inodes _are_
378 : : * taken care of and do not need specific handling.
379 : : *
380 : : * Upon calling this function, the filesystem may no longer alter or
381 : : * rearrange the set of dentries belonging to this super_block, nor may it
382 : : * change the attachments of dentries to inodes.
383 : : */
384 : 0 : void generic_shutdown_super(struct super_block *sb)
385 : : {
386 : 3 : const struct super_operations *sop = sb->s_op;
387 : :
388 [ + - ]: 3 : if (sb->s_root) {
389 : 3 : shrink_dcache_for_umount(sb);
390 : 3 : sync_filesystem(sb);
391 : 3 : sb->s_flags &= ~MS_ACTIVE;
392 : :
393 : 3 : fsnotify_unmount_inodes(&sb->s_inodes);
394 : :
395 : 3 : evict_inodes(sb);
396 : :
397 [ - + ]: 3 : if (sb->s_dio_done_wq) {
398 : 0 : destroy_workqueue(sb->s_dio_done_wq);
399 : 0 : sb->s_dio_done_wq = NULL;
400 : : }
401 : :
402 [ - + ]: 3 : if (sop->put_super)
403 : 0 : sop->put_super(sb);
404 : :
405 [ - + ]: 3 : if (!list_empty(&sb->s_inodes)) {
406 : 0 : printk("VFS: Busy inodes after unmount of %s. "
407 : : "Self-destruct in 5 seconds. Have a nice day...\n",
408 : 0 : sb->s_id);
409 : : }
410 : : }
411 : : spin_lock(&sb_lock);
412 : : /* should be initialized for __put_super_and_need_restart() */
413 : : hlist_del_init(&sb->s_instances);
414 : : spin_unlock(&sb_lock);
415 : 3 : up_write(&sb->s_umount);
416 : 3 : }
417 : :
418 : : EXPORT_SYMBOL(generic_shutdown_super);
419 : :
420 : : /**
421 : : * sget - find or create a superblock
422 : : * @type: filesystem type superblock should belong to
423 : : * @test: comparison callback
424 : : * @set: setup callback
425 : : * @flags: mount flags
426 : : * @data: argument to each of them
427 : : */
428 : 6 : struct super_block *sget(struct file_system_type *type,
429 : : int (*test)(struct super_block *,void *),
430 : : int (*set)(struct super_block *,void *),
431 : : int flags,
432 : : void *data)
433 : : {
434 : : struct super_block *s = NULL;
435 : : struct super_block *old;
436 : : int err;
437 : :
438 : : retry:
439 : : spin_lock(&sb_lock);
440 [ + - ]: 6 : if (test) {
441 [ - + ][ # # ]: 6 : hlist_for_each_entry(old, &type->fs_supers, s_instances) {
[ - + ]
442 [ # # ]: 0 : if (!test(old, data))
443 : 0 : continue;
444 [ # # ]: 0 : if (!grab_super(old))
445 : : goto retry;
446 [ # # ]: 0 : if (s) {
447 : 0 : up_write(&s->s_umount);
448 : 0 : destroy_super(s);
449 : : s = NULL;
450 : : }
451 : 0 : return old;
452 : : }
453 : : }
454 [ + + ]: 6 : if (!s) {
455 : : spin_unlock(&sb_lock);
456 : 3 : s = alloc_super(type, flags);
457 [ + - ]: 3 : if (!s)
458 : : return ERR_PTR(-ENOMEM);
459 : : goto retry;
460 : : }
461 : :
462 : 3 : err = set(s, data);
463 [ - + ]: 3 : if (err) {
464 : : spin_unlock(&sb_lock);
465 : 0 : up_write(&s->s_umount);
466 : 0 : destroy_super(s);
467 : 0 : return ERR_PTR(err);
468 : : }
469 : 3 : s->s_type = type;
470 : 3 : strlcpy(s->s_id, type->name, sizeof(s->s_id));
471 : 3 : list_add_tail(&s->s_list, &super_blocks);
472 : 3 : hlist_add_head(&s->s_instances, &type->fs_supers);
473 : : spin_unlock(&sb_lock);
474 : 3 : get_filesystem(type);
475 : 3 : register_shrinker(&s->s_shrink);
476 : 3 : return s;
477 : : }
478 : :
479 : : EXPORT_SYMBOL(sget);
480 : :
481 : 0 : void drop_super(struct super_block *sb)
482 : : {
483 : 16287226 : up_read(&sb->s_umount);
484 : 16287002 : put_super(sb);
485 : 5399 : }
486 : :
487 : : EXPORT_SYMBOL(drop_super);
488 : :
489 : : /**
490 : : * iterate_supers - call function for all active superblocks
491 : : * @f: function to call
492 : : * @arg: argument to pass to it
493 : : *
494 : : * Scans the superblock list and calls given function, passing it
495 : : * locked superblock and given argument.
496 : : */
497 : 0 : void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
498 : : {
499 : : struct super_block *sb, *p = NULL;
500 : :
501 : : spin_lock(&sb_lock);
502 [ + + ]: 203872 : list_for_each_entry(sb, &super_blocks, s_list) {
503 [ - + ]: 195008 : if (hlist_unhashed(&sb->s_instances))
504 : 0 : continue;
505 : 186171 : sb->s_count++;
506 : : spin_unlock(&sb_lock);
507 : :
508 : 195008 : down_read(&sb->s_umount);
509 [ + + ][ + + ]: 195004 : if (sb->s_root && (sb->s_flags & MS_BORN))
510 : 194999 : f(sb, arg);
511 : 194856 : up_read(&sb->s_umount);
512 : :
513 : : spin_lock(&sb_lock);
514 [ + + ]: 195008 : if (p)
515 : 195008 : __put_super(p);
516 : : p = sb;
517 : : }
518 [ + - ]: 8864 : if (p)
519 : 8864 : __put_super(p);
520 : : spin_unlock(&sb_lock);
521 : 8864 : }
522 : :
523 : : /**
524 : : * iterate_supers_type - call function for superblocks of given type
525 : : * @type: fs type
526 : : * @f: function to call
527 : : * @arg: argument to pass to it
528 : : *
529 : : * Scans the superblock list and calls given function, passing it
530 : : * locked superblock and given argument.
531 : : */
532 : 0 : void iterate_supers_type(struct file_system_type *type,
533 : : void (*f)(struct super_block *, void *), void *arg)
534 : : {
535 : : struct super_block *sb, *p = NULL;
536 : :
537 : : spin_lock(&sb_lock);
538 [ # # ][ # # ]: 0 : hlist_for_each_entry(sb, &type->fs_supers, s_instances) {
[ # # ]
539 : 0 : sb->s_count++;
540 : : spin_unlock(&sb_lock);
541 : :
542 : 0 : down_read(&sb->s_umount);
543 [ # # ][ # # ]: 0 : if (sb->s_root && (sb->s_flags & MS_BORN))
544 : 0 : f(sb, arg);
545 : 0 : up_read(&sb->s_umount);
546 : :
547 : : spin_lock(&sb_lock);
548 [ # # ]: 0 : if (p)
549 : 0 : __put_super(p);
550 : : p = sb;
551 : : }
552 [ # # ]: 0 : if (p)
553 : 0 : __put_super(p);
554 : : spin_unlock(&sb_lock);
555 : 0 : }
556 : :
557 : : EXPORT_SYMBOL(iterate_supers_type);
558 : :
559 : : /**
560 : : * get_super - get the superblock of a device
561 : : * @bdev: device to get the superblock for
562 : : *
563 : : * Scans the superblock list and finds the superblock of the file system
564 : : * mounted on the device given. %NULL is returned if no match is found.
565 : : */
566 : :
567 : 0 : struct super_block *get_super(struct block_device *bdev)
568 : : {
569 : : struct super_block *sb;
570 : :
571 [ # # ]: 0 : if (!bdev)
572 : : return NULL;
573 : :
574 : : spin_lock(&sb_lock);
575 : : rescan:
576 [ # # ]: 0 : list_for_each_entry(sb, &super_blocks, s_list) {
577 [ # # ]: 0 : if (hlist_unhashed(&sb->s_instances))
578 : 0 : continue;
579 [ # # ]: 0 : if (sb->s_bdev == bdev) {
580 : 0 : sb->s_count++;
581 : : spin_unlock(&sb_lock);
582 : 0 : down_read(&sb->s_umount);
583 : : /* still alive? */
584 [ # # ][ # # ]: 0 : if (sb->s_root && (sb->s_flags & MS_BORN))
585 : : return sb;
586 : 0 : up_read(&sb->s_umount);
587 : : /* nope, got unmounted */
588 : : spin_lock(&sb_lock);
589 : 0 : __put_super(sb);
590 : 0 : goto rescan;
591 : : }
592 : : }
593 : : spin_unlock(&sb_lock);
594 : 0 : return NULL;
595 : : }
596 : :
597 : : EXPORT_SYMBOL(get_super);
598 : :
599 : : /**
600 : : * get_super_thawed - get thawed superblock of a device
601 : : * @bdev: device to get the superblock for
602 : : *
603 : : * Scans the superblock list and finds the superblock of the file system
604 : : * mounted on the device. The superblock is returned once it is thawed
605 : : * (or immediately if it was not frozen). %NULL is returned if no match
606 : : * is found.
607 : : */
608 : 0 : struct super_block *get_super_thawed(struct block_device *bdev)
609 : : {
610 : : while (1) {
611 : 0 : struct super_block *s = get_super(bdev);
612 [ # # ][ # # ]: 0 : if (!s || s->s_writers.frozen == SB_UNFROZEN)
613 : 0 : return s;
614 : 0 : up_read(&s->s_umount);
615 [ # # ][ # # ]: 0 : wait_event(s->s_writers.wait_unfrozen,
616 : : s->s_writers.frozen == SB_UNFROZEN);
617 : 0 : put_super(s);
618 : 0 : }
619 : : }
620 : : EXPORT_SYMBOL(get_super_thawed);
621 : :
622 : : /**
623 : : * get_active_super - get an active reference to the superblock of a device
624 : : * @bdev: device to get the superblock for
625 : : *
626 : : * Scans the superblock list and finds the superblock of the file system
627 : : * mounted on the device given. Returns the superblock with an active
628 : : * reference or %NULL if none was found.
629 : : */
630 : 0 : struct super_block *get_active_super(struct block_device *bdev)
631 : : {
632 : : struct super_block *sb;
633 : :
634 [ # # ]: 0 : if (!bdev)
635 : : return NULL;
636 : :
637 : : restart:
638 : : spin_lock(&sb_lock);
639 [ # # ]: 0 : list_for_each_entry(sb, &super_blocks, s_list) {
640 [ # # ]: 0 : if (hlist_unhashed(&sb->s_instances))
641 : 0 : continue;
642 [ # # ]: 0 : if (sb->s_bdev == bdev) {
643 [ # # ]: 0 : if (!grab_super(sb))
644 : : goto restart;
645 : 0 : up_write(&sb->s_umount);
646 : 0 : return sb;
647 : : }
648 : : }
649 : : spin_unlock(&sb_lock);
650 : 0 : return NULL;
651 : : }
652 : :
653 : 0 : struct super_block *user_get_super(dev_t dev)
654 : : {
655 : : struct super_block *sb;
656 : :
657 : : spin_lock(&sb_lock);
658 : : rescan:
659 [ + - ]: 30 : list_for_each_entry(sb, &super_blocks, s_list) {
660 [ - + ]: 30 : if (hlist_unhashed(&sb->s_instances))
661 : 0 : continue;
662 [ + + ]: 30 : if (sb->s_dev == dev) {
663 : 0 : sb->s_count++;
664 : : spin_unlock(&sb_lock);
665 : 2 : down_read(&sb->s_umount);
666 : : /* still alive? */
667 [ + - ][ - + ]: 2 : if (sb->s_root && (sb->s_flags & MS_BORN))
668 : : return sb;
669 : 0 : up_read(&sb->s_umount);
670 : : /* nope, got unmounted */
671 : : spin_lock(&sb_lock);
672 : 0 : __put_super(sb);
673 : 0 : goto rescan;
674 : : }
675 : : }
676 : : spin_unlock(&sb_lock);
677 : 0 : return NULL;
678 : : }
679 : :
680 : : /**
681 : : * do_remount_sb - asks filesystem to change mount options.
682 : : * @sb: superblock in question
683 : : * @flags: numeric part of options
684 : : * @data: the rest of options
685 : : * @force: whether or not to force the change
686 : : *
687 : : * Alters the mount options of a mounted file system.
688 : : */
689 : 0 : int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
690 : : {
691 : : int retval;
692 : : int remount_ro;
693 : :
694 [ + - ]: 4 : if (sb->s_writers.frozen != SB_UNFROZEN)
695 : : return -EBUSY;
696 : :
697 : : #ifdef CONFIG_BLOCK
698 [ + - ][ + - ]: 4 : if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
699 : : return -EACCES;
700 : : #endif
701 : :
702 [ - + ]: 4 : if (flags & MS_RDONLY)
703 : 0 : acct_auto_close(sb);
704 : 4 : shrink_dcache_sb(sb);
705 : 4 : sync_filesystem(sb);
706 : :
707 [ - + ][ # # ]: 4 : remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
708 : :
709 : : /* If we are remounting RDONLY and current sb is read/write,
710 : : make sure there are no rw files opened */
711 [ - + ]: 4 : if (remount_ro) {
712 [ # # ]: 0 : if (force) {
713 : 0 : sb->s_readonly_remount = 1;
714 : 0 : smp_wmb();
715 : : } else {
716 : 0 : retval = sb_prepare_remount_readonly(sb);
717 [ # # ]: 0 : if (retval)
718 : : return retval;
719 : : }
720 : : }
721 : :
722 [ + - ]: 4 : if (sb->s_op->remount_fs) {
723 : 4 : retval = sb->s_op->remount_fs(sb, &flags, data);
724 [ - + ]: 4 : if (retval) {
725 [ # # ]: 0 : if (!force)
726 : : goto cancel_readonly;
727 : : /* If forced remount, go ahead despite any errors */
728 : 0 : WARN(1, "forced remount of a %s fs returned %i\n",
729 : : sb->s_type->name, retval);
730 : : }
731 : : }
732 : 0 : sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
733 : : /* Needs to be ordered wrt mnt_is_readonly() */
734 : 4 : smp_wmb();
735 : 4 : sb->s_readonly_remount = 0;
736 : :
737 : : /*
738 : : * Some filesystems modify their metadata via some other path than the
739 : : * bdev buffer cache (eg. use a private mapping, or directories in
740 : : * pagecache, etc). Also file data modifications go via their own
741 : : * mappings. So If we try to mount readonly then copy the filesystem
742 : : * from bdev, we could get stale data, so invalidate it to give a best
743 : : * effort at coherency.
744 : : */
745 [ - + ][ # # ]: 4 : if (remount_ro && sb->s_bdev)
746 : 0 : invalidate_bdev(sb->s_bdev);
747 : : return 0;
748 : :
749 : : cancel_readonly:
750 : 0 : sb->s_readonly_remount = 0;
751 : 0 : return retval;
752 : : }
753 : :
754 : 0 : static void do_emergency_remount(struct work_struct *work)
755 : : {
756 : : struct super_block *sb, *p = NULL;
757 : :
758 : : spin_lock(&sb_lock);
759 [ # # ]: 0 : list_for_each_entry(sb, &super_blocks, s_list) {
760 [ # # ]: 0 : if (hlist_unhashed(&sb->s_instances))
761 : 0 : continue;
762 : 0 : sb->s_count++;
763 : : spin_unlock(&sb_lock);
764 : 0 : down_write(&sb->s_umount);
765 [ # # ][ # # ]: 0 : if (sb->s_root && sb->s_bdev && (sb->s_flags & MS_BORN) &&
[ # # ]
766 : : !(sb->s_flags & MS_RDONLY)) {
767 : : /*
768 : : * What lock protects sb->s_flags??
769 : : */
770 : 0 : do_remount_sb(sb, MS_RDONLY, NULL, 1);
771 : : }
772 : 0 : up_write(&sb->s_umount);
773 : : spin_lock(&sb_lock);
774 [ # # ]: 0 : if (p)
775 : 0 : __put_super(p);
776 : : p = sb;
777 : : }
778 [ # # ]: 0 : if (p)
779 : 0 : __put_super(p);
780 : : spin_unlock(&sb_lock);
781 : 0 : kfree(work);
782 : 0 : printk("Emergency Remount complete\n");
783 : 0 : }
784 : :
785 : 0 : void emergency_remount(void)
786 : : {
787 : : struct work_struct *work;
788 : :
789 : : work = kmalloc(sizeof(*work), GFP_ATOMIC);
790 [ # # ]: 0 : if (work) {
791 : 0 : INIT_WORK(work, do_emergency_remount);
792 : : schedule_work(work);
793 : : }
794 : 0 : }
795 : :
796 : : /*
797 : : * Unnamed block devices are dummy devices used by virtual
798 : : * filesystems which don't use real block-devices. -- jrs
799 : : */
800 : :
801 : : static DEFINE_IDA(unnamed_dev_ida);
802 : : static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
803 : : static int unnamed_dev_start = 0; /* don't bother trying below it */
804 : :
805 : 3 : int get_anon_bdev(dev_t *p)
806 : : {
807 : : int dev;
808 : : int error;
809 : :
810 : : retry:
811 [ + - ]: 3 : if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
812 : : return -ENOMEM;
813 : : spin_lock(&unnamed_dev_lock);
814 : 3 : error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
815 [ + - ]: 3 : if (!error)
816 : 3 : unnamed_dev_start = dev + 1;
817 : : spin_unlock(&unnamed_dev_lock);
818 [ - + ]: 3 : if (error == -EAGAIN)
819 : : /* We raced and lost with another CPU. */
820 : : goto retry;
821 [ + - ]: 3 : else if (error)
822 : : return -EAGAIN;
823 : :
824 [ - + ]: 3 : if (dev == (1 << MINORBITS)) {
825 : : spin_lock(&unnamed_dev_lock);
826 : 0 : ida_remove(&unnamed_dev_ida, dev);
827 [ # # ]: 0 : if (unnamed_dev_start > dev)
828 : 0 : unnamed_dev_start = dev;
829 : : spin_unlock(&unnamed_dev_lock);
830 : 0 : return -EMFILE;
831 : : }
832 : 3 : *p = MKDEV(0, dev & MINORMASK);
833 : 3 : return 0;
834 : : }
835 : : EXPORT_SYMBOL(get_anon_bdev);
836 : :
837 : 0 : void free_anon_bdev(dev_t dev)
838 : : {
839 : 3 : int slot = MINOR(dev);
840 : : spin_lock(&unnamed_dev_lock);
841 : 3 : ida_remove(&unnamed_dev_ida, slot);
842 [ + - ]: 3 : if (slot < unnamed_dev_start)
843 : 3 : unnamed_dev_start = slot;
844 : : spin_unlock(&unnamed_dev_lock);
845 : 3 : }
846 : : EXPORT_SYMBOL(free_anon_bdev);
847 : :
848 : 0 : int set_anon_super(struct super_block *s, void *data)
849 : : {
850 : 3 : int error = get_anon_bdev(&s->s_dev);
851 [ # # + - ]: 3 : if (!error)
852 : 3 : s->s_bdi = &noop_backing_dev_info;
853 : 0 : return error;
854 : : }
855 : :
856 : : EXPORT_SYMBOL(set_anon_super);
857 : :
858 : 0 : void kill_anon_super(struct super_block *sb)
859 : : {
860 : 0 : dev_t dev = sb->s_dev;
861 : 3 : generic_shutdown_super(sb);
862 : 3 : free_anon_bdev(dev);
863 : 0 : }
864 : :
865 : : EXPORT_SYMBOL(kill_anon_super);
866 : :
867 : 0 : void kill_litter_super(struct super_block *sb)
868 : : {
869 [ + - ]: 3 : if (sb->s_root)
870 : 3 : d_genocide(sb->s_root);
871 : : kill_anon_super(sb);
872 : 3 : }
873 : :
874 : : EXPORT_SYMBOL(kill_litter_super);
875 : :
876 : 0 : static int ns_test_super(struct super_block *sb, void *data)
877 : : {
878 : 0 : return sb->s_fs_info == data;
879 : : }
880 : :
881 : 0 : static int ns_set_super(struct super_block *sb, void *data)
882 : : {
883 : 0 : sb->s_fs_info = data;
884 : 0 : return set_anon_super(sb, NULL);
885 : : }
886 : :
887 : 0 : struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
888 : : void *data, int (*fill_super)(struct super_block *, void *, int))
889 : : {
890 : : struct super_block *sb;
891 : :
892 : 0 : sb = sget(fs_type, ns_test_super, ns_set_super, flags, data);
893 [ # # ]: 0 : if (IS_ERR(sb))
894 : : return ERR_CAST(sb);
895 : :
896 [ # # ]: 0 : if (!sb->s_root) {
897 : : int err;
898 : 0 : err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
899 [ # # ]: 0 : if (err) {
900 : 0 : deactivate_locked_super(sb);
901 : 0 : return ERR_PTR(err);
902 : : }
903 : :
904 : 0 : sb->s_flags |= MS_ACTIVE;
905 : : }
906 : :
907 : 0 : return dget(sb->s_root);
908 : : }
909 : :
910 : : EXPORT_SYMBOL(mount_ns);
911 : :
912 : : #ifdef CONFIG_BLOCK
913 : 0 : static int set_bdev_super(struct super_block *s, void *data)
914 : : {
915 : 0 : s->s_bdev = data;
916 : 0 : s->s_dev = s->s_bdev->bd_dev;
917 : :
918 : : /*
919 : : * We set the bdi here to the queue backing, file systems can
920 : : * overwrite this in ->fill_super()
921 : : */
922 : 0 : s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
923 : 0 : return 0;
924 : : }
925 : :
926 : 0 : static int test_bdev_super(struct super_block *s, void *data)
927 : : {
928 : 0 : return (void *)s->s_bdev == data;
929 : : }
930 : :
931 : 0 : struct dentry *mount_bdev(struct file_system_type *fs_type,
932 : : int flags, const char *dev_name, void *data,
933 : : int (*fill_super)(struct super_block *, void *, int))
934 : : {
935 : 0 : struct block_device *bdev;
936 : : struct super_block *s;
937 : : fmode_t mode = FMODE_READ | FMODE_EXCL;
938 : : int error = 0;
939 : :
940 [ # # ]: 0 : if (!(flags & MS_RDONLY))
941 : : mode |= FMODE_WRITE;
942 : :
943 : 0 : bdev = blkdev_get_by_path(dev_name, mode, fs_type);
944 [ # # ]: 0 : if (IS_ERR(bdev))
945 : : return ERR_CAST(bdev);
946 : :
947 : : /*
948 : : * once the super is inserted into the list by sget, s_umount
949 : : * will protect the lockfs code from trying to start a snapshot
950 : : * while we are mounting
951 : : */
952 : 0 : mutex_lock(&bdev->bd_fsfreeze_mutex);
953 [ # # ]: 0 : if (bdev->bd_fsfreeze_count > 0) {
954 : 0 : mutex_unlock(&bdev->bd_fsfreeze_mutex);
955 : : error = -EBUSY;
956 : 0 : goto error_bdev;
957 : : }
958 : 0 : s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
959 : : bdev);
960 : 0 : mutex_unlock(&bdev->bd_fsfreeze_mutex);
961 [ # # ]: 0 : if (IS_ERR(s))
962 : : goto error_s;
963 : :
964 [ # # ]: 0 : if (s->s_root) {
965 [ # # ]: 0 : if ((flags ^ s->s_flags) & MS_RDONLY) {
966 : 0 : deactivate_locked_super(s);
967 : : error = -EBUSY;
968 : 0 : goto error_bdev;
969 : : }
970 : :
971 : : /*
972 : : * s_umount nests inside bd_mutex during
973 : : * __invalidate_device(). blkdev_put() acquires
974 : : * bd_mutex and can't be called under s_umount. Drop
975 : : * s_umount temporarily. This is safe as we're
976 : : * holding an active reference.
977 : : */
978 : 0 : up_write(&s->s_umount);
979 : 0 : blkdev_put(bdev, mode);
980 : 0 : down_write(&s->s_umount);
981 : : } else {
982 : : char b[BDEVNAME_SIZE];
983 : :
984 : 0 : s->s_mode = mode;
985 : 0 : strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
986 : 0 : sb_set_blocksize(s, block_size(bdev));
987 : 0 : error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
988 [ # # ]: 0 : if (error) {
989 : 0 : deactivate_locked_super(s);
990 : 0 : goto error;
991 : : }
992 : :
993 : 0 : s->s_flags |= MS_ACTIVE;
994 : 0 : bdev->bd_super = s;
995 : : }
996 : :
997 : 0 : return dget(s->s_root);
998 : :
999 : : error_s:
1000 : : error = PTR_ERR(s);
1001 : : error_bdev:
1002 : 0 : blkdev_put(bdev, mode);
1003 : : error:
1004 : 0 : return ERR_PTR(error);
1005 : : }
1006 : : EXPORT_SYMBOL(mount_bdev);
1007 : :
1008 : 0 : void kill_block_super(struct super_block *sb)
1009 : : {
1010 : 0 : struct block_device *bdev = sb->s_bdev;
1011 : 0 : fmode_t mode = sb->s_mode;
1012 : :
1013 : 0 : bdev->bd_super = NULL;
1014 : 0 : generic_shutdown_super(sb);
1015 : 0 : sync_blockdev(bdev);
1016 [ # # ][ # # ]: 0 : WARN_ON_ONCE(!(mode & FMODE_EXCL));
[ # # ]
1017 : 0 : blkdev_put(bdev, mode | FMODE_EXCL);
1018 : 0 : }
1019 : :
1020 : : EXPORT_SYMBOL(kill_block_super);
1021 : : #endif
1022 : :
1023 : 0 : struct dentry *mount_nodev(struct file_system_type *fs_type,
1024 : : int flags, void *data,
1025 : : int (*fill_super)(struct super_block *, void *, int))
1026 : : {
1027 : : int error;
1028 : 0 : struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
1029 : :
1030 [ # # ]: 0 : if (IS_ERR(s))
1031 : : return ERR_CAST(s);
1032 : :
1033 : 0 : error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1034 [ # # ]: 0 : if (error) {
1035 : 0 : deactivate_locked_super(s);
1036 : 0 : return ERR_PTR(error);
1037 : : }
1038 : 0 : s->s_flags |= MS_ACTIVE;
1039 : 0 : return dget(s->s_root);
1040 : : }
1041 : : EXPORT_SYMBOL(mount_nodev);
1042 : :
1043 : 0 : static int compare_single(struct super_block *s, void *p)
1044 : : {
1045 : 0 : return 1;
1046 : : }
1047 : :
1048 : 0 : struct dentry *mount_single(struct file_system_type *fs_type,
1049 : : int flags, void *data,
1050 : : int (*fill_super)(struct super_block *, void *, int))
1051 : : {
1052 : : struct super_block *s;
1053 : : int error;
1054 : :
1055 : 0 : s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
1056 [ # # ]: 0 : if (IS_ERR(s))
1057 : : return ERR_CAST(s);
1058 [ # # ]: 0 : if (!s->s_root) {
1059 : 0 : error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1060 [ # # ]: 0 : if (error) {
1061 : 0 : deactivate_locked_super(s);
1062 : 0 : return ERR_PTR(error);
1063 : : }
1064 : 0 : s->s_flags |= MS_ACTIVE;
1065 : : } else {
1066 : 0 : do_remount_sb(s, flags, data, 0);
1067 : : }
1068 : 0 : return dget(s->s_root);
1069 : : }
1070 : : EXPORT_SYMBOL(mount_single);
1071 : :
1072 : : struct dentry *
1073 : 0 : mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
1074 : : {
1075 : : struct dentry *root;
1076 : : struct super_block *sb;
1077 : : char *secdata = NULL;
1078 : : int error = -ENOMEM;
1079 : :
1080 [ + + ][ + - ]: 4978 : if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
1081 : : secdata = alloc_secdata();
1082 [ + - ]: 3 : if (!secdata)
1083 : : goto out;
1084 : :
1085 : 3 : error = security_sb_copy_data(data, secdata);
1086 [ + - ]: 3 : if (error)
1087 : : goto out_free_secdata;
1088 : : }
1089 : :
1090 : 4978 : root = type->mount(type, flags, name, data);
1091 [ + + ]: 4978 : if (IS_ERR(root)) {
1092 : : error = PTR_ERR(root);
1093 : 4975 : goto out_free_secdata;
1094 : : }
1095 : 3 : sb = root->d_sb;
1096 [ - + ]: 3 : BUG_ON(!sb);
1097 [ - + ]: 3 : WARN_ON(!sb->s_bdi);
1098 [ - + ]: 3 : WARN_ON(sb->s_bdi == &default_backing_dev_info);
1099 : 3 : sb->s_flags |= MS_BORN;
1100 : :
1101 : 3 : error = security_sb_kern_mount(sb, flags, secdata);
1102 [ + - ]: 3 : if (error)
1103 : : goto out_sb;
1104 : :
1105 : : /*
1106 : : * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
1107 : : * but s_maxbytes was an unsigned long long for many releases. Throw
1108 : : * this warning for a little while to try and catch filesystems that
1109 : : * violate this rule.
1110 : : */
1111 [ - + ]: 3 : WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
1112 : : "negative value (%lld)\n", type->name, sb->s_maxbytes);
1113 : :
1114 : 3 : up_write(&sb->s_umount);
1115 : : free_secdata(secdata);
1116 : 3 : return root;
1117 : : out_sb:
1118 : 0 : dput(root);
1119 : 0 : deactivate_locked_super(sb);
1120 : : out_free_secdata:
1121 : : free_secdata(secdata);
1122 : : out:
1123 : 4975 : return ERR_PTR(error);
1124 : : }
1125 : :
1126 : : /*
1127 : : * This is an internal function, please use sb_end_{write,pagefault,intwrite}
1128 : : * instead.
1129 : : */
1130 : 0 : void __sb_end_write(struct super_block *sb, int level)
1131 : : {
1132 : 10269677 : percpu_counter_dec(&sb->s_writers.counter[level-1]);
1133 : : /*
1134 : : * Make sure s_writers are updated before we wake up waiters in
1135 : : * freeze_super().
1136 : : */
1137 : 10269741 : smp_mb();
1138 [ - + ]: 10269405 : if (waitqueue_active(&sb->s_writers.wait))
1139 : 0 : wake_up(&sb->s_writers.wait);
1140 : : rwsem_release(&sb->s_writers.lock_map[level-1], 1, _RET_IP_);
1141 : 0 : }
1142 : : EXPORT_SYMBOL(__sb_end_write);
1143 : :
1144 : : #ifdef CONFIG_LOCKDEP
1145 : : /*
1146 : : * We want lockdep to tell us about possible deadlocks with freezing but
1147 : : * it's it bit tricky to properly instrument it. Getting a freeze protection
1148 : : * works as getting a read lock but there are subtle problems. XFS for example
1149 : : * gets freeze protection on internal level twice in some cases, which is OK
1150 : : * only because we already hold a freeze protection also on higher level. Due
1151 : : * to these cases we have to tell lockdep we are doing trylock when we
1152 : : * already hold a freeze protection for a higher freeze level.
1153 : : */
1154 : : static void acquire_freeze_lock(struct super_block *sb, int level, bool trylock,
1155 : : unsigned long ip)
1156 : : {
1157 : : int i;
1158 : :
1159 : : if (!trylock) {
1160 : : for (i = 0; i < level - 1; i++)
1161 : : if (lock_is_held(&sb->s_writers.lock_map[i])) {
1162 : : trylock = true;
1163 : : break;
1164 : : }
1165 : : }
1166 : : rwsem_acquire_read(&sb->s_writers.lock_map[level-1], 0, trylock, ip);
1167 : : }
1168 : : #endif
1169 : :
1170 : : /*
1171 : : * This is an internal function, please use sb_start_{write,pagefault,intwrite}
1172 : : * instead.
1173 : : */
1174 : 10269522 : int __sb_start_write(struct super_block *sb, int level, bool wait)
1175 : : {
1176 : : retry:
1177 [ - + ]: 10269522 : if (unlikely(sb->s_writers.frozen >= level)) {
1178 [ # # ]: 0 : if (!wait)
1179 : : return 0;
1180 [ # # ][ # # ]: 0 : wait_event(sb->s_writers.wait_unfrozen,
1181 : : sb->s_writers.frozen < level);
1182 : : }
1183 : :
1184 : : #ifdef CONFIG_LOCKDEP
1185 : : acquire_freeze_lock(sb, level, !wait, _RET_IP_);
1186 : : #endif
1187 : 10269522 : percpu_counter_inc(&sb->s_writers.counter[level-1]);
1188 : : /*
1189 : : * Make sure counter is updated before we check for frozen.
1190 : : * freeze_super() first sets frozen and then checks the counter.
1191 : : */
1192 : 10269809 : smp_mb();
1193 [ - + ]: 10269747 : if (unlikely(sb->s_writers.frozen >= level)) {
1194 : 0 : __sb_end_write(sb, level);
1195 : 0 : goto retry;
1196 : : }
1197 : : return 1;
1198 : : }
1199 : : EXPORT_SYMBOL(__sb_start_write);
1200 : :
1201 : : /**
1202 : : * sb_wait_write - wait until all writers to given file system finish
1203 : : * @sb: the super for which we wait
1204 : : * @level: type of writers we wait for (normal vs page fault)
1205 : : *
1206 : : * This function waits until there are no writers of given type to given file
1207 : : * system. Caller of this function should make sure there can be no new writers
1208 : : * of type @level before calling this function. Otherwise this function can
1209 : : * livelock.
1210 : : */
1211 : 0 : static void sb_wait_write(struct super_block *sb, int level)
1212 : : {
1213 : : s64 writers;
1214 : :
1215 : : /*
1216 : : * We just cycle-through lockdep here so that it does not complain
1217 : : * about returning with lock to userspace
1218 : : */
1219 : : rwsem_acquire(&sb->s_writers.lock_map[level-1], 0, 0, _THIS_IP_);
1220 : : rwsem_release(&sb->s_writers.lock_map[level-1], 1, _THIS_IP_);
1221 : :
1222 : : do {
1223 : 0 : DEFINE_WAIT(wait);
1224 : :
1225 : : /*
1226 : : * We use a barrier in prepare_to_wait() to separate setting
1227 : : * of frozen and checking of the counter
1228 : : */
1229 : 0 : prepare_to_wait(&sb->s_writers.wait, &wait,
1230 : : TASK_UNINTERRUPTIBLE);
1231 : :
1232 : 0 : writers = percpu_counter_sum(&sb->s_writers.counter[level-1]);
1233 [ # # ]: 0 : if (writers)
1234 : 0 : schedule();
1235 : :
1236 : 0 : finish_wait(&sb->s_writers.wait, &wait);
1237 [ # # ]: 0 : } while (writers);
1238 : 0 : }
1239 : :
1240 : : /**
1241 : : * freeze_super - lock the filesystem and force it into a consistent state
1242 : : * @sb: the super to lock
1243 : : *
1244 : : * Syncs the super to make sure the filesystem is consistent and calls the fs's
1245 : : * freeze_fs. Subsequent calls to this without first thawing the fs will return
1246 : : * -EBUSY.
1247 : : *
1248 : : * During this function, sb->s_writers.frozen goes through these values:
1249 : : *
1250 : : * SB_UNFROZEN: File system is normal, all writes progress as usual.
1251 : : *
1252 : : * SB_FREEZE_WRITE: The file system is in the process of being frozen. New
1253 : : * writes should be blocked, though page faults are still allowed. We wait for
1254 : : * all writes to complete and then proceed to the next stage.
1255 : : *
1256 : : * SB_FREEZE_PAGEFAULT: Freezing continues. Now also page faults are blocked
1257 : : * but internal fs threads can still modify the filesystem (although they
1258 : : * should not dirty new pages or inodes), writeback can run etc. After waiting
1259 : : * for all running page faults we sync the filesystem which will clean all
1260 : : * dirty pages and inodes (no new dirty pages or inodes can be created when
1261 : : * sync is running).
1262 : : *
1263 : : * SB_FREEZE_FS: The file system is frozen. Now all internal sources of fs
1264 : : * modification are blocked (e.g. XFS preallocation truncation on inode
1265 : : * reclaim). This is usually implemented by blocking new transactions for
1266 : : * filesystems that have them and need this additional guard. After all
1267 : : * internal writers are finished we call ->freeze_fs() to finish filesystem
1268 : : * freezing. Then we transition to SB_FREEZE_COMPLETE state. This state is
1269 : : * mostly auxiliary for filesystems to verify they do not modify frozen fs.
1270 : : *
1271 : : * sb->s_writers.frozen is protected by sb->s_umount.
1272 : : */
1273 : 0 : int freeze_super(struct super_block *sb)
1274 : : {
1275 : : int ret;
1276 : :
1277 : 0 : atomic_inc(&sb->s_active);
1278 : 0 : down_write(&sb->s_umount);
1279 [ # # ]: 0 : if (sb->s_writers.frozen != SB_UNFROZEN) {
1280 : 0 : deactivate_locked_super(sb);
1281 : 0 : return -EBUSY;
1282 : : }
1283 : :
1284 [ # # ]: 0 : if (!(sb->s_flags & MS_BORN)) {
1285 : 0 : up_write(&sb->s_umount);
1286 : 0 : return 0; /* sic - it's "nothing to do" */
1287 : : }
1288 : :
1289 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY) {
1290 : : /* Nothing to do really... */
1291 : 0 : sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1292 : 0 : up_write(&sb->s_umount);
1293 : 0 : return 0;
1294 : : }
1295 : :
1296 : : /* From now on, no new normal writers can start */
1297 : 0 : sb->s_writers.frozen = SB_FREEZE_WRITE;
1298 : 0 : smp_wmb();
1299 : :
1300 : : /* Release s_umount to preserve sb_start_write -> s_umount ordering */
1301 : 0 : up_write(&sb->s_umount);
1302 : :
1303 : 0 : sb_wait_write(sb, SB_FREEZE_WRITE);
1304 : :
1305 : : /* Now we go and block page faults... */
1306 : 0 : down_write(&sb->s_umount);
1307 : 0 : sb->s_writers.frozen = SB_FREEZE_PAGEFAULT;
1308 : 0 : smp_wmb();
1309 : :
1310 : 0 : sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
1311 : :
1312 : : /* All writers are done so after syncing there won't be dirty data */
1313 : 0 : sync_filesystem(sb);
1314 : :
1315 : : /* Now wait for internal filesystem counter */
1316 : 0 : sb->s_writers.frozen = SB_FREEZE_FS;
1317 : 0 : smp_wmb();
1318 : 0 : sb_wait_write(sb, SB_FREEZE_FS);
1319 : :
1320 [ # # ]: 0 : if (sb->s_op->freeze_fs) {
1321 : 0 : ret = sb->s_op->freeze_fs(sb);
1322 [ # # ]: 0 : if (ret) {
1323 : 0 : printk(KERN_ERR
1324 : : "VFS:Filesystem freeze failed\n");
1325 : 0 : sb->s_writers.frozen = SB_UNFROZEN;
1326 : 0 : smp_wmb();
1327 : 0 : wake_up(&sb->s_writers.wait_unfrozen);
1328 : 0 : deactivate_locked_super(sb);
1329 : 0 : return ret;
1330 : : }
1331 : : }
1332 : : /*
1333 : : * This is just for debugging purposes so that fs can warn if it
1334 : : * sees write activity when frozen is set to SB_FREEZE_COMPLETE.
1335 : : */
1336 : 0 : sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1337 : 0 : up_write(&sb->s_umount);
1338 : 0 : return 0;
1339 : : }
1340 : : EXPORT_SYMBOL(freeze_super);
1341 : :
1342 : : /**
1343 : : * thaw_super -- unlock filesystem
1344 : : * @sb: the super to thaw
1345 : : *
1346 : : * Unlocks the filesystem and marks it writeable again after freeze_super().
1347 : : */
1348 : 0 : int thaw_super(struct super_block *sb)
1349 : : {
1350 : : int error;
1351 : :
1352 : 0 : down_write(&sb->s_umount);
1353 [ # # ]: 0 : if (sb->s_writers.frozen == SB_UNFROZEN) {
1354 : 0 : up_write(&sb->s_umount);
1355 : 0 : return -EINVAL;
1356 : : }
1357 : :
1358 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY)
1359 : : goto out;
1360 : :
1361 [ # # ]: 0 : if (sb->s_op->unfreeze_fs) {
1362 : 0 : error = sb->s_op->unfreeze_fs(sb);
1363 [ # # ]: 0 : if (error) {
1364 : 0 : printk(KERN_ERR
1365 : : "VFS:Filesystem thaw failed\n");
1366 : 0 : up_write(&sb->s_umount);
1367 : 0 : return error;
1368 : : }
1369 : : }
1370 : :
1371 : : out:
1372 : 0 : sb->s_writers.frozen = SB_UNFROZEN;
1373 : 0 : smp_wmb();
1374 : 0 : wake_up(&sb->s_writers.wait_unfrozen);
1375 : 0 : deactivate_locked_super(sb);
1376 : :
1377 : 0 : return 0;
1378 : : }
1379 : : EXPORT_SYMBOL(thaw_super);
|
