9 files changed, 94 insertions, 57 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/dir.c b/fs/ntfs/dir.c
index d1e2c6f9f05e..85c36b8ca452 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1149,8 +1149,7 @@ static int ntfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
          * Allocate a buffer to store the current name being processed
          * converted to format determined by current NLS.
          */
-        name = (u8*)kmalloc(NTFS_MAX_NAME_LEN * NLS_MAX_CHARSET_SIZE + 1,
-                        GFP_NOFS);
+        name = kmalloc(NTFS_MAX_NAME_LEN * NLS_MAX_CHARSET_SIZE + 1, GFP_NOFS);
         if (unlikely(!name)) {
                 err = -ENOMEM;
                 goto err_out;
@@ -1191,7 +1190,7 @@ static int ntfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
          * map the mft record without deadlocking.
          */
         rc = le32_to_cpu(ctx->attr->data.resident.value_length);
-        ir = (INDEX_ROOT*)kmalloc(rc, GFP_NOFS);
+        ir = kmalloc(rc, GFP_NOFS);
         if (unlikely(!ir)) {
                 err = -ENOMEM;
                 goto err_out;
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 88292f9e4b9b..2e42c2dcae12 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1358,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;
@@ -1376,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;
                 }
@@ -1420,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.
  */
@@ -1441,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;
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 4c86b7e1d1eb..933dbd89c2a4 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -137,7 +137,7 @@ static int ntfs_init_locked_inode(struct inode *vi, ntfs_attr *na)
 
                 BUG_ON(!na->name);
                 i = na->name_len * sizeof(ntfschar);
-                ni->name = (ntfschar*)kmalloc(i + sizeof(ntfschar), GFP_ATOMIC);
+                ni->name = kmalloc(i + sizeof(ntfschar), GFP_ATOMIC);
                 if (!ni->name)
                         return -ENOMEM;
                 memcpy(ni->name, na->name, i);
@@ -367,6 +367,12 @@ static void ntfs_destroy_extent_inode(ntfs_inode *ni)
         kmem_cache_free(ntfs_inode_cache, ni);
 }
 
