vfs: Fix crashes when reading /proc/mounts
Jan Kara
reviewerv2 cover vfs: Fix crashes when reading /proc/mounts
Hello,
this is a second revision of the patch series which aims at fixing possible races between functions formatting output for /proc/mounts and friends and remount. Especially ->show_options functions of filesystems are not counting with the fact that options can change under them and thus races can result in bogus output or outright crashes (like was the case with ext4 handling of quota mount option, or udf could crash when printing charset name, or xfs when printing log device name etc.).
Since v1, I have changed the logic so that all the locking & restart magic happens in m_show() so that we don't bail back to traverse(), then m_start(), and then back to m_show(). Al, is it better this way?
I was not able to get rid of the hold_sb() helper which you didn't like much as namespace_sem is private to fs/namespace.c and we need to drop it after acquiring sb reference and before blocking on sb->s_umount semaphore. So hold_sb() still looked like the least painful solution.
Honza
Jan Kara
reviewerPATCH v2 1/2 vfs: Provide function to grab superblock reference
Provide function to hold superblock reference when we are sure the superblock is active. This function will get used by code reading /proc/mounts and friends.
--- fs/internal.h | 2 ++ fs/super.c | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+)
fs/internal.h +2 -0
@@ -104,6 +104,8 @@ extern bool trylock_super(struct super_block *sb);extern struct dentry *mount_fs (struct file_system_type *,int ,const char *,void *);extern struct super_block *user_get_super (dev_t ); +extern void hold_sb (struct super_block *sb); +extern bool mount_trylock_super (struct super_block *sb);/* * open.c
fs/super.c +35 -0
@@ -775,6 +775,41 @@ struct super_block *get_super_exclusive_thawed(struct block_device *bdev) }EXPORT_SYMBOL (get_super_exclusive_thawed); +/** +* hold_sb - get superblock reference for active superblock +* @sb: superblock to get reference for +* +* Get reference to superblock. The caller must make sure the superblock +* is currently active by other means (e.g. holding an active reference +* itself or holding namespace_sem preventing unmount). +*/ +void hold_sb (struct super_block *sb) +{ +spin_lock (&sb_lock); +WARN_ON_ONCE (!atomic_read (&sb->s_active)); + sb->s_count++; +spin_unlock (&sb_lock); +} + +/** +* mount_trylock_super - get superblock and lock it against remount +* @sb: superblock to get reference for +* +* Get reference to superblock and protect superblock against racing +* remount or umount. The caller must make sure the superblock +* is currently active by other means (e.g. holding an active reference +* itself or holding namespace_sem preventing unmount). +*/ +bool mount_trylock_super (struct super_block *sb) +{ +hold_sb (sb); +if (!down_read_trylock (&sb->s_umount)) { +put_super (sb); +return false; + } +return true; +} +/** * get_active_super - get an active reference to the superblock of a device * @bdev: device to get the superblock for
Signature · 1 line
2.16.4
Jan Kara
reviewerPATCH v2 2/2 proc: Protect readers of /proc/mounts from remount
In reply to Jan KaraReaders of /proc/mounts (and similar files) are currently unprotected from concurrently running remount on the filesystem they are reporting. This can not only result in bogus reported information but also in confusion in filesystems ->show_options callbacks resulting in use-after-free issues or similar (for example ext4 handling of quota file names is prone to such races).
Fix the problem by protecting showing of mount information with sb->s_umount semaphore.
--- fs/namespace.c | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-)
fs/namespace.c +33 -3
@@ -1263,7 +1263,7 @@ static void *m_next(struct seq_file *m, void *v, loff_t *pos) {struct proc_mounts *p = m->private; - p->cached_mount =seq_list_next (v, &p->ns->list, pos); + p->cached_mount =seq_list_next (p->cached_mount, &p->ns->list, pos); p->cached_index = *pos;return p->cached_mount; }
@@ -1276,8 +1276,38 @@ static void m_stop(struct seq_file *m, void *v)static int m_show (struct seq_file *m,void *v) {struct proc_mounts *p = m->private; - struct mount *r = list_entry(v, struct mount, mnt_list); -return p->show (m, &r->mnt); +struct mount *r; +struct super_block *sb; +int ret; + +restart: + r = list_entry(v, struct mount, mnt_list); + sb = r->mnt.mnt_sb; + +/* Protect show function against racing remount */ +if (mount_trylock_super (sb)) + goto show; +/* +* Trylock failed. Since namepace_sem ranks below s_umount (through +* sb->s_umount > dir->i_rwsem > namespace_sem in the mount path), we +* have to drop it, wait for s_umount and then try again to guarantee +* forward progress. +*/ +hold_sb (sb); +up_read (&namespace_sem); +down_read (&sb->s_umount); +down_read (&namespace_sem); + v =seq_list_start (&p->ns->list, p->cached_index); +if (!sb->s_root || v != p->cached_mount) { +drop_super (sb); + p->cached_event = p->ns->event; + p->cached_mount = v; + goto restart; + } +show: + ret = p->show (m, &r->mnt); +drop_super (sb); +return ret; }const struct seq_operations mounts_op = {
Signature · 1 line
2.16.4
Jan Kara
reviewerPing Al?
Quoted 20 lines · Jan Kara
Hello,
this is a second revision of the patch series which aims at fixing possible races between functions formatting output for
/proc/mountsand friends and remount. Especially ->show_options functions of filesystems are not counting with the fact that options can change under them and thus races can result in bogus output or outright crashes (like was the case with ext4 handling of quota mount option, or udf could crash when printing charset name, or xfs when printing log device name etc.).Since v1, I have changed the logic so that all the locking & restart magic happens in
m_show()so that we don't bail back totraverse(), thenm_start(), and then back tom_show(). Al, is it better this way?I was not able to get rid of the
hold_sb()helper which you didn't like much asnamespace_semis private tofs/namespace.cand we need to drop it after acquiring sb reference and before blocking onsb->s_umountsemaphore. Sohold_sb()still looked like the least painful solution.Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR