6 files changed, 37 insertions, 36 deletions

diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index 580412d330cb..bc579bfdfbd8 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -1544,7 +1544,7 @@ err_out:
 /**
  * ntfs_aops - general address space operations for inodes and attributes
  */
-struct address_space_operations ntfs_aops = {
+const struct address_space_operations ntfs_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
         .sync_page      = block_sync_page,      /* Currently, just unplugs the
                                                    disk request queue. */
@@ -1560,7 +1560,7 @@ struct address_space_operations ntfs_aops = {
  * ntfs_mst_aops - general address space operations for mst protecteed inodes
  *                 and attributes
  */
-struct address_space_operations ntfs_mst_aops = {
+const struct address_space_operations ntfs_mst_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
         .sync_page      = block_sync_page,      /* Currently, just unplugs the
                                                    disk request queue. */
diff --git a/fs/ntfs/aops.h b/fs/ntfs/aops.h
index 3b74e66ca2ff..325ce261a107 100644
--- a/fs/ntfs/aops.h
+++ b/fs/ntfs/aops.h
@@ -86,8 +86,7 @@ static inline void ntfs_unmap_page(struct page *page)
 static inline struct page *ntfs_map_page(struct address_space *mapping,
                 unsigned long index)
 {
-        struct page *page = read_cache_page(mapping, index,
-                        (filler_t*)mapping->a_ops->readpage, NULL);
+        struct page *page = read_mapping_page(mapping, index, NULL);
 
         if (!IS_ERR(page)) {
                 wait_on_page_locked(page);
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 1663f5c3c6aa..6708e1d68a9e 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -2529,8 +2529,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
         end >>= PAGE_CACHE_SHIFT;
         /* If there is a first partial page, need to do it the slow way. */
         if (start_ofs) {
-                page = read_cache_page(mapping, idx,
-                                (filler_t*)mapping->a_ops->readpage, NULL);
+                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);
@@ -2600,8 +2599,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
         }
         /* If there is a last partial page, need to do it the slow way. */
         if (end_ofs) {
-                page = read_cache_page(mapping, idx,
-                                (filler_t*)mapping->a_ops->readpage, NULL);
+                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);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index c63a83e8da98..2e42c2dcae12 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -231,8 +231,7 @@ do_non_resident_extend:
                  * Read the page.  If the page is not present, this will zero
                  * the uninitialized regions for us.
                  */
-                page = read_cache_page(mapping, index,
-                                (filler_t*)mapping->a_ops->readpage, NULL);
+                page = read_mapping_page(mapping, index, NULL);
                 if (IS_ERR(page)) {
                         err = PTR_ERR(page);
                         goto init_err_out;
@@ -1359,7 +1358,7 @@ err_out:
         goto out;
 }
 
-static size_t __ntfs_copy_from_user_iovec(char *vaddr,
+static size_t __ntfs_copy_from_user_iovec_inatomic(char *vaddr,
                 const struct iovec *iov, size_t iov_ofs, size_t bytes)
 {
         size_t total = 0;
@@ -1377,10 +1376,6 @@ static size_t __ntfs_copy_from_user_iovec(char *vaddr,
                 bytes -= len;
                 vaddr += len;
                 if (unlikely(left)) {
-                        /*
-                         * Zero the rest of the target like __copy_from_user().
-                         */
-                        memset(vaddr, 0, bytes);
                         total -= left;
                         break;
                 }
@@ -1421,11 +1416,13 @@ static inline void ntfs_set_next_iovec(const struct iovec **iovp,
  * pages (out to offset + bytes), to emulate ntfs_copy_from_user()'s
  * single-segment behaviour.
  *
- * We call the same helper (__ntfs_copy_from_user_iovec()) both when atomic and
- * when not atomic.  This is ok because __ntfs_copy_from_user_iovec() calls
- * __copy_from_user_inatomic() and it is ok to call this when non-atomic.  In
- * fact, the only difference between __copy_from_user_inatomic() and
- * __copy_from_user() is that the latter calls might_sleep().  And on many
+ * We call the same helper (__ntfs_copy_from_user_iovec_inatomic()) both
+ * when atomic and when not atomic.  This is ok because
+ * __ntfs_copy_from_user_iovec_inatomic() calls __copy_from_user_inatomic()
+ * and it is ok to call this when non-atomic.
+ * Infact, the only difference between __copy_from_user_inatomic() and
+ * __copy_from_user() is that the latter calls might_sleep() and the former
+ * should not zero the tail of the buffer on error.  And on many
  * architectures __copy_from_user_inatomic() is just defined to
  * __copy_from_user() so it makes no difference at all on those architectures.
  */
@@ -1442,14 +1439,18 @@ static inline size_t ntfs_copy_from_user_iovec(struct page **pages,
                 if (len > bytes)
                         len = bytes;
                 kaddr = kmap_atomic(*pages, KM_USER0);
-                copied = __ntfs_copy_from_user_iovec(kaddr + ofs,
+                copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
                                 *iov, *iov_ofs, len);
                 kunmap_atomic(kaddr, KM_USER0);
                 if (unlikely(copied != len)) {
                         /* Do it the slow way. */
                         kaddr = kmap(*pages);
-                        copied = __ntfs_copy_from_user_iovec(kaddr + ofs,
+                        copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
                                         *iov, *iov_ofs, len);
+                        /*
+                         * Zero the rest of the target like __copy_from_user().
+                         */
+                        memset(kaddr + ofs + copied, 0, len - copied);
                         kunmap(*pages);
                         if (unlikely(copied != len))
                                 goto err_out;
@@ -1484,14 +1485,15 @@ static inline void ntfs_flush_dcache_pages(struct page **pages,
                 unsigned nr_pages)
 {
         BUG_ON(!nr_pages);
+        /*
+         * Warning: Do not do the decrement at the same time as the call to
+         * flush_dcache_page() because it is a NULL macro on i386 and hence the
+         * decrement never happens so the loop never terminates.
+         */
         do {
-                /*
-                 * Warning: Do not do the decrement at the same time as the
-                 * call because flush_dcache_page() is a NULL macro on i386
-                 * and hence the decrement never happens.
-                 */
+                --nr_pages;
                 flush_dcache_page(pages[nr_pages]);
-        } while (--nr_pages > 0);
+        } while (nr_pages > 0);
 }
 
 /**
diff --git a/fs/ntfs/ntfs.h b/fs/ntfs/ntfs.h
index bf7b3d7c0930..ddd3d503097c 100644
--- a/fs/ntfs/ntfs.h
+++ b/fs/ntfs/ntfs.h
@@ -57,8 +57,8 @@ extern struct kmem_cache *ntfs_attr_ctx_cache;
 extern struct kmem_cache *ntfs_index_ctx_cache;
 
 /* The various operations structs defined throughout the driver files. */
-extern struct address_space_operations ntfs_aops;
-extern struct address_space_operations ntfs_mst_aops;
+extern const struct address_space_operations ntfs_aops;
+extern const struct address_space_operations ntfs_mst_aops;
 
 extern const struct  file_operations ntfs_file_ops;
 extern struct inode_operations ntfs_file_inode_ops;
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 27833f6df49f..0e14acea3f8b 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2601,10 +2601,10 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
 
 /**
  * ntfs_statfs - return information about mounted NTFS volume
- * @sb:         super block of mounted volume
+ * @dentry:     dentry from mounted volume
  * @sfs:        statfs structure in which to return the information
  *
- * Return information about the mounted NTFS volume @sb in the statfs structure
+ * Return information about the mounted NTFS volume @dentry in the statfs structure
  * pointed to by @sfs (this is initialized with zeros before ntfs_statfs is
  * called). We interpret the values to be correct of the moment in time at
  * which we are called. Most values are variable otherwise and this isn't just
@@ -2617,8 +2617,9 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
  *
  * Return 0 on success or -errno on error.
  */
-static int ntfs_statfs(struct super_block *sb, struct kstatfs *sfs)
+static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
 {
+        struct super_block *sb = dentry->d_sb;
         s64 size;
         ntfs_volume *vol = NTFS_SB(sb);
         ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
@@ -3093,10 +3094,11 @@ struct kmem_cache *ntfs_index_ctx_cache;
 /* Driver wide mutex. */
 DEFINE_MUTEX(ntfs_lock);
 
-static struct super_block *ntfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+static int ntfs_get_sb(struct file_system_type *fs_type,
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ntfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ntfs_fill_super,
+                           mnt);
 }
 
 static struct file_system_type ntfs_fs_type = {