blob: 823e061faa87277407efb79369ed469dd35f2125 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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:
Jan Engelhardt96de0e22007-10-19 23:21:04 +020018 * Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/module.h>
24#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/acct.h>
26#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/mount.h>
28#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/writeback.h> /* for the emergency remount stuff */
30#include <linux/idr.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080031#include <linux/mutex.h>
Jens Axboe5477d0f2010-04-29 20:33:35 +020032#include <linux/backing-dev.h>
Nick Pigginceb5bdc2011-01-07 17:50:05 +110033#include <linux/rculist_bl.h>
Al Viro6d59e7f2008-03-22 15:48:17 -040034#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037LIST_HEAD(super_blocks);
38DEFINE_SPINLOCK(sb_lock);
39
40/**
41 * alloc_super - create new superblock
Henrik Kretzschmarfe2bbc42006-09-06 00:03:41 -070042 * @type: filesystem type superblock should belong to
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 *
44 * Allocates and initializes a new &struct super_block. alloc_super()
45 * returns a pointer new superblock or %NULL if allocation had failed.
46 */
Ingo Molnarcf516242006-07-03 00:25:27 -070047static struct super_block *alloc_super(struct file_system_type *type)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
Oliver Neukum11b0b5a2006-03-25 03:08:13 -080049 struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
Alexey Dobriyanb87221d2009-09-21 17:01:09 -070050 static const struct super_operations default_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52 if (s) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 if (security_sb_alloc(s)) {
54 kfree(s);
55 s = NULL;
56 goto out;
57 }
Nick Piggin6416ccb2010-08-18 04:37:38 +100058#ifdef CONFIG_SMP
59 s->s_files = alloc_percpu(struct list_head);
60 if (!s->s_files) {
61 security_sb_free(s);
62 kfree(s);
63 s = NULL;
64 goto out;
65 } else {
66 int i;
67
68 for_each_possible_cpu(i)
69 INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));
70 }
71#else
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 INIT_LIST_HEAD(&s->s_files);
Nick Piggin6416ccb2010-08-18 04:37:38 +100073#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 INIT_LIST_HEAD(&s->s_instances);
Nick Pigginceb5bdc2011-01-07 17:50:05 +110075 INIT_HLIST_BL_HEAD(&s->s_anon);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 INIT_LIST_HEAD(&s->s_inodes);
Kentaro Makitada3bbdd2008-07-23 21:27:13 -070077 INIT_LIST_HEAD(&s->s_dentry_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 init_rwsem(&s->s_umount);
Ingo Molnar7892f2f2006-01-09 15:59:25 -080079 mutex_init(&s->s_lock);
Arjan van de Ven897c6ff2006-07-03 00:25:28 -070080 lockdep_set_class(&s->s_umount, &type->s_umount_key);
Ingo Molnarcf516242006-07-03 00:25:27 -070081 /*
82 * The locking rules for s_lock are up to the
83 * filesystem. For example ext3fs has different
84 * lock ordering than usbfs:
85 */
86 lockdep_set_class(&s->s_lock, &type->s_lock_key);
Peter Zijlstraada723d2009-02-18 14:48:30 -080087 /*
88 * sget() can have s_umount recursion.
89 *
90 * When it cannot find a suitable sb, it allocates a new
91 * one (this one), and tries again to find a suitable old
92 * one.
93 *
94 * In case that succeeds, it will acquire the s_umount
95 * lock of the old one. Since these are clearly distrinct
96 * locks, and this object isn't exposed yet, there's no
97 * risk of deadlocks.
98 *
99 * Annotate this by putting this lock in a different
100 * subclass.
101 */
102 down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
Al Virob20bd1a2010-03-22 08:53:19 -0400103 s->s_count = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 atomic_set(&s->s_active, 1);
Arjan van de Vena11f3a02006-03-23 03:00:33 -0800105 mutex_init(&s->s_vfs_rename_mutex);
Roland Dreier51ee0492010-04-27 14:23:57 -0700106 lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
Ingo Molnard3be9152006-03-23 03:00:29 -0800107 mutex_init(&s->s_dquot.dqio_mutex);
108 mutex_init(&s->s_dquot.dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 init_rwsem(&s->s_dquot.dqptr_sem);
110 init_waitqueue_head(&s->s_wait_unfrozen);
111 s->s_maxbytes = MAX_NON_LFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 s->s_op = &default_op;
113 s->s_time_gran = 1000000000;
114 }
115out:
116 return s;
117}
118
119/**
120 * destroy_super - frees a superblock
121 * @s: superblock to free
122 *
123 * Frees a superblock.
124 */
125static inline void destroy_super(struct super_block *s)
126{
Nick Piggin6416ccb2010-08-18 04:37:38 +1000127#ifdef CONFIG_SMP
128 free_percpu(s->s_files);
129#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 security_sb_free(s);
Miklos Szeredi79c0b2d2007-05-08 00:25:43 -0700131 kfree(s->s_subtype);
Miklos Szeredib3b304a2008-02-08 04:21:35 -0800132 kfree(s->s_options);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 kfree(s);
134}
135
136/* Superblock refcounting */
137
138/*
Al Viro35cf7ba2010-03-22 21:13:53 -0400139 * Drop a superblock's refcount. The caller must hold sb_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 */
Al Viro35cf7ba2010-03-22 21:13:53 -0400141void __put_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 if (!--sb->s_count) {
Al Viro551de6f2010-03-22 19:36:35 -0400144 list_del_init(&sb->s_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 destroy_super(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
149/**
150 * put_super - drop a temporary reference to superblock
151 * @sb: superblock in question
152 *
153 * Drops a temporary reference, frees superblock if there's no
154 * references left.
155 */
Jens Axboe03ba3782009-09-09 09:08:54 +0200156void put_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 spin_lock(&sb_lock);
159 __put_super(sb);
160 spin_unlock(&sb_lock);
161}
162
163
164/**
Al Viro74dbbdd2009-05-06 01:07:50 -0400165 * deactivate_locked_super - drop an active reference to superblock
166 * @s: superblock to deactivate
167 *
Al Viro1712ac82010-03-22 15:22:31 -0400168 * Drops an active reference to superblock, converting it into a temprory
169 * one if there is no other active references left. In that case we
170 * tell fs driver to shut it down and drop the temporary reference we
171 * had just acquired.
172 *
173 * Caller holds exclusive lock on superblock; that lock is released.
Al Viro74dbbdd2009-05-06 01:07:50 -0400174 */
175void deactivate_locked_super(struct super_block *s)
176{
177 struct file_system_type *fs = s->s_type;
Al Virob20bd1a2010-03-22 08:53:19 -0400178 if (atomic_dec_and_test(&s->s_active)) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400179 fs->kill_sb(s);
180 put_filesystem(fs);
181 put_super(s);
182 } else {
183 up_write(&s->s_umount);
184 }
185}
186
187EXPORT_SYMBOL(deactivate_locked_super);
188
189/**
Al Viro1712ac82010-03-22 15:22:31 -0400190 * deactivate_super - drop an active reference to superblock
191 * @s: superblock to deactivate
192 *
193 * Variant of deactivate_locked_super(), except that superblock is *not*
194 * locked by caller. If we are going to drop the final active reference,
195 * lock will be acquired prior to that.
196 */
197void deactivate_super(struct super_block *s)
198{
199 if (!atomic_add_unless(&s->s_active, -1, 1)) {
200 down_write(&s->s_umount);
201 deactivate_locked_super(s);
202 }
203}
204
205EXPORT_SYMBOL(deactivate_super);
206
207/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 * grab_super - acquire an active reference
209 * @s: reference we are trying to make active
210 *
211 * Tries to acquire an active reference. grab_super() is used when we
212 * had just found a superblock in super_blocks or fs_type->fs_supers
213 * and want to turn it into a full-blown active reference. grab_super()
214 * is called with sb_lock held and drops it. Returns 1 in case of
215 * success, 0 if we had failed (superblock contents was already dead or
216 * dying when grab_super() had been called).
217 */
Josh Triplett9c4dbee2006-09-29 01:59:29 -0700218static int grab_super(struct super_block *s) __releases(sb_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Al Virob20bd1a2010-03-22 08:53:19 -0400220 if (atomic_inc_not_zero(&s->s_active)) {
221 spin_unlock(&sb_lock);
Al Virob20bd1a2010-03-22 08:53:19 -0400222 return 1;
223 }
224 /* it's going away */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 s->s_count++;
226 spin_unlock(&sb_lock);
Al Viro1712ac82010-03-22 15:22:31 -0400227 /* wait for it to die */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 down_write(&s->s_umount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 up_write(&s->s_umount);
230 put_super(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return 0;
232}
233
David Howellscf9a2ae2006-08-29 19:05:54 +0100234/*
Al Viro914e2632006-10-18 13:55:46 -0400235 * Superblock locking. We really ought to get rid of these two.
236 */
237void lock_super(struct super_block * sb)
238{
239 get_fs_excl();
240 mutex_lock(&sb->s_lock);
241}
242
243void unlock_super(struct super_block * sb)
244{
245 put_fs_excl();
246 mutex_unlock(&sb->s_lock);
247}
248
249EXPORT_SYMBOL(lock_super);
250EXPORT_SYMBOL(unlock_super);
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252/**
253 * generic_shutdown_super - common helper for ->kill_sb()
254 * @sb: superblock to kill
255 *
256 * generic_shutdown_super() does all fs-independent work on superblock
257 * shutdown. Typical ->kill_sb() should pick all fs-specific objects
258 * that need destruction out of superblock, call generic_shutdown_super()
259 * and release aforementioned objects. Note: dentries and inodes _are_
260 * taken care of and do not need specific handling.
David Howellsc636ebd2006-10-11 01:22:19 -0700261 *
262 * Upon calling this function, the filesystem may no longer alter or
263 * rearrange the set of dentries belonging to this super_block, nor may it
264 * change the attachments of dentries to inodes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 */
266void generic_shutdown_super(struct super_block *sb)
267{
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800268 const struct super_operations *sop = sb->s_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Arjan van de Venefaee192009-01-06 07:20:54 -0800270
David Howellsc636ebd2006-10-11 01:22:19 -0700271 if (sb->s_root) {
272 shrink_dcache_for_umount(sb);
Jan Kara60b06802009-04-27 16:43:53 +0200273 sync_filesystem(sb);
Al Viroa9e220f2009-05-05 22:10:44 -0400274 get_fs_excl();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 sb->s_flags &= ~MS_ACTIVE;
Arjan van de Venefaee192009-01-06 07:20:54 -0800276
Al Viro63997e92010-10-25 20:49:35 -0400277 fsnotify_unmount_inodes(&sb->s_inodes);
278
279 evict_inodes(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (sop->put_super)
282 sop->put_super(sb);
283
Al Viro63997e92010-10-25 20:49:35 -0400284 if (!list_empty(&sb->s_inodes)) {
Dave Jones7b4fe292006-02-07 12:58:48 -0800285 printk("VFS: Busy inodes after unmount of %s. "
286 "Self-destruct in 5 seconds. Have a nice day...\n",
287 sb->s_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 }
Al Viroa9e220f2009-05-05 22:10:44 -0400289 put_fs_excl();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
291 spin_lock(&sb_lock);
292 /* should be initialized for __put_super_and_need_restart() */
Al Viro551de6f2010-03-22 19:36:35 -0400293 list_del_init(&sb->s_instances);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 spin_unlock(&sb_lock);
295 up_write(&sb->s_umount);
296}
297
298EXPORT_SYMBOL(generic_shutdown_super);
299
300/**
301 * sget - find or create a superblock
302 * @type: filesystem type superblock should belong to
303 * @test: comparison callback
304 * @set: setup callback
305 * @data: argument to each of them
306 */
307struct super_block *sget(struct file_system_type *type,
308 int (*test)(struct super_block *,void *),
309 int (*set)(struct super_block *,void *),
310 void *data)
311{
312 struct super_block *s = NULL;
Matthias Kaehlcked4730122007-10-18 23:39:57 -0700313 struct super_block *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 int err;
315
316retry:
317 spin_lock(&sb_lock);
Matthias Kaehlcked4730122007-10-18 23:39:57 -0700318 if (test) {
319 list_for_each_entry(old, &type->fs_supers, s_instances) {
320 if (!test(old, data))
321 continue;
322 if (!grab_super(old))
323 goto retry;
Li Zefana3cfbb52009-03-12 14:31:29 -0700324 if (s) {
325 up_write(&s->s_umount);
Matthias Kaehlcked4730122007-10-18 23:39:57 -0700326 destroy_super(s);
Al Viro7a4dec52010-08-09 12:05:43 -0400327 s = NULL;
Li Zefana3cfbb52009-03-12 14:31:29 -0700328 }
Al Virod3f21472010-03-23 11:11:05 -0400329 down_write(&old->s_umount);
Al Viro7a4dec52010-08-09 12:05:43 -0400330 if (unlikely(!(old->s_flags & MS_BORN))) {
331 deactivate_locked_super(old);
332 goto retry;
333 }
Matthias Kaehlcked4730122007-10-18 23:39:57 -0700334 return old;
335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
337 if (!s) {
338 spin_unlock(&sb_lock);
Ingo Molnarcf516242006-07-03 00:25:27 -0700339 s = alloc_super(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 if (!s)
341 return ERR_PTR(-ENOMEM);
342 goto retry;
343 }
344
345 err = set(s, data);
346 if (err) {
347 spin_unlock(&sb_lock);
Li Zefana3cfbb52009-03-12 14:31:29 -0700348 up_write(&s->s_umount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 destroy_super(s);
350 return ERR_PTR(err);
351 }
352 s->s_type = type;
353 strlcpy(s->s_id, type->name, sizeof(s->s_id));
354 list_add_tail(&s->s_list, &super_blocks);
355 list_add(&s->s_instances, &type->fs_supers);
356 spin_unlock(&sb_lock);
357 get_filesystem(type);
358 return s;
359}
360
361EXPORT_SYMBOL(sget);
362
363void drop_super(struct super_block *sb)
364{
365 up_read(&sb->s_umount);
366 put_super(sb);
367}
368
369EXPORT_SYMBOL(drop_super);
370
Christoph Hellwige5004752009-05-05 16:08:56 +0200371/**
372 * sync_supers - helper for periodic superblock writeback
373 *
374 * Call the write_super method if present on all dirty superblocks in
375 * the system. This is for the periodic writeback used by most older
376 * filesystems. For data integrity superblock writeback use
377 * sync_filesystems() instead.
378 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 * Note: check the dirty flag before waiting, so we don't
380 * hold up the sync while mounting a device. (The newly
381 * mounted device won't need syncing.)
382 */
383void sync_supers(void)
384{
Al Virodca33252010-07-25 02:31:46 +0400385 struct super_block *sb, *p = NULL;
Kirill Korotaev618f0632005-06-23 00:09:54 -0700386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400388 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro551de6f2010-03-22 19:36:35 -0400389 if (list_empty(&sb->s_instances))
390 continue;
Christoph Hellwige5004752009-05-05 16:08:56 +0200391 if (sb->s_op->write_super && sb->s_dirt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 sb->s_count++;
393 spin_unlock(&sb_lock);
Christoph Hellwige5004752009-05-05 16:08:56 +0200394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 down_read(&sb->s_umount);
Christoph Hellwige5004752009-05-05 16:08:56 +0200396 if (sb->s_root && sb->s_dirt)
397 sb->s_op->write_super(sb);
Kirill Korotaev618f0632005-06-23 00:09:54 -0700398 up_read(&sb->s_umount);
Christoph Hellwige5004752009-05-05 16:08:56 +0200399
Kirill Korotaev618f0632005-06-23 00:09:54 -0700400 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400401 if (p)
402 __put_super(p);
403 p = sb;
Kirill Korotaev618f0632005-06-23 00:09:54 -0700404 }
405 }
Al Virodca33252010-07-25 02:31:46 +0400406 if (p)
407 __put_super(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 spin_unlock(&sb_lock);
409}
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/**
Al Viro01a05b32010-03-23 06:06:58 -0400412 * iterate_supers - call function for all active superblocks
413 * @f: function to call
414 * @arg: argument to pass to it
415 *
416 * Scans the superblock list and calls given function, passing it
417 * locked superblock and given argument.
418 */
419void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
420{
Al Virodca33252010-07-25 02:31:46 +0400421 struct super_block *sb, *p = NULL;
Al Viro01a05b32010-03-23 06:06:58 -0400422
423 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400424 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro01a05b32010-03-23 06:06:58 -0400425 if (list_empty(&sb->s_instances))
426 continue;
427 sb->s_count++;
428 spin_unlock(&sb_lock);
429
430 down_read(&sb->s_umount);
431 if (sb->s_root)
432 f(sb, arg);
433 up_read(&sb->s_umount);
434
435 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400436 if (p)
437 __put_super(p);
438 p = sb;
Al Viro01a05b32010-03-23 06:06:58 -0400439 }
Al Virodca33252010-07-25 02:31:46 +0400440 if (p)
441 __put_super(p);
Al Viro01a05b32010-03-23 06:06:58 -0400442 spin_unlock(&sb_lock);
443}
444
445/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 * get_super - get the superblock of a device
447 * @bdev: device to get the superblock for
448 *
449 * Scans the superblock list and finds the superblock of the file system
450 * mounted on the device given. %NULL is returned if no match is found.
451 */
452
Al Virodf40c012010-03-22 20:23:25 -0400453struct super_block *get_super(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
Kirill Korotaev618f0632005-06-23 00:09:54 -0700455 struct super_block *sb;
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 if (!bdev)
458 return NULL;
Kirill Korotaev618f0632005-06-23 00:09:54 -0700459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 spin_lock(&sb_lock);
Kirill Korotaev618f0632005-06-23 00:09:54 -0700461rescan:
462 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro551de6f2010-03-22 19:36:35 -0400463 if (list_empty(&sb->s_instances))
464 continue;
Kirill Korotaev618f0632005-06-23 00:09:54 -0700465 if (sb->s_bdev == bdev) {
466 sb->s_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 spin_unlock(&sb_lock);
Kirill Korotaev618f0632005-06-23 00:09:54 -0700468 down_read(&sb->s_umount);
Al Virodf40c012010-03-22 20:23:25 -0400469 /* still alive? */
Kirill Korotaev618f0632005-06-23 00:09:54 -0700470 if (sb->s_root)
471 return sb;
472 up_read(&sb->s_umount);
Al Virodf40c012010-03-22 20:23:25 -0400473 /* nope, got unmounted */
Kirill Korotaev618f0632005-06-23 00:09:54 -0700474 spin_lock(&sb_lock);
Al Virodf40c012010-03-22 20:23:25 -0400475 __put_super(sb);
476 goto rescan;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
478 }
479 spin_unlock(&sb_lock);
480 return NULL;
481}
482
483EXPORT_SYMBOL(get_super);
Christoph Hellwig45042302009-08-03 23:28:35 +0200484
485/**
486 * get_active_super - get an active reference to the superblock of a device
487 * @bdev: device to get the superblock for
488 *
489 * Scans the superblock list and finds the superblock of the file system
490 * mounted on the device given. Returns the superblock with an active
Al Virod3f21472010-03-23 11:11:05 -0400491 * reference or %NULL if none was found.
Christoph Hellwig45042302009-08-03 23:28:35 +0200492 */
493struct super_block *get_active_super(struct block_device *bdev)
494{
495 struct super_block *sb;
496
497 if (!bdev)
498 return NULL;
499
Al Viro14945832010-03-22 20:15:33 -0400500restart:
Christoph Hellwig45042302009-08-03 23:28:35 +0200501 spin_lock(&sb_lock);
502 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro551de6f2010-03-22 19:36:35 -0400503 if (list_empty(&sb->s_instances))
504 continue;
Al Viro14945832010-03-22 20:15:33 -0400505 if (sb->s_bdev == bdev) {
506 if (grab_super(sb)) /* drops sb_lock */
507 return sb;
508 else
509 goto restart;
510 }
Christoph Hellwig45042302009-08-03 23:28:35 +0200511 }
512 spin_unlock(&sb_lock);
513 return NULL;
514}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Al Virodf40c012010-03-22 20:23:25 -0400516struct super_block *user_get_super(dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
Kirill Korotaev618f0632005-06-23 00:09:54 -0700518 struct super_block *sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 spin_lock(&sb_lock);
Kirill Korotaev618f0632005-06-23 00:09:54 -0700521rescan:
522 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro551de6f2010-03-22 19:36:35 -0400523 if (list_empty(&sb->s_instances))
524 continue;
Kirill Korotaev618f0632005-06-23 00:09:54 -0700525 if (sb->s_dev == dev) {
526 sb->s_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 spin_unlock(&sb_lock);
Kirill Korotaev618f0632005-06-23 00:09:54 -0700528 down_read(&sb->s_umount);
Al Virodf40c012010-03-22 20:23:25 -0400529 /* still alive? */
Kirill Korotaev618f0632005-06-23 00:09:54 -0700530 if (sb->s_root)
531 return sb;
532 up_read(&sb->s_umount);
Al Virodf40c012010-03-22 20:23:25 -0400533 /* nope, got unmounted */
Kirill Korotaev618f0632005-06-23 00:09:54 -0700534 spin_lock(&sb_lock);
Al Virodf40c012010-03-22 20:23:25 -0400535 __put_super(sb);
536 goto rescan;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 }
538 }
539 spin_unlock(&sb_lock);
540 return NULL;
541}
542
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 * do_remount_sb - asks filesystem to change mount options.
545 * @sb: superblock in question
546 * @flags: numeric part of options
547 * @data: the rest of options
548 * @force: whether or not to force the change
549 *
550 * Alters the mount options of a mounted file system.
551 */
552int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
553{
554 int retval;
Christoph Hellwigc79d9672010-05-19 07:16:40 -0400555 int remount_ro;
Christoph Hellwig45042302009-08-03 23:28:35 +0200556
557 if (sb->s_frozen != SB_UNFROZEN)
558 return -EBUSY;
559
David Howells93614012006-09-30 20:45:40 +0200560#ifdef CONFIG_BLOCK
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
562 return -EACCES;
David Howells93614012006-09-30 20:45:40 +0200563#endif
Christoph Hellwig45042302009-08-03 23:28:35 +0200564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 if (flags & MS_RDONLY)
566 acct_auto_close(sb);
567 shrink_dcache_sb(sb);
Jan Kara60b06802009-04-27 16:43:53 +0200568 sync_filesystem(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Nick Piggind208bbd2009-12-21 16:28:53 -0800570 remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
Nick Piggind208bbd2009-12-21 16:28:53 -0800571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 /* If we are remounting RDONLY and current sb is read/write,
573 make sure there are no rw files opened */
Nick Piggind208bbd2009-12-21 16:28:53 -0800574 if (remount_ro) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (force)
576 mark_files_ro(sb);
J. R. Okajimab0895512009-06-17 01:16:50 +0900577 else if (!fs_may_remount_ro(sb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 return -EBUSY;
579 }
580
581 if (sb->s_op->remount_fs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 retval = sb->s_op->remount_fs(sb, &flags, data);
J. R. Okajimab0895512009-06-17 01:16:50 +0900583 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return retval;
585 }
586 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
Christoph Hellwigc79d9672010-05-19 07:16:40 -0400587
Nick Piggind208bbd2009-12-21 16:28:53 -0800588 /*
589 * Some filesystems modify their metadata via some other path than the
590 * bdev buffer cache (eg. use a private mapping, or directories in
591 * pagecache, etc). Also file data modifications go via their own
592 * mappings. So If we try to mount readonly then copy the filesystem
593 * from bdev, we could get stale data, so invalidate it to give a best
594 * effort at coherency.
595 */
596 if (remount_ro && sb->s_bdev)
597 invalidate_bdev(sb->s_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 return 0;
599}
600
Jens Axboea2a95372009-03-17 09:38:40 +0100601static void do_emergency_remount(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
Al Virodca33252010-07-25 02:31:46 +0400603 struct super_block *sb, *p = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400606 list_for_each_entry(sb, &super_blocks, s_list) {
Al Viro551de6f2010-03-22 19:36:35 -0400607 if (list_empty(&sb->s_instances))
608 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 sb->s_count++;
610 spin_unlock(&sb_lock);
Al Viro443b94b2009-05-05 23:48:50 -0400611 down_write(&sb->s_umount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
613 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 * What lock protects sb->s_flags??
615 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 do_remount_sb(sb, MS_RDONLY, NULL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
Al Viro443b94b2009-05-05 23:48:50 -0400618 up_write(&sb->s_umount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 spin_lock(&sb_lock);
Al Virodca33252010-07-25 02:31:46 +0400620 if (p)
621 __put_super(p);
622 p = sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
Al Virodca33252010-07-25 02:31:46 +0400624 if (p)
625 __put_super(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 spin_unlock(&sb_lock);
Jens Axboea2a95372009-03-17 09:38:40 +0100627 kfree(work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 printk("Emergency Remount complete\n");
629}
630
631void emergency_remount(void)
632{
Jens Axboea2a95372009-03-17 09:38:40 +0100633 struct work_struct *work;
634
635 work = kmalloc(sizeof(*work), GFP_ATOMIC);
636 if (work) {
637 INIT_WORK(work, do_emergency_remount);
638 schedule_work(work);
639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640}
641
642/*
643 * Unnamed block devices are dummy devices used by virtual
644 * filesystems which don't use real block-devices. -- jrs
645 */
646
Alexey Dobriyanad76cbc2008-08-28 06:26:23 +0400647static DEFINE_IDA(unnamed_dev_ida);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
Al Viroc63e09e2009-06-24 02:05:18 -0400649static int unnamed_dev_start = 0; /* don't bother trying below it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651int set_anon_super(struct super_block *s, void *data)
652{
653 int dev;
654 int error;
655
656 retry:
Alexey Dobriyanad76cbc2008-08-28 06:26:23 +0400657 if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 return -ENOMEM;
659 spin_lock(&unnamed_dev_lock);
Al Viroc63e09e2009-06-24 02:05:18 -0400660 error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
Al Virof21f6222009-06-24 03:12:00 -0400661 if (!error)
662 unnamed_dev_start = dev + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 spin_unlock(&unnamed_dev_lock);
664 if (error == -EAGAIN)
665 /* We raced and lost with another CPU. */
666 goto retry;
667 else if (error)
668 return -EAGAIN;
669
670 if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
671 spin_lock(&unnamed_dev_lock);
Alexey Dobriyanad76cbc2008-08-28 06:26:23 +0400672 ida_remove(&unnamed_dev_ida, dev);
Al Virof21f6222009-06-24 03:12:00 -0400673 if (unnamed_dev_start > dev)
674 unnamed_dev_start = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 spin_unlock(&unnamed_dev_lock);
676 return -EMFILE;
677 }
678 s->s_dev = MKDEV(0, dev & MINORMASK);
Jörn Engel5129a462010-04-25 08:54:42 +0200679 s->s_bdi = &noop_backing_dev_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return 0;
681}
682
683EXPORT_SYMBOL(set_anon_super);
684
685void kill_anon_super(struct super_block *sb)
686{
687 int slot = MINOR(sb->s_dev);
688
689 generic_shutdown_super(sb);
690 spin_lock(&unnamed_dev_lock);
Alexey Dobriyanad76cbc2008-08-28 06:26:23 +0400691 ida_remove(&unnamed_dev_ida, slot);
Al Viroc63e09e2009-06-24 02:05:18 -0400692 if (slot < unnamed_dev_start)
693 unnamed_dev_start = slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 spin_unlock(&unnamed_dev_lock);
695}
696
697EXPORT_SYMBOL(kill_anon_super);
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699void kill_litter_super(struct super_block *sb)
700{
701 if (sb->s_root)
702 d_genocide(sb->s_root);
703 kill_anon_super(sb);
704}
705
706EXPORT_SYMBOL(kill_litter_super);
707
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700708static int ns_test_super(struct super_block *sb, void *data)
709{
710 return sb->s_fs_info == data;
711}
712
713static int ns_set_super(struct super_block *sb, void *data)
714{
715 sb->s_fs_info = data;
716 return set_anon_super(sb, NULL);
717}
718
Al Viroceefda62010-07-26 13:16:50 +0400719struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
720 void *data, int (*fill_super)(struct super_block *, void *, int))
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700721{
722 struct super_block *sb;
723
724 sb = sget(fs_type, ns_test_super, ns_set_super, data);
725 if (IS_ERR(sb))
Al Viroceefda62010-07-26 13:16:50 +0400726 return ERR_CAST(sb);
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700727
728 if (!sb->s_root) {
729 int err;
730 sb->s_flags = flags;
731 err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
732 if (err) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400733 deactivate_locked_super(sb);
Al Viroceefda62010-07-26 13:16:50 +0400734 return ERR_PTR(err);
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700735 }
736
737 sb->s_flags |= MS_ACTIVE;
738 }
739
Al Viroceefda62010-07-26 13:16:50 +0400740 return dget(sb->s_root);
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700741}
742
Al Viroceefda62010-07-26 13:16:50 +0400743EXPORT_SYMBOL(mount_ns);
Serge E. Hallyn909e6d92009-04-06 19:01:07 -0700744
David Howells93614012006-09-30 20:45:40 +0200745#ifdef CONFIG_BLOCK
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746static int set_bdev_super(struct super_block *s, void *data)
747{
748 s->s_bdev = data;
749 s->s_dev = s->s_bdev->bd_dev;
Jens Axboe32a88aa2009-09-16 15:02:33 +0200750
751 /*
752 * We set the bdi here to the queue backing, file systems can
753 * overwrite this in ->fill_super()
754 */
755 s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 return 0;
757}
758
759static int test_bdev_super(struct super_block *s, void *data)
760{
761 return (void *)s->s_bdev == data;
762}
763
Al Viro152a0832010-07-25 00:46:55 +0400764struct dentry *mount_bdev(struct file_system_type *fs_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 int flags, const char *dev_name, void *data,
Al Viro152a0832010-07-25 00:46:55 +0400766 int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767{
768 struct block_device *bdev;
769 struct super_block *s;
Al Viro30c40d22008-02-22 19:50:45 -0500770 fmode_t mode = FMODE_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 int error = 0;
772
Al Viro30c40d22008-02-22 19:50:45 -0500773 if (!(flags & MS_RDONLY))
774 mode |= FMODE_WRITE;
775
776 bdev = open_bdev_exclusive(dev_name, mode, fs_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (IS_ERR(bdev))
Al Viro152a0832010-07-25 00:46:55 +0400778 return ERR_CAST(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 /*
781 * once the super is inserted into the list by sget, s_umount
782 * will protect the lockfs code from trying to start a snapshot
783 * while we are mounting
784 */
Christoph Hellwig4fadd7b2009-08-03 23:28:06 +0200785 mutex_lock(&bdev->bd_fsfreeze_mutex);
786 if (bdev->bd_fsfreeze_count > 0) {
787 mutex_unlock(&bdev->bd_fsfreeze_mutex);
788 error = -EBUSY;
789 goto error_bdev;
790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
Christoph Hellwig4fadd7b2009-08-03 23:28:06 +0200792 mutex_unlock(&bdev->bd_fsfreeze_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (IS_ERR(s))
David Howells454e2392006-06-23 02:02:57 -0700794 goto error_s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
796 if (s->s_root) {
797 if ((flags ^ s->s_flags) & MS_RDONLY) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400798 deactivate_locked_super(s);
David Howells454e2392006-06-23 02:02:57 -0700799 error = -EBUSY;
800 goto error_bdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 }
David Howells454e2392006-06-23 02:02:57 -0700802
Tejun Heo4f331f02010-07-20 15:18:07 -0700803 /*
804 * s_umount nests inside bd_mutex during
805 * __invalidate_device(). close_bdev_exclusive()
806 * acquires bd_mutex and can't be called under
807 * s_umount. Drop s_umount temporarily. This is safe
808 * as we're holding an active reference.
809 */
810 up_write(&s->s_umount);
Al Viro30c40d22008-02-22 19:50:45 -0500811 close_bdev_exclusive(bdev, mode);
Tejun Heo4f331f02010-07-20 15:18:07 -0700812 down_write(&s->s_umount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 } else {
814 char b[BDEVNAME_SIZE];
815
816 s->s_flags = flags;
Al Viro30c40d22008-02-22 19:50:45 -0500817 s->s_mode = mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
Pekka Enberge78c9a02006-01-08 01:03:39 -0800819 sb_set_blocksize(s, block_size(bdev));
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800820 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (error) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400822 deactivate_locked_super(s);
David Howells454e2392006-06-23 02:02:57 -0700823 goto error;
Greg Kroah-Hartmanfa675762006-02-22 09:39:02 -0800824 }
David Howells454e2392006-06-23 02:02:57 -0700825
826 s->s_flags |= MS_ACTIVE;
Theodore Ts'o87d8fe12009-01-03 09:47:09 -0500827 bdev->bd_super = s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 }
829
Al Viro152a0832010-07-25 00:46:55 +0400830 return dget(s->s_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
David Howells454e2392006-06-23 02:02:57 -0700832error_s:
833 error = PTR_ERR(s);
834error_bdev:
Al Viro30c40d22008-02-22 19:50:45 -0500835 close_bdev_exclusive(bdev, mode);
David Howells454e2392006-06-23 02:02:57 -0700836error:
Al Viro152a0832010-07-25 00:46:55 +0400837 return ERR_PTR(error);
838}
839EXPORT_SYMBOL(mount_bdev);
840
841int get_sb_bdev(struct file_system_type *fs_type,
842 int flags, const char *dev_name, void *data,
843 int (*fill_super)(struct super_block *, void *, int),
844 struct vfsmount *mnt)
845{
846 struct dentry *root;
847
848 root = mount_bdev(fs_type, flags, dev_name, data, fill_super);
849 if (IS_ERR(root))
850 return PTR_ERR(root);
851 mnt->mnt_root = root;
852 mnt->mnt_sb = root->d_sb;
853 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
855
856EXPORT_SYMBOL(get_sb_bdev);
857
858void kill_block_super(struct super_block *sb)
859{
860 struct block_device *bdev = sb->s_bdev;
Al Viro30c40d22008-02-22 19:50:45 -0500861 fmode_t mode = sb->s_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
H Hartley Sweetenddbaaf32009-04-29 20:14:57 -0400863 bdev->bd_super = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 generic_shutdown_super(sb);
865 sync_blockdev(bdev);
Al Viro30c40d22008-02-22 19:50:45 -0500866 close_bdev_exclusive(bdev, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867}
868
869EXPORT_SYMBOL(kill_block_super);
David Howells93614012006-09-30 20:45:40 +0200870#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Al Viro3c26ff62010-07-25 11:46:36 +0400872struct dentry *mount_nodev(struct file_system_type *fs_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 int flags, void *data,
Al Viro3c26ff62010-07-25 11:46:36 +0400874 int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
876 int error;
877 struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
878
879 if (IS_ERR(s))
Al Viro3c26ff62010-07-25 11:46:36 +0400880 return ERR_CAST(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 s->s_flags = flags;
883
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800884 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 if (error) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400886 deactivate_locked_super(s);
Al Viro3c26ff62010-07-25 11:46:36 +0400887 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
889 s->s_flags |= MS_ACTIVE;
Al Viro3c26ff62010-07-25 11:46:36 +0400890 return dget(s->s_root);
891}
892EXPORT_SYMBOL(mount_nodev);
893
894int get_sb_nodev(struct file_system_type *fs_type,
895 int flags, void *data,
896 int (*fill_super)(struct super_block *, void *, int),
897 struct vfsmount *mnt)
898{
899 struct dentry *root;
900
901 root = mount_nodev(fs_type, flags, data, fill_super);
902 if (IS_ERR(root))
903 return PTR_ERR(root);
904 mnt->mnt_root = root;
905 mnt->mnt_sb = root->d_sb;
Sukadev Bhattiprolua3ec9472009-03-04 12:06:34 -0800906 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908EXPORT_SYMBOL(get_sb_nodev);
909
910static int compare_single(struct super_block *s, void *p)
911{
912 return 1;
913}
914
Al Virofc14f2f2010-07-25 01:48:30 +0400915struct dentry *mount_single(struct file_system_type *fs_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 int flags, void *data,
Al Virofc14f2f2010-07-25 01:48:30 +0400917 int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918{
919 struct super_block *s;
920 int error;
921
922 s = sget(fs_type, compare_single, set_anon_super, NULL);
923 if (IS_ERR(s))
Al Virofc14f2f2010-07-25 01:48:30 +0400924 return ERR_CAST(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 if (!s->s_root) {
926 s->s_flags = flags;
Theodore Ts'o9b04c992006-03-24 03:15:10 -0800927 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 if (error) {
Al Viro74dbbdd2009-05-06 01:07:50 -0400929 deactivate_locked_super(s);
Al Virofc14f2f2010-07-25 01:48:30 +0400930 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 }
932 s->s_flags |= MS_ACTIVE;
Kay Sievers9329d1b2009-12-18 21:18:15 +0100933 } else {
934 do_remount_sb(s, flags, data, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 }
Al Virofc14f2f2010-07-25 01:48:30 +0400936 return dget(s->s_root);
937}
938EXPORT_SYMBOL(mount_single);
939
940int get_sb_single(struct file_system_type *fs_type,
941 int flags, void *data,
942 int (*fill_super)(struct super_block *, void *, int),
943 struct vfsmount *mnt)
944{
945 struct dentry *root;
946 root = mount_single(fs_type, flags, data, fill_super);
947 if (IS_ERR(root))
948 return PTR_ERR(root);
949 mnt->mnt_root = root;
950 mnt->mnt_sb = root->d_sb;
Sukadev Bhattiprolua3ec9472009-03-04 12:06:34 -0800951 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
953
954EXPORT_SYMBOL(get_sb_single);
955
956struct vfsmount *
Trond Myklebustbb4a58b2006-06-09 09:34:15 -0400957vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 struct vfsmount *mnt;
Al Viroc96e41e2010-07-25 00:17:56 +0400960 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 char *secdata = NULL;
David Howells454e2392006-06-23 02:02:57 -0700962 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 if (!type)
965 return ERR_PTR(-ENODEV);
966
David Howells454e2392006-06-23 02:02:57 -0700967 error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 mnt = alloc_vfsmnt(name);
969 if (!mnt)
970 goto out;
971
Al Viro80893522010-02-05 09:30:46 -0500972 if (flags & MS_KERNMOUNT)
973 mnt->mnt_flags = MNT_INTERNAL;
974
Eric Parise0007522008-03-05 10:31:54 -0500975 if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 secdata = alloc_secdata();
David Howells454e2392006-06-23 02:02:57 -0700977 if (!secdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 goto out_mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
Eric Parise0007522008-03-05 10:31:54 -0500980 error = security_sb_copy_data(data, secdata);
David Howells454e2392006-06-23 02:02:57 -0700981 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 goto out_free_secdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 }
984
Al Viroc96e41e2010-07-25 00:17:56 +0400985 if (type->mount) {
986 root = type->mount(type, flags, name, data);
987 if (IS_ERR(root)) {
988 error = PTR_ERR(root);
989 goto out_free_secdata;
990 }
991 mnt->mnt_root = root;
992 mnt->mnt_sb = root->d_sb;
993 } else {
994 error = type->get_sb(type, flags, name, data, mnt);
995 if (error < 0)
996 goto out_free_secdata;
997 }
Lee Schermerhornb4c07bc2007-07-15 23:40:54 -0700998 BUG_ON(!mnt->mnt_sb);
Jörn Engel5129a462010-04-25 08:54:42 +0200999 WARN_ON(!mnt->mnt_sb->s_bdi);
Al Viro7a4dec52010-08-09 12:05:43 -04001000 mnt->mnt_sb->s_flags |= MS_BORN;
David Howells454e2392006-06-23 02:02:57 -07001001
Jörn Engel5129a462010-04-25 08:54:42 +02001002 error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
1003 if (error)
1004 goto out_sb;
David Howells454e2392006-06-23 02:02:57 -07001005
Jeff Layton42cb56a2009-09-18 13:05:53 -07001006 /*
1007 * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
1008 * but s_maxbytes was an unsigned long long for many releases. Throw
1009 * this warning for a little while to try and catch filesystems that
1010 * violate this rule. This warning should be either removed or
1011 * converted to a BUG() in 2.6.34.
1012 */
1013 WARN((mnt->mnt_sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
1014 "negative value (%lld)\n", type->name, mnt->mnt_sb->s_maxbytes);
1015
David Howells454e2392006-06-23 02:02:57 -07001016 mnt->mnt_mountpoint = mnt->mnt_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 mnt->mnt_parent = mnt;
David Howells454e2392006-06-23 02:02:57 -07001018 up_write(&mnt->mnt_sb->s_umount);
Gerald Schaefer8680e222005-06-21 17:15:16 -07001019 free_secdata(secdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 return mnt;
1021out_sb:
David Howells454e2392006-06-23 02:02:57 -07001022 dput(mnt->mnt_root);
Al Viro74dbbdd2009-05-06 01:07:50 -04001023 deactivate_locked_super(mnt->mnt_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024out_free_secdata:
1025 free_secdata(secdata);
1026out_mnt:
1027 free_vfsmnt(mnt);
1028out:
David Howells454e2392006-06-23 02:02:57 -07001029 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030}
1031
Trond Myklebustbb4a58b2006-06-09 09:34:15 -04001032EXPORT_SYMBOL_GPL(vfs_kern_mount);
1033
Josef Bacik18e9e512010-03-23 10:34:56 -04001034/**
Randy Dunlap7000d3c2010-05-24 22:22:34 -07001035 * freeze_super - lock the filesystem and force it into a consistent state
1036 * @sb: the super to lock
Josef Bacik18e9e512010-03-23 10:34:56 -04001037 *
1038 * Syncs the super to make sure the filesystem is consistent and calls the fs's
1039 * freeze_fs. Subsequent calls to this without first thawing the fs will return
1040 * -EBUSY.
1041 */
1042int freeze_super(struct super_block *sb)
1043{
1044 int ret;
1045
1046 atomic_inc(&sb->s_active);
1047 down_write(&sb->s_umount);
1048 if (sb->s_frozen) {
1049 deactivate_locked_super(sb);
1050 return -EBUSY;
1051 }
1052
1053 if (sb->s_flags & MS_RDONLY) {
1054 sb->s_frozen = SB_FREEZE_TRANS;
1055 smp_wmb();
1056 up_write(&sb->s_umount);
1057 return 0;
1058 }
1059
1060 sb->s_frozen = SB_FREEZE_WRITE;
1061 smp_wmb();
1062
1063 sync_filesystem(sb);
1064
1065 sb->s_frozen = SB_FREEZE_TRANS;
1066 smp_wmb();
1067
1068 sync_blockdev(sb->s_bdev);
1069 if (sb->s_op->freeze_fs) {
1070 ret = sb->s_op->freeze_fs(sb);
1071 if (ret) {
1072 printk(KERN_ERR
1073 "VFS:Filesystem freeze failed\n");
1074 sb->s_frozen = SB_UNFROZEN;
1075 deactivate_locked_super(sb);
1076 return ret;
1077 }
1078 }
1079 up_write(&sb->s_umount);
1080 return 0;
1081}
1082EXPORT_SYMBOL(freeze_super);
1083
1084/**
1085 * thaw_super -- unlock filesystem
1086 * @sb: the super to thaw
1087 *
1088 * Unlocks the filesystem and marks it writeable again after freeze_super().
1089 */
1090int thaw_super(struct super_block *sb)
1091{
1092 int error;
1093
1094 down_write(&sb->s_umount);
1095 if (sb->s_frozen == SB_UNFROZEN) {
1096 up_write(&sb->s_umount);
1097 return -EINVAL;
1098 }
1099
1100 if (sb->s_flags & MS_RDONLY)
1101 goto out;
1102
1103 if (sb->s_op->unfreeze_fs) {
1104 error = sb->s_op->unfreeze_fs(sb);
1105 if (error) {
1106 printk(KERN_ERR
1107 "VFS:Filesystem thaw failed\n");
1108 sb->s_frozen = SB_FREEZE_TRANS;
1109 up_write(&sb->s_umount);
1110 return error;
1111 }
1112 }
1113
1114out:
1115 sb->s_frozen = SB_UNFROZEN;
1116 smp_wmb();
1117 wake_up(&sb->s_wait_unfrozen);
1118 deactivate_locked_super(sb);
1119
1120 return 0;
1121}
1122EXPORT_SYMBOL(thaw_super);
1123
Miklos Szeredi79c0b2d2007-05-08 00:25:43 -07001124static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
1125{
1126 int err;
1127 const char *subtype = strchr(fstype, '.');
1128 if (subtype) {
1129 subtype++;
1130 err = -EINVAL;
1131 if (!subtype[0])
1132 goto err;
1133 } else
1134 subtype = "";
1135
1136 mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
1137 err = -ENOMEM;
1138 if (!mnt->mnt_sb->s_subtype)
1139 goto err;
1140 return mnt;
1141
1142 err:
Nick Pigginb3e19d92011-01-07 17:50:11 +11001143 mntput_long(mnt);
Miklos Szeredi79c0b2d2007-05-08 00:25:43 -07001144 return ERR_PTR(err);
1145}
1146
Trond Myklebustbb4a58b2006-06-09 09:34:15 -04001147struct vfsmount *
1148do_kern_mount(const char *fstype, int flags, const char *name, void *data)
1149{
1150 struct file_system_type *type = get_fs_type(fstype);
1151 struct vfsmount *mnt;
1152 if (!type)
1153 return ERR_PTR(-ENODEV);
1154 mnt = vfs_kern_mount(type, flags, name, data);
Miklos Szeredi79c0b2d2007-05-08 00:25:43 -07001155 if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
1156 !mnt->mnt_sb->s_subtype)
1157 mnt = fs_set_subtype(mnt, fstype);
Trond Myklebustbb4a58b2006-06-09 09:34:15 -04001158 put_filesystem(type);
1159 return mnt;
1160}
Al Viro8a4e98d2008-02-24 01:43:03 -05001161EXPORT_SYMBOL_GPL(do_kern_mount);
Trond Myklebustbb4a58b2006-06-09 09:34:15 -04001162
Pavel Emelyanov8bf97252007-10-18 23:40:02 -07001163struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
Pavel Emelyanov8bf97252007-10-18 23:40:02 -07001165 return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166}
1167
Pavel Emelyanov8bf97252007-10-18 23:40:02 -07001168EXPORT_SYMBOL_GPL(kern_mount_data);