mm: remove destroy_dirty_buffers from invalidate_bdev()
[linux-2.6.git] / fs / block_dev.c
index 17c7618..21e59ac 100644 (file)
@@ -5,25 +5,25 @@
  *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
  */
 
-#include <linux/config.h>
 #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/devfs_fs_kernel.h>
 #include <linux/smp_lock.h>
 #include <linux/highmem.h>
 #include <linux/blkdev.h>
 #include <linux/module.h>
 #include <linux/blkpg.h>
 #include <linux/buffer_head.h>
+#include <linux/writeback.h>
 #include <linux/mpage.h>
 #include <linux/mount.h>
 #include <linux/uio.h>
 #include <linux/namei.h>
 #include <asm/uaccess.h>
+#include "internal.h"
 
 struct bdev_inode {
        struct block_device bdev;
@@ -58,7 +58,7 @@ static sector_t max_block(struct block_device *bdev)
 /* Kill _all_ buffers, dirty or not.. */
 static void kill_bdev(struct block_device *bdev)
 {
-       invalidate_bdev(bdev, 1);
+       invalidate_bdev(bdev);
        truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
 }      
 
@@ -168,6 +168,203 @@ blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
                                iov, offset, nr_segs, blkdev_get_blocks, NULL);
 }
 
+#if 0
+static int blk_end_aio(struct bio *bio, unsigned int bytes_done, int error)
+{
+       struct kiocb *iocb = bio->bi_private;
+       atomic_t *bio_count = &iocb->ki_bio_count;
+
+       if (bio_data_dir(bio) == READ)
+               bio_check_pages_dirty(bio);
+       else {
+               bio_release_pages(bio);
+               bio_put(bio);
+       }
+
+       /* iocb->ki_nbytes stores error code from LLDD */
+       if (error)
+               iocb->ki_nbytes = -EIO;
+
+       if (atomic_dec_and_test(bio_count)) {
+               if ((long)iocb->ki_nbytes < 0)
+                       aio_complete(iocb, iocb->ki_nbytes, 0);
+               else
+                       aio_complete(iocb, iocb->ki_left, 0);
+       }
+
+       return 0;
+}
+
+#define VEC_SIZE       16
+struct pvec {
+       unsigned short nr;
+       unsigned short idx;
+       struct page *page[VEC_SIZE];
+};
+
+#define PAGES_SPANNED(addr, len)       \
+       (DIV_ROUND_UP((addr) + (len), PAGE_SIZE) - (addr) / PAGE_SIZE);
+
+/*
+ * get page pointer for user addr, we internally cache struct page array for
+ * (addr, count) range in pvec to avoid frequent call to get_user_pages.  If
+ * internal page list is exhausted, a batch count of up to VEC_SIZE is used
+ * to get next set of page struct.
+ */
+static struct page *blk_get_page(unsigned long addr, size_t count, int rw,
+                                struct pvec *pvec)
+{
+       int ret, nr_pages;
+       if (pvec->idx == pvec->nr) {
+               nr_pages = PAGES_SPANNED(addr, count);
+               nr_pages = min(nr_pages, VEC_SIZE);
+               down_read(&current->mm->mmap_sem);
+               ret = get_user_pages(current, current->mm, addr, nr_pages,
+                                    rw == READ, 0, pvec->page, NULL);
+               up_read(&current->mm->mmap_sem);
+               if (ret < 0)
+                       return ERR_PTR(ret);
+               pvec->nr = ret;
+               pvec->idx = 0;
+       }
+       return pvec->page[pvec->idx++];
+}
+
+/* return a page back to pvec array */
+static void blk_unget_page(struct page *page, struct pvec *pvec)
+{
+       pvec->page[--pvec->idx] = page;
+}
+
+static ssize_t
+blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
+                loff_t pos, unsigned long nr_segs)
+{
+       struct inode *inode = iocb->ki_filp->f_mapping->host;
+       unsigned blkbits = blksize_bits(bdev_hardsect_size(I_BDEV(inode)));
+       unsigned blocksize_mask = (1 << blkbits) - 1;
+       unsigned long seg = 0;  /* iov segment iterator */
+       unsigned long nvec;     /* number of bio vec needed */
+       unsigned long cur_off;  /* offset into current page */
+       unsigned long cur_len;  /* I/O len of current page, up to PAGE_SIZE */
+
+       unsigned long addr;     /* user iovec address */
+       size_t count;           /* user iovec len */
+       size_t nbytes = iocb->ki_nbytes = iocb->ki_left; /* total xfer size */
+       loff_t size;            /* size of block device */
+       struct bio *bio;
+       atomic_t *bio_count = &iocb->ki_bio_count;
+       struct page *page;
+       struct pvec pvec;
+
+       pvec.nr = 0;
+       pvec.idx = 0;
+
+       if (pos & blocksize_mask)
+               return -EINVAL;
+
+       size = i_size_read(inode);
+       if (pos + nbytes > size) {
+               nbytes = size - pos;
+               iocb->ki_left = nbytes;
+       }
+
+       /*
+        * check first non-zero iov alignment, the remaining
+        * iov alignment is checked inside bio loop below.
+        */
+       do {
+               addr = (unsigned long) iov[seg].iov_base;
+               count = min(iov[seg].iov_len, nbytes);
+               if (addr & blocksize_mask || count & blocksize_mask)
+                       return -EINVAL;
+       } while (!count && ++seg < nr_segs);
+       atomic_set(bio_count, 1);
+
+       while (nbytes) {
+               /* roughly estimate number of bio vec needed */
+               nvec = (nbytes + PAGE_SIZE - 1) / PAGE_SIZE;
+               nvec = max(nvec, nr_segs - seg);
+               nvec = min(nvec, (unsigned long) BIO_MAX_PAGES);
+
+               /* bio_alloc should not fail with GFP_KERNEL flag */
+               bio = bio_alloc(GFP_KERNEL, nvec);
+               bio->bi_bdev = I_BDEV(inode);
+               bio->bi_end_io = blk_end_aio;
+               bio->bi_private = iocb;
+               bio->bi_sector = pos >> blkbits;
+same_bio:
+               cur_off = addr & ~PAGE_MASK;
+               cur_len = PAGE_SIZE - cur_off;
+               if (count < cur_len)
+                       cur_len = count;
+
+               page = blk_get_page(addr, count, rw, &pvec);
+               if (unlikely(IS_ERR(page)))
+                       goto backout;
+
+               if (bio_add_page(bio, page, cur_len, cur_off)) {
+                       pos += cur_len;
+                       addr += cur_len;
+                       count -= cur_len;
+                       nbytes -= cur_len;
+
+                       if (count)
+                               goto same_bio;
+                       while (++seg < nr_segs) {
+                               addr = (unsigned long) iov[seg].iov_base;
+                               count = iov[seg].iov_len;
+                               if (!count)
+                                       continue;
+                               if (unlikely(addr & blocksize_mask ||
+                                            count & blocksize_mask)) {
+                                       page = ERR_PTR(-EINVAL);
+                                       goto backout;
+                               }
+                               count = min(count, nbytes);
+                               goto same_bio;
+                       }
+               } else {
+                       blk_unget_page(page, &pvec);
+               }
+
+               /* bio is ready, submit it */
+               if (rw == READ)
+                       bio_set_pages_dirty(bio);
+               atomic_inc(bio_count);
+               submit_bio(rw, bio);
+       }
+
+completion:
+       iocb->ki_left -= nbytes;
+       nbytes = iocb->ki_left;
+       iocb->ki_pos += nbytes;
+
+       blk_run_address_space(inode->i_mapping);
+       if (atomic_dec_and_test(bio_count))
+               aio_complete(iocb, nbytes, 0);
+
+       return -EIOCBQUEUED;
+
+backout:
+       /*
+        * back out nbytes count constructed so far for this bio,
+        * we will throw away current bio.
+        */
+       nbytes += bio->bi_size;
+       bio_release_pages(bio);
+       bio_put(bio);
+
+       /*
+        * if no bio was submmitted, return the error code.
+        * otherwise, proceed with pending I/O completion.
+        */
+       if (atomic_read(bio_count) == 1)
+               return PTR_ERR(page);
+       goto completion;
+}
+#endif
+
 static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
 {
        return block_write_full_page(page, blkdev_get_block, wbc);
@@ -190,7 +387,7 @@ static int blkdev_commit_write(struct file *file, struct page *page, unsigned fr
 
 /*
  * private llseek:
- * for a block special file file->f_dentry->d_inode->i_size is zero
+ * 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)
@@ -235,11 +432,11 @@ static int block_fsync(struct file *filp, struct dentry *dentry, int datasync)
  */
 
 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
-static kmem_cache_t * bdev_cachep __read_mostly;
+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, SLAB_KERNEL);
+       struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -253,7 +450,7 @@ static void bdev_destroy_inode(struct inode *inode)
        kmem_cache_free(bdev_cachep, bdi);
 }
 
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct bdev_inode *ei = (struct bdev_inode *) foo;
        struct block_device *bdev = &ei->bdev;
