Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 5cee5815d1564bbbd505fea86f4550f1efdb5cd0

Authored by Jan Kara 2009-04-27 22:43:51 +0800

Committed by Al Viro 2009-06-12 09:36:03 +0800

Exists in master and in 7 other branches

vfs: Make sys_sync() use fsync_super() (version 4)

It is unnecessarily fragile to have two places (fsync_super() and do_sync())
doing data integrity sync of the filesystem. Alter __fsync_super() to
accommodate needs of both callers and use it. So after this patch
__fsync_super() is the only place where we gather all the calls needed to
properly send all data on a filesystem to disk.

Nice bonus is that we get a complete livelock avoidance and write_supers()
is now only used for periodic writeback of superblocks.

sync_blockdevs() introduced a couple of patches ago is gone now.

[build fixes folded]

Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 7 changed files with 51 additions and 135 deletions Inline Diff

fs/block_dev.c
fs/fs-writeback.c
fs/internal.h
fs/super.c
fs/sync.c
include/linux/fs.h
include/linux/writeback.h

fs/block_dev.c

Diff comments View file @ 5cee581

 /*
  *  linux/fs/block_dev.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
  */
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/fcntl.h>
 #include <linux/slab.h>
 #include <linux/kmod.h>
 #include <linux/major.h>
 #include <linux/smp_lock.h>
 #include <linux/device_cgroup.h>
 #include <linux/highmem.h>
 #include <linux/blkdev.h>
 #include <linux/module.h>
 #include <linux/blkpg.h>
 #include <linux/buffer_head.h>
 #include <linux/pagevec.h>
 #include <linux/writeback.h>
 #include <linux/mpage.h>
 #include <linux/mount.h>
 #include <linux/uio.h>
 #include <linux/namei.h>
 #include <linux/log2.h>
 #include <linux/kmemleak.h>
 #include <asm/uaccess.h>
 #include "internal.h"
 struct bdev_inode {
 	struct block_device bdev;
 	struct inode vfs_inode;
 };
 static const struct address_space_operations def_blk_aops;
 static inline struct bdev_inode *BDEV_I(struct inode *inode)
 {
 	return container_of(inode, struct bdev_inode, vfs_inode);
 }
 inline struct block_device *I_BDEV(struct inode *inode)
 {
 	return &BDEV_I(inode)->bdev;
 }
 EXPORT_SYMBOL(I_BDEV);
 static sector_t max_block(struct block_device *bdev)
 {
 	sector_t retval = ~((sector_t)0);
 	loff_t sz = i_size_read(bdev->bd_inode);
 	if (sz) {
 		unsigned int size = block_size(bdev);
 		unsigned int sizebits = blksize_bits(size);
 		retval = (sz >> sizebits);
 	}
 	return retval;
 }
 /* Kill _all_ buffers and pagecache , dirty or not.. */
 static void kill_bdev(struct block_device *bdev)
 {
 	if (bdev->bd_inode->i_mapping->nrpages == 0)
 		return;
 	invalidate_bh_lrus();
 	truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
 }
 int set_blocksize(struct block_device *bdev, int size)
 {
 	/* Size must be a power of two, and between 512 and PAGE_SIZE */
 	if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
 		return -EINVAL;
 	/* Size cannot be smaller than the size supported by the device */
 	if (size < bdev_logical_block_size(bdev))
 		return -EINVAL;
 	/* Don't change the size if it is same as current */
 	if (bdev->bd_block_size != size) {
 		sync_blockdev(bdev);
 		bdev->bd_block_size = size;
 		bdev->bd_inode->i_blkbits = blksize_bits(size);
 		kill_bdev(bdev);
 	}
 	return 0;
 }
 EXPORT_SYMBOL(set_blocksize);
 int sb_set_blocksize(struct super_block *sb, int size)
 {
 	if (set_blocksize(sb->s_bdev, size))
 		return 0;
 	/* If we get here, we know size is power of two
 	 * and it's value is between 512 and PAGE_SIZE */
 	sb->s_blocksize = size;
 	sb->s_blocksize_bits = blksize_bits(size);
 	return sb->s_blocksize;
 }
 EXPORT_SYMBOL(sb_set_blocksize);
 int sb_min_blocksize(struct super_block *sb, int size)
 {
 	int minsize = bdev_logical_block_size(sb->s_bdev);
 	if (size < minsize)
 		size = minsize;
 	return sb_set_blocksize(sb, size);
 }
 EXPORT_SYMBOL(sb_min_blocksize);
 static int
 blkdev_get_block(struct inode *inode, sector_t iblock,
 		struct buffer_head *bh, int create)
 {
 	if (iblock >= max_block(I_BDEV(inode))) {
 		if (create)
 			return -EIO;
 		/*
 		 * for reads, we're just trying to fill a partial page.
 		 * return a hole, they will have to call get_block again
 		 * before they can fill it, and they will get -EIO at that
 		 * time
 		 */
 		return 0;
 	}
 	bh->b_bdev = I_BDEV(inode);
 	bh->b_blocknr = iblock;
 	set_buffer_mapped(bh);
 	return 0;
 }
 static int
 blkdev_get_blocks(struct inode *inode, sector_t iblock,
 		struct buffer_head *bh, int create)
 {
 	sector_t end_block = max_block(I_BDEV(inode));
 	unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
 	if ((iblock + max_blocks) > end_block) {
 		max_blocks = end_block - iblock;
 		if ((long)max_blocks <= 0) {
 			if (create)
 				return -EIO;	/* write fully beyond EOF */
 			/*
 			 * It is a read which is fully beyond EOF.  We return
 			 * a !buffer_mapped buffer
 			 */
 			max_blocks = 0;
 		}
 	}
 	bh->b_bdev = I_BDEV(inode);
 	bh->b_blocknr = iblock;
 	bh->b_size = max_blocks << inode->i_blkbits;
 	if (max_blocks)
 		set_buffer_mapped(bh);
 	return 0;
 }
 static ssize_t
 blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
 			loff_t offset, unsigned long nr_segs)
 {
 	struct file *file = iocb->ki_filp;
 	struct inode *inode = file->f_mapping->host;
 	return blockdev_direct_IO_no_locking(rw, iocb, inode, I_BDEV(inode),
 				iov, offset, nr_segs, blkdev_get_blocks, NULL);
 }
