6 files changed, 12 insertions, 68 deletions

diff --git a/fs/ntfs/aops.h b/fs/ntfs/aops.h
index 9393f4b1e2..caecc58f52 100644
--- a/fs/ntfs/aops.h
+++ b/fs/ntfs/aops.h
@@ -89,9 +89,8 @@ static inline struct page *ntfs_map_page(struct address_space *mapping,
         struct page *page = read_mapping_page(mapping, index, NULL);
 
         if (!IS_ERR(page)) {
-                wait_on_page_locked(page);
                 kmap(page);
-                if (PageUptodate(page) && !PageError(page))
+                if (!PageError(page))
                         return page;
                 ntfs_unmap_page(page);
                 return ERR_PTR(-EIO);
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 7659cc1929..1c08fefe48 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -2532,14 +2532,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
                 page = read_mapping_page(mapping, idx, NULL);
                 if (IS_ERR(page)) {
                         ntfs_error(vol->sb, "Failed to read first partial "
-                                        "page (sync error, index 0x%lx).", idx);
-                        return PTR_ERR(page);
-                }
-                wait_on_page_locked(page);
-                if (unlikely(!PageUptodate(page))) {
-                        ntfs_error(vol->sb, "Failed to read first partial page "
-                                        "(async error, index 0x%lx).", idx);
-                        page_cache_release(page);
+                                        "page (error, index 0x%lx).", idx);
                         return PTR_ERR(page);
                 }
                 /*
@@ -2602,14 +2595,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
                 page = read_mapping_page(mapping, idx, NULL);
                 if (IS_ERR(page)) {
                         ntfs_error(vol->sb, "Failed to read last partial page "
-                                        "(sync error, index 0x%lx).", idx);
-                        return PTR_ERR(page);
-                }
-                wait_on_page_locked(page);
-                if (unlikely(!PageUptodate(page))) {
-                        ntfs_error(vol->sb, "Failed to read last partial page "
-                                        "(async error, index 0x%lx).", idx);
-                        page_cache_release(page);
+                                        "(error, index 0x%lx).", idx);
                         return PTR_ERR(page);
                 }
                 kaddr = kmap_atomic(page, KM_USER0);
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 74f99a6a36..34314b33db 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -20,7 +20,6 @@
  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 
 #include "dir.h"
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index d69c4595cc..621de369e6 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -236,8 +236,7 @@ do_non_resident_extend:
                         err = PTR_ERR(page);
                         goto init_err_out;
                 }
-                wait_on_page_locked(page);
-                if (unlikely(!PageUptodate(page) || PageError(page))) {
+                if (unlikely(PageError(page))) {
                         page_cache_release(page);
                         err = -EIO;
                         goto init_err_out;
@@ -2130,28 +2129,13 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
         struct address_space *mapping = file->f_mapping;
         struct inode *inode = mapping->host;
         loff_t pos;
-        unsigned long seg;
         size_t count;           /* after file limit checks */
         ssize_t written, err;
 
         count = 0;
-        for (seg = 0; seg < nr_segs; seg++) {
-                const struct iovec *iv = &iov[seg];
-                /*
-                 * If any segment has a negative length, or the cumulative
-                 * length ever wraps negative then return -EINVAL.
-                 */
-                count += iv->iov_len;
-                if (unlikely((ssize_t)(count|iv->iov_len) < 0))
-                        return -EINVAL;
-                if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
-                        continue;
-                if (!seg)
-                        return -EFAULT;
-                nr_segs = seg;
-                count -= iv->iov_len;   /* This segment is no good */
-                break;
-        }
+        err = generic_segment_checks(iov, &nr_segs, &count, VERIFY_READ);
+        if (err)
+                return err;
         pos = *ppos;
         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
         /* We can write back this queue in page reclaim. */
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index f8bf8da67e..074791ce4a 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -27,7 +27,6 @@
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include "aops.h"
 #include "attrib.h"
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 1594c90b71..21d834e5ed 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2471,7 +2471,6 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
         s64 nr_free = vol->nr_clusters;
         u32 *kaddr;
         struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
-        filler_t *readpage = (filler_t*)mapping->a_ops->readpage;
         struct page *page;
         pgoff_t index, max_index;
 
@@ -2494,24 +2493,14 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
                  * Read the page from page cache, getting it from backing store
                  * if necessary, and increment the use count.
                  */
-                page = read_cache_page(mapping, index, (filler_t*)readpage,
-                                NULL);
+                page = read_mapping_page(mapping, index, NULL);
                 /* Ignore pages which errored synchronously. */
                 if (IS_ERR(page)) {
-                        ntfs_debug("Sync read_cache_page() error. Skipping "
+                        ntfs_debug("read_mapping_page() error. Skipping "
                                         "page (index 0x%lx).", index);
                         nr_free -= PAGE_CACHE_SIZE * 8;
                         continue;
                 }
-                wait_on_page_locked(page);
-                /* Ignore pages which errored asynchronously. */
-                if (!PageUptodate(page)) {
-                        ntfs_debug("Async read_cache_page() error. Skipping "
-                                        "page (index 0x%lx).", index);
-                        page_cache_release(page);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
-                        continue;
-                }
                 kaddr = (u32*)kmap_atomic(page, KM_USER0);
                 /*
                  * For each 4 bytes, subtract the number of set bits. If this
@@ -2562,7 +2551,6 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
 {
         u32 *kaddr;
         struct address_space *mapping = vol->mftbmp_ino->i_mapping;
-        filler_t *readpage = (filler_t*)mapping->a_ops->readpage;
         struct page *page;
         pgoff_t index;
 
@@ -2576,21 +2564,11 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
                  * Read the page from page cache, getting it from backing store
                  * if necessary, and increment the use count.
                  */
-                page = read_cache_page(mapping, index, (filler_t*)readpage,
-                                NULL);
+                page = read_mapping_page(mapping, index, NULL);
                 /* Ignore pages which errored synchronously. */
                 if (IS_ERR(page)) {
-                        ntfs_debug("Sync read_cache_page() error. Skipping "
-                                        "page (index 0x%lx).", index);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
-                        continue;
-                }
-                wait_on_page_locked(page);
-                /* Ignore pages which errored asynchronously. */
-                if (!PageUptodate(page)) {
-                        ntfs_debug("Async read_cache_page() error. Skipping "
+                        ntfs_debug("read_mapping_page() error. Skipping "
                                         "page (index 0x%lx).", index);
-                        page_cache_release(page);
                         nr_free -= PAGE_CACHE_SIZE * 8;
                         continue;
                 }
@@ -3107,8 +3085,7 @@ static void ntfs_big_inode_init_once(void *foo, struct kmem_cache *cachep,
 {
         ntfs_inode *ni = (ntfs_inode *)foo;
 
-        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
-                        SLAB_CTOR_CONSTRUCTOR)
+        if (flags & SLAB_CTOR_CONSTRUCTOR)
                 inode_init_once(VFS_I(ni));
 }