@@ -263,7 +460,7 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
        {
                memset(bdev, 0, sizeof(*bdev));
                mutex_init(&bdev->bd_mutex);
-               mutex_init(&bdev->bd_mount_mutex);
+               sema_init(&bdev->bd_mount_sem, 1);
                INIT_LIST_HEAD(&bdev->bd_inodes);
                INIT_LIST_HEAD(&bdev->bd_list);
 #ifdef CONFIG_SYSFS
@@ -292,7 +489,7 @@ static void bdev_clear_inode(struct inode *inode)
        spin_unlock(&bdev_lock);
 }
 
-static struct super_operations bdev_sops = {
+static const struct super_operations bdev_sops = {
        .statfs = simple_statfs,
        .alloc_inode = bdev_alloc_inode,
        .destroy_inode = bdev_destroy_inode,
@@ -300,10 +497,10 @@ static struct super_operations bdev_sops = {
        .clear_inode = bdev_clear_inode,
 };
 
-static struct super_block *bd_get_sb(struct file_system_type *fs_type,
-       int flags, const char *dev_name, void *data)
+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);
+       return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
 }
 
 static struct file_system_type bd_type = {
@@ -414,21 +611,31 @@ 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 && igrab(bdev->bd_inode)) {
+       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)
-                       __bd_forget(inode);
-               inode->i_bdev = bdev;
-               inode->i_mapping = bdev->bd_inode->i_mapping;
-               list_add(&inode->i_devices, &bdev->bd_inodes);
+               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;
@@ -438,10 +645,18 @@ static struct block_device *bd_acquire(struct inode *inode)
 
 void bd_forget(struct inode *inode)
 {
+       struct block_device *bdev = NULL;
+
        spin_lock(&bdev_lock);
-       if (inode->i_bdev)
+       if (inode->i_bdev) {
+               if (inode->i_sb != blockdev_superblock)
+                       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)
@@ -527,11 +742,11 @@ static struct kobject *bdev_get_holder(struct block_device *bdev)
                return kobject_get(bdev->bd_disk->holder_dir);
 }
 