+int __sync_blockdev(struct block_device *bdev, int wait)
+{
+	if (!bdev)
+		return 0;
+	if (!wait)
+		return filemap_flush(bdev->bd_inode->i_mapping);
+	return filemap_write_and_wait(bdev->bd_inode->i_mapping);
+}
 /*
  * Write out and wait upon all the dirty data associated with a block
  * device via its mapping.  Does not take the superblock lock.
  */
 int sync_blockdev(struct block_device *bdev)
 {
-	int ret = 0;
+	return __sync_blockdev(bdev, 1);
-	if (bdev)
-		ret = filemap_write_and_wait(bdev->bd_inode->i_mapping);
-	return ret;
 }
 EXPORT_SYMBOL(sync_blockdev);
 /*
  * Write out and wait upon all dirty data associated with this
  * device.   Filesystem data as well as the underlying block
  * device.  Takes the superblock lock.
  */
 int fsync_bdev(struct block_device *bdev)
 {
 	struct super_block *sb = get_super(bdev);
 	if (sb) {
 		int res = fsync_super(sb);
 		drop_super(sb);
 		return res;
 	}
 	return sync_blockdev(bdev);
 }
 EXPORT_SYMBOL(fsync_bdev);
 /**
  * freeze_bdev  --  lock a filesystem and force it into a consistent state
  * @bdev:	blockdevice to lock
  *
  * This takes the block device bd_mount_sem to make sure no new mounts
  * happen on bdev until thaw_bdev() is called.
  * If a superblock is found on this device, we take the s_umount semaphore
  * on it to make sure nobody unmounts until the snapshot creation is done.
  * The reference counter (bd_fsfreeze_count) guarantees that only the last
  * unfreeze process can unfreeze the frozen filesystem actually when multiple
  * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
  * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
  * actually.
  */
 struct super_block *freeze_bdev(struct block_device *bdev)
 {
 	struct super_block *sb;
 	int error = 0;
 	mutex_lock(&bdev->bd_fsfreeze_mutex);
 	if (bdev->bd_fsfreeze_count > 0) {
 		bdev->bd_fsfreeze_count++;
 		sb = get_super(bdev);
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
 		return sb;
 	}
 	bdev->bd_fsfreeze_count++;
 	down(&bdev->bd_mount_sem);
 	sb = get_super(bdev);
 	if (sb && !(sb->s_flags & MS_RDONLY)) {
 		sb->s_frozen = SB_FREEZE_WRITE;
 		smp_wmb();
 		fsync_super(sb);
 		sb->s_frozen = SB_FREEZE_TRANS;
 		smp_wmb();
 		sync_blockdev(sb->s_bdev);
 		if (sb->s_op->freeze_fs) {
 			error = sb->s_op->freeze_fs(sb);
 			if (error) {
 				printk(KERN_ERR
 					"VFS:Filesystem freeze failed\n");
 				sb->s_frozen = SB_UNFROZEN;
 				drop_super(sb);
 				up(&bdev->bd_mount_sem);
 				bdev->bd_fsfreeze_count--;
 				mutex_unlock(&bdev->bd_fsfreeze_mutex);
 				return ERR_PTR(error);
 			}
 		}
 	}
 	sync_blockdev(bdev);
 	mutex_unlock(&bdev->bd_fsfreeze_mutex);
 	return sb;	/* thaw_bdev releases s->s_umount and bd_mount_sem */
 }
 EXPORT_SYMBOL(freeze_bdev);
 /**
  * thaw_bdev  -- unlock filesystem
  * @bdev:	blockdevice to unlock
  * @sb:		associated superblock
  *
  * Unlocks the filesystem and marks it writeable again after freeze_bdev().
  */
 int thaw_bdev(struct block_device *bdev, struct super_block *sb)
 {
 	int error = 0;
 	mutex_lock(&bdev->bd_fsfreeze_mutex);
 	if (!bdev->bd_fsfreeze_count) {
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
 		return -EINVAL;
 	}
 	bdev->bd_fsfreeze_count--;
 	if (bdev->bd_fsfreeze_count > 0) {
 		if (sb)
 			drop_super(sb);
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
 		return 0;
 	}
 	if (sb) {
 		BUG_ON(sb->s_bdev != bdev);
 		if (!(sb->s_flags & MS_RDONLY)) {
 			if (sb->s_op->unfreeze_fs) {
 				error = sb->s_op->unfreeze_fs(sb);
 				if (error) {
 					printk(KERN_ERR
 						"VFS:Filesystem thaw failed\n");
 					sb->s_frozen = SB_FREEZE_TRANS;
 					bdev->bd_fsfreeze_count++;
 					mutex_unlock(&bdev->bd_fsfreeze_mutex);
 					return error;
 				}
 			}
 			sb->s_frozen = SB_UNFROZEN;
 			smp_wmb();
 			wake_up(&sb->s_wait_unfrozen);
 		}
 		drop_super(sb);
 	}
 	up(&bdev->bd_mount_sem);
 	mutex_unlock(&bdev->bd_fsfreeze_mutex);
 	return 0;
 }
 EXPORT_SYMBOL(thaw_bdev);
 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
 {
 	return block_write_full_page(page, blkdev_get_block, wbc);
 }
 static int blkdev_readpage(struct file * file, struct page * page)
 {
 	return block_read_full_page(page, blkdev_get_block);
 }
 static int blkdev_write_begin(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned flags,
 			struct page **pagep, void **fsdata)
 {
 	*pagep = NULL;
 	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
 				blkdev_get_block);
 }
 static int blkdev_write_end(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned copied,
 			struct page *page, void *fsdata)
 {
 	int ret;
 	ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
 	unlock_page(page);
 	page_cache_release(page);
 	return ret;
 }
 /*
  * private llseek:
  * for a block special file file->f_path.dentry->d_inode->i_size is zero
  * so we compute the size by hand (just as in block_read/write above)
  */
 static loff_t block_llseek(struct file *file, loff_t offset, int origin)
 {
 	struct inode *bd_inode = file->f_mapping->host;
 	loff_t size;
 	loff_t retval;
 	mutex_lock(&bd_inode->i_mutex);
 	size = i_size_read(bd_inode);
 	switch (origin) {
 		case 2:
 			offset += size;
 			break;
 		case 1:
 			offset += file->f_pos;
 	}
 	retval = -EINVAL;
 	if (offset >= 0 && offset <= size) {
 		if (offset != file->f_pos) {
 			file->f_pos = offset;
 		}
 		retval = offset;
 	}
 	mutex_unlock(&bd_inode->i_mutex);
 	return retval;
 }
 /*
  *	Filp is never NULL; the only case when ->fsync() is called with
  *	NULL first argument is nfsd_sync_dir() and that's not a directory.
  */
 static int block_fsync(struct file *filp, struct dentry *dentry, int datasync)
 {
 	return sync_blockdev(I_BDEV(filp->f_mapping->host));
 }
 /*
  * pseudo-fs
  */
 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
 static struct kmem_cache * bdev_cachep __read_mostly;
 static struct inode *bdev_alloc_inode(struct super_block *sb)
 {
 	struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
 	if (!ei)
 		return NULL;
 	return &ei->vfs_inode;
 }
 static void bdev_destroy_inode(struct inode *inode)
 {
 	struct bdev_inode *bdi = BDEV_I(inode);
 	bdi->bdev.bd_inode_backing_dev_info = NULL;
 	kmem_cache_free(bdev_cachep, bdi);
 }
 static void init_once(void *foo)
 {
 	struct bdev_inode *ei = (struct bdev_inode *) foo;
 	struct block_device *bdev = &ei->bdev;
 	memset(bdev, 0, sizeof(*bdev));
 	mutex_init(&bdev->bd_mutex);
 	sema_init(&bdev->bd_mount_sem, 1);
 	INIT_LIST_HEAD(&bdev->bd_inodes);
 	INIT_LIST_HEAD(&bdev->bd_list);
 #ifdef CONFIG_SYSFS
 	INIT_LIST_HEAD(&bdev->bd_holder_list);
 #endif
 	inode_init_once(&ei->vfs_inode);
 	/* Initialize mutex for freeze. */
 	mutex_init(&bdev->bd_fsfreeze_mutex);
 }
 static inline void __bd_forget(struct inode *inode)
 {
 	list_del_init(&inode->i_devices);
 	inode->i_bdev = NULL;
 	inode->i_mapping = &inode->i_data;
 }
 static void bdev_clear_inode(struct inode *inode)
 {
 	struct block_device *bdev = &BDEV_I(inode)->bdev;
 	struct list_head *p;
 	spin_lock(&bdev_lock);
 	while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
 		__bd_forget(list_entry(p, struct inode, i_devices));
 	}
 	list_del_init(&bdev->bd_list);
 	spin_unlock(&bdev_lock);
 }
 static const struct super_operations bdev_sops = {
 	.statfs = simple_statfs,
 	.alloc_inode = bdev_alloc_inode,
 	.destroy_inode = bdev_destroy_inode,
 	.drop_inode = generic_delete_inode,
 	.clear_inode = bdev_clear_inode,
 };
 static int bd_get_sb(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
 	return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
 }
 static struct file_system_type bd_type = {
 	.name		= "bdev",
 	.get_sb		= bd_get_sb,
 	.kill_sb	= kill_anon_super,
 };
 struct super_block *blockdev_superblock __read_mostly;
 void __init bdev_cache_init(void)
 {
 	int err;
 	struct vfsmount *bd_mnt;
 	bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
 			0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
 				SLAB_MEM_SPREAD|SLAB_PANIC),
 			init_once);
 	err = register_filesystem(&bd_type);
 	if (err)
 		panic("Cannot register bdev pseudo-fs");
 	bd_mnt = kern_mount(&bd_type);
 	if (IS_ERR(bd_mnt))
 		panic("Cannot create bdev pseudo-fs");
 	/*
 	 * This vfsmount structure is only used to obtain the
 	 * blockdev_superblock, so tell kmemleak not to report it.
 	 */
 	kmemleak_not_leak(bd_mnt);
 	blockdev_superblock = bd_mnt->mnt_sb;	/* For writeback */
 }
 /*
  * Most likely _very_ bad one - but then it's hardly critical for small
  * /dev and can be fixed when somebody will need really large one.
  * Keep in mind that it will be fed through icache hash function too.
  */
 static inline unsigned long hash(dev_t dev)
 {
 	return MAJOR(dev)+MINOR(dev);
 }
 static int bdev_test(struct inode *inode, void *data)
 {
 	return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
 }
 static int bdev_set(struct inode *inode, void *data)
 {
 	BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
 	return 0;
 }
 static LIST_HEAD(all_bdevs);
 struct block_device *bdget(dev_t dev)
 {
 	struct block_device *bdev;
 	struct inode *inode;
 	inode = iget5_locked(blockdev_superblock, hash(dev),
 			bdev_test, bdev_set, &dev);
 	if (!inode)
 		return NULL;
 	bdev = &BDEV_I(inode)->bdev;
 	if (inode->i_state & I_NEW) {
 		bdev->bd_contains = NULL;
 		bdev->bd_inode = inode;
 		bdev->bd_block_size = (1 << inode->i_blkbits);
 		bdev->bd_part_count = 0;
 		bdev->bd_invalidated = 0;
 		inode->i_mode = S_IFBLK;
 		inode->i_rdev = dev;
 		inode->i_bdev = bdev;
 		inode->i_data.a_ops = &def_blk_aops;
 		mapping_set_gfp_mask(&inode->i_data, GFP_USER);
 		inode->i_data.backing_dev_info = &default_backing_dev_info;
 		spin_lock(&bdev_lock);
 		list_add(&bdev->bd_list, &all_bdevs);
 		spin_unlock(&bdev_lock);
 		unlock_new_inode(inode);
 	}
 	return bdev;
 }
 EXPORT_SYMBOL(bdget);
 long nr_blockdev_pages(void)
 {
 	struct block_device *bdev;
 	long ret = 0;
 	spin_lock(&bdev_lock);
 	list_for_each_entry(bdev, &all_bdevs, bd_list) {
 		ret += bdev->bd_inode->i_mapping->nrpages;
 	}
 	spin_unlock(&bdev_lock);
 	return ret;
 }
 void bdput(struct block_device *bdev)
 {
 	iput(bdev->bd_inode);
 }
 EXPORT_SYMBOL(bdput);
 static struct block_device *bd_acquire(struct inode *inode)
 {
 	struct block_device *bdev;
 	spin_lock(&bdev_lock);
 	bdev = inode->i_bdev;
 	if (bdev) {
 		atomic_inc(&bdev->bd_inode->i_count);
 		spin_unlock(&bdev_lock);
 		return bdev;
 	}
 	spin_unlock(&bdev_lock);
 	bdev = bdget(inode->i_rdev);
 	if (bdev) {
 		spin_lock(&bdev_lock);
 		if (!inode->i_bdev) {
 			/*
 			 * We take an additional bd_inode->i_count for inode,
 			 * and it's released in clear_inode() of inode.
 			 * So, we can access it via ->i_mapping always
 			 * without igrab().
 			 */
 			atomic_inc(&bdev->bd_inode->i_count);
 			inode->i_bdev = bdev;
 			inode->i_mapping = bdev->bd_inode->i_mapping;
 			list_add(&inode->i_devices, &bdev->bd_inodes);
 		}
 		spin_unlock(&bdev_lock);
 	}
 	return bdev;
 }
 /* Call when you free inode */
 void bd_forget(struct inode *inode)
 {
 	struct block_device *bdev = NULL;
 	spin_lock(&bdev_lock);
 	if (inode->i_bdev) {
 		if (!sb_is_blkdev_sb(inode->i_sb))
 			bdev = inode->i_bdev;
 		__bd_forget(inode);
 	}
 	spin_unlock(&bdev_lock);
 	if (bdev)
 		iput(bdev->bd_inode);
 }
 int bd_claim(struct block_device *bdev, void *holder)
 {
 	int res;
 	spin_lock(&bdev_lock);
 	/* first decide result */
 	if (bdev->bd_holder == holder)
 		res = 0;	 /* already a holder */
 	else if (bdev->bd_holder != NULL)
 		res = -EBUSY; 	 /* held by someone else */
 	else if (bdev->bd_contains == bdev)
 		res = 0;  	 /* is a whole device which isn't held */
 	else if (bdev->bd_contains->bd_holder == bd_claim)
 		res = 0; 	 /* is a partition of a device that is being partitioned */
 	else if (bdev->bd_contains->bd_holder != NULL)
 		res = -EBUSY;	 /* is a partition of a held device */
 	else
 		res = 0;	 /* is a partition of an un-held device */
 	/* now impose change */
 	if (res==0) {
 		/* note that for a whole device bd_holders
 		 * will be incremented twice, and bd_holder will
 		 * be set to bd_claim before being set to holder
 		 */
 		bdev->bd_contains->bd_holders ++;
 		bdev->bd_contains->bd_holder = bd_claim;
 		bdev->bd_holders++;
 		bdev->bd_holder = holder;
 	}
 	spin_unlock(&bdev_lock);
 	return res;
 }
 EXPORT_SYMBOL(bd_claim);
 void bd_release(struct block_device *bdev)
 {
 	spin_lock(&bdev_lock);
 	if (!--bdev->bd_contains->bd_holders)
 		bdev->bd_contains->bd_holder = NULL;
 	if (!--bdev->bd_holders)
 		bdev->bd_holder = NULL;
 	spin_unlock(&bdev_lock);
 }
 EXPORT_SYMBOL(bd_release);
 #ifdef CONFIG_SYSFS
 /*
  * Functions for bd_claim_by_kobject / bd_release_from_kobject
  *
  *     If a kobject is passed to bd_claim_by_kobject()
  *     and the kobject has a parent directory,
  *     following symlinks are created:
  *        o from the kobject to the claimed bdev
  *        o from "holders" directory of the bdev to the parent of the kobject
  *     bd_release_from_kobject() removes these symlinks.
  *
  *     Example:
  *        If /dev/dm-0 maps to /dev/sda, kobject corresponding to
  *        /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
  *           /sys/block/dm-0/slaves/sda --> /sys/block/sda
  *           /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
  */
 static int add_symlink(struct kobject *from, struct kobject *to)
 {
 	if (!from || !to)
 		return 0;
 	return sysfs_create_link(from, to, kobject_name(to));
 }
 static void del_symlink(struct kobject *from, struct kobject *to)
 {
 	if (!from || !to)
 		return;
 	sysfs_remove_link(from, kobject_name(to));
 }
 /*
  * 'struct bd_holder' contains pointers to kobjects symlinked by
  * bd_claim_by_kobject.
  * It's connected to bd_holder_list which is protected by bdev->bd_sem.
  */
 struct bd_holder {
 	struct list_head list;	/* chain of holders of the bdev */
 	int count;		/* references from the holder */
 	struct kobject *sdir;	/* holder object, e.g. "/block/dm-0/slaves" */
 	struct kobject *hdev;	/* e.g. "/block/dm-0" */
 	struct kobject *hdir;	/* e.g. "/block/sda/holders" */
 	struct kobject *sdev;	/* e.g. "/block/sda" */
 };
 /*
  * Get references of related kobjects at once.
  * Returns 1 on success. 0 on failure.
  *
  * Should call bd_holder_release_dirs() after successful use.
  */
 static int bd_holder_grab_dirs(struct block_device *bdev,
 			struct bd_holder *bo)
 {
 	if (!bdev || !bo)
 		return 0;
 	bo->sdir = kobject_get(bo->sdir);
 	if (!bo->sdir)
 		return 0;
 	bo->hdev = kobject_get(bo->sdir->parent);
 	if (!bo->hdev)
 		goto fail_put_sdir;
 	bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
 	if (!bo->sdev)
 		goto fail_put_hdev;
 	bo->hdir = kobject_get(bdev->bd_part->holder_dir);
 	if (!bo->hdir)
 		goto fail_put_sdev;
 	return 1;
 fail_put_sdev:
 	kobject_put(bo->sdev);
 fail_put_hdev:
 	kobject_put(bo->hdev);
 fail_put_sdir:
 	kobject_put(bo->sdir);
 	return 0;
 }
 /* Put references of related kobjects at once. */
 static void bd_holder_release_dirs(struct bd_holder *bo)
 {
 	kobject_put(bo->hdir);
 	kobject_put(bo->sdev);
 	kobject_put(bo->hdev);
 	kobject_put(bo->sdir);
 }
 static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
 {
 	struct bd_holder *bo;
 	bo = kzalloc(sizeof(*bo), GFP_KERNEL);
 	if (!bo)
 		return NULL;
 	bo->count = 1;
 	bo->sdir = kobj;
 	return bo;
 }
 static void free_bd_holder(struct bd_holder *bo)
 {
 	kfree(bo);
 }
 /**
  * find_bd_holder - find matching struct bd_holder from the block device
  *
  * @bdev:	struct block device to be searched
  * @bo:		target struct bd_holder
  *
  * Returns matching entry with @bo in @bdev->bd_holder_list.
  * If found, increment the reference count and return the pointer.
  * If not found, returns NULL.
  */
 static struct bd_holder *find_bd_holder(struct block_device *bdev,
 					struct bd_holder *bo)
 {
 	struct bd_holder *tmp;
 	list_for_each_entry(tmp, &bdev->bd_holder_list, list)
 		if (tmp->sdir == bo->sdir) {
 			tmp->count++;
 			return tmp;
 		}
 	return NULL;
 }
 /**
  * add_bd_holder - create sysfs symlinks for bd_claim() relationship
  *
  * @bdev:	block device to be bd_claimed
  * @bo:		preallocated and initialized by alloc_bd_holder()
  *
  * Add @bo to @bdev->bd_holder_list, create symlinks.
  *
  * Returns 0 if symlinks are created.
  * Returns -ve if something fails.
  */
 static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
 {
 	int err;
 	if (!bo)
 		return -EINVAL;
 	if (!bd_holder_grab_dirs(bdev, bo))
 		return -EBUSY;
 	err = add_symlink(bo->sdir, bo->sdev);
 	if (err)
 		return err;
 	err = add_symlink(bo->hdir, bo->hdev);
 	if (err) {
 		del_symlink(bo->sdir, bo->sdev);
 		return err;
 	}
 	list_add_tail(&bo->list, &bdev->bd_holder_list);
 	return 0;
 }
 /**
  * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
  *
  * @bdev:	block device to be bd_claimed
  * @kobj:	holder's kobject
  *
  * If there is matching entry with @kobj in @bdev->bd_holder_list
  * and no other bd_claim() from the same kobject,
  * remove the struct bd_holder from the list, delete symlinks for it.
  *
  * Returns a pointer to the struct bd_holder when it's removed from the list
  * and ready to be freed.
  * Returns NULL if matching claim isn't found or there is other bd_claim()
  * by the same kobject.
  */
 static struct bd_holder *del_bd_holder(struct block_device *bdev,
 					struct kobject *kobj)
 {
 	struct bd_holder *bo;
 	list_for_each_entry(bo, &bdev->bd_holder_list, list) {
 		if (bo->sdir == kobj) {
 			bo->count--;
 			BUG_ON(bo->count < 0);
 			if (!bo->count) {
 				list_del(&bo->list);
 				del_symlink(bo->sdir, bo->sdev);
 				del_symlink(bo->hdir, bo->hdev);
 				bd_holder_release_dirs(bo);
 				return bo;
 			}
 			break;
 		}
 	}
 	return NULL;
 }
 /**
  * bd_claim_by_kobject - bd_claim() with additional kobject signature
  *
  * @bdev:	block device to be claimed
  * @holder:	holder's signature
  * @kobj:	holder's kobject
  *
  * Do bd_claim() and if it succeeds, create sysfs symlinks between
  * the bdev and the holder's kobject.
  * Use bd_release_from_kobject() when relesing the claimed bdev.
  *
  * Returns 0 on success. (same as bd_claim())
  * Returns errno on failure.
  */
 static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
 				struct kobject *kobj)
 {
 	int err;
 	struct bd_holder *bo, *found;
 	if (!kobj)
 		return -EINVAL;
 	bo = alloc_bd_holder(kobj);
 	if (!bo)
 		return -ENOMEM;
 	mutex_lock(&bdev->bd_mutex);
 	err = bd_claim(bdev, holder);
 	if (err)
 		goto fail;
 	found = find_bd_holder(bdev, bo);
 	if (found)
 		goto fail;
 	err = add_bd_holder(bdev, bo);
 	if (err)
 		bd_release(bdev);
 	else
 		bo = NULL;
 fail:
 	mutex_unlock(&bdev->bd_mutex);
 	free_bd_holder(bo);
 	return err;
 }
 /**
  * bd_release_from_kobject - bd_release() with additional kobject signature
  *
  * @bdev:	block device to be released
  * @kobj:	holder's kobject
  *
  * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
  */
 static void bd_release_from_kobject(struct block_device *bdev,
 					struct kobject *kobj)
 {
 	if (!kobj)
 		return;
 	mutex_lock(&bdev->bd_mutex);
 	bd_release(bdev);
 	free_bd_holder(del_bd_holder(bdev, kobj));
 	mutex_unlock(&bdev->bd_mutex);
 }
 /**
  * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
  *
  * @bdev:	block device to be claimed
  * @holder:	holder's signature
  * @disk:	holder's gendisk
  *
  * Call bd_claim_by_kobject() with getting @disk->slave_dir.
  */
 int bd_claim_by_disk(struct block_device *bdev, void *holder,
 			struct gendisk *disk)
 {
 	return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
 }
 EXPORT_SYMBOL_GPL(bd_claim_by_disk);
 /**
  * bd_release_from_disk - wrapper function for bd_release_from_kobject()
  *
  * @bdev:	block device to be claimed
  * @disk:	holder's gendisk
  *
  * Call bd_release_from_kobject() and put @disk->slave_dir.
  */
 void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
 {
 	bd_release_from_kobject(bdev, disk->slave_dir);
 	kobject_put(disk->slave_dir);
 }
 EXPORT_SYMBOL_GPL(bd_release_from_disk);
 #endif
 /*
  * Tries to open block device by device number.  Use it ONLY if you
  * really do not have anything better - i.e. when you are behind a
  * truly sucky interface and all you are given is a device number.  _Never_
  * to be used for internal purposes.  If you ever need it - reconsider
  * your API.
  */
 struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
 {
 	struct block_device *bdev = bdget(dev);
 	int err = -ENOMEM;
 	if (bdev)
 		err = blkdev_get(bdev, mode);
 	return err ? ERR_PTR(err) : bdev;
 }
 EXPORT_SYMBOL(open_by_devnum);
 /**
  * flush_disk - invalidates all buffer-cache entries on a disk
  *
  * @bdev:      struct block device to be flushed
  *
  * Invalidates all buffer-cache entries on a disk. It should be called
  * when a disk has been changed -- either by a media change or online
  * resize.
  */
 static void flush_disk(struct block_device *bdev)
 {
 	if (__invalidate_device(bdev)) {
 		char name[BDEVNAME_SIZE] = "";
 		if (bdev->bd_disk)
 			disk_name(bdev->bd_disk, 0, name);
 		printk(KERN_WARNING "VFS: busy inodes on changed media or "
 		       "resized disk %s\n", name);
 	}
 	if (!bdev->bd_disk)
 		return;
 	if (disk_partitionable(bdev->bd_disk))
 		bdev->bd_invalidated = 1;
 }
 /**
  * check_disk_size_change - checks for disk size change and adjusts bdev size.
  * @disk: struct gendisk to check
  * @bdev: struct bdev to adjust.
  *
  * This routine checks to see if the bdev size does not match the disk size
  * and adjusts it if it differs.
  */
 void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
 {
 	loff_t disk_size, bdev_size;
 	disk_size = (loff_t)get_capacity(disk) << 9;
 	bdev_size = i_size_read(bdev->bd_inode);
 	if (disk_size != bdev_size) {
 		char name[BDEVNAME_SIZE];
 		disk_name(disk, 0, name);
 		printk(KERN_INFO
 		       "%s: detected capacity change from %lld to %lld\n",
 		       name, bdev_size, disk_size);
 		i_size_write(bdev->bd_inode, disk_size);
 		flush_disk(bdev);
 	}
 }
 EXPORT_SYMBOL(check_disk_size_change);
 /**
  * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
  * @disk: struct gendisk to be revalidated
  *
  * This routine is a wrapper for lower-level driver's revalidate_disk
  * call-backs.  It is used to do common pre and post operations needed
  * for all revalidate_disk operations.
  */
 int revalidate_disk(struct gendisk *disk)
 {
 	struct block_device *bdev;
 	int ret = 0;
 	if (disk->fops->revalidate_disk)
 		ret = disk->fops->revalidate_disk(disk);
 	bdev = bdget_disk(disk, 0);
 	if (!bdev)
 		return ret;
 	mutex_lock(&bdev->bd_mutex);
 	check_disk_size_change(disk, bdev);
 	mutex_unlock(&bdev->bd_mutex);
 	bdput(bdev);
 	return ret;
 }
 EXPORT_SYMBOL(revalidate_disk);
 /*
  * This routine checks whether a removable media has been changed,
  * and invalidates all buffer-cache-entries in that case. This
  * is a relatively slow routine, so we have to try to minimize using
  * it. Thus it is called only upon a 'mount' or 'open'. This
  * is the best way of combining speed and utility, I think.
  * People changing diskettes in the middle of an operation deserve
  * to lose :-)
  */
 int check_disk_change(struct block_device *bdev)
 {
 	struct gendisk *disk = bdev->bd_disk;
 	struct block_device_operations * bdops = disk->fops;
 	if (!bdops->media_changed)
 		return 0;
 	if (!bdops->media_changed(bdev->bd_disk))
 		return 0;
 	flush_disk(bdev);
 	if (bdops->revalidate_disk)
 		bdops->revalidate_disk(bdev->bd_disk);
 	return 1;
 }
 EXPORT_SYMBOL(check_disk_change);
 void bd_set_size(struct block_device *bdev, loff_t size)
 {
 	unsigned bsize = bdev_logical_block_size(bdev);
 	bdev->bd_inode->i_size = size;
 	while (bsize < PAGE_CACHE_SIZE) {
 		if (size & bsize)
 			break;
 		bsize <<= 1;
 	}
 	bdev->bd_block_size = bsize;
 	bdev->bd_inode->i_blkbits = blksize_bits(bsize);
 }
 EXPORT_SYMBOL(bd_set_size);
 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
 /*
  * bd_mutex locking:
  *
  *  mutex_lock(part->bd_mutex)
  *    mutex_lock_nested(whole->bd_mutex, 1)
  */
 static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
 {
 	struct gendisk *disk;
 	int ret;
 	int partno;
 	int perm = 0;
 	if (mode & FMODE_READ)
 		perm |= MAY_READ;
 	if (mode & FMODE_WRITE)
 		perm |= MAY_WRITE;
 	/*
 	 * hooks: /n/, see "layering violations".
 	 */
 	ret = devcgroup_inode_permission(bdev->bd_inode, perm);
 	if (ret != 0) {
 		bdput(bdev);
 		return ret;
 	}
 	lock_kernel();
  restart:
 	ret = -ENXIO;
 	disk = get_gendisk(bdev->bd_dev, &partno);
 	if (!disk)
 		goto out_unlock_kernel;
 	mutex_lock_nested(&bdev->bd_mutex, for_part);
 	if (!bdev->bd_openers) {
 		bdev->bd_disk = disk;
 		bdev->bd_contains = bdev;
 		if (!partno) {
 			struct backing_dev_info *bdi;
 			ret = -ENXIO;
 			bdev->bd_part = disk_get_part(disk, partno);
 			if (!bdev->bd_part)
 				goto out_clear;
 			if (disk->fops->open) {
 				ret = disk->fops->open(bdev, mode);
 				if (ret == -ERESTARTSYS) {
 					/* Lost a race with 'disk' being
 					 * deleted, try again.
 					 * See md.c
 					 */
 					disk_put_part(bdev->bd_part);
 					bdev->bd_part = NULL;
 					module_put(disk->fops->owner);
 					put_disk(disk);
 					bdev->bd_disk = NULL;
 					mutex_unlock(&bdev->bd_mutex);
 					goto restart;
 				}
 				if (ret)
 					goto out_clear;
 			}
 			if (!bdev->bd_openers) {
 				bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
 				bdi = blk_get_backing_dev_info(bdev);
 				if (bdi == NULL)
 					bdi = &default_backing_dev_info;
 				bdev->bd_inode->i_data.backing_dev_info = bdi;
 			}
 			if (bdev->bd_invalidated)
 				rescan_partitions(disk, bdev);
 		} else {
 			struct block_device *whole;
 			whole = bdget_disk(disk, 0);
 			ret = -ENOMEM;
 			if (!whole)
 				goto out_clear;
 			BUG_ON(for_part);
 			ret = __blkdev_get(whole, mode, 1);
 			if (ret)
 				goto out_clear;
 			bdev->bd_contains = whole;
 			bdev->bd_inode->i_data.backing_dev_info =
 			   whole->bd_inode->i_data.backing_dev_info;
 			bdev->bd_part = disk_get_part(disk, partno);
 			if (!(disk->flags & GENHD_FL_UP) ||
 			    !bdev->bd_part || !bdev->bd_part->nr_sects) {
 				ret = -ENXIO;
 				goto out_clear;
 			}
 			bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
 		}
 	} else {
 		put_disk(disk);
 		module_put(disk->fops->owner);
 		disk = NULL;
 		if (bdev->bd_contains == bdev) {
 			if (bdev->bd_disk->fops->open) {
 				ret = bdev->bd_disk->fops->open(bdev, mode);
 				if (ret)
 					goto out_unlock_bdev;
 			}
 			if (bdev->bd_invalidated)
 				rescan_partitions(bdev->bd_disk, bdev);
 		}
 	}
 	bdev->bd_openers++;
 	if (for_part)
 		bdev->bd_part_count++;
 	mutex_unlock(&bdev->bd_mutex);
 	unlock_kernel();
 	return 0;
  out_clear:
 	disk_put_part(bdev->bd_part);
 	bdev->bd_disk = NULL;
 	bdev->bd_part = NULL;
 	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
 	if (bdev != bdev->bd_contains)
 		__blkdev_put(bdev->bd_contains, mode, 1);
 	bdev->bd_contains = NULL;
  out_unlock_bdev:
 	mutex_unlock(&bdev->bd_mutex);
  out_unlock_kernel:
 	unlock_kernel();
 	if (disk)
 		module_put(disk->fops->owner);
 	put_disk(disk);
 	bdput(bdev);
 	return ret;
 }
 int blkdev_get(struct block_device *bdev, fmode_t mode)
 {
 	return __blkdev_get(bdev, mode, 0);
 }
 EXPORT_SYMBOL(blkdev_get);
 static int blkdev_open(struct inode * inode, struct file * filp)
 {
 	struct block_device *bdev;
 	int res;
 	/*
 	 * Preserve backwards compatibility and allow large file access
 	 * even if userspace doesn't ask for it explicitly. Some mkfs
 	 * binary needs it. We might want to drop this workaround
 	 * during an unstable branch.
 	 */
 	filp->f_flags |= O_LARGEFILE;
 	if (filp->f_flags & O_NDELAY)
 		filp->f_mode |= FMODE_NDELAY;
 	if (filp->f_flags & O_EXCL)
 		filp->f_mode |= FMODE_EXCL;
 	if ((filp->f_flags & O_ACCMODE) == 3)
 		filp->f_mode |= FMODE_WRITE_IOCTL;
 	bdev = bd_acquire(inode);
 	if (bdev == NULL)
 		return -ENOMEM;
 	filp->f_mapping = bdev->bd_inode->i_mapping;
 	res = blkdev_get(bdev, filp->f_mode);
 	if (res)
 		return res;
 	if (filp->f_mode & FMODE_EXCL) {
 		res = bd_claim(bdev, filp);
 		if (res)
 			goto out_blkdev_put;
 	}
 	return 0;
  out_blkdev_put:
 	blkdev_put(bdev, filp->f_mode);
 	return res;
 }
 static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
 {
 	int ret = 0;
 	struct gendisk *disk = bdev->bd_disk;
 	struct block_device *victim = NULL;
 	mutex_lock_nested(&bdev->bd_mutex, for_part);
 	lock_kernel();
 	if (for_part)
 		bdev->bd_part_count--;
 	if (!--bdev->bd_openers) {
 		sync_blockdev(bdev);
 		kill_bdev(bdev);
 	}
 	if (bdev->bd_contains == bdev) {
 		if (disk->fops->release)
 			ret = disk->fops->release(disk, mode);
 	}
 	if (!bdev->bd_openers) {
 		struct module *owner = disk->fops->owner;
 		put_disk(disk);
 		module_put(owner);
 		disk_put_part(bdev->bd_part);
 		bdev->bd_part = NULL;
 		bdev->bd_disk = NULL;
 		bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
 		if (bdev != bdev->bd_contains)
 			victim = bdev->bd_contains;
 		bdev->bd_contains = NULL;
 	}
 	unlock_kernel();
 	mutex_unlock(&bdev->bd_mutex);
 	bdput(bdev);
 	if (victim)
 		__blkdev_put(victim, mode, 1);
 	return ret;
 }
 int blkdev_put(struct block_device *bdev, fmode_t mode)
 {
 	return __blkdev_put(bdev, mode, 0);
 }
 EXPORT_SYMBOL(blkdev_put);
 static int blkdev_close(struct inode * inode, struct file * filp)
 {
 	struct block_device *bdev = I_BDEV(filp->f_mapping->host);
 	if (bdev->bd_holder == filp)
 		bd_release(bdev);
 	return blkdev_put(bdev, filp->f_mode);
 }
 static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
 	struct block_device *bdev = I_BDEV(file->f_mapping->host);
 	fmode_t mode = file->f_mode;
 	/*
 	 * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
 	 * to updated it before every ioctl.
 	 */
 	if (file->f_flags & O_NDELAY)
 		mode |= FMODE_NDELAY;
 	else
 		mode &= ~FMODE_NDELAY;
 	return blkdev_ioctl(bdev, mode, cmd, arg);
 }
 /*
  * Try to release a page associated with block device when the system
  * is under memory pressure.
  */
 static int blkdev_releasepage(struct page *page, gfp_t wait)
 {
 	struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
 	if (super && super->s_op->bdev_try_to_free_page)
 		return super->s_op->bdev_try_to_free_page(super, page, wait);
 	return try_to_free_buffers(page);
 }
 static const struct address_space_operations def_blk_aops = {
 	.readpage	= blkdev_readpage,
 	.writepage	= blkdev_writepage,
 	.sync_page	= block_sync_page,
 	.write_begin	= blkdev_write_begin,
 	.write_end	= blkdev_write_end,
 	.writepages	= generic_writepages,
 	.releasepage	= blkdev_releasepage,
 	.direct_IO	= blkdev_direct_IO,
 };
 const struct file_operations def_blk_fops = {
 	.open		= blkdev_open,
 	.release	= blkdev_close,
 	.llseek		= block_llseek,
 	.read		= do_sync_read,
 	.write		= do_sync_write,
   	.aio_read	= generic_file_aio_read,
   	.aio_write	= generic_file_aio_write_nolock,
 	.mmap		= generic_file_mmap,
 	.fsync		= block_fsync,
 	.unlocked_ioctl	= block_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl	= compat_blkdev_ioctl,
 #endif
 	.splice_read	= generic_file_splice_read,
 	.splice_write	= generic_file_splice_write,
 };
 int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
 {
 	int res;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	res = blkdev_ioctl(bdev, 0, cmd, arg);
 	set_fs(old_fs);
 	return res;
 }
 EXPORT_SYMBOL(ioctl_by_bdev);
 /**
  * lookup_bdev  - lookup a struct block_device by name
  * @pathname:	special file representing the block device
  *
  * Get a reference to the blockdevice at @pathname in the current
  * namespace if possible and return it.  Return ERR_PTR(error)
  * otherwise.
  */
 struct block_device *lookup_bdev(const char *pathname)
 {
 	struct block_device *bdev;
 	struct inode *inode;
 	struct path path;
 	int error;
 	if (!pathname || !*pathname)
 		return ERR_PTR(-EINVAL);
 	error = kern_path(pathname, LOOKUP_FOLLOW, &path);
 	if (error)
 		return ERR_PTR(error);
 	inode = path.dentry->d_inode;
 	error = -ENOTBLK;
 	if (!S_ISBLK(inode->i_mode))
 		goto fail;
 	error = -EACCES;
 	if (path.mnt->mnt_flags & MNT_NODEV)
 		goto fail;
 	error = -ENOMEM;
 	bdev = bd_acquire(inode);
 	if (!bdev)
 		goto fail;
 out:
 	path_put(&path);
 	return bdev;
 fail:
 	bdev = ERR_PTR(error);
 	goto out;
 }
 EXPORT_SYMBOL(lookup_bdev);
 /**
  * open_bdev_exclusive  -  open a block device by name and set it up for use
  *
  * @path:	special file representing the block device
  * @mode:	FMODE_... combination to pass be used
  * @holder:	owner for exclusion
  *
  * Open the blockdevice described by the special file at @path, claim it
  * for the @holder.
  */
 struct block_device *open_bdev_exclusive(const char *path, fmode_t mode, void *holder)
 {
 	struct block_device *bdev;
 	int error = 0;
 	bdev = lookup_bdev(path);
 	if (IS_ERR(bdev))
 		return bdev;
 	error = blkdev_get(bdev, mode);
 	if (error)
 		return ERR_PTR(error);
 	error = -EACCES;
 	if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
 		goto blkdev_put;
 	error = bd_claim(bdev, holder);
 	if (error)
 		goto blkdev_put;
 	return bdev;
 blkdev_put:
 	blkdev_put(bdev, mode);
 	return ERR_PTR(error);
 }
 EXPORT_SYMBOL(open_bdev_exclusive);
 /**
  * close_bdev_exclusive  -  close a blockdevice opened by open_bdev_exclusive()
  *
  * @bdev:	blockdevice to close
  * @mode:	mode, must match that used to open.
  *
  * This is the counterpart to open_bdev_exclusive().
  */
 void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
 {
 	bd_release(bdev);
 	blkdev_put(bdev, mode);
 }
 EXPORT_SYMBOL(close_bdev_exclusive);
 int __invalidate_device(struct block_device *bdev)
 {
 	struct super_block *sb = get_super(bdev);
 	int res = 0;
 	if (sb) {
 		/*
 		 * no need to lock the super, get_super holds the
 		 * read mutex so the filesystem cannot go away
 		 * under us (->put_super runs with the write lock
 		 * hold).
 		 */
 		shrink_dcache_sb(sb);
 		res = invalidate_inodes(sb);
 		drop_super(sb);
 	}
 	invalidate_bdev(bdev);

fs/fs-writeback.c

Diff comments View file @ 5cee581

 /*
  * fs/fs-writeback.c
  *
  * Copyright (C) 2002, Linus Torvalds.
  *
  * Contains all the functions related to writing back and waiting
  * upon dirty inodes against superblocks, and writing back dirty
  * pages against inodes.  ie: data writeback.  Writeout of the
  * inode itself is not handled here.
  *
  * 10Apr2002	Andrew Morton
  *		Split out of fs/inode.c
  *		Additions for address_space-based writeback
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/writeback.h>
 #include <linux/blkdev.h>
 #include <linux/backing-dev.h>
 #include <linux/buffer_head.h>
 #include "internal.h"
 /**
  * writeback_acquire - attempt to get exclusive writeback access to a device
  * @bdi: the device's backing_dev_info structure
  *
  * It is a waste of resources to have more than one pdflush thread blocked on
  * a single request queue.  Exclusion at the request_queue level is obtained
  * via a flag in the request_queue's backing_dev_info.state.
  *
  * Non-request_queue-backed address_spaces will share default_backing_dev_info,
  * unless they implement their own.  Which is somewhat inefficient, as this
  * may prevent concurrent writeback against multiple devices.
  */
 static int writeback_acquire(struct backing_dev_info *bdi)
 {
 	return !test_and_set_bit(BDI_pdflush, &bdi->state);
 }
 /**
  * writeback_in_progress - determine whether there is writeback in progress
  * @bdi: the device's backing_dev_info structure.
  *
  * Determine whether there is writeback in progress against a backing device.
  */
 int writeback_in_progress(struct backing_dev_info *bdi)
 {
 	return test_bit(BDI_pdflush, &bdi->state);
 }
 /**
  * writeback_release - relinquish exclusive writeback access against a device.
  * @bdi: the device's backing_dev_info structure
  */
 static void writeback_release(struct backing_dev_info *bdi)
 {
 	BUG_ON(!writeback_in_progress(bdi));
 	clear_bit(BDI_pdflush, &bdi->state);
 }
 /**
  *	__mark_inode_dirty -	internal function
  *	@inode: inode to mark
  *	@flags: what kind of dirty (i.e. I_DIRTY_SYNC)
  *	Mark an inode as dirty. Callers should use mark_inode_dirty or
  *  	mark_inode_dirty_sync.
  *
  * Put the inode on the super block's dirty list.
  *
  * CAREFUL! We mark it dirty unconditionally, but move it onto the
  * dirty list only if it is hashed or if it refers to a blockdev.
  * If it was not hashed, it will never be added to the dirty list
  * even if it is later hashed, as it will have been marked dirty already.
  *
  * In short, make sure you hash any inodes _before_ you start marking
  * them dirty.
  *
  * This function *must* be atomic for the I_DIRTY_PAGES case -
  * set_page_dirty() is called under spinlock in several places.
  *
  * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
  * the block-special inode (/dev/hda1) itself.  And the ->dirtied_when field of
  * the kernel-internal blockdev inode represents the dirtying time of the
  * blockdev's pages.  This is why for I_DIRTY_PAGES we always use
  * page->mapping->host, so the page-dirtying time is recorded in the internal
  * blockdev inode.
  */
 void __mark_inode_dirty(struct inode *inode, int flags)
 {
 	struct super_block *sb = inode->i_sb;
 	/*
 	 * Don't do this for I_DIRTY_PAGES - that doesn't actually
 	 * dirty the inode itself
 	 */
 	if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
 		if (sb->s_op->dirty_inode)
 			sb->s_op->dirty_inode(inode);
 	}
 	/*
 	 * make sure that changes are seen by all cpus before we test i_state
 	 * -- mikulas
 	 */
 	smp_mb();
 	/* avoid the locking if we can */
 	if ((inode->i_state & flags) == flags)
 		return;
 	if (unlikely(block_dump)) {
 		struct dentry *dentry = NULL;
 		const char *name = "?";
 		if (!list_empty(&inode->i_dentry)) {
 			dentry = list_entry(inode->i_dentry.next,
 					    struct dentry, d_alias);
 			if (dentry && dentry->d_name.name)
 				name = (const char *) dentry->d_name.name;
 		}
 		if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev"))
 			printk(KERN_DEBUG
 			       "%s(%d): dirtied inode %lu (%s) on %s\n",
 			       current->comm, task_pid_nr(current), inode->i_ino,
 			       name, inode->i_sb->s_id);
 	}
 	spin_lock(&inode_lock);
 	if ((inode->i_state & flags) != flags) {
 		const int was_dirty = inode->i_state & I_DIRTY;
 		inode->i_state |= flags;
 		/*
 		 * If the inode is being synced, just update its dirty state.
 		 * The unlocker will place the inode on the appropriate
 		 * superblock list, based upon its state.
 		 */
 		if (inode->i_state & I_SYNC)
 			goto out;
 		/*
 		 * Only add valid (hashed) inodes to the superblock's
 		 * dirty list.  Add blockdev inodes as well.
 		 */
 		if (!S_ISBLK(inode->i_mode)) {
 			if (hlist_unhashed(&inode->i_hash))
 				goto out;
 		}
 		if (inode->i_state & (I_FREEING|I_CLEAR))
 			goto out;
 		/*
 		 * If the inode was already on s_dirty/s_io/s_more_io, don't
 		 * reposition it (that would break s_dirty time-ordering).
 		 */
 		if (!was_dirty) {
 			inode->dirtied_when = jiffies;
 			list_move(&inode->i_list, &sb->s_dirty);
 		}
 	}
 out:
 	spin_unlock(&inode_lock);
 }
 EXPORT_SYMBOL(__mark_inode_dirty);
 static int write_inode(struct inode *inode, int sync)
 {
 	if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
 		return inode->i_sb->s_op->write_inode(inode, sync);
 	return 0;
 }
 /*
  * Redirty an inode: set its when-it-was dirtied timestamp and move it to the
  * furthest end of its superblock's dirty-inode list.
  *
  * Before stamping the inode's ->dirtied_when, we check to see whether it is
  * already the most-recently-dirtied inode on the s_dirty list.  If that is
  * the case then the inode must have been redirtied while it was being written
  * out and we don't reset its dirtied_when.
  */
 static void redirty_tail(struct inode *inode)
 {
 	struct super_block *sb = inode->i_sb;
 	if (!list_empty(&sb->s_dirty)) {
 		struct inode *tail_inode;
 		tail_inode = list_entry(sb->s_dirty.next, struct inode, i_list);
 		if (time_before(inode->dirtied_when,
 				tail_inode->dirtied_when))
 			inode->dirtied_when = jiffies;
 	}
 	list_move(&inode->i_list, &sb->s_dirty);
 }
 /*
  * requeue inode for re-scanning after sb->s_io list is exhausted.
  */
 static void requeue_io(struct inode *inode)
 {
 	list_move(&inode->i_list, &inode->i_sb->s_more_io);
 }
 static void inode_sync_complete(struct inode *inode)
 {
 	/*
 	 * Prevent speculative execution through spin_unlock(&inode_lock);
 	 */
 	smp_mb();
 	wake_up_bit(&inode->i_state, __I_SYNC);
 }
 static bool inode_dirtied_after(struct inode *inode, unsigned long t)
 {
 	bool ret = time_after(inode->dirtied_when, t);
 #ifndef CONFIG_64BIT
 	/*
 	 * For inodes being constantly redirtied, dirtied_when can get stuck.
 	 * It _appears_ to be in the future, but is actually in distant past.
 	 * This test is necessary to prevent such wrapped-around relative times
 	 * from permanently stopping the whole pdflush writeback.
 	 */
 	ret = ret && time_before_eq(inode->dirtied_when, jiffies);
 #endif
 	return ret;
 }
 /*
  * Move expired dirty inodes from @delaying_queue to @dispatch_queue.
  */
 static void move_expired_inodes(struct list_head *delaying_queue,
 			       struct list_head *dispatch_queue,
 				unsigned long *older_than_this)
 {
 	while (!list_empty(delaying_queue)) {
 		struct inode *inode = list_entry(delaying_queue->prev,
 						struct inode, i_list);
 		if (older_than_this &&
 		    inode_dirtied_after(inode, *older_than_this))
 			break;
 		list_move(&inode->i_list, dispatch_queue);
 	}
 }
 /*
  * Queue all expired dirty inodes for io, eldest first.
  */
 static void queue_io(struct super_block *sb,
 				unsigned long *older_than_this)
 {
 	list_splice_init(&sb->s_more_io, sb->s_io.prev);
 	move_expired_inodes(&sb->s_dirty, &sb->s_io, older_than_this);
 }
 int sb_has_dirty_inodes(struct super_block *sb)
 {
 	return !list_empty(&sb->s_dirty) ||
 	       !list_empty(&sb->s_io) ||
 	       !list_empty(&sb->s_more_io);
 }
 EXPORT_SYMBOL(sb_has_dirty_inodes);
 /*
  * Write a single inode's dirty pages and inode data out to disk.
  * If `wait' is set, wait on the writeout.
  *
  * The whole writeout design is quite complex and fragile.  We want to avoid
  * starvation of particular inodes when others are being redirtied, prevent
  * livelocks, etc.
  *
  * Called under inode_lock.
  */
 static int
 __sync_single_inode(struct inode *inode, struct writeback_control *wbc)
 {
 	unsigned dirty;
 	struct address_space *mapping = inode->i_mapping;
 	int wait = wbc->sync_mode == WB_SYNC_ALL;
 	int ret;
 	BUG_ON(inode->i_state & I_SYNC);
 	WARN_ON(inode->i_state & I_NEW);
 	/* Set I_SYNC, reset I_DIRTY */
 	dirty = inode->i_state & I_DIRTY;
 	inode->i_state |= I_SYNC;
 	inode->i_state &= ~I_DIRTY;
 	spin_unlock(&inode_lock);
 	ret = do_writepages(mapping, wbc);
 	/* Don't write the inode if only I_DIRTY_PAGES was set */
 	if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
 		int err = write_inode(inode, wait);
 		if (ret == 0)
 			ret = err;
 	}
 	if (wait) {
 		int err = filemap_fdatawait(mapping);
 		if (ret == 0)
 			ret = err;
 	}
 	spin_lock(&inode_lock);
 	WARN_ON(inode->i_state & I_NEW);
 	inode->i_state &= ~I_SYNC;
 	if (!(inode->i_state & I_FREEING)) {
 		if (!(inode->i_state & I_DIRTY) &&
 		    mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
 			/*
 			 * We didn't write back all the pages.  nfs_writepages()
 			 * sometimes bales out without doing anything. Redirty
 			 * the inode; Move it from s_io onto s_more_io/s_dirty.
 			 */
 			/*
 			 * akpm: if the caller was the kupdate function we put
 			 * this inode at the head of s_dirty so it gets first
 			 * consideration.  Otherwise, move it to the tail, for
 			 * the reasons described there.  I'm not really sure
 			 * how much sense this makes.  Presumably I had a good
 			 * reasons for doing it this way, and I'd rather not
 			 * muck with it at present.
 			 */
 			if (wbc->for_kupdate) {
 				/*
 				 * For the kupdate function we move the inode
 				 * to s_more_io so it will get more writeout as
 				 * soon as the queue becomes uncongested.
 				 */
 				inode->i_state |= I_DIRTY_PAGES;
 				if (wbc->nr_to_write <= 0) {
 					/*
 					 * slice used up: queue for next turn
 					 */
 					requeue_io(inode);
 				} else {
 					/*
 					 * somehow blocked: retry later
 					 */
 					redirty_tail(inode);
 				}
 			} else {
 				/*
 				 * Otherwise fully redirty the inode so that
 				 * other inodes on this superblock will get some
 				 * writeout.  Otherwise heavy writing to one
 				 * file would indefinitely suspend writeout of
 				 * all the other files.
 				 */
 				inode->i_state |= I_DIRTY_PAGES;
 				redirty_tail(inode);
 			}
 		} else if (inode->i_state & I_DIRTY) {
 			/*
 			 * Someone redirtied the inode while were writing back
 			 * the pages.
 			 */
 			redirty_tail(inode);
 		} else if (atomic_read(&inode->i_count)) {
 			/*
 			 * The inode is clean, inuse
 			 */
 			list_move(&inode->i_list, &inode_in_use);
 		} else {
 			/*
 			 * The inode is clean, unused
 			 */
 			list_move(&inode->i_list, &inode_unused);
 		}
 	}
 	inode_sync_complete(inode);
 	return ret;
 }
 /*
  * Write out an inode's dirty pages.  Called under inode_lock.  Either the
  * caller has ref on the inode (either via __iget or via syscall against an fd)
  * or the inode has I_WILL_FREE set (via generic_forget_inode)
  */
 static int
 __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
 {
 	wait_queue_head_t *wqh;
 	if (!atomic_read(&inode->i_count))
 		WARN_ON(!(inode->i_state & (I_WILL_FREE|I_FREEING)));
 	else
 		WARN_ON(inode->i_state & I_WILL_FREE);
 	if ((wbc->sync_mode != WB_SYNC_ALL) && (inode->i_state & I_SYNC)) {
 		/*
 		 * We're skipping this inode because it's locked, and we're not
 		 * doing writeback-for-data-integrity.  Move it to s_more_io so
 		 * that writeback can proceed with the other inodes on s_io.
 		 * We'll have another go at writing back this inode when we
 		 * completed a full scan of s_io.
 		 */
 		requeue_io(inode);
 		return 0;
 	}
 	/*
 	 * It's a data-integrity sync.  We must wait.
 	 */
 	if (inode->i_state & I_SYNC) {
 		DEFINE_WAIT_BIT(wq, &inode->i_state, __I_SYNC);
 		wqh = bit_waitqueue(&inode->i_state, __I_SYNC);
 		do {
 			spin_unlock(&inode_lock);
 			__wait_on_bit(wqh, &wq, inode_wait,
 							TASK_UNINTERRUPTIBLE);
 			spin_lock(&inode_lock);
 		} while (inode->i_state & I_SYNC);
 	}
 	return __sync_single_inode(inode, wbc);
 }
 /*
  * Write out a superblock's list of dirty inodes.  A wait will be performed
  * upon no inodes, all inodes or the final one, depending upon sync_mode.
  *
  * If older_than_this is non-NULL, then only write out inodes which
  * had their first dirtying at a time earlier than *older_than_this.
  *
  * If we're a pdflush thread, then implement pdflush collision avoidance
  * against the entire list.
  *
  * If `bdi' is non-zero then we're being asked to writeback a specific queue.
  * This function assumes that the blockdev superblock's inodes are backed by
  * a variety of queues, so all inodes are searched.  For other superblocks,
  * assume that all inodes are backed by the same queue.
  *
  * FIXME: this linear search could get expensive with many fileystems.  But
  * how to fix?  We need to go from an address_space to all inodes which share
  * a queue with that address_space.  (Easy: have a global "dirty superblocks"
  * list).
  *
  * The inodes to be written are parked on sb->s_io.  They are moved back onto
  * sb->s_dirty as they are selected for writing.  This way, none can be missed
  * on the writer throttling path, and we get decent balancing between many
  * throttled threads: we don't want them all piling up on inode_sync_wait.
  */
 void generic_sync_sb_inodes(struct super_block *sb,
 				struct writeback_control *wbc)
 {
 	const unsigned long start = jiffies;	/* livelock avoidance */
 	int sync = wbc->sync_mode == WB_SYNC_ALL;
 	spin_lock(&inode_lock);
 	if (!wbc->for_kupdate || list_empty(&sb->s_io))
 		queue_io(sb, wbc->older_than_this);
 	while (!list_empty(&sb->s_io)) {
 		struct inode *inode = list_entry(sb->s_io.prev,
 						struct inode, i_list);
 		struct address_space *mapping = inode->i_mapping;
 		struct backing_dev_info *bdi = mapping->backing_dev_info;
 		long pages_skipped;
 		if (!bdi_cap_writeback_dirty(bdi)) {
 			redirty_tail(inode);
 			if (sb_is_blkdev_sb(sb)) {
 				/*
 				 * Dirty memory-backed blockdev: the ramdisk
 				 * driver does this.  Skip just this inode
 				 */
 				continue;
 			}
 			/*
 			 * Dirty memory-backed inode against a filesystem other
 			 * than the kernel-internal bdev filesystem.  Skip the
 			 * entire superblock.
 			 */
 			break;
 		}
 		if (inode->i_state & I_NEW) {
 			requeue_io(inode);
 			continue;
 		}
 		if (wbc->nonblocking && bdi_write_congested(bdi)) {
 			wbc->encountered_congestion = 1;
 			if (!sb_is_blkdev_sb(sb))
 				break;		/* Skip a congested fs */
 			requeue_io(inode);
 			continue;		/* Skip a congested blockdev */
 		}
 		if (wbc->bdi && bdi != wbc->bdi) {
 			if (!sb_is_blkdev_sb(sb))
 				break;		/* fs has the wrong queue */
 			requeue_io(inode);
 			continue;		/* blockdev has wrong queue */
 		}
 		/*
 		 * Was this inode dirtied after sync_sb_inodes was called?
 		 * This keeps sync from extra jobs and livelock.
 		 */
 		if (inode_dirtied_after(inode, start))
 			break;
 		/* Is another pdflush already flushing this queue? */
 		if (current_is_pdflush() && !writeback_acquire(bdi))
 			break;
 		BUG_ON(inode->i_state & I_FREEING);
 		__iget(inode);
 		pages_skipped = wbc->pages_skipped;
 		__writeback_single_inode(inode, wbc);
 		if (current_is_pdflush())
 			writeback_release(bdi);
 		if (wbc->pages_skipped != pages_skipped) {
 			/*
 			 * writeback is not making progress due to locked
 			 * buffers.  Skip this inode for now.
 			 */
 			redirty_tail(inode);
 		}
 		spin_unlock(&inode_lock);
 		iput(inode);
 		cond_resched();
 		spin_lock(&inode_lock);
 		if (wbc->nr_to_write <= 0) {
 			wbc->more_io = 1;
 			break;
 		}
 		if (!list_empty(&sb->s_more_io))
 			wbc->more_io = 1;
 	}
 	if (sync) {
 		struct inode *inode, *old_inode = NULL;
 		/*
 		 * Data integrity sync. Must wait for all pages under writeback,
 		 * because there may have been pages dirtied before our sync
 		 * call, but which had writeout started before we write it out.
 		 * In which case, the inode may not be on the dirty list, but
 		 * we still have to wait for that writeout.
 		 */
 		list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 			struct address_space *mapping;
 			if (inode->i_state &
 					(I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
 				continue;
 			mapping = inode->i_mapping;
 			if (mapping->nrpages == 0)
 				continue;
 			__iget(inode);
 			spin_unlock(&inode_lock);
 			/*
 			 * We hold a reference to 'inode' so it couldn't have
 			 * been removed from s_inodes list while we dropped the
 			 * inode_lock.  We cannot iput the inode now as we can
 			 * be holding the last reference and we cannot iput it
 			 * under inode_lock. So we keep the reference and iput
 			 * it later.
 			 */
 			iput(old_inode);
 			old_inode = inode;
 			filemap_fdatawait(mapping);
 			cond_resched();
 			spin_lock(&inode_lock);
 		}
 		spin_unlock(&inode_lock);
 		iput(old_inode);
 	} else
 		spin_unlock(&inode_lock);
 	return;		/* Leave any unwritten inodes on s_io */
 }
 EXPORT_SYMBOL_GPL(generic_sync_sb_inodes);
 static void sync_sb_inodes(struct super_block *sb,
 				struct writeback_control *wbc)
 {
 	generic_sync_sb_inodes(sb, wbc);
 }
 /*
  * Start writeback of dirty pagecache data against all unlocked inodes.
  *
  * Note:
  * We don't need to grab a reference to superblock here. If it has non-empty
  * ->s_dirty it's hadn't been killed yet and kill_super() won't proceed
  * past sync_inodes_sb() until the ->s_dirty/s_io/s_more_io lists are all
  * empty. Since __sync_single_inode() regains inode_lock before it finally moves
  * inode from superblock lists we are OK.
  *
  * If `older_than_this' is non-zero then only flush inodes which have a
  * flushtime older than *older_than_this.
  *
  * If `bdi' is non-zero then we will scan the first inode against each
  * superblock until we find the matching ones.  One group will be the dirty
  * inodes against a filesystem.  Then when we hit the dummy blockdev superblock,
  * sync_sb_inodes will seekout the blockdev which matches `bdi'.  Maybe not
  * super-efficient but we're about to do a ton of I/O...
  */
 void
 writeback_inodes(struct writeback_control *wbc)
 {
 	struct super_block *sb;
 	might_sleep();
 	spin_lock(&sb_lock);
 restart:
 	list_for_each_entry_reverse(sb, &super_blocks, s_list) {
 		if (sb_has_dirty_inodes(sb)) {
 			/* we're making our own get_super here */
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			/*
 			 * If we can't get the readlock, there's no sense in
 			 * waiting around, most of the time the FS is going to
 			 * be unmounted by the time it is released.
 			 */
 			if (down_read_trylock(&sb->s_umount)) {
 				if (sb->s_root)
 					sync_sb_inodes(sb, wbc);
 				up_read(&sb->s_umount);
 			}
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto restart;
 		}
 		if (wbc->nr_to_write <= 0)
 			break;
 	}
 	spin_unlock(&sb_lock);
 }
 /*
  * writeback and wait upon the filesystem's dirty inodes.  The caller will
  * do this in two passes - one to write, and one to wait.
  *
  * A finite limit is set on the number of pages which will be written.
  * To prevent infinite livelock of sys_sync().
  *
  * We add in the number of potentially dirty inodes, because each inode write
  * can dirty pagecache in the underlying blockdev.
  */
 void sync_inodes_sb(struct super_block *sb, int wait)
 {
 	struct writeback_control wbc = {
 		.sync_mode	= wait ? WB_SYNC_ALL : WB_SYNC_NONE,
 		.range_start	= 0,
 		.range_end	= LLONG_MAX,
 	};
 	if (!wait) {
 		unsigned long nr_dirty = global_page_state(NR_FILE_DIRTY);
 		unsigned long nr_unstable = global_page_state(NR_UNSTABLE_NFS);
 		wbc.nr_to_write = nr_dirty + nr_unstable +
 			(inodes_stat.nr_inodes - inodes_stat.nr_unused);
 	} else
 		wbc.nr_to_write = LONG_MAX; /* doesn't actually matter */
 	sync_sb_inodes(sb, &wbc);
 }
 /**
- * sync_inodes - writes all inodes to disk
- * @wait: wait for completion
- *
- * sync_inodes() goes through each super block's dirty inode list, writes the
- * inodes out, waits on the writeout and puts the inodes back on the normal
- * list.
- *
- * This is for sys_sync().  fsync_dev() uses the same algorithm.  The subtle
- * part of the sync functions is that the blockdev "superblock" is processed
- * last.  This is because the write_inode() function of a typical fs will
- * perform no I/O, but will mark buffers in the blockdev mapping as dirty.
- * What we want to do is to perform all that dirtying first, and then write
- * back all those inode blocks via the blockdev mapping in one sweep.  So the
- * additional (somewhat redundant) sync_blockdev() calls here are to make
- * sure that really happens.  Because if we call sync_inodes_sb(wait=1) with
- * outstanding dirty inodes, the writeback goes block-at-a-time within the
- * filesystem's write_inode().  This is extremely slow.
- */
-static void __sync_inodes(int wait)
-{
-	struct super_block *sb;
-	spin_lock(&sb_lock);
-restart:
-	list_for_each_entry(sb, &super_blocks, s_list) {
-		sb->s_count++;
-		spin_unlock(&sb_lock);
-		down_read(&sb->s_umount);
-		if (sb->s_root) {
-			sync_inodes_sb(sb, wait);
-			sync_blockdev(sb->s_bdev);
-		}
-		up_read(&sb->s_umount);
-		spin_lock(&sb_lock);
-		if (__put_super_and_need_restart(sb))
-			goto restart;
-	}
-	spin_unlock(&sb_lock);
-}
-void sync_inodes(int wait)
-{
-	__sync_inodes(0);
-	if (wait)
-		__sync_inodes(1);
-}
-/**
  * write_inode_now	-	write an inode to disk
  * @inode: inode to write to disk
  * @sync: whether the write should be synchronous or not
  *
  * This function commits an inode to disk immediately if it is dirty. This is
  * primarily needed by knfsd.
  *
  * The caller must either have a ref on the inode or must have set I_WILL_FREE.
  */
 int write_inode_now(struct inode *inode, int sync)
 {
 	int ret;
 	struct writeback_control wbc = {
 		.nr_to_write = LONG_MAX,
 		.sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
 		.range_start = 0,
 		.range_end = LLONG_MAX,
 	};
 	if (!mapping_cap_writeback_dirty(inode->i_mapping))
 		wbc.nr_to_write = 0;
 	might_sleep();
 	spin_lock(&inode_lock);
 	ret = __writeback_single_inode(inode, &wbc);
 	spin_unlock(&inode_lock);
 	if (sync)
 		inode_sync_wait(inode);
 	return ret;
 }
 EXPORT_SYMBOL(write_inode_now);
 /**
  * sync_inode - write an inode and its pages to disk.
  * @inode: the inode to sync
  * @wbc: controls the writeback mode
  *
  * sync_inode() will write an inode and its pages to disk.  It will also
  * correctly update the inode on its superblock's dirty inode lists and will
  * update inode->i_state.
  *
  * The caller must have a ref on the inode.
  */
 int sync_inode(struct inode *inode, struct writeback_control *wbc)
 {
 	int ret;
 	spin_lock(&inode_lock);
 	ret = __writeback_single_inode(inode, wbc);
 	spin_unlock(&inode_lock);
 	return ret;
 }
 EXPORT_SYMBOL(sync_inode);
 /**
  * generic_osync_inode - flush all dirty data for a given inode to disk
  * @inode: inode to write
  * @mapping: the address_space that should be flushed
  * @what:  what to write and wait upon
  *
  * This can be called by file_write functions for files which have the
  * O_SYNC flag set, to flush dirty writes to disk.
  *
  * @what is a bitmask, specifying which part of the inode's data should be
  * written and waited upon.
  *
  *    OSYNC_DATA:     i_mapping's dirty data
  *    OSYNC_METADATA: the buffers at i_mapping->private_list
  *    OSYNC_INODE:    the inode itself
  */
 int generic_osync_inode(struct inode *inode, struct address_space *mapping, int what)
 {
 	int err = 0;
 	int need_write_inode_now = 0;
 	int err2;
 	if (what & OSYNC_DATA)
 		err = filemap_fdatawrite(mapping);
 	if (what & (OSYNC_METADATA|OSYNC_DATA)) {
 		err2 = sync_mapping_buffers(mapping);
 		if (!err)
 			err = err2;
 	}
 	if (what & OSYNC_DATA) {
 		err2 = filemap_fdatawait(mapping);
 		if (!err)
 			err = err2;
 	}
 	spin_lock(&inode_lock);
 	if ((inode->i_state & I_DIRTY) &&
 	    ((what & OSYNC_INODE) || (inode->i_state & I_DIRTY_DATASYNC)))
 		need_write_inode_now = 1;
 	spin_unlock(&inode_lock);
 	if (need_write_inode_now) {
 		err2 = write_inode_now(inode, 1);
 		if (!err)
 			err = err2;
 	}
 	else
 		inode_sync_wait(inode);
 	return err;
 }
 EXPORT_SYMBOL(generic_osync_inode);

fs/internal.h

Diff comments View file @ 5cee581

 /* fs/ internal definitions
  *
  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 struct super_block;
 struct linux_binprm;
 struct path;
 /*
  * block_dev.c
  */
 #ifdef CONFIG_BLOCK
 extern struct super_block *blockdev_superblock;
 extern void __init bdev_cache_init(void);
 static inline int sb_is_blkdev_sb(struct super_block *sb)
 {
 	return sb == blockdev_superblock;
 }
+extern int __sync_blockdev(struct block_device *bdev, int wait);
 #else
 static inline void bdev_cache_init(void)
 {
 }
 static inline int sb_is_blkdev_sb(struct super_block *sb)
 {
 	return 0;
 }
+static inline int __sync_blockdev(struct block_device *bdev, int wait)
+{
+	return 0;
+}
 #endif
 /*
  * char_dev.c
  */
 extern void __init chrdev_init(void);
 /*
  * exec.c
  */
 extern int check_unsafe_exec(struct linux_binprm *);
 /*
  * namespace.c
  */
 extern int copy_mount_options(const void __user *, unsigned long *);
 extern void free_vfsmnt(struct vfsmount *);
 extern struct vfsmount *alloc_vfsmnt(const char *);
 extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
 extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
 				struct vfsmount *);
 extern void release_mounts(struct list_head *);
 extern void umount_tree(struct vfsmount *, int, struct list_head *);
 extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);
 extern void __init mnt_init(void);
 /*
  * fs_struct.c
  */
 extern void chroot_fs_refs(struct path *, struct path *);
 /*
  * file_table.c
  */
 extern void mark_files_ro(struct super_block *);
