4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * super.c contains code to handle: - mount structures
8 * - filesystem drivers list
10 * - umount system call
13 * GK 2/5/95 - Changed to support mounting the root fs via NFS
15 * Added kerneld support: Jacques Gelinas and Bjorn Ekwall
16 * Added change_root: Werner Almesberger & Hans Lermen, Feb '96
17 * Added options to /proc/mounts:
18 * Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
19 * Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
20 * Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
23 #include <linux/config.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/init.h>
27 #include <linux/smp_lock.h>
28 #include <linux/acct.h>
29 #include <linux/blkdev.h>
30 #include <linux/quotaops.h>
31 #include <linux/namei.h>
32 #include <linux/buffer_head.h> /* for fsync_super() */
33 #include <linux/mount.h>
34 #include <linux/security.h>
35 #include <linux/syscalls.h>
36 #include <linux/vfs.h>
37 #include <linux/writeback.h> /* for the emergency remount stuff */
38 #include <linux/idr.h>
39 #include <linux/kobject.h>
40 #include <asm/uaccess.h>
43 void get_filesystem(struct file_system_type
*fs
);
44 void put_filesystem(struct file_system_type
*fs
);
45 struct file_system_type
*get_fs_type(const char *name
);
47 LIST_HEAD(super_blocks
);
48 DEFINE_SPINLOCK(sb_lock
);
51 * alloc_super - create new superblock
53 * Allocates and initializes a new &struct super_block. alloc_super()
54 * returns a pointer new superblock or %NULL if allocation had failed.
56 static struct super_block
*alloc_super(void)
58 struct super_block
*s
= kmalloc(sizeof(struct super_block
), GFP_USER
);
59 static struct super_operations default_op
;
62 memset(s
, 0, sizeof(struct super_block
));
63 if (security_sb_alloc(s
)) {
68 INIT_LIST_HEAD(&s
->s_dirty
);
69 INIT_LIST_HEAD(&s
->s_io
);
70 INIT_LIST_HEAD(&s
->s_files
);
71 INIT_LIST_HEAD(&s
->s_instances
);
72 INIT_HLIST_HEAD(&s
->s_anon
);
73 INIT_LIST_HEAD(&s
->s_inodes
);
74 init_rwsem(&s
->s_umount
);
75 sema_init(&s
->s_lock
, 1);
76 down_write(&s
->s_umount
);
78 atomic_set(&s
->s_active
, 1);
79 sema_init(&s
->s_vfs_rename_sem
,1);
80 sema_init(&s
->s_dquot
.dqio_sem
, 1);
81 sema_init(&s
->s_dquot
.dqonoff_sem
, 1);
82 init_rwsem(&s
->s_dquot
.dqptr_sem
);
83 init_waitqueue_head(&s
->s_wait_unfrozen
);
84 s
->s_maxbytes
= MAX_NON_LFS
;
85 s
->dq_op
= sb_dquot_ops
;
86 s
->s_qcop
= sb_quotactl_ops
;
87 s
->s_op
= &default_op
;
88 s
->s_time_gran
= 1000000000;
95 * destroy_super - frees a superblock
96 * @s: superblock to free
100 static inline void destroy_super(struct super_block
*s
)
106 /* Superblock refcounting */
109 * Drop a superblock's refcount. Returns non-zero if the superblock was
110 * destroyed. The caller must hold sb_lock.
112 int __put_super(struct super_block
*sb
)
116 if (!--sb
->s_count
) {
124 * Drop a superblock's refcount.
125 * Returns non-zero if the superblock is about to be destroyed and
126 * at least is already removed from super_blocks list, so if we are
127 * making a loop through super blocks then we need to restart.
128 * The caller must hold sb_lock.
130 int __put_super_and_need_restart(struct super_block
*sb
)
132 /* check for race with generic_shutdown_super() */
133 if (list_empty(&sb
->s_list
)) {
134 /* super block is removed, need to restart... */
138 /* can't be the last, since s_list is still in use */
140 BUG_ON(sb
->s_count
== 0);
145 * put_super - drop a temporary reference to superblock
146 * @sb: superblock in question
148 * Drops a temporary reference, frees superblock if there's no
151 static void put_super(struct super_block
*sb
)
155 spin_unlock(&sb_lock
);
160 * deactivate_super - drop an active reference to superblock
161 * @s: superblock to deactivate
163 * Drops an active reference to superblock, acquiring a temprory one if
164 * there is no active references left. In that case we lock superblock,
165 * tell fs driver to shut it down and drop the temporary reference we
168 void deactivate_super(struct super_block
*s
)
170 struct file_system_type
*fs
= s
->s_type
;
171 if (atomic_dec_and_lock(&s
->s_active
, &sb_lock
)) {
172 s
->s_count
-= S_BIAS
-1;
173 spin_unlock(&sb_lock
);
175 down_write(&s
->s_umount
);
182 EXPORT_SYMBOL(deactivate_super
);
185 * grab_super - acquire an active reference
186 * @s: reference we are trying to make active
188 * Tries to acquire an active reference. grab_super() is used when we
189 * had just found a superblock in super_blocks or fs_type->fs_supers
190 * and want to turn it into a full-blown active reference. grab_super()
191 * is called with sb_lock held and drops it. Returns 1 in case of
192 * success, 0 if we had failed (superblock contents was already dead or
193 * dying when grab_super() had been called).
195 static int grab_super(struct super_block
*s
)
198 spin_unlock(&sb_lock
);
199 down_write(&s
->s_umount
);
202 if (s
->s_count
> S_BIAS
) {
203 atomic_inc(&s
->s_active
);
205 spin_unlock(&sb_lock
);
208 spin_unlock(&sb_lock
);
210 up_write(&s
->s_umount
);
217 * generic_shutdown_super - common helper for ->kill_sb()
218 * @sb: superblock to kill
220 * generic_shutdown_super() does all fs-independent work on superblock
221 * shutdown. Typical ->kill_sb() should pick all fs-specific objects
222 * that need destruction out of superblock, call generic_shutdown_super()
223 * and release aforementioned objects. Note: dentries and inodes _are_
224 * taken care of and do not need specific handling.
226 void generic_shutdown_super(struct super_block
*sb
)
228 struct dentry
*root
= sb
->s_root
;
229 struct super_operations
*sop
= sb
->s_op
;
233 shrink_dcache_parent(root
);
234 shrink_dcache_anon(&sb
->s_anon
);
238 sb
->s_flags
&= ~MS_ACTIVE
;
239 /* bad name - it should be evict_inodes() */
240 invalidate_inodes(sb
);
243 if (sop
->write_super
&& sb
->s_dirt
)
244 sop
->write_super(sb
);
248 /* Forget any remaining inodes */
249 if (invalidate_inodes(sb
)) {
250 printk("VFS: Busy inodes after unmount. "
251 "Self-destruct in 5 seconds. Have a nice day...\n");
258 /* should be initialized for __put_super_and_need_restart() */
259 list_del_init(&sb
->s_list
);
260 list_del(&sb
->s_instances
);
261 spin_unlock(&sb_lock
);
262 up_write(&sb
->s_umount
);
265 EXPORT_SYMBOL(generic_shutdown_super
);
268 * sget - find or create a superblock
269 * @type: filesystem type superblock should belong to
270 * @test: comparison callback
271 * @set: setup callback
272 * @data: argument to each of them
274 struct super_block
*sget(struct file_system_type
*type
,
275 int (*test
)(struct super_block
*,void *),
276 int (*set
)(struct super_block
*,void *),
279 struct super_block
*s
= NULL
;
285 if (test
) list_for_each(p
, &type
->fs_supers
) {
286 struct super_block
*old
;
287 old
= list_entry(p
, struct super_block
, s_instances
);
288 if (!test(old
, data
))
290 if (!grab_super(old
))
297 spin_unlock(&sb_lock
);
300 return ERR_PTR(-ENOMEM
);
306 spin_unlock(&sb_lock
);
311 strlcpy(s
->s_id
, type
->name
, sizeof(s
->s_id
));
312 list_add_tail(&s
->s_list
, &super_blocks
);
313 list_add(&s
->s_instances
, &type
->fs_supers
);
314 spin_unlock(&sb_lock
);
315 get_filesystem(type
);
321 void drop_super(struct super_block
*sb
)
323 up_read(&sb
->s_umount
);
327 EXPORT_SYMBOL(drop_super
);
329 static inline void write_super(struct super_block
*sb
)
332 if (sb
->s_root
&& sb
->s_dirt
)
333 if (sb
->s_op
->write_super
)
334 sb
->s_op
->write_super(sb
);
339 * Note: check the dirty flag before waiting, so we don't
340 * hold up the sync while mounting a device. (The newly
341 * mounted device won't need syncing.)
343 void sync_supers(void)
345 struct super_block
*sb
;
349 list_for_each_entry(sb
, &super_blocks
, s_list
) {
352 spin_unlock(&sb_lock
);
353 down_read(&sb
->s_umount
);
355 up_read(&sb
->s_umount
);
357 if (__put_super_and_need_restart(sb
))
361 spin_unlock(&sb_lock
);
365 * Call the ->sync_fs super_op against all filesytems which are r/w and
366 * which implement it.
368 * This operation is careful to avoid the livelock which could easily happen
369 * if two or more filesystems are being continuously dirtied. s_need_sync_fs
370 * is used only here. We set it against all filesystems and then clear it as
371 * we sync them. So redirtied filesystems are skipped.
373 * But if process A is currently running sync_filesytems and then process B
374 * calls sync_filesystems as well, process B will set all the s_need_sync_fs
375 * flags again, which will cause process A to resync everything. Fix that with
378 * (Fabian) Avoid sync_fs with clean fs & wait mode 0
380 void sync_filesystems(int wait
)
382 struct super_block
*sb
;
383 static DECLARE_MUTEX(mutex
);
385 down(&mutex
); /* Could be down_interruptible */
387 list_for_each_entry(sb
, &super_blocks
, s_list
) {
388 if (!sb
->s_op
->sync_fs
)
390 if (sb
->s_flags
& MS_RDONLY
)
392 sb
->s_need_sync_fs
= 1;
396 list_for_each_entry(sb
, &super_blocks
, s_list
) {
397 if (!sb
->s_need_sync_fs
)
399 sb
->s_need_sync_fs
= 0;
400 if (sb
->s_flags
& MS_RDONLY
)
401 continue; /* hm. Was remounted r/o meanwhile */
403 spin_unlock(&sb_lock
);
404 down_read(&sb
->s_umount
);
405 if (sb
->s_root
&& (wait
|| sb
->s_dirt
))
406 sb
->s_op
->sync_fs(sb
, wait
);
407 up_read(&sb
->s_umount
);
408 /* restart only when sb is no longer on the list */
410 if (__put_super_and_need_restart(sb
))
413 spin_unlock(&sb_lock
);
418 * get_super - get the superblock of a device
419 * @bdev: device to get the superblock for
421 * Scans the superblock list and finds the superblock of the file system
422 * mounted on the device given. %NULL is returned if no match is found.
425 struct super_block
* get_super(struct block_device
*bdev
)
427 struct super_block
*sb
;
434 list_for_each_entry(sb
, &super_blocks
, s_list
) {
435 if (sb
->s_bdev
== bdev
) {
437 spin_unlock(&sb_lock
);
438 down_read(&sb
->s_umount
);
441 up_read(&sb
->s_umount
);
442 /* restart only when sb is no longer on the list */
444 if (__put_super_and_need_restart(sb
))
448 spin_unlock(&sb_lock
);
452 EXPORT_SYMBOL(get_super
);
454 struct super_block
* user_get_super(dev_t dev
)
456 struct super_block
*sb
;
460 list_for_each_entry(sb
, &super_blocks
, s_list
) {
461 if (sb
->s_dev
== dev
) {
463 spin_unlock(&sb_lock
);
464 down_read(&sb
->s_umount
);
467 up_read(&sb
->s_umount
);
468 /* restart only when sb is no longer on the list */
470 if (__put_super_and_need_restart(sb
))
474 spin_unlock(&sb_lock
);
478 asmlinkage
long sys_ustat(unsigned dev
, struct ustat __user
* ubuf
)
480 struct super_block
*s
;
485 s
= user_get_super(new_decode_dev(dev
));
488 err
= vfs_statfs(s
, &sbuf
);
493 memset(&tmp
,0,sizeof(struct ustat
));
494 tmp
.f_tfree
= sbuf
.f_bfree
;
495 tmp
.f_tinode
= sbuf
.f_ffree
;
497 err
= copy_to_user(ubuf
,&tmp
,sizeof(struct ustat
)) ? -EFAULT
: 0;
504 * @sb: superblock in question
506 * All files are marked read/only. We don't care about pending
507 * delete files so this should be used in 'force' mode only
510 static void mark_files_ro(struct super_block
*sb
)
515 list_for_each_entry(f
, &sb
->s_files
, f_u
.fu_list
) {
516 if (S_ISREG(f
->f_dentry
->d_inode
->i_mode
) && file_count(f
))
517 f
->f_mode
&= ~FMODE_WRITE
;
523 * do_remount_sb - asks filesystem to change mount options.
524 * @sb: superblock in question
525 * @flags: numeric part of options
526 * @data: the rest of options
527 * @force: whether or not to force the change
529 * Alters the mount options of a mounted file system.
531 int do_remount_sb(struct super_block
*sb
, int flags
, void *data
, int force
)
535 if (!(flags
& MS_RDONLY
) && bdev_read_only(sb
->s_bdev
))
537 if (flags
& MS_RDONLY
)
539 shrink_dcache_sb(sb
);
542 /* If we are remounting RDONLY and current sb is read/write,
543 make sure there are no rw files opened */
544 if ((flags
& MS_RDONLY
) && !(sb
->s_flags
& MS_RDONLY
)) {
547 else if (!fs_may_remount_ro(sb
))
551 if (sb
->s_op
->remount_fs
) {
553 retval
= sb
->s_op
->remount_fs(sb
, &flags
, data
);
558 sb
->s_flags
= (sb
->s_flags
& ~MS_RMT_MASK
) | (flags
& MS_RMT_MASK
);
562 static void do_emergency_remount(unsigned long foo
)
564 struct super_block
*sb
;
567 list_for_each_entry(sb
, &super_blocks
, s_list
) {
569 spin_unlock(&sb_lock
);
570 down_read(&sb
->s_umount
);
571 if (sb
->s_root
&& sb
->s_bdev
&& !(sb
->s_flags
& MS_RDONLY
)) {
573 * ->remount_fs needs lock_kernel().
575 * What lock protects sb->s_flags??
578 do_remount_sb(sb
, MS_RDONLY
, NULL
, 1);
584 spin_unlock(&sb_lock
);
585 printk("Emergency Remount complete\n");
588 void emergency_remount(void)
590 pdflush_operation(do_emergency_remount
, 0);
594 * Unnamed block devices are dummy devices used by virtual
595 * filesystems which don't use real block-devices. -- jrs
598 static struct idr unnamed_dev_idr
;
599 static DEFINE_SPINLOCK(unnamed_dev_lock
);/* protects the above */
601 int set_anon_super(struct super_block
*s
, void *data
)
607 if (idr_pre_get(&unnamed_dev_idr
, GFP_ATOMIC
) == 0)
609 spin_lock(&unnamed_dev_lock
);
610 error
= idr_get_new(&unnamed_dev_idr
, NULL
, &dev
);
611 spin_unlock(&unnamed_dev_lock
);
612 if (error
== -EAGAIN
)
613 /* We raced and lost with another CPU. */
618 if ((dev
& MAX_ID_MASK
) == (1 << MINORBITS
)) {
619 spin_lock(&unnamed_dev_lock
);
620 idr_remove(&unnamed_dev_idr
, dev
);
621 spin_unlock(&unnamed_dev_lock
);
624 s
->s_dev
= MKDEV(0, dev
& MINORMASK
);
628 EXPORT_SYMBOL(set_anon_super
);
630 void kill_anon_super(struct super_block
*sb
)
632 int slot
= MINOR(sb
->s_dev
);
634 generic_shutdown_super(sb
);
635 spin_lock(&unnamed_dev_lock
);
636 idr_remove(&unnamed_dev_idr
, slot
);
637 spin_unlock(&unnamed_dev_lock
);
640 EXPORT_SYMBOL(kill_anon_super
);
642 void __init
unnamed_dev_init(void)
644 idr_init(&unnamed_dev_idr
);
647 void kill_litter_super(struct super_block
*sb
)
650 d_genocide(sb
->s_root
);
654 EXPORT_SYMBOL(kill_litter_super
);
656 static int set_bdev_super(struct super_block
*s
, void *data
)
659 s
->s_dev
= s
->s_bdev
->bd_dev
;
663 static int test_bdev_super(struct super_block
*s
, void *data
)
665 return (void *)s
->s_bdev
== data
;
668 struct super_block
*get_sb_bdev(struct file_system_type
*fs_type
,
669 int flags
, const char *dev_name
, void *data
,
670 int (*fill_super
)(struct super_block
*, void *, int))
672 struct block_device
*bdev
;
673 struct super_block
*s
;
676 bdev
= open_bdev_excl(dev_name
, flags
, fs_type
);
678 return (struct super_block
*)bdev
;
681 * once the super is inserted into the list by sget, s_umount
682 * will protect the lockfs code from trying to start a snapshot
683 * while we are mounting
685 down(&bdev
->bd_mount_sem
);
686 s
= sget(fs_type
, test_bdev_super
, set_bdev_super
, bdev
);
687 up(&bdev
->bd_mount_sem
);
692 if ((flags
^ s
->s_flags
) & MS_RDONLY
) {
693 up_write(&s
->s_umount
);
699 char b
[BDEVNAME_SIZE
];
702 strlcpy(s
->s_id
, bdevname(bdev
, b
), sizeof(s
->s_id
));
703 sb_set_blocksize(s
, block_size(bdev
));
704 error
= fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
706 up_write(&s
->s_umount
);
710 s
->s_flags
|= MS_ACTIVE
;
716 close_bdev_excl(bdev
);
720 EXPORT_SYMBOL(get_sb_bdev
);
722 void kill_block_super(struct super_block
*sb
)
724 struct block_device
*bdev
= sb
->s_bdev
;
726 generic_shutdown_super(sb
);
728 close_bdev_excl(bdev
);
731 EXPORT_SYMBOL(kill_block_super
);
733 struct super_block
*get_sb_nodev(struct file_system_type
*fs_type
,
734 int flags
, void *data
,
735 int (*fill_super
)(struct super_block
*, void *, int))
738 struct super_block
*s
= sget(fs_type
, NULL
, set_anon_super
, NULL
);
745 error
= fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
747 up_write(&s
->s_umount
);
749 return ERR_PTR(error
);
751 s
->s_flags
|= MS_ACTIVE
;
755 EXPORT_SYMBOL(get_sb_nodev
);
757 static int compare_single(struct super_block
*s
, void *p
)
762 struct super_block
*get_sb_single(struct file_system_type
*fs_type
,
763 int flags
, void *data
,
764 int (*fill_super
)(struct super_block
*, void *, int))
766 struct super_block
*s
;
769 s
= sget(fs_type
, compare_single
, set_anon_super
, NULL
);
774 error
= fill_super(s
, data
, flags
& MS_VERBOSE
? 1 : 0);
776 up_write(&s
->s_umount
);
778 return ERR_PTR(error
);
780 s
->s_flags
|= MS_ACTIVE
;
782 do_remount_sb(s
, flags
, data
, 0);
786 EXPORT_SYMBOL(get_sb_single
);
789 do_kern_mount(const char *fstype
, int flags
, const char *name
, void *data
)
791 struct file_system_type
*type
= get_fs_type(fstype
);
792 struct super_block
*sb
= ERR_PTR(-ENOMEM
);
793 struct vfsmount
*mnt
;
795 char *secdata
= NULL
;
798 return ERR_PTR(-ENODEV
);
800 mnt
= alloc_vfsmnt(name
);
805 secdata
= alloc_secdata();
807 sb
= ERR_PTR(-ENOMEM
);
811 error
= security_sb_copy_data(type
, data
, secdata
);
814 goto out_free_secdata
;
818 sb
= type
->get_sb(type
, flags
, name
, data
);
820 goto out_free_secdata
;
821 error
= security_sb_kern_mount(sb
, secdata
);
825 mnt
->mnt_root
= dget(sb
->s_root
);
826 mnt
->mnt_mountpoint
= sb
->s_root
;
827 mnt
->mnt_parent
= mnt
;
828 up_write(&sb
->s_umount
);
829 free_secdata(secdata
);
830 put_filesystem(type
);
833 up_write(&sb
->s_umount
);
834 deactivate_super(sb
);
837 free_secdata(secdata
);
841 put_filesystem(type
);
842 return (struct vfsmount
*)sb
;
845 EXPORT_SYMBOL_GPL(do_kern_mount
);
847 struct vfsmount
*kern_mount(struct file_system_type
*type
)
849 return do_kern_mount(type
->name
, 0, type
->name
, NULL
);
852 EXPORT_SYMBOL(kern_mount
);