-static void add_symlink(struct kobject *from, struct kobject *to)
+static int add_symlink(struct kobject *from, struct kobject *to)
 {
        if (!from || !to)
-               return;
-       sysfs_create_link(from, to, kobject_name(to));
+               return 0;
+       return sysfs_create_link(from, to, kobject_name(to));
 }
 
 static void del_symlink(struct kobject *from, struct kobject *to)
@@ -624,38 +839,59 @@ static void free_bd_holder(struct bd_holder *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()
  *
- * If there is no matching entry with @bo in @bdev->bd_holder_list,
- * add @bo to the list, create symlinks.
+ * Add @bo to @bdev->bd_holder_list, create symlinks.
  *
- * Returns 1 if @bo was added to the list.
- * Returns 0 if @bo wasn't used by any reason and should be freed.
+ * Returns 0 if symlinks are created.
+ * Returns -ve if something fails.
  */
 static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
 {
-       struct bd_holder *tmp;
+       int ret;
 
        if (!bo)
-               return 0;
-
-       list_for_each_entry(tmp, &bdev->bd_holder_list, list) {
-               if (tmp->sdir == bo->sdir) {
-                       tmp->count++;
-                       return 0;
-               }
-       }
+               return -EINVAL;
 
        if (!bd_holder_grab_dirs(bdev, bo))
-               return 0;
+               return -EBUSY;
 
-       add_symlink(bo->sdir, bo->sdev);
-       add_symlink(bo->hdir, bo->hdev);
-       list_add_tail(&bo->list, &bdev->bd_holder_list);
-       return 1;
+       ret = add_symlink(bo->sdir, bo->sdev);
+       if (ret == 0) {
+               ret = add_symlink(bo->hdir, bo->hdev);
+               if (ret)
+                       del_symlink(bo->sdir, bo->sdev);
+       }
+       if (ret == 0)
+               list_add_tail(&bo->list, &bdev->bd_holder_list);
+       return ret;
 }
 
 /**
@@ -714,7 +950,7 @@ static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
                                struct kobject *kobj)
 {
        int res;
-       struct bd_holder *bo;
+       struct bd_holder *bo, *found;
 
        if (!kobj)
                return -EINVAL;
@@ -725,7 +961,16 @@ static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
 
        mutex_lock(&bdev->bd_mutex);
        res = bd_claim(bdev, holder);
-       if (res || !add_bd_holder(bdev, bo))
+       if (res == 0) {
+               found = find_bd_holder(bdev, bo);
+               if (found == NULL) {
+                       res = add_bd_holder(bdev, bo);
+                       if (res)
+                               bd_release(bdev);
+               }
+       }
+
+       if (res || found)
                free_bd_holder(bo);
        mutex_unlock(&bdev->bd_mutex);
 
@@ -852,7 +1097,18 @@ void bd_set_size(struct block_device *bdev, loff_t size)
 }
 EXPORT_SYMBOL(bd_set_size);
 
-static int do_open(struct block_device *bdev, struct file *file)
+static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,
+                       int for_part);
+static int __blkdev_put(struct block_device *bdev, int for_part);
+
+/*
+ * bd_mutex locking:
+ *
+ *  mutex_lock(part->bd_mutex)
+ *    mutex_lock_nested(whole->bd_mutex, 1)
+ */
+
+static int do_open(struct block_device *bdev, struct file *file, int for_part)
 {
        struct module *owner = NULL;
        struct gendisk *disk;
@@ -869,7 +1125,7 @@ static int do_open(struct block_device *bdev, struct file *file)
        }
        owner = disk->fops->owner;
 
-       mutex_lock(&bdev->bd_mutex);
+       mutex_lock_nested(&bdev->bd_mutex, for_part);
        if (!bdev->bd_openers) {
                bdev->bd_disk = disk;
                bdev->bd_contains = bdev;
@@ -896,25 +1152,21 @@ static int do_open(struct block_device *bdev, struct file *file)
                        ret = -ENOMEM;
                        if (!whole)
                                goto out_first;
-                       ret = blkdev_get(whole, file->f_mode, file->f_flags);
+                       BUG_ON(for_part);
+                       ret = __blkdev_get(whole, file->f_mode, file->f_flags, 1);
                        if (ret)
                                goto out_first;
                        bdev->bd_contains = whole;
-                       mutex_lock(&whole->bd_mutex);
-                       whole->bd_part_count++;
                        p = disk->part[part - 1];
                        bdev->bd_inode->i_data.backing_dev_info =
                           whole->bd_inode->i_data.backing_dev_info;
                        if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {
-                               whole->bd_part_count--;
-                               mutex_unlock(&whole->bd_mutex);
                                ret = -ENXIO;
                                goto out_first;
                        }
                        kobject_get(&p->kobj);
                        bdev->bd_part = p;
                        bd_set_size(bdev, (loff_t) p->nr_sects << 9);
-                       mutex_unlock(&whole->bd_mutex);
                }
        } else {
                put_disk(disk);
@@ -927,13 +1179,11 @@ static int do_open(struct block_device *bdev, struct file *file)
                        }
                        if (bdev->bd_invalidated)
                                rescan_partitions(bdev->bd_disk, bdev);