-/*
- * super.c

fs/super.c

Diff comments View file @ 5cee581

 /*
  *  linux/fs/super.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  super.c contains code to handle: - mount structures
  *                                   - super-block tables
  *                                   - filesystem drivers list
  *                                   - mount system call
  *                                   - umount system call
  *                                   - ustat system call
  *
  * GK 2/5/95  -  Changed to support mounting the root fs via NFS
  *
  *  Added kerneld support: Jacques Gelinas and Bjorn Ekwall
  *  Added change_root: Werner Almesberger & Hans Lermen, Feb '96
  *  Added options to /proc/mounts:
  *    Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
  *  Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
  *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>
 #include <linux/acct.h>
 #include <linux/blkdev.h>
 #include <linux/quotaops.h>
 #include <linux/namei.h>
 #include <linux/buffer_head.h>		/* for fsync_super() */
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/vfs.h>
 #include <linux/writeback.h>		/* for the emergency remount stuff */
 #include <linux/idr.h>
 #include <linux/kobject.h>
 #include <linux/mutex.h>
 #include <linux/file.h>
 #include <asm/uaccess.h>
 #include "internal.h"
 LIST_HEAD(super_blocks);
 DEFINE_SPINLOCK(sb_lock);
 /**
  *	alloc_super	-	create new superblock
  *	@type:	filesystem type superblock should belong to
  *
  *	Allocates and initializes a new &struct super_block.  alloc_super()
  *	returns a pointer new superblock or %NULL if allocation had failed.
  */
 static struct super_block *alloc_super(struct file_system_type *type)
 {
 	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
 	static struct super_operations default_op;
 	if (s) {
 		if (security_sb_alloc(s)) {
 			kfree(s);
 			s = NULL;
 			goto out;
 		}
 		INIT_LIST_HEAD(&s->s_dirty);
 		INIT_LIST_HEAD(&s->s_io);
 		INIT_LIST_HEAD(&s->s_more_io);
 		INIT_LIST_HEAD(&s->s_files);
 		INIT_LIST_HEAD(&s->s_instances);
 		INIT_HLIST_HEAD(&s->s_anon);
 		INIT_LIST_HEAD(&s->s_inodes);
 		INIT_LIST_HEAD(&s->s_dentry_lru);
 		init_rwsem(&s->s_umount);
 		mutex_init(&s->s_lock);
 		lockdep_set_class(&s->s_umount, &type->s_umount_key);
 		/*
 		 * The locking rules for s_lock are up to the
 		 * filesystem. For example ext3fs has different
 		 * lock ordering than usbfs:
 		 */
 		lockdep_set_class(&s->s_lock, &type->s_lock_key);
 		/*
 		 * sget() can have s_umount recursion.
 		 *
 		 * When it cannot find a suitable sb, it allocates a new
 		 * one (this one), and tries again to find a suitable old
 		 * one.
 		 *
 		 * In case that succeeds, it will acquire the s_umount
 		 * lock of the old one. Since these are clearly distrinct
 		 * locks, and this object isn't exposed yet, there's no
 		 * risk of deadlocks.
 		 *
 		 * Annotate this by putting this lock in a different
 		 * subclass.
 		 */
 		down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
 		s->s_count = S_BIAS;
 		atomic_set(&s->s_active, 1);
 		mutex_init(&s->s_vfs_rename_mutex);
 		mutex_init(&s->s_dquot.dqio_mutex);
 		mutex_init(&s->s_dquot.dqonoff_mutex);
 		init_rwsem(&s->s_dquot.dqptr_sem);
 		init_waitqueue_head(&s->s_wait_unfrozen);
 		s->s_maxbytes = MAX_NON_LFS;
 		s->dq_op = sb_dquot_ops;
 		s->s_qcop = sb_quotactl_ops;
 		s->s_op = &default_op;
 		s->s_time_gran = 1000000000;
 	}
 out:
 	return s;
 }
 /**
  *	destroy_super	-	frees a superblock
  *	@s: superblock to free
  *
  *	Frees a superblock.
  */
 static inline void destroy_super(struct super_block *s)
 {
 	security_sb_free(s);
 	kfree(s->s_subtype);
 	kfree(s->s_options);
 	kfree(s);
 }
 /* Superblock refcounting  */
 /*
  * Drop a superblock's refcount.  Returns non-zero if the superblock was
  * destroyed.  The caller must hold sb_lock.
  */
 static int __put_super(struct super_block *sb)
 {
 	int ret = 0;
 	if (!--sb->s_count) {
 		destroy_super(sb);
 		ret = 1;
 	}
 	return ret;
 }
 /*
  * Drop a superblock's refcount.
  * Returns non-zero if the superblock is about to be destroyed and
  * at least is already removed from super_blocks list, so if we are
  * making a loop through super blocks then we need to restart.
  * The caller must hold sb_lock.
  */
 int __put_super_and_need_restart(struct super_block *sb)
 {
 	/* check for race with generic_shutdown_super() */
 	if (list_empty(&sb->s_list)) {
 		/* super block is removed, need to restart... */
 		__put_super(sb);
 		return 1;
 	}
 	/* can't be the last, since s_list is still in use */
 	sb->s_count--;
 	BUG_ON(sb->s_count == 0);
 	return 0;
 }
 /**
  *	put_super	-	drop a temporary reference to superblock
  *	@sb: superblock in question
  *
  *	Drops a temporary reference, frees superblock if there's no
  *	references left.
  */
 static void put_super(struct super_block *sb)
 {
 	spin_lock(&sb_lock);
 	__put_super(sb);
 	spin_unlock(&sb_lock);
 }
 /**
  *	deactivate_super	-	drop an active reference to superblock
  *	@s: superblock to deactivate
  *
  *	Drops an active reference to superblock, acquiring a temprory one if
  *	there is no active references left.  In that case we lock superblock,
  *	tell fs driver to shut it down and drop the temporary reference we
  *	had just acquired.
  */
 void deactivate_super(struct super_block *s)
 {
 	struct file_system_type *fs = s->s_type;
 	if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
 		s->s_count -= S_BIAS-1;
 		spin_unlock(&sb_lock);
 		vfs_dq_off(s, 0);
 		down_write(&s->s_umount);
 		fs->kill_sb(s);
 		put_filesystem(fs);
 		put_super(s);
 	}
 }
 EXPORT_SYMBOL(deactivate_super);
 /**
  *	deactivate_locked_super	-	drop an active reference to superblock
  *	@s: superblock to deactivate
  *
  *	Equivalent of up_write(&s->s_umount); deactivate_super(s);, except that
  *	it does not unlock it until it's all over.  As the result, it's safe to
  *	use to dispose of new superblock on ->get_sb() failure exits - nobody
  *	will see the sucker until it's all over.  Equivalent using up_write +
  *	deactivate_super is safe for that purpose only if superblock is either
  *	safe to use or has NULL ->s_root when we unlock.
  */
 void deactivate_locked_super(struct super_block *s)
 {
 	struct file_system_type *fs = s->s_type;
 	if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
 		s->s_count -= S_BIAS-1;
 		spin_unlock(&sb_lock);
 		vfs_dq_off(s, 0);
 		fs->kill_sb(s);
 		put_filesystem(fs);
 		put_super(s);
 	} else {
 		up_write(&s->s_umount);
 	}
 }
 EXPORT_SYMBOL(deactivate_locked_super);
 /**
  *	grab_super - acquire an active reference
  *	@s: reference we are trying to make active
  *
  *	Tries to acquire an active reference.  grab_super() is used when we
  * 	had just found a superblock in super_blocks or fs_type->fs_supers
  *	and want to turn it into a full-blown active reference.  grab_super()
  *	is called with sb_lock held and drops it.  Returns 1 in case of
  *	success, 0 if we had failed (superblock contents was already dead or
  *	dying when grab_super() had been called).
  */
 static int grab_super(struct super_block *s) __releases(sb_lock)
 {
 	s->s_count++;
 	spin_unlock(&sb_lock);
 	down_write(&s->s_umount);
 	if (s->s_root) {
 		spin_lock(&sb_lock);
 		if (s->s_count > S_BIAS) {
 			atomic_inc(&s->s_active);
 			s->s_count--;
 			spin_unlock(&sb_lock);
 			return 1;
 		}
 		spin_unlock(&sb_lock);
 	}
 	up_write(&s->s_umount);
 	put_super(s);
 	yield();
 	return 0;
 }
 /*
  * Superblock locking.  We really ought to get rid of these two.
  */
 void lock_super(struct super_block * sb)
 {
 	get_fs_excl();
 	mutex_lock(&sb->s_lock);
 }
 void unlock_super(struct super_block * sb)
 {
 	put_fs_excl();
 	mutex_unlock(&sb->s_lock);
 }
 EXPORT_SYMBOL(lock_super);
 EXPORT_SYMBOL(unlock_super);
 /*
- * Write out and wait upon all dirty data associated with this
+ * Do the filesystem syncing work. For simple filesystems sync_inodes_sb(sb, 0)
- * superblock.  Filesystem data as well as the underlying block
+ * just dirties buffers with inodes so we have to submit IO for these buffers
- * device.  Takes the superblock lock.  Requires a second blkdev
+ * via __sync_blockdev(). This also speeds up the wait == 1 case since in that
- * flush by the caller to complete the operation.
+ * case write_inode() functions do sync_dirty_buffer() and thus effectively
+ * write one block at a time.
  */
