5 files changed, 18 insertions, 90 deletions

diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index 6386d76f44a7..a2038928f9a3 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -427,7 +427,7 @@ static inline int rsv_is_empty(struct ext3_reserve_window *rsv)
 void ext3_init_block_alloc_info(struct inode *inode)
 {
         struct ext3_inode_info *ei = EXT3_I(inode);
-        struct ext3_block_alloc_info *block_i = ei->i_block_alloc_info;
+        struct ext3_block_alloc_info *block_i;
         struct super_block *sb = inode->i_sb;
 
         block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
@@ -1440,14 +1440,14 @@ out:
  *
  * Check if filesystem has at least 1 free block available for allocation.
  */
-static int ext3_has_free_blocks(struct ext3_sb_info *sbi)
+static int ext3_has_free_blocks(struct ext3_sb_info *sbi, int use_reservation)
 {
         ext3_fsblk_t free_blocks, root_blocks;
 
         free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
         root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
         if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
-                sbi->s_resuid != current_fsuid() &&
+                !use_reservation && sbi->s_resuid != current_fsuid() &&
                 (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
                 return 0;
         }
@@ -1468,7 +1468,7 @@ static int ext3_has_free_blocks(struct ext3_sb_info *sbi)
  */
 int ext3_should_retry_alloc(struct super_block *sb, int *retries)
 {
-        if (!ext3_has_free_blocks(EXT3_SB(sb)) || (*retries)++ > 3)
+        if (!ext3_has_free_blocks(EXT3_SB(sb), 0) || (*retries)++ > 3)
                 return 0;
 
         jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
@@ -1546,7 +1546,7 @@ ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
         if (block_i && ((windowsz = block_i->rsv_window_node.rsv_goal_size) > 0))
                 my_rsv = &block_i->rsv_window_node;
 
-        if (!ext3_has_free_blocks(sbi)) {
+        if (!ext3_has_free_blocks(sbi, IS_NOQUOTA(inode))) {
                 *errp = -ENOSPC;
                 goto out;
         }
@@ -1924,9 +1924,10 @@ unsigned long ext3_bg_num_gdb(struct super_block *sb, int group)
  * reaches any used block. Then issue a TRIM command on this extent and free
  * the extent in the block bitmap. This is done until whole group is scanned.
  */
-ext3_grpblk_t ext3_trim_all_free(struct super_block *sb, unsigned int group,
-                                ext3_grpblk_t start, ext3_grpblk_t max,
-                                ext3_grpblk_t minblocks)
+static ext3_grpblk_t ext3_trim_all_free(struct super_block *sb,
+                                        unsigned int group,
+                                        ext3_grpblk_t start, ext3_grpblk_t max,
+                                        ext3_grpblk_t minblocks)
 {
         handle_t *handle;
         ext3_grpblk_t next, free_blocks, bit, freed, count = 0;
diff --git a/fs/ext3/fsync.c b/fs/ext3/fsync.c
index d494c554c6e6..1860ed356323 100644
--- a/fs/ext3/fsync.c
+++ b/fs/ext3/fsync.c
@@ -61,13 +61,6 @@ int ext3_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         if (ret)
                 goto out;
 
-        /*
-         * Taking the mutex here just to keep consistent with how fsync was
-         * called previously, however it looks like we don't need to take
-         * i_mutex at all.
-         */
-        mutex_lock(&inode->i_mutex);
-
         J_ASSERT(ext3_journal_current_handle() == NULL);
 
         /*
@@ -85,7 +78,6 @@ int ext3_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
          *  safe in-journal, which is all fsync() needs to ensure.
          */
         if (ext3_should_journal_data(inode)) {
-                mutex_unlock(&inode->i_mutex);
                 ret = ext3_force_commit(inode->i_sb);
                 goto out;
         }
@@ -108,8 +100,6 @@ int ext3_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
          */
         if (needs_barrier)
                 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
-
-        mutex_unlock(&inode->i_mutex);
 out:
         trace_ext3_sync_file_exit(inode, ret);
         return ret;
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 835d4ea61b0e..5c866e06e7ab 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -178,42 +178,6 @@ error_return:
 }
 
 /*
- * There are two policies for allocating an inode.  If the new inode is
- * a directory, then a forward search is made for a block group with both
- * free space and a low directory-to-inode ratio; if that fails, then of
- * the groups with above-average free space, that group with the fewest
- * directories already is chosen.
- *
- * For other inodes, search forward from the parent directory\'s block
- * group to find a free inode.
- */
-static int find_group_dir(struct super_block *sb, struct inode *parent)
-{
-        int ngroups = EXT3_SB(sb)->s_groups_count;
-        unsigned int freei, avefreei;
-        struct ext3_group_desc *desc, *best_desc = NULL;
-        int group, best_group = -1;
-
-        freei = percpu_counter_read_positive(&EXT3_SB(sb)->s_freeinodes_counter);
-        avefreei = freei / ngroups;
-
-        for (group = 0; group < ngroups; group++) {
-                desc = ext3_get_group_desc (sb, group, NULL);
-                if (!desc || !desc->bg_free_inodes_count)
-                        continue;
-                if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
-                        continue;
-                if (!best_desc ||
-                    (le16_to_cpu(desc->bg_free_blocks_count) >
-                     le16_to_cpu(best_desc->bg_free_blocks_count))) {
-                        best_group = group;
-                        best_desc = desc;
-                }
-        }
-        return best_group;
-}
-
-/*
  * Orlov's allocator for directories.
  *
  * We always try to spread first-level directories.
@@ -436,12 +400,9 @@ struct inode *ext3_new_inode(handle_t *handle, struct inode * dir,
 
         sbi = EXT3_SB(sb);
         es = sbi->s_es;
-        if (S_ISDIR(mode)) {
-                if (test_opt (sb, OLDALLOC))
-                        group = find_group_dir(sb, dir);
-                else
-                        group = find_group_orlov(sb, dir);
-        } else
+        if (S_ISDIR(mode))
+                group = find_group_orlov(sb, dir);
+        else
                 group = find_group_other(sb, dir);
 
         err = -ENOSPC;
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index c7f43944f160..ba1b54e23cae 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -150,30 +150,6 @@ setversion_out:
                 mnt_drop_write(filp->f_path.mnt);
                 return err;
         }
-#ifdef CONFIG_JBD_DEBUG
-        case EXT3_IOC_WAIT_FOR_READONLY:
-                /*
-                 * This is racy - by the time we're woken up and running,
-                 * the superblock could be released.  And the module could
-                 * have been unloaded.  So sue me.
-                 *
-                 * Returns 1 if it slept, else zero.
-                 */
-                {
-                        struct super_block *sb = inode->i_sb;
-                        DECLARE_WAITQUEUE(wait, current);
-                        int ret = 0;
-
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        add_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait);
-                        if (timer_pending(&EXT3_SB(sb)->turn_ro_timer)) {
-                                schedule();
-                                ret = 1;
-                        }
-                        remove_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait);
-                        return ret;
-                }
-#endif
         case EXT3_IOC_GETRSVSZ:
                 if (test_opt(inode->i_sb, RESERVATION)
                         && S_ISREG(inode->i_mode)
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 7beb69ae0015..922d289aeeb3 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -652,8 +652,6 @@ static int ext3_show_options(struct seq_file *seq, struct vfsmount *vfs)
                 seq_puts(seq, ",nouid32");
         if (test_opt(sb, DEBUG))
                 seq_puts(seq, ",debug");
-        if (test_opt(sb, OLDALLOC))
-                seq_puts(seq, ",oldalloc");
 #ifdef CONFIG_EXT3_FS_XATTR
         if (test_opt(sb, XATTR_USER))
                 seq_puts(seq, ",user_xattr");
@@ -1049,10 +1047,12 @@ static int parse_options (char *options, struct super_block *sb,
                         set_opt (sbi->s_mount_opt, DEBUG);
                         break;
                 case Opt_oldalloc:
-                        set_opt (sbi->s_mount_opt, OLDALLOC);
+                        ext3_msg(sb, KERN_WARNING,
+                                "Ignoring deprecated oldalloc option");
                         break;
                 case Opt_orlov:
-                        clear_opt (sbi->s_mount_opt, OLDALLOC);
+                        ext3_msg(sb, KERN_WARNING,
+                                "Ignoring deprecated orlov option");
                         break;
 #ifdef CONFIG_EXT3_FS_XATTR
                 case Opt_user_xattr:
@@ -2669,13 +2669,13 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
                         /*
                          * If we have an unprocessed orphan list hanging
                          * around from a previously readonly bdev mount,
-                         * require a full umount/remount for now.
+                         * require a full umount & mount for now.
                          */
                         if (es->s_last_orphan) {
                                 ext3_msg(sb, KERN_WARNING, "warning: couldn't "
                                        "remount RDWR because of unprocessed "
                                        "orphan inode list.  Please "
-                                       "umount/remount instead.");
+                                       "umount & mount instead.");
                                 err = -EINVAL;
                                 goto restore_opts;
                         }