Merge branch 'master' into for-next

Sync with Linus' tree to be able to apply patch to a newer
code (namely drivers/gpu/drm/gma500/psb_intel_lvds.c)

3 files changed, 69 insertions, 79 deletions

diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index a945cd265228..70de42f09f1d 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -1364,10 +1364,7 @@ int reiserfs_init_bitmap_cache(struct super_block *sb)
         struct reiserfs_bitmap_info *bitmap;
         unsigned int bmap_nr = reiserfs_bmap_count(sb);
 
-        /* Avoid lock recursion in fault case */
-        reiserfs_write_unlock(sb);
         bitmap = vmalloc(sizeof(*bitmap) * bmap_nr);
-        reiserfs_write_lock(sb);
         if (bitmap == NULL)
                 return -ENOMEM;
 
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index eb711060a6f2..c3cf54fd4de3 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -2678,16 +2678,10 @@ int journal_init(struct super_block *sb, const char *j_dev_name,
         char b[BDEVNAME_SIZE];
         int ret;
 
-        /*
-         * Unlock here to avoid various RECLAIM-FS-ON <-> IN-RECLAIM-FS
-         * dependency inversion warnings.
-         */
-        reiserfs_write_unlock(sb);
         journal = SB_JOURNAL(sb) = vzalloc(sizeof(struct reiserfs_journal));
         if (!journal) {
                 reiserfs_warning(sb, "journal-1256",
                                  "unable to get memory for journal structure");
-                reiserfs_write_lock(sb);
                 return 1;
         }
         INIT_LIST_HEAD(&journal->j_bitmap_nodes);
@@ -2695,10 +2689,8 @@ int journal_init(struct super_block *sb, const char *j_dev_name,
         INIT_LIST_HEAD(&journal->j_working_list);
         INIT_LIST_HEAD(&journal->j_journal_list);
         journal->j_persistent_trans = 0;
-        ret = reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap,
-                                           reiserfs_bmap_count(sb));
-        reiserfs_write_lock(sb);
-        if (ret)
+        if (reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap,
+                                           reiserfs_bmap_count(sb)))
                 goto free_and_return;
 
         allocate_bitmap_nodes(sb);
@@ -2727,27 +2719,11 @@ int journal_init(struct super_block *sb, const char *j_dev_name,
                 goto free_and_return;
         }
 
-        /*
-         * We need to unlock here to avoid creating the following
-         * dependency:
-         * reiserfs_lock -> sysfs_mutex
-         * Because the reiserfs mmap path creates the following dependency:
-         * mm->mmap -> reiserfs_lock, hence we have
-         * mm->mmap -> reiserfs_lock ->sysfs_mutex
-         * This would ends up in a circular dependency with sysfs readdir path
-         * which does sysfs_mutex -> mm->mmap_sem
-         * This is fine because the reiserfs lock is useless in mount path,
-         * at least until we call journal_begin. We keep it for paranoid
-         * reasons.
-         */
-        reiserfs_write_unlock(sb);
         if (journal_init_dev(sb, journal, j_dev_name) != 0) {
-                reiserfs_write_lock(sb);
                 reiserfs_warning(sb, "sh-462",
                                  "unable to initialize jornal device");
                 goto free_and_return;
         }
-        reiserfs_write_lock(sb);
 
         rs = SB_DISK_SUPER_BLOCK(sb);
 
