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