+/*
+ * The attribute runlist lock has separate locking rules from the
+ * normal runlist lock, so split the two lock-classes:
+ */
+static struct lock_class_key attr_list_rl_lock_class;
+
 /**
  * __ntfs_init_inode - initialize ntfs specific part of an inode
  * @sb:         super block of mounted volume
@@ -394,6 +400,8 @@ void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni)
         ni->attr_list_size = 0;
         ni->attr_list = NULL;
         ntfs_init_runlist(&ni->attr_list_rl);
+        lockdep_set_class(&ni->attr_list_rl.lock,
+                                &attr_list_rl_lock_class);
         ni->itype.index.bmp_ino = NULL;
         ni->itype.index.block_size = 0;
         ni->itype.index.vcn_size = 0;
@@ -405,6 +413,13 @@ void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni)
         ni->ext.base_ntfs_ino = NULL;
 }
 
+/*
+ * Extent inodes get MFT-mapped in a nested way, while the base inode
+ * is still mapped. Teach this nesting to the lock validator by creating
+ * a separate class for nested inode's mrec_lock's:
+ */
+static struct lock_class_key extent_inode_mrec_lock_key;
+
 inline ntfs_inode *ntfs_new_extent_inode(struct super_block *sb,
                 unsigned long mft_no)
 {
@@ -413,6 +428,7 @@ inline ntfs_inode *ntfs_new_extent_inode(struct super_block *sb,
         ntfs_debug("Entering.");
         if (likely(ni != NULL)) {
                 __ntfs_init_inode(sb, ni);
+                lockdep_set_class(&ni->mrec_lock, &extent_inode_mrec_lock_key);
                 ni->mft_no = mft_no;
                 ni->type = AT_UNUSED;
                 ni->name = NULL;
@@ -540,8 +556,6 @@ static int ntfs_read_locked_inode(struct inode *vi)
 
         /* Setup the generic vfs inode parts now. */
 
-        /* This is the optimal IO size (for stat), not the fs block size. */
-        vi->i_blksize = PAGE_CACHE_SIZE;
         /*
          * This is for checking whether an inode has changed w.r.t. a file so
          * that the file can be updated if necessary (compare with f_version).
@@ -1218,7 +1232,6 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
         base_ni = NTFS_I(base_vi);
 
         /* Just mirror the values from the base inode. */
-        vi->i_blksize   = base_vi->i_blksize;
         vi->i_version   = base_vi->i_version;
         vi->i_uid       = base_vi->i_uid;
         vi->i_gid       = base_vi->i_gid;
@@ -1488,7 +1501,6 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
         ni      = NTFS_I(vi);
         base_ni = NTFS_I(base_vi);
         /* Just mirror the values from the base inode. */
-        vi->i_blksize   = base_vi->i_blksize;
         vi->i_version   = base_vi->i_version;
         vi->i_uid       = base_vi->i_uid;
         vi->i_gid       = base_vi->i_gid;
@@ -1722,6 +1734,15 @@ err_out:
         return err;
 }
 
+/*
+ * The MFT inode has special locking, so teach the lock validator
+ * about this by splitting off the locking rules of the MFT from
+ * the locking rules of other inodes. The MFT inode can never be
+ * accessed from the VFS side (or even internally), only by the
+ * map_mft functions.
+ */
+static struct lock_class_key mft_ni_runlist_lock_key, mft_ni_mrec_lock_key;
+
 /**
  * ntfs_read_inode_mount - special read_inode for mount time use only
  * @vi:         inode to read
@@ -2148,6 +2169,14 @@ int ntfs_read_inode_mount(struct inode *vi)
         ntfs_attr_put_search_ctx(ctx);
         ntfs_debug("Done.");
         ntfs_free(m);
+
+        /*
+         * Split the locking rules of the MFT inode from the
+         * locking rules of other inodes:
+         */
+        lockdep_set_class(&ni->runlist.lock, &mft_ni_runlist_lock_key);
+        lockdep_set_class(&ni->mrec_lock, &mft_ni_mrec_lock_key);
+
         return 0;
 
 em_put_err_out:
diff --git a/fs/ntfs/mft.c b/fs/ntfs/mft.c
index 2438c00ec0ce..584260fd6848 100644
--- a/fs/ntfs/mft.c
+++ b/fs/ntfs/mft.c
@@ -331,7 +331,7 @@ map_err_out:
                 ntfs_inode **tmp;
                 int new_size = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
 
-                tmp = (ntfs_inode **)kmalloc(new_size, GFP_NOFS);
+                tmp = kmalloc(new_size, GFP_NOFS);
                 if (unlikely(!tmp)) {
                         ntfs_error(base_ni->vol->sb, "Failed to allocate "
                                         "internal buffer.");
@@ -2638,11 +2638,6 @@ mft_rec_already_initialized:
                 }
                 vi->i_ino = bit;
                 /*
-                 * This is the optimal IO size (for stat), not the fs block
-                 * size.
-                 */
-                vi->i_blksize = PAGE_CACHE_SIZE;
-                /*
                  * This is for checking whether an inode has changed w.r.t. a
                  * file so that the file can be updated if necessary (compare
                  * with f_version).
@@ -2893,7 +2888,7 @@ rollback:
         if (!(base_ni->nr_extents & 3)) {
                 int new_size = (base_ni->nr_extents + 4) * sizeof(ntfs_inode*);
 
-                extent_nis = (ntfs_inode**)kmalloc(new_size, GFP_NOFS);
+                extent_nis = kmalloc(new_size, GFP_NOFS);
                 if (unlikely(!extent_nis)) {
                         ntfs_error(vol->sb, "Failed to allocate internal "
                                         "buffer during rollback.%s", es);
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 0e14acea3f8b..6b2712f10dd2 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -1724,6 +1724,14 @@ upcase_failed:
         return FALSE;
 }
 
+/*
+ * The lcn and mft bitmap inodes are NTFS-internal inodes with
+ * their own special locking rules:
+ */
+static struct lock_class_key
+        lcnbmp_runlist_lock_key, lcnbmp_mrec_lock_key,
+        mftbmp_runlist_lock_key, mftbmp_mrec_lock_key;
+
 /**
  * load_system_files - open the system files using normal functions
  * @vol:        ntfs super block describing device whose system files to load
@@ -1780,6 +1788,10 @@ static BOOL load_system_files(ntfs_volume *vol)
                 ntfs_error(sb, "Failed to load $MFT/$BITMAP attribute.");
                 goto iput_mirr_err_out;
         }
+        lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
+                           &mftbmp_runlist_lock_key);
+        lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
+                           &mftbmp_mrec_lock_key);
         /* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
         if (!load_and_init_upcase(vol))
                 goto iput_mftbmp_err_out;
@@ -1802,6 +1814,11 @@ static BOOL load_system_files(ntfs_volume *vol)
                         iput(vol->lcnbmp_ino);
                 goto bitmap_failed;
         }
+        lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
+                           &lcnbmp_runlist_lock_key);
+        lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
+                           &lcnbmp_mrec_lock_key);
+
         NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
         if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
                 iput(vol->lcnbmp_ino);
@@ -2743,6 +2760,17 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
         struct inode *tmp_ino;
         int blocksize, result;
 
+        /*
+         * We do a pretty difficult piece of bootstrap by reading the
+         * MFT (and other metadata) from disk into memory. We'll only
+         * release this metadata during umount, so the locking patterns
+         * observed during bootstrap do not count. So turn off the
+         * observation of locking patterns (strictly for this context
+         * only) while mounting NTFS. [The validator is still active
+         * otherwise, even for this context: it will for example record
+         * lock class registrations.]
+         */
+        lockdep_off();
         ntfs_debug("Entering.");
 #ifndef NTFS_RW
         sb->s_flags |= MS_RDONLY;
@@ -2754,6 +2782,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                 if (!silent)
                         ntfs_error(sb, "Allocation of NTFS volume structure "
                                         "failed. Aborting mount...");
+                lockdep_on();
                 return -ENOMEM;
         }
         /* Initialize ntfs_volume structure. */
@@ -2940,6 +2969,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                 mutex_unlock(&ntfs_lock);
                 sb->s_export_op = &ntfs_export_ops;
                 lock_kernel();
+                lockdep_on();
                 return 0;
         }
         ntfs_error(sb, "Failed to allocate root directory.");