@@ -2829,9 +2805,7 @@ int journal_init(struct super_block *sb, const char *j_dev_name,
         journal->j_mount_id = 10;
         journal->j_state = 0;
         atomic_set(&(journal->j_jlock), 0);
-        reiserfs_write_unlock(sb);
         journal->j_cnode_free_list = allocate_cnodes(num_cnodes);
-        reiserfs_write_lock(sb);
         journal->j_cnode_free_orig = journal->j_cnode_free_list;
         journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0;
         journal->j_cnode_used = 0;
@@ -2848,24 +2822,37 @@ int journal_init(struct super_block *sb, const char *j_dev_name,
 
         init_journal_hash(sb);
         jl = journal->j_current_jl;
+
+        /*
+         * get_list_bitmap() may call flush_commit_list() which
+         * requires the lock. Calling flush_commit_list() shouldn't happen
+         * this early but I like to be paranoid.
+         */
+        reiserfs_write_lock(sb);
         jl->j_list_bitmap = get_list_bitmap(sb, jl);
+        reiserfs_write_unlock(sb);
         if (!jl->j_list_bitmap) {
                 reiserfs_warning(sb, "journal-2005",
                                  "get_list_bitmap failed for journal list 0");
                 goto free_and_return;
         }
-        if (journal_read(sb) < 0) {
+
+        /*
+         * Journal_read needs to be inspected in order to push down
+         * the lock further inside (or even remove it).
+         */
+        reiserfs_write_lock(sb);
+        ret = journal_read(sb);
+        reiserfs_write_unlock(sb);
+        if (ret < 0) {
                 reiserfs_warning(sb, "reiserfs-2006",
                                  "Replay Failure, unable to mount");
                 goto free_and_return;
         }
 
         reiserfs_mounted_fs_count++;
-        if (reiserfs_mounted_fs_count <= 1) {
-                reiserfs_write_unlock(sb);
+        if (reiserfs_mounted_fs_count <= 1)
                 commit_wq = alloc_workqueue("reiserfs", WQ_MEM_RECLAIM, 0);
-                reiserfs_write_lock(sb);
-        }
 
         INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
         journal->j_work_sb = sb;
@@ -2896,14 +2883,13 @@ int journal_transaction_should_end(struct reiserfs_transaction_handle *th,
             journal->j_cnode_free < (journal->j_trans_max * 3)) {
                 return 1;
         }
-        /* protected by the BKL here */
+
         journal->j_len_alloc += new_alloc;
         th->t_blocks_allocated += new_alloc ;
         return 0;
 }
 
-/* this must be called inside a transaction, and requires the
-** kernel_lock to be held
+/* this must be called inside a transaction
 */
 void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
 {
@@ -2914,8 +2900,7 @@ void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
         return;
 }
 
-/* this must be called without a transaction started, and does not
-** require BKL
+/* this must be called without a transaction started
 */
 void reiserfs_allow_writes(struct super_block *s)
 {
@@ -2924,8 +2909,7 @@ void reiserfs_allow_writes(struct super_block *s)
         wake_up(&journal->j_join_wait);
 }
 
-/* this must be called without a transaction started, and does not
-** require BKL
+/* this must be called without a transaction started
 */
 void reiserfs_wait_on_write_block(struct super_block *s)
 {
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 19c454e61b79..e12d8b97cd4d 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -455,16 +455,20 @@ int remove_save_link(struct inode *inode, int truncate)
 static void reiserfs_kill_sb(struct super_block *s)
 {
         if (REISERFS_SB(s)) {
-                if (REISERFS_SB(s)->xattr_root) {
-                        d_invalidate(REISERFS_SB(s)->xattr_root);
-                        dput(REISERFS_SB(s)->xattr_root);
-                        REISERFS_SB(s)->xattr_root = NULL;
-                }
-                if (REISERFS_SB(s)->priv_root) {
-                        d_invalidate(REISERFS_SB(s)->priv_root);
-                        dput(REISERFS_SB(s)->priv_root);
-                        REISERFS_SB(s)->priv_root = NULL;
-                }
+                /*
+                 * Force any pending inode evictions to occur now. Any
+                 * inodes to be removed that have extended attributes
+                 * associated with them need to clean them up before
+                 * we can release the extended attribute root dentries.
+                 * shrink_dcache_for_umount will BUG if we don't release
+                 * those before it's called so ->put_super is too late.
+                 */
+                shrink_dcache_sb(s);
+
+                dput(REISERFS_SB(s)->xattr_root);
+                REISERFS_SB(s)->xattr_root = NULL;
+                dput(REISERFS_SB(s)->priv_root);
+                REISERFS_SB(s)->priv_root = NULL;
         }
 
         kill_block_super(s);
@@ -1249,7 +1253,8 @@ static void handle_quota_files(struct super_block *s, char **qf_names,
                         kfree(REISERFS_SB(s)->s_qf_names[i]);
                 REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
         }
-        REISERFS_SB(s)->s_jquota_fmt = *qfmt;
+        if (*qfmt)
+                REISERFS_SB(s)->s_jquota_fmt = *qfmt;
 }
 #endif
 
@@ -1514,9 +1519,7 @@ static int read_super_block(struct super_block *s, int offset)
 static int reread_meta_blocks(struct super_block *s)
 {
         ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
-        reiserfs_write_unlock(s);
         wait_on_buffer(SB_BUFFER_WITH_SB(s));
-        reiserfs_write_lock(s);
         if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
                 reiserfs_warning(s, "reiserfs-2504", "error reading the super");
                 return 1;
@@ -1741,22 +1744,11 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         mutex_init(&REISERFS_SB(s)->lock);
         REISERFS_SB(s)->lock_depth = -1;
 
-        /*
-         * This function is called with the bkl, which also was the old
-         * locking used here.
-         * do_journal_begin() will soon check if we hold the lock (ie: was the
-         * bkl). This is likely because do_journal_begin() has several another
-         * callers because at this time, it doesn't seem to be necessary to
-         * protect against anything.
-         * Anyway, let's be conservative and lock for now.
-         */
-        reiserfs_write_lock(s);
-
         jdev_name = NULL;
         if (reiserfs_parse_options
             (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
              &commit_max_age, qf_names, &qfmt) == 0) {
-                goto error;
+                goto error_unlocked;
         }
         if (jdev_name && jdev_name[0]) {
                 REISERFS_SB(s)->s_jdev = kstrdup(jdev_name, GFP_KERNEL);
@@ -1772,7 +1764,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
 
         if (blocks) {
                 SWARN(silent, s, "jmacd-7", "resize option for remount only");
-                goto error;
+                goto error_unlocked;
         }
 
         /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
@@ -1782,7 +1774,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
                 SWARN(silent, s, "sh-2021", "can not find reiserfs on %s",
                       reiserfs_bdevname(s));
-                goto error;
+                goto error_unlocked;
         }
 
         rs = SB_DISK_SUPER_BLOCK(s);
@@ -1798,7 +1790,7 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                       "or increase size of your LVM partition");
                 SWARN(silent, s, "", "Or may be you forgot to "
                       "reboot after fdisk when it told you to");
-                goto error;
+                goto error_unlocked;
         }
 
         sbi->s_mount_state = SB_REISERFS_STATE(s);
@@ -1806,8 +1798,9 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
 
         if ((errval = reiserfs_init_bitmap_cache(s))) {
                 SWARN(silent, s, "jmacd-8", "unable to read bitmap");
-                goto error;
+                goto error_unlocked;
         }
+
         errval = -EINVAL;
 #ifdef CONFIG_REISERFS_CHECK
         SWARN(silent, s, "", "CONFIG_REISERFS_CHECK is set ON");
@@ -1830,24 +1823,26 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         if (reiserfs_barrier_flush(s)) {
                 printk("reiserfs: using flush barriers\n");
         }
+
         // set_device_ro(s->s_dev, 1) ;
         if (journal_init(s, jdev_name, old_format, commit_max_age)) {
                 SWARN(silent, s, "sh-2022",
                       "unable to initialize journal space");
-                goto error;
+                goto error_unlocked;
         } else {
                 jinit_done = 1; /* once this is set, journal_release must be called
                                  ** if we error out of the mount
                                  */
         }
+
         if (reread_meta_blocks(s)) {
                 SWARN(silent, s, "jmacd-9",
                       "unable to reread meta blocks after journal init");
-                goto error;
+                goto error_unlocked;
         }
 
         if (replay_only(s))
-                goto error;
+                goto error_unlocked;
 
         if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
                 SWARN(silent, s, "clm-7000",
@@ -1861,9 +1856,19 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
                          reiserfs_init_locked_inode, (void *)(&args));
         if (!root_inode) {
                 SWARN(silent, s, "jmacd-10", "get root inode failed");
-                goto error;
+                goto error_unlocked;
         }
 
+        /*
+         * This path assumed to be called with the BKL in the old times.
+         * Now we have inherited the big reiserfs lock from it and many
+         * reiserfs helpers called in the mount path and elsewhere require
+         * this lock to be held even if it's not always necessary. Let's be
+         * conservative and hold it early. The window can be reduced after
+         * careful review of the code.
+         */
+        reiserfs_write_lock(s);
+
         if (root_inode->i_state & I_NEW) {
                 reiserfs_read_locked_inode(root_inode, &args);
                 unlock_new_inode(root_inode);
@@ -1990,12 +1995,16 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         return (0);
 
 error:
-        if (jinit_done) {       /* kill the commit thread, free journal ram */
+        reiserfs_write_unlock(s);
+
+error_unlocked:
+        /* kill the commit thread, free journal ram */
+        if (jinit_done) {
+                reiserfs_write_lock(s);
                 journal_release_error(NULL, s);
+                reiserfs_write_unlock(s);
         }
 
-        reiserfs_write_unlock(s);
-
         reiserfs_free_bitmap_cache(s);
         if (SB_BUFFER_WITH_SB(s))
                 brelse(SB_BUFFER_WITH_SB(s));