-               } else {
-                       mutex_lock(&bdev->bd_contains->bd_mutex);
-                       bdev->bd_contains->bd_part_count++;
-                       mutex_unlock(&bdev->bd_contains->bd_mutex);
                }
        }
        bdev->bd_openers++;
+       if (for_part)
+               bdev->bd_part_count++;
        mutex_unlock(&bdev->bd_mutex);
        unlock_kernel();
        return 0;
@@ -942,7 +1192,7 @@ out_first:
        bdev->bd_disk = NULL;
        bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
        if (bdev != bdev->bd_contains)
-               blkdev_put(bdev->bd_contains);
+               __blkdev_put(bdev->bd_contains, 1);
        bdev->bd_contains = NULL;
        put_disk(disk);
        module_put(owner);
@@ -954,7 +1204,8 @@ out:
        return ret;
 }
 
-int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
+static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,
+                       int for_part)
 {
        /*
         * This crockload is due to bad choice of ->open() type.
@@ -966,12 +1217,16 @@ int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
        struct dentry fake_dentry = {};
        fake_file.f_mode = mode;
        fake_file.f_flags = flags;
-       fake_file.f_dentry = &fake_dentry;
+       fake_file.f_path.dentry = &fake_dentry;
        fake_dentry.d_inode = bdev->bd_inode;
 
-       return do_open(bdev, &fake_file);
+       return do_open(bdev, &fake_file, for_part);
 }
 
+int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
+{
+       return __blkdev_get(bdev, mode, flags, 0);
+}
 EXPORT_SYMBOL(blkdev_get);
 
 static int blkdev_open(struct inode * inode, struct file * filp)
@@ -988,8 +1243,10 @@ static int blkdev_open(struct inode * inode, struct file * filp)
        filp->f_flags |= O_LARGEFILE;
 
        bdev = bd_acquire(inode);
+       if (bdev == NULL)
+               return -ENOMEM;
 
-       res = do_open(bdev, filp);
+       res = do_open(bdev, filp, 0);
        if (res)
                return res;
 
@@ -1003,14 +1260,18 @@ static int blkdev_open(struct inode * inode, struct file * filp)
        return res;
 }
 
-int blkdev_put(struct block_device *bdev)
+static int __blkdev_put(struct block_device *bdev, int for_part)
 {
        int ret = 0;
        struct inode *bd_inode = bdev->bd_inode;
        struct gendisk *disk = bdev->bd_disk;
+       struct block_device *victim = NULL;
 
-       mutex_lock(&bdev->bd_mutex);
+       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);
@@ -1018,10 +1279,6 @@ int blkdev_put(struct block_device *bdev)
        if (bdev->bd_contains == bdev) {
                if (disk->fops->release)
                        ret = disk->fops->release(bd_inode, NULL);
-       } else {
-               mutex_lock(&bdev->bd_contains->bd_mutex);
-               bdev->bd_contains->bd_part_count--;
-               mutex_unlock(&bdev->bd_contains->bd_mutex);
        }
        if (!bdev->bd_openers) {
                struct module *owner = disk->fops->owner;
@@ -1035,17 +1292,22 @@ int blkdev_put(struct block_device *bdev)
                }
                bdev->bd_disk = NULL;
                bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
-               if (bdev != bdev->bd_contains) {
-                       blkdev_put(bdev->bd_contains);
-               }
+               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, 1);
        return ret;
 }
 
+int blkdev_put(struct block_device *bdev)
+{
+       return __blkdev_put(bdev, 0);
+}
 EXPORT_SYMBOL(blkdev_put);
 
 static int blkdev_close(struct inode * inode, struct file * filp)
@@ -1056,28 +1318,12 @@ static int blkdev_close(struct inode * inode, struct file * filp)
        return blkdev_put(bdev);
 }
 
-static ssize_t blkdev_file_write(struct file *file, const char __user *buf,
-                                  size_t count, loff_t *ppos)
-{
-       struct iovec local_iov = { .iov_base = (void __user *)buf, .iov_len = count };
-
-       return generic_file_write_nolock(file, &local_iov, 1, ppos);
-}
-
-static ssize_t blkdev_file_aio_write(struct kiocb *iocb, const char __user *buf,
-                                  size_t count, loff_t pos)
-{
-       struct iovec local_iov = { .iov_base = (void __user *)buf, .iov_len = count };
-
-       return generic_file_aio_write_nolock(iocb, &local_iov, 1, &iocb->ki_pos);
-}
-
 static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
        return blkdev_ioctl(file->f_mapping->host, file, cmd, arg);
 }
 
-struct address_space_operations def_blk_aops = {
+const struct address_space_operations def_blk_aops = {
        .readpage       = blkdev_readpage,
        .writepage      = blkdev_writepage,
        .sync_page      = block_sync_page,
@@ -1087,23 +1333,23 @@ struct address_space_operations def_blk_aops = {
        .direct_IO      = blkdev_direct_IO,
 };
 
-struct file_operations def_blk_fops = {
+const struct file_operations def_blk_fops = {
        .open           = blkdev_open,
        .release        = blkdev_close,
        .llseek         = block_llseek,
-       .read           = generic_file_read,
-       .write          = blkdev_file_write,
+       .read           = do_sync_read,
+       .write          = do_sync_write,
        .aio_read       = generic_file_aio_read,
-       .aio_write      = blkdev_file_aio_write, 
+       .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
-       .readv          = generic_file_readv,
-       .writev         = generic_file_write_nolock,
        .sendfile       = generic_file_sendfile,
+       .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)
@@ -1215,3 +1461,24 @@ void close_bdev_excl(struct block_device *bdev)
 }
 
 EXPORT_SYMBOL(close_bdev_excl);
+
+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);
+       return res;
+}
+EXPORT_SYMBOL(__invalidate_device);