-static int __fsync_super(struct super_block *sb)
+static int __fsync_super(struct super_block *sb, int wait)
 {
-	sync_inodes_sb(sb, 0);
 	vfs_dq_sync(sb);
-	sync_inodes_sb(sb, 1);
+	sync_inodes_sb(sb, wait);
 	lock_super(sb);
 	if (sb->s_dirt && sb->s_op->write_super)
 		sb->s_op->write_super(sb);
 	unlock_super(sb);
 	if (sb->s_op->sync_fs)
-		sb->s_op->sync_fs(sb, 1);
+		sb->s_op->sync_fs(sb, wait);
-	return sync_blockdev(sb->s_bdev);
+	return __sync_blockdev(sb->s_bdev, wait);
 }
 /*
  * Write out and wait upon all dirty data associated with this
  * superblock.  Filesystem data as well as the underlying block
  * device.  Takes the superblock lock.
  */
 int fsync_super(struct super_block *sb)
 {
-	return __fsync_super(sb);
+	int ret;
+	ret = __fsync_super(sb, 0);
+	if (ret < 0)
+		return ret;
+	return __fsync_super(sb, 1);
 }
 EXPORT_SYMBOL_GPL(fsync_super);
 /**
  *	generic_shutdown_super	-	common helper for ->kill_sb()
  *	@sb: superblock to kill
  *
  *	generic_shutdown_super() does all fs-independent work on superblock
  *	shutdown.  Typical ->kill_sb() should pick all fs-specific objects
  *	that need destruction out of superblock, call generic_shutdown_super()
  *	and release aforementioned objects.  Note: dentries and inodes _are_
  *	taken care of and do not need specific handling.
  *
  *	Upon calling this function, the filesystem may no longer alter or
  *	rearrange the set of dentries belonging to this super_block, nor may it
  *	change the attachments of dentries to inodes.
  */
 void generic_shutdown_super(struct super_block *sb)
 {
 	const struct super_operations *sop = sb->s_op;
 	if (sb->s_root) {
 		shrink_dcache_for_umount(sb);
 		fsync_super(sb);
 		lock_super(sb);
 		sb->s_flags &= ~MS_ACTIVE;
 		/* bad name - it should be evict_inodes() */
 		invalidate_inodes(sb);
 		lock_kernel();
 		if (sop->write_super && sb->s_dirt)
 			sop->write_super(sb);
 		if (sop->put_super)
 			sop->put_super(sb);
 		/* Forget any remaining inodes */
 		if (invalidate_inodes(sb)) {
 			printk("VFS: Busy inodes after unmount of %s. "
 			   "Self-destruct in 5 seconds.  Have a nice day...\n",
 			   sb->s_id);
 		}
 		unlock_kernel();
 		unlock_super(sb);
 	}
 	spin_lock(&sb_lock);
 	/* should be initialized for __put_super_and_need_restart() */
 	list_del_init(&sb->s_list);
 	list_del(&sb->s_instances);
 	spin_unlock(&sb_lock);
 	up_write(&sb->s_umount);
 }
 EXPORT_SYMBOL(generic_shutdown_super);
 /**
  *	sget	-	find or create a superblock
  *	@type:	filesystem type superblock should belong to
  *	@test:	comparison callback
  *	@set:	setup callback
  *	@data:	argument to each of them
  */
 struct super_block *sget(struct file_system_type *type,
 			int (*test)(struct super_block *,void *),
 			int (*set)(struct super_block *,void *),
 			void *data)
 {
 	struct super_block *s = NULL;
 	struct super_block *old;
 	int err;
 retry:
 	spin_lock(&sb_lock);
 	if (test) {
 		list_for_each_entry(old, &type->fs_supers, s_instances) {
 			if (!test(old, data))
 				continue;
 			if (!grab_super(old))
 				goto retry;
 			if (s) {
 				up_write(&s->s_umount);
 				destroy_super(s);
 			}
 			return old;
 		}
 	}
 	if (!s) {
 		spin_unlock(&sb_lock);
 		s = alloc_super(type);
 		if (!s)
 			return ERR_PTR(-ENOMEM);
 		goto retry;
 	}
 	err = set(s, data);
 	if (err) {
 		spin_unlock(&sb_lock);
 		up_write(&s->s_umount);
 		destroy_super(s);
 		return ERR_PTR(err);
 	}
 	s->s_type = type;
 	strlcpy(s->s_id, type->name, sizeof(s->s_id));
 	list_add_tail(&s->s_list, &super_blocks);
 	list_add(&s->s_instances, &type->fs_supers);
 	spin_unlock(&sb_lock);
 	get_filesystem(type);
 	return s;
 }
 EXPORT_SYMBOL(sget);
 void drop_super(struct super_block *sb)
 {
 	up_read(&sb->s_umount);
 	put_super(sb);
 }
 EXPORT_SYMBOL(drop_super);
 static inline void write_super(struct super_block *sb)
 {
 	lock_super(sb);
 	if (sb->s_root && sb->s_dirt)
 		if (sb->s_op->write_super)
 			sb->s_op->write_super(sb);
 	unlock_super(sb);
 }
 /*
  * Note: check the dirty flag before waiting, so we don't
  * hold up the sync while mounting a device. (The newly
  * mounted device won't need syncing.)
  */
 void sync_supers(void)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 restart:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_dirt) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			write_super(sb);
 			up_read(&sb->s_umount);
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto restart;
 		}
 	}
 	spin_unlock(&sb_lock);
 }
 /*
- * Call the ->sync_fs super_op against all filesystems which are r/w and
+ * Sync all the data for all the filesystems (called by sys_sync() and
- * which implement it.
+ * emergency sync)
  *
  * This operation is careful to avoid the livelock which could easily happen
- * if two or more filesystems are being continuously dirtied.  s_need_sync_fs
+ * if two or more filesystems are being continuously dirtied.  s_need_sync
  * is used only here.  We set it against all filesystems and then clear it as
  * we sync them.  So redirtied filesystems are skipped.
  *
  * But if process A is currently running sync_filesystems and then process B
- * calls sync_filesystems as well, process B will set all the s_need_sync_fs
+ * calls sync_filesystems as well, process B will set all the s_need_sync
  * flags again, which will cause process A to resync everything.  Fix that with
  * a local mutex.
- *
- * (Fabian) Avoid sync_fs with clean fs & wait mode 0
  */
 void sync_filesystems(int wait)
 {
 	struct super_block *sb;
 	static DEFINE_MUTEX(mutex);
 	mutex_lock(&mutex);		/* Could be down_interruptible */
 	spin_lock(&sb_lock);
 	list_for_each_entry(sb, &super_blocks, s_list) {
-		if (!sb->s_op->sync_fs)
-			continue;
 		if (sb->s_flags & MS_RDONLY)
 			continue;
-		sb->s_need_sync_fs = 1;
+		sb->s_need_sync = 1;
 	}
 restart:
 	list_for_each_entry(sb, &super_blocks, s_list) {
-		if (!sb->s_need_sync_fs)
+		if (!sb->s_need_sync)
 			continue;
-		sb->s_need_sync_fs = 0;
+		sb->s_need_sync = 0;
 		if (sb->s_flags & MS_RDONLY)
 			continue;	/* hm.  Was remounted r/o meanwhile */
 		sb->s_count++;
 		spin_unlock(&sb_lock);
 		down_read(&sb->s_umount);
 		if (sb->s_root)
-			sb->s_op->sync_fs(sb, wait);
+			__fsync_super(sb, wait);
 		up_read(&sb->s_umount);
 		/* restart only when sb is no longer on the list */
 		spin_lock(&sb_lock);
 		if (__put_super_and_need_restart(sb))
 			goto restart;
 	}
 	spin_unlock(&sb_lock);
 	mutex_unlock(&mutex);
 }