@@ -3059,6 +3089,7 @@ err_out_now:
         sb->s_fs_info = NULL;
         kfree(vol);
         ntfs_debug("Failed, returning -EINVAL.");
+        lockdep_on();
         return -EINVAL;
 }
 
@@ -3217,32 +3248,14 @@ ictx_err_out:
 
 static void __exit exit_ntfs_fs(void)
 {
-        int err = 0;
-
         ntfs_debug("Unregistering NTFS driver.");
 
         unregister_filesystem(&ntfs_fs_type);
-
-        if (kmem_cache_destroy(ntfs_big_inode_cache) && (err = 1))
-                printk(KERN_CRIT "NTFS: Failed to destory %s.\n",
-                                ntfs_big_inode_cache_name);
-        if (kmem_cache_destroy(ntfs_inode_cache) && (err = 1))
-                printk(KERN_CRIT "NTFS: Failed to destory %s.\n",
-                                ntfs_inode_cache_name);
-        if (kmem_cache_destroy(ntfs_name_cache) && (err = 1))
-                printk(KERN_CRIT "NTFS: Failed to destory %s.\n",
-                                ntfs_name_cache_name);
-        if (kmem_cache_destroy(ntfs_attr_ctx_cache) && (err = 1))
-                printk(KERN_CRIT "NTFS: Failed to destory %s.\n",
-                                ntfs_attr_ctx_cache_name);
-        if (kmem_cache_destroy(ntfs_index_ctx_cache) && (err = 1))
-                printk(KERN_CRIT "NTFS: Failed to destory %s.\n",
-                                ntfs_index_ctx_cache_name);
-        if (err)
-                printk(KERN_CRIT "NTFS: This causes memory to leak! There is "
-                                "probably a BUG in the driver! Please report "
-                                "you saw this message to "
-                                "linux-ntfs-dev@lists.sourceforge.net\n");
+        kmem_cache_destroy(ntfs_big_inode_cache);
+        kmem_cache_destroy(ntfs_inode_cache);
+        kmem_cache_destroy(ntfs_name_cache);
+        kmem_cache_destroy(ntfs_attr_ctx_cache);
+        kmem_cache_destroy(ntfs_index_ctx_cache);
         /* Unregister the ntfs sysctls. */
         ntfs_sysctl(0);
 }
diff --git a/fs/ntfs/sysctl.h b/fs/ntfs/sysctl.h
index c8064cae8f17..beda5bf96405 100644
--- a/fs/ntfs/sysctl.h
+++ b/fs/ntfs/sysctl.h
@@ -24,7 +24,6 @@
 #ifndef _LINUX_NTFS_SYSCTL_H
 #define _LINUX_NTFS_SYSCTL_H
 
-#include <linux/config.h>
 
 #if defined(DEBUG) && defined(CONFIG_SYSCTL)
 
diff --git a/fs/ntfs/unistr.c b/fs/ntfs/unistr.c
index b123c0fa6bf6..a1b572196fe4 100644
--- a/fs/ntfs/unistr.c
+++ b/fs/ntfs/unistr.c
@@ -350,7 +350,7 @@ int ntfs_ucstonls(const ntfs_volume *vol, const ntfschar *ins,
                 }
                 if (!ns) {
                         ns_len = ins_len * NLS_MAX_CHARSET_SIZE;
-                        ns = (unsigned char*)kmalloc(ns_len + 1, GFP_NOFS);
+                        ns = kmalloc(ns_len + 1, GFP_NOFS);
                         if (!ns)
                                 goto mem_err_out;
                 }
@@ -365,7 +365,7 @@ retry:			wc = nls->uni2char(le16_to_cpu(ins[i]), ns + o,
                         else if (wc == -ENAMETOOLONG && ns != *outs) {
                                 unsigned char *tc;
                                 /* Grow in multiples of 64 bytes. */
-                                tc = (unsigned char*)kmalloc((ns_len + 64) &
+                                tc = kmalloc((ns_len + 64) &
                                                 ~63, GFP_NOFS);
                                 if (tc) {
                                         memcpy(tc, ns, ns_len);