-#ifdef CONFIG_BLOCK
-/*
- *  Sync all block devices underlying some superblock
- */
-void sync_blockdevs(void)
-{
-	struct super_block *sb;
-	spin_lock(&sb_lock);
-restart:
-	list_for_each_entry(sb, &super_blocks, s_list) {
-		if (!sb->s_bdev)
-			continue;
-		sb->s_count++;
-		spin_unlock(&sb_lock);
-		down_read(&sb->s_umount);
-		if (sb->s_root)
-			sync_blockdev(sb->s_bdev);
-		up_read(&sb->s_umount);
-		spin_lock(&sb_lock);
-		if (__put_super_and_need_restart(sb))
-			goto restart;
-	}
-	spin_unlock(&sb_lock);
-}
-#endif
 /**
  *	get_super - get the superblock of a device
  *	@bdev: device to get the superblock for
  *
  *	Scans the superblock list and finds the superblock of the file system
  *	mounted on the device given. %NULL is returned if no match is found.
  */
 struct super_block * get_super(struct block_device *bdev)
 {
 	struct super_block *sb;
 	if (!bdev)
 		return NULL;
 	spin_lock(&sb_lock);
 rescan:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_bdev == bdev) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			if (sb->s_root)
 				return sb;
 			up_read(&sb->s_umount);
 			/* restart only when sb is no longer on the list */
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto rescan;
 		}
 	}
 	spin_unlock(&sb_lock);
 	return NULL;
 }
 EXPORT_SYMBOL(get_super);
 struct super_block * user_get_super(dev_t dev)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 rescan:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_dev ==  dev) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			if (sb->s_root)
 				return sb;
 			up_read(&sb->s_umount);
 			/* restart only when sb is no longer on the list */
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto rescan;
 		}
 	}
 	spin_unlock(&sb_lock);
 	return NULL;
 }
 SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
 {
         struct super_block *s;
         struct ustat tmp;
         struct kstatfs sbuf;
 	int err = -EINVAL;
         s = user_get_super(new_decode_dev(dev));
         if (s == NULL)
                 goto out;
 	err = vfs_statfs(s->s_root, &sbuf);
 	drop_super(s);
 	if (err)
 		goto out;
         memset(&tmp,0,sizeof(struct ustat));
         tmp.f_tfree = sbuf.f_bfree;
         tmp.f_tinode = sbuf.f_ffree;
         err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
 out:
 	return err;
 }
 /**
  *	do_remount_sb - asks filesystem to change mount options.
  *	@sb:	superblock in question
  *	@flags:	numeric part of options
  *	@data:	the rest of options
  *      @force: whether or not to force the change
  *
  *	Alters the mount options of a mounted file system.
  */
 int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
 {
 	int retval;
 	int remount_rw;
 #ifdef CONFIG_BLOCK
 	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
 		return -EACCES;
 #endif
 	if (flags & MS_RDONLY)
 		acct_auto_close(sb);
 	shrink_dcache_sb(sb);
 	fsync_super(sb);
 	/* If we are remounting RDONLY and current sb is read/write,
 	   make sure there are no rw files opened */
 	if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {
 		if (force)
 			mark_files_ro(sb);
 		else if (!fs_may_remount_ro(sb))
 			return -EBUSY;
 		retval = vfs_dq_off(sb, 1);
 		if (retval < 0 && retval != -ENOSYS)
 			return -EBUSY;
 	}
 	remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);
 	if (sb->s_op->remount_fs) {
 		lock_super(sb);
 		retval = sb->s_op->remount_fs(sb, &flags, data);
 		unlock_super(sb);
 		if (retval)
 			return retval;
 	}
 	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
 	if (remount_rw)
 		vfs_dq_quota_on_remount(sb);
 	return 0;
 }
 static void do_emergency_remount(struct work_struct *work)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		sb->s_count++;
 		spin_unlock(&sb_lock);
 		down_read(&sb->s_umount);
 		if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
 			/*
 			 * ->remount_fs needs lock_kernel().
 			 *
 			 * What lock protects sb->s_flags??
 			 */
 			lock_kernel();
 			do_remount_sb(sb, MS_RDONLY, NULL, 1);
 			unlock_kernel();
 		}
 		drop_super(sb);
 		spin_lock(&sb_lock);
 	}
 	spin_unlock(&sb_lock);
 	kfree(work);
 	printk("Emergency Remount complete\n");
 }
 void emergency_remount(void)
 {
 	struct work_struct *work;
 	work = kmalloc(sizeof(*work), GFP_ATOMIC);
 	if (work) {
 		INIT_WORK(work, do_emergency_remount);
 		schedule_work(work);
 	}
 }
 /*
  * Unnamed block devices are dummy devices used by virtual
  * filesystems which don't use real block-devices.  -- jrs
  */
 static DEFINE_IDA(unnamed_dev_ida);
 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
 int set_anon_super(struct super_block *s, void *data)
 {
 	int dev;
 	int error;
  retry:
 	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
 		return -ENOMEM;
 	spin_lock(&unnamed_dev_lock);
 	error = ida_get_new(&unnamed_dev_ida, &dev);
 	spin_unlock(&unnamed_dev_lock);
 	if (error == -EAGAIN)
 		/* We raced and lost with another CPU. */
 		goto retry;
 	else if (error)
 		return -EAGAIN;
 	if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
 		spin_lock(&unnamed_dev_lock);
 		ida_remove(&unnamed_dev_ida, dev);
 		spin_unlock(&unnamed_dev_lock);
 		return -EMFILE;
 	}
 	s->s_dev = MKDEV(0, dev & MINORMASK);
 	return 0;
 }
 EXPORT_SYMBOL(set_anon_super);
 void kill_anon_super(struct super_block *sb)
 {
 	int slot = MINOR(sb->s_dev);
 	generic_shutdown_super(sb);
 	spin_lock(&unnamed_dev_lock);
 	ida_remove(&unnamed_dev_ida, slot);
 	spin_unlock(&unnamed_dev_lock);
 }
 EXPORT_SYMBOL(kill_anon_super);
 void kill_litter_super(struct super_block *sb)
 {
 	if (sb->s_root)
 		d_genocide(sb->s_root);
 	kill_anon_super(sb);
 }
 EXPORT_SYMBOL(kill_litter_super);
 static int ns_test_super(struct super_block *sb, void *data)
 {
 	return sb->s_fs_info == data;
 }
 static int ns_set_super(struct super_block *sb, void *data)
 {
 	sb->s_fs_info = data;
 	return set_anon_super(sb, NULL);
 }
 int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct super_block *sb;
 	sb = sget(fs_type, ns_test_super, ns_set_super, data);
 	if (IS_ERR(sb))
 		return PTR_ERR(sb);
 	if (!sb->s_root) {
 		int err;
 		sb->s_flags = flags;
 		err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
 		if (err) {
 			deactivate_locked_super(sb);
 			return err;
 		}
 		sb->s_flags |= MS_ACTIVE;
 	}
 	simple_set_mnt(mnt, sb);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_ns);
 #ifdef CONFIG_BLOCK
 static int set_bdev_super(struct super_block *s, void *data)
 {
 	s->s_bdev = data;
 	s->s_dev = s->s_bdev->bd_dev;
 	return 0;
 }
 static int test_bdev_super(struct super_block *s, void *data)
 {
 	return (void *)s->s_bdev == data;
 }
 int get_sb_bdev(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct block_device *bdev;
 	struct super_block *s;
 	fmode_t mode = FMODE_READ;
 	int error = 0;
 	if (!(flags & MS_RDONLY))
 		mode |= FMODE_WRITE;
 	bdev = open_bdev_exclusive(dev_name, mode, fs_type);
 	if (IS_ERR(bdev))
 		return PTR_ERR(bdev);
 	/*
 	 * once the super is inserted into the list by sget, s_umount
 	 * will protect the lockfs code from trying to start a snapshot
 	 * while we are mounting
 	 */
 	down(&bdev->bd_mount_sem);
 	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
 	up(&bdev->bd_mount_sem);
 	if (IS_ERR(s))
 		goto error_s;
 	if (s->s_root) {
 		if ((flags ^ s->s_flags) & MS_RDONLY) {
 			deactivate_locked_super(s);
 			error = -EBUSY;
 			goto error_bdev;
 		}
 		close_bdev_exclusive(bdev, mode);
 	} else {
 		char b[BDEVNAME_SIZE];
 		s->s_flags = flags;
 		s->s_mode = mode;
 		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
 		sb_set_blocksize(s, block_size(bdev));
 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 		if (error) {
 			deactivate_locked_super(s);
 			goto error;
 		}
 		s->s_flags |= MS_ACTIVE;
 		bdev->bd_super = s;
 	}
 	simple_set_mnt(mnt, s);
 	return 0;
 error_s:
 	error = PTR_ERR(s);
 error_bdev:
 	close_bdev_exclusive(bdev, mode);
 error:
 	return error;
 }
 EXPORT_SYMBOL(get_sb_bdev);
 void kill_block_super(struct super_block *sb)
 {
 	struct block_device *bdev = sb->s_bdev;
 	fmode_t mode = sb->s_mode;
 	bdev->bd_super = NULL;
 	generic_shutdown_super(sb);
 	sync_blockdev(bdev);
 	close_bdev_exclusive(bdev, mode);
 }
 EXPORT_SYMBOL(kill_block_super);
 #endif
 int get_sb_nodev(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	int error;
 	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
 	if (IS_ERR(s))
 		return PTR_ERR(s);
 	s->s_flags = flags;
 	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 	if (error) {
 		deactivate_locked_super(s);
 		return error;
 	}
 	s->s_flags |= MS_ACTIVE;
 	simple_set_mnt(mnt, s);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_nodev);
 static int compare_single(struct super_block *s, void *p)
 {
 	return 1;
 }
 int get_sb_single(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct super_block *s;
 	int error;
 	s = sget(fs_type, compare_single, set_anon_super, NULL);
 	if (IS_ERR(s))
 		return PTR_ERR(s);
 	if (!s->s_root) {
 		s->s_flags = flags;
 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 		if (error) {
 			deactivate_locked_super(s);
 			return error;
 		}
 		s->s_flags |= MS_ACTIVE;
 	}
 	do_remount_sb(s, flags, data, 0);
 	simple_set_mnt(mnt, s);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_single);
 struct vfsmount *
 vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
 {
 	struct vfsmount *mnt;
 	char *secdata = NULL;
 	int error;
 	if (!type)
 		return ERR_PTR(-ENODEV);
 	error = -ENOMEM;
 	mnt = alloc_vfsmnt(name);
 	if (!mnt)
 		goto out;
 	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
 		secdata = alloc_secdata();
 		if (!secdata)
 			goto out_mnt;
 		error = security_sb_copy_data(data, secdata);
 		if (error)
 			goto out_free_secdata;
 	}
 	error = type->get_sb(type, flags, name, data, mnt);
 	if (error < 0)
 		goto out_free_secdata;
 	BUG_ON(!mnt->mnt_sb);
  	error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
  	if (error)
  		goto out_sb;
 	mnt->mnt_mountpoint = mnt->mnt_root;
 	mnt->mnt_parent = mnt;
 	up_write(&mnt->mnt_sb->s_umount);
 	free_secdata(secdata);
 	return mnt;
 out_sb:
 	dput(mnt->mnt_root);
 	deactivate_locked_super(mnt->mnt_sb);
 out_free_secdata:
 	free_secdata(secdata);
 out_mnt:
 	free_vfsmnt(mnt);
 out:
 	return ERR_PTR(error);
 }
 EXPORT_SYMBOL_GPL(vfs_kern_mount);
 static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
 {
 	int err;
 	const char *subtype = strchr(fstype, '.');
 	if (subtype) {
 		subtype++;
 		err = -EINVAL;
 		if (!subtype[0])
 			goto err;
 	} else
 		subtype = "";
 	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
 	err = -ENOMEM;
 	if (!mnt->mnt_sb->s_subtype)
 		goto err;
 	return mnt;
  err:
 	mntput(mnt);
 	return ERR_PTR(err);
 }
 struct vfsmount *
 do_kern_mount(const char *fstype, int flags, const char *name, void *data)
 {
 	struct file_system_type *type = get_fs_type(fstype);
 	struct vfsmount *mnt;
 	if (!type)
 		return ERR_PTR(-ENODEV);
 	mnt = vfs_kern_mount(type, flags, name, data);
 	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
 	    !mnt->mnt_sb->s_subtype)
 		mnt = fs_set_subtype(mnt, fstype);
 	put_filesystem(type);
 	return mnt;
 }
 EXPORT_SYMBOL_GPL(do_kern_mount);
 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)

fs/sync.c

Diff comments View file @ 5cee581

 /*
  * High-level sync()-related operations
  */
 #include <linux/kernel.h>
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/writeback.h>
 #include <linux/syscalls.h>
 #include <linux/linkage.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 #include "internal.h"
 #define VALID_FLAGS (SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE| \
 			SYNC_FILE_RANGE_WAIT_AFTER)
-/*
+SYSCALL_DEFINE0(sync)
- * sync everything.  Start out by waking pdflush, because that writes back
- * all queues in parallel.
- */
-static void do_sync(unsigned long wait)
 {
-	wakeup_pdflush(0);
+	sync_filesystems(0);
-	sync_inodes(0);		/* All mappings, inodes and their blockdevs */
+	sync_filesystems(1);
-	vfs_dq_sync(NULL);
-	sync_inodes(wait);	/* Mappings, inodes and blockdevs, again. */
-	sync_supers();		/* Write the superblocks */
-	sync_filesystems(0);	/* Start syncing the filesystems */
-	sync_filesystems(wait);	/* Waitingly sync the filesystems */
-	sync_blockdevs();
-	if (!wait)
-		printk("Emergency Sync complete\n");
 	if (unlikely(laptop_mode))
 		laptop_sync_completion();
-}
-SYSCALL_DEFINE0(sync)
-{
-	do_sync(1);
 	return 0;
 }
 static void do_sync_work(struct work_struct *work)
 {
-	do_sync(0);
+	/*
+	 * Sync twice to reduce the possibility we skipped some inodes / pages
+	 * because they were temporarily locked
+	 */
+	sync_filesystems(0);
+	sync_filesystems(0);
+	printk("Emergency Sync complete\n");
 	kfree(work);
 }
 void emergency_sync(void)
 {
 	struct work_struct *work;
 	work = kmalloc(sizeof(*work), GFP_ATOMIC);
 	if (work) {
 		INIT_WORK(work, do_sync_work);
 		schedule_work(work);
 	}
 }
 /*
  * Generic function to fsync a file.
  *
  * filp may be NULL if called via the msync of a vma.
  */
 int file_fsync(struct file *filp, struct dentry *dentry, int datasync)
 {
 	struct inode * inode = dentry->d_inode;
 	struct super_block * sb;
 	int ret, err;
 	/* sync the inode to buffers */
 	ret = write_inode_now(inode, 0);
 	/* sync the superblock to buffers */
 	sb = inode->i_sb;
 	lock_super(sb);
 	if (sb->s_dirt && sb->s_op->write_super)
 		sb->s_op->write_super(sb);
 	unlock_super(sb);
 	/* .. finally sync the buffers to disk */
 	err = sync_blockdev(sb->s_bdev);
 	if (!ret)
 		ret = err;
 	return ret;
 }
 /**
  * vfs_fsync - perform a fsync or fdatasync on a file
  * @file:		file to sync
  * @dentry:		dentry of @file
  * @data:		only perform a fdatasync operation
  *
  * Write back data and metadata for @file to disk.  If @datasync is
  * set only metadata needed to access modified file data is written.
  *
  * In case this function is called from nfsd @file may be %NULL and
  * only @dentry is set.  This can only happen when the filesystem
  * implements the export_operations API.
  */
 int vfs_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
 	const struct file_operations *fop;
 	struct address_space *mapping;
 	int err, ret;
 	/*
 	 * Get mapping and operations from the file in case we have
 	 * as file, or get the default values for them in case we
 	 * don't have a struct file available.  Damn nfsd..
 	 */
 	if (file) {
 		mapping = file->f_mapping;
 		fop = file->f_op;
 	} else {
 		mapping = dentry->d_inode->i_mapping;
 		fop = dentry->d_inode->i_fop;
 	}
 	if (!fop || !fop->fsync) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ret = filemap_fdatawrite(mapping);
 	/*
 	 * We need to protect against concurrent writers, which could cause
 	 * livelocks in fsync_buffers_list().
 	 */
 	mutex_lock(&mapping->host->i_mutex);
 	err = fop->fsync(file, dentry, datasync);
 	if (!ret)
 		ret = err;
 	mutex_unlock(&mapping->host->i_mutex);
 	err = filemap_fdatawait(mapping);
 	if (!ret)
 		ret = err;
 out:
 	return ret;
 }
 EXPORT_SYMBOL(vfs_fsync);
 static int do_fsync(unsigned int fd, int datasync)
 {
 	struct file *file;
 	int ret = -EBADF;
 	file = fget(fd);
 	if (file) {
 		ret = vfs_fsync(file, file->f_path.dentry, datasync);
 		fput(file);
 	}
 	return ret;
 }
 SYSCALL_DEFINE1(fsync, unsigned int, fd)
 {
 	return do_fsync(fd, 0);
 }
 SYSCALL_DEFINE1(fdatasync, unsigned int, fd)
 {
 	return do_fsync(fd, 1);
 }
 /*
  * sys_sync_file_range() permits finely controlled syncing over a segment of
  * a file in the range offset .. (offset+nbytes-1) inclusive.  If nbytes is
  * zero then sys_sync_file_range() will operate from offset out to EOF.
  *
  * The flag bits are:
  *
  * SYNC_FILE_RANGE_WAIT_BEFORE: wait upon writeout of all pages in the range
  * before performing the write.
  *
  * SYNC_FILE_RANGE_WRITE: initiate writeout of all those dirty pages in the
  * range which are not presently under writeback. Note that this may block for
  * significant periods due to exhaustion of disk request structures.
  *
  * SYNC_FILE_RANGE_WAIT_AFTER: wait upon writeout of all pages in the range
  * after performing the write.
  *
  * Useful combinations of the flag bits are:
  *
  * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE: ensures that all pages
  * in the range which were dirty on entry to sys_sync_file_range() are placed
  * under writeout.  This is a start-write-for-data-integrity operation.
  *
  * SYNC_FILE_RANGE_WRITE: start writeout of all dirty pages in the range which
  * are not presently under writeout.  This is an asynchronous flush-to-disk
  * operation.  Not suitable for data integrity operations.
  *
  * SYNC_FILE_RANGE_WAIT_BEFORE (or SYNC_FILE_RANGE_WAIT_AFTER): wait for
  * completion of writeout of all pages in the range.  This will be used after an
  * earlier SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE operation to wait
  * for that operation to complete and to return the result.
  *
  * SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER:
  * a traditional sync() operation.  This is a write-for-data-integrity operation
  * which will ensure that all pages in the range which were dirty on entry to
  * sys_sync_file_range() are committed to disk.
  *
  *
  * SYNC_FILE_RANGE_WAIT_BEFORE and SYNC_FILE_RANGE_WAIT_AFTER will detect any
  * I/O errors or ENOSPC conditions and will return those to the caller, after
  * clearing the EIO and ENOSPC flags in the address_space.
  *
  * It should be noted that none of these operations write out the file's
  * metadata.  So unless the application is strictly performing overwrites of
  * already-instantiated disk blocks, there are no guarantees here that the data
  * will be available after a crash.
  */
 SYSCALL_DEFINE(sync_file_range)(int fd, loff_t offset, loff_t nbytes,
 				unsigned int flags)
 {
 	int ret;
 	struct file *file;
 	loff_t endbyte;			/* inclusive */
 	int fput_needed;
 	umode_t i_mode;
 	ret = -EINVAL;
 	if (flags & ~VALID_FLAGS)
 		goto out;
 	endbyte = offset + nbytes;
 	if ((s64)offset < 0)
 		goto out;
 	if ((s64)endbyte < 0)
 		goto out;
 	if (endbyte < offset)
 		goto out;
 	if (sizeof(pgoff_t) == 4) {
 		if (offset >= (0x100000000ULL << PAGE_CACHE_SHIFT)) {
 			/*
 			 * The range starts outside a 32 bit machine's
 			 * pagecache addressing capabilities.  Let it "succeed"
 			 */
 			ret = 0;
 			goto out;
 		}
 		if (endbyte >= (0x100000000ULL << PAGE_CACHE_SHIFT)) {
 			/*
 			 * Out to EOF
 			 */
 			nbytes = 0;
 		}
 	}
 	if (nbytes == 0)
 		endbyte = LLONG_MAX;
 	else
 		endbyte--;		/* inclusive */
 	ret = -EBADF;
 	file = fget_light(fd, &fput_needed);
 	if (!file)
 		goto out;
 	i_mode = file->f_path.dentry->d_inode->i_mode;
 	ret = -ESPIPE;
 	if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) &&
 			!S_ISLNK(i_mode))
 		goto out_put;
 	ret = do_sync_mapping_range(file->f_mapping, offset, endbyte, flags);
 out_put:
 	fput_light(file, fput_needed);
 out:
 	return ret;
 }
 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 asmlinkage long SyS_sync_file_range(long fd, loff_t offset, loff_t nbytes,
 				    long flags)
 {
 	return SYSC_sync_file_range((int) fd, offset, nbytes,
 				    (unsigned int) flags);
 }
 SYSCALL_ALIAS(sys_sync_file_range, SyS_sync_file_range);
 #endif
 /* It would be nice if people remember that not all the world's an i386
    when they introduce new system calls */
 SYSCALL_DEFINE(sync_file_range2)(int fd, unsigned int flags,
 				 loff_t offset, loff_t nbytes)
 {
 	return sys_sync_file_range(fd, offset, nbytes, flags);
 }
 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 asmlinkage long SyS_sync_file_range2(long fd, long flags,
 				     loff_t offset, loff_t nbytes)
 {
 	return SYSC_sync_file_range2((int) fd, (unsigned int) flags,
 				     offset, nbytes);
 }
 SYSCALL_ALIAS(sys_sync_file_range2, SyS_sync_file_range2);
 #endif
 /*
  * `endbyte' is inclusive
  */
 int do_sync_mapping_range(struct address_space *mapping, loff_t offset,
 			  loff_t endbyte, unsigned int flags)
 {
 	int ret;
 	if (!mapping) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ret = 0;
 	if (flags & SYNC_FILE_RANGE_WAIT_BEFORE) {
 		ret = wait_on_page_writeback_range(mapping,
 					offset >> PAGE_CACHE_SHIFT,
 					endbyte >> PAGE_CACHE_SHIFT);
 		if (ret < 0)
 			goto out;
 	}
 	if (flags & SYNC_FILE_RANGE_WRITE) {
 		ret = __filemap_fdatawrite_range(mapping, offset, endbyte,
 						WB_SYNC_ALL);
 		if (ret < 0)
 			goto out;
 	}
 	if (flags & SYNC_FILE_RANGE_WAIT_AFTER) {
 		ret = wait_on_page_writeback_range(mapping,
 					offset >> PAGE_CACHE_SHIFT,
 					endbyte >> PAGE_CACHE_SHIFT);

include/linux/fs.h

Diff comments View file @ 5cee581

include/linux/writeback.h

Diff comments View file @ 5cee581

 /*
  * include/linux/writeback.h
  */
 #ifndef WRITEBACK_H
 #define WRITEBACK_H
 #include <linux/sched.h>
 #include <linux/fs.h>
 struct backing_dev_info;
 extern spinlock_t inode_lock;
 extern struct list_head inode_in_use;
 extern struct list_head inode_unused;
 /*
  * Yes, writeback.h requires sched.h
  * No, sched.h is not included from here.
  */
 static inline int task_is_pdflush(struct task_struct *task)
 {
 	return task->flags & PF_FLUSHER;
 }
 #define current_is_pdflush()	task_is_pdflush(current)
 /*
  * fs/fs-writeback.c
  */
 enum writeback_sync_modes {
 	WB_SYNC_NONE,	/* Don't wait on anything */
 	WB_SYNC_ALL,	/* Wait on every mapping */
 };
 /*
  * A control structure which tells the writeback code what to do.  These are
  * always on the stack, and hence need no locking.  They are always initialised
  * in a manner such that unspecified fields are set to zero.
  */
 struct writeback_control {
 	struct backing_dev_info *bdi;	/* If !NULL, only write back this
 					   queue */
 	enum writeback_sync_modes sync_mode;
 	unsigned long *older_than_this;	/* If !NULL, only write back inodes
 					   older than this */
 	long nr_to_write;		/* Write this many pages, and decrement
 					   this for each page written */
 	long pages_skipped;		/* Pages which were not written */
 	/*
 	 * For a_ops->writepages(): is start or end are non-zero then this is
 	 * a hint that the filesystem need only write out the pages inside that
 	 * byterange.  The byte at `end' is included in the writeout request.
 	 */
 	loff_t range_start;
 	loff_t range_end;
 	unsigned nonblocking:1;		/* Don't get stuck on request queues */
 	unsigned encountered_congestion:1; /* An output: a queue is full */
 	unsigned for_kupdate:1;		/* A kupdate writeback */
 	unsigned for_reclaim:1;		/* Invoked from the page allocator */
 	unsigned for_writepages:1;	/* This is a writepages() call */
 	unsigned range_cyclic:1;	/* range_start is cyclic */
 	unsigned more_io:1;		/* more io to be dispatched */
 	/*
 	 * write_cache_pages() won't update wbc->nr_to_write and
 	 * mapping->writeback_index if no_nrwrite_index_update
 	 * is set.  write_cache_pages() may write more than we
 	 * requested and we want to make sure nr_to_write and
 	 * writeback_index are updated in a consistent manner
 	 * so we use a single control to update them
 	 */
 	unsigned no_nrwrite_index_update:1;
 };
 /*
  * fs/fs-writeback.c
  */
 void writeback_inodes(struct writeback_control *wbc);
 int inode_wait(void *);
 void sync_inodes_sb(struct super_block *, int wait);
-void sync_inodes(int wait);
 /* writeback.h requires fs.h; it, too, is not included from here. */
 static inline void wait_on_inode(struct inode *inode)
 {
 	might_sleep();
 	wait_on_bit(&inode->i_state, __I_LOCK, inode_wait,
 							TASK_UNINTERRUPTIBLE);
 }
 static inline void inode_sync_wait(struct inode *inode)
 {
 	might_sleep();
 	wait_on_bit(&inode->i_state, __I_SYNC, inode_wait,
 							TASK_UNINTERRUPTIBLE);
 }
 /*
  * mm/page-writeback.c
  */
 int wakeup_pdflush(long nr_pages);
 void laptop_io_completion(void);
 void laptop_sync_completion(void);
 void throttle_vm_writeout(gfp_t gfp_mask);
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
 extern unsigned long dirty_background_bytes;
 extern int vm_dirty_ratio;
 extern unsigned long vm_dirty_bytes;
 extern unsigned int dirty_writeback_interval;
 extern unsigned int dirty_expire_interval;
 extern int vm_highmem_is_dirtyable;
 extern int block_dump;
 extern int laptop_mode;
 extern unsigned long determine_dirtyable_memory(void);
 extern int dirty_background_ratio_handler(struct ctl_table *table, int write,
 		struct file *filp, void __user *buffer, size_t *lenp,
 		loff_t *ppos);
 extern int dirty_background_bytes_handler(struct ctl_table *table, int write,
 		struct file *filp, void __user *buffer, size_t *lenp,
 		loff_t *ppos);
 extern int dirty_ratio_handler(struct ctl_table *table, int write,
 		struct file *filp, void __user *buffer, size_t *lenp,
 		loff_t *ppos);
 extern int dirty_bytes_handler(struct ctl_table *table, int write,
 		struct file *filp, void __user *buffer, size_t *lenp,
 		loff_t *ppos);
 struct ctl_table;
 struct file;
 int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *,
 				      void __user *, size_t *, loff_t *);
 void get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,
 		      unsigned long *pbdi_dirty, struct backing_dev_info *bdi);
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
 					unsigned long nr_pages_dirtied);
 static inline void
 balance_dirty_pages_ratelimited(struct address_space *mapping)
 {
 	balance_dirty_pages_ratelimited_nr(mapping, 1);
 }
 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
 				void *data);
 int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
 int generic_writepages(struct address_space *mapping,
 		       struct writeback_control *wbc);
 int write_cache_pages(struct address_space *mapping,
 		      struct writeback_control *wbc, writepage_t writepage,
 		      void *data);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 int sync_page_range(struct inode *inode, struct address_space *mapping,
 			loff_t pos, loff_t count);
 int sync_page_range_nolock(struct inode *inode, struct address_space *mapping,
 			   loff_t pos, loff_t count);
 void set_page_dirty_balance(struct page *page, int page_mkwrite);
 void writeback_set_ratelimit(void);
 /* pdflush.c */
 extern int nr_pdflush_threads;	/* Global so it can be exported to sysctl
 				   read-only. */
 #endif		/* WRITEBACK_H */

1	#ifndef _LINUX_FS_H	1	#ifndef _LINUX_FS_H
2	#define _LINUX_FS_H	2	#define _LINUX_FS_H
3		3
4	/*	4	/*
5	* This file has definitions for some important file table	5	* This file has definitions for some important file table
6	* structures etc.	6	* structures etc.
7	*/	7	*/
8		8
9	#include <linux/limits.h>	9	#include <linux/limits.h>
10	#include <linux/ioctl.h>	10	#include <linux/ioctl.h>
11		11
12	/*	12	/*
13	* It's silly to have NR_OPEN bigger than NR_FILE, but you can change	13	* It's silly to have NR_OPEN bigger than NR_FILE, but you can change
14	* the file limit at runtime and only root can increase the per-process	14	* the file limit at runtime and only root can increase the per-process
15	* nr_file rlimit, so it's safe to set up a ridiculously high absolute	15	* nr_file rlimit, so it's safe to set up a ridiculously high absolute
16	* upper limit on files-per-process.	16	* upper limit on files-per-process.
17	*	17	*
18	* Some programs (notably those using select()) may have to be	18	* Some programs (notably those using select()) may have to be
19	* recompiled to take full advantage of the new limits..	19	* recompiled to take full advantage of the new limits..
20	*/	20	*/
21		21
22	/* Fixed constants first: */	22	/* Fixed constants first: */
23	#undef NR_OPEN	23	#undef NR_OPEN
24	#define INR_OPEN 1024 /* Initial setting for nfile rlimits */	24	#define INR_OPEN 1024 /* Initial setting for nfile rlimits */
25		25
26	#define BLOCK_SIZE_BITS 10	26	#define BLOCK_SIZE_BITS 10
27	#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)	27	#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
28		28
29	#define SEEK_SET 0 /* seek relative to beginning of file */	29	#define SEEK_SET 0 /* seek relative to beginning of file */
30	#define SEEK_CUR 1 /* seek relative to current file position */	30	#define SEEK_CUR 1 /* seek relative to current file position */
31	#define SEEK_END 2 /* seek relative to end of file */	31	#define SEEK_END 2 /* seek relative to end of file */
32	#define SEEK_MAX SEEK_END	32	#define SEEK_MAX SEEK_END
33		33
34	/* And dynamically-tunable limits and defaults: */	34	/* And dynamically-tunable limits and defaults: */
35	struct files_stat_struct {	35	struct files_stat_struct {
36	int nr_files; /* read only */	36	int nr_files; /* read only */
37	int nr_free_files; /* read only */	37	int nr_free_files; /* read only */
38	int max_files; /* tunable */	38	int max_files; /* tunable */
39	};	39	};
40		40