Merge branch 'x86/trampoline' into x86/urgent

x86/trampoline contains an urgent commit which is necessarily on a
newer baseline.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>

6 files changed, 135 insertions, 74 deletions

diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index cc761ad8fa57..92490e9f85ca 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -21,30 +21,15 @@
  *
  */
 
+#include <linux/compat.h>
 #include "ext3.h"
 
 static unsigned char ext3_filetype_table[] = {
         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
 };
 
-static int ext3_readdir(struct file *, void *, filldir_t);
 static int ext3_dx_readdir(struct file * filp,
                            void * dirent, filldir_t filldir);
-static int ext3_release_dir (struct inode * inode,
-                                struct file * filp);
-
-const struct file_operations ext3_dir_operations = {
-        .llseek         = generic_file_llseek,
-        .read           = generic_read_dir,
-        .readdir        = ext3_readdir,         /* we take BKL. needed?*/
-        .unlocked_ioctl = ext3_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = ext3_compat_ioctl,
-#endif
-        .fsync          = ext3_sync_file,       /* BKL held */
-        .release        = ext3_release_dir,
-};
-
 
 static unsigned char get_dtype(struct super_block *sb, int filetype)
 {
@@ -55,6 +40,25 @@ static unsigned char get_dtype(struct super_block *sb, int filetype)
         return (ext3_filetype_table[filetype]);
 }
 
+/**
+ * Check if the given dir-inode refers to an htree-indexed directory
+ * (or a directory which chould potentially get coverted to use htree
+ * indexing).
+ *
+ * Return 1 if it is a dx dir, 0 if not
+ */
+static int is_dx_dir(struct inode *inode)
+{
+        struct super_block *sb = inode->i_sb;
+
+        if (EXT3_HAS_COMPAT_FEATURE(inode->i_sb,
+                     EXT3_FEATURE_COMPAT_DIR_INDEX) &&
+            ((EXT3_I(inode)->i_flags & EXT3_INDEX_FL) ||
+             ((inode->i_size >> sb->s_blocksize_bits) == 1)))
+                return 1;
+
+        return 0;
+}
 
 int ext3_check_dir_entry (const char * function, struct inode * dir,
                           struct ext3_dir_entry_2 * de,
@@ -94,18 +98,13 @@ static int ext3_readdir(struct file * filp,
         unsigned long offset;
         int i, stored;
         struct ext3_dir_entry_2 *de;
-        struct super_block *sb;
         int err;
         struct inode *inode = filp->f_path.dentry->d_inode;
+        struct super_block *sb = inode->i_sb;
         int ret = 0;
         int dir_has_error = 0;
 
-        sb = inode->i_sb;
-
-        if (EXT3_HAS_COMPAT_FEATURE(inode->i_sb,
-                                    EXT3_FEATURE_COMPAT_DIR_INDEX) &&
-            ((EXT3_I(inode)->i_flags & EXT3_INDEX_FL) ||
-             ((inode->i_size >> sb->s_blocksize_bits) == 1))) {
+        if (is_dx_dir(inode)) {
                 err = ext3_dx_readdir(filp, dirent, filldir);
                 if (err != ERR_BAD_DX_DIR) {
                         ret = err;
@@ -227,22 +226,87 @@ out:
         return ret;
 }
 
+static inline int is_32bit_api(void)
+{
+#ifdef CONFIG_COMPAT
+        return is_compat_task();
+#else
+        return (BITS_PER_LONG == 32);
+#endif
+}
+
 /*
  * These functions convert from the major/minor hash to an f_pos
- * value.
+ * value for dx directories
  *
- * Currently we only use major hash numer.  This is unfortunate, but
- * on 32-bit machines, the same VFS interface is used for lseek and
- * llseek, so if we use the 64 bit offset, then the 32-bit versions of
- * lseek/telldir/seekdir will blow out spectacularly, and from within
- * the ext2 low-level routine, we don't know if we're being called by
- * a 64-bit version of the system call or the 32-bit version of the
- * system call.  Worse yet, NFSv2 only allows for a 32-bit readdir
- * cookie.  Sigh.
+ * Upper layer (for example NFS) should specify FMODE_32BITHASH or
+ * FMODE_64BITHASH explicitly. On the other hand, we allow ext3 to be mounted
+ * directly on both 32-bit and 64-bit nodes, under such case, neither
+ * FMODE_32BITHASH nor FMODE_64BITHASH is specified.
  */
-#define hash2pos(major, minor)  (major >> 1)
-#define pos2maj_hash(pos)       ((pos << 1) & 0xffffffff)
-#define pos2min_hash(pos)       (0)
+static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
+{
+        if ((filp->f_mode & FMODE_32BITHASH) ||
+            (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+                return major >> 1;
+        else
+                return ((__u64)(major >> 1) << 32) | (__u64)minor;
+}
+
+static inline __u32 pos2maj_hash(struct file *filp, loff_t pos)
+{
+        if ((filp->f_mode & FMODE_32BITHASH) ||
+            (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+                return (pos << 1) & 0xffffffff;
+        else
+                return ((pos >> 32) << 1) & 0xffffffff;
+}
+
+static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
+{
+        if ((filp->f_mode & FMODE_32BITHASH) ||
+            (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+                return 0;
+        else
+                return pos & 0xffffffff;
+}
+
+/*
+ * Return 32- or 64-bit end-of-file for dx directories
+ */
+static inline loff_t ext3_get_htree_eof(struct file *filp)
+{
+        if ((filp->f_mode & FMODE_32BITHASH) ||
+            (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+                return EXT3_HTREE_EOF_32BIT;
+        else
+                return EXT3_HTREE_EOF_64BIT;
+}
+
+
+/*
+ * ext3_dir_llseek() calls generic_file_llseek[_size]() to handle both
+ * non-htree and htree directories, where the "offset" is in terms
+ * of the filename hash value instead of the byte offset.
+ *
+ * Because we may return a 64-bit hash that is well beyond s_maxbytes,
+ * we need to pass the max hash as the maximum allowable offset in
+ * the htree directory case.
+ *
+ * NOTE: offsets obtained *before* ext3_set_inode_flag(dir, EXT3_INODE_INDEX)
+ *       will be invalid once the directory was converted into a dx directory
+ */
+loff_t ext3_dir_llseek(struct file *file, loff_t offset, int origin)
+{
+        struct inode *inode = file->f_mapping->host;
+        int dx_dir = is_dx_dir(inode);
+
+        if (likely(dx_dir))
+                return generic_file_llseek_size(file, offset, origin,
+                                                ext3_get_htree_eof(file));
+        else
+                return generic_file_llseek(file, offset, origin);
+}
 
 /*
  * This structure holds the nodes of the red-black tree used to store
@@ -303,15 +367,16 @@ static void free_rb_tree_fname(struct rb_root *root)
 }
 
 
-static struct dir_private_info *ext3_htree_create_dir_info(loff_t pos)
+static struct dir_private_info *ext3_htree_create_dir_info(struct file *filp,
+                                                           loff_t pos)
 {
         struct dir_private_info *p;
 
         p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
         if (!p)
                 return NULL;
-        p->curr_hash = pos2maj_hash(pos);
-        p->curr_minor_hash = pos2min_hash(pos);
+        p->curr_hash = pos2maj_hash(filp, pos);
+        p->curr_minor_hash = pos2min_hash(filp, pos);
         return p;
 }
 
@@ -401,7 +466,7 @@ static int call_filldir(struct file * filp, void * dirent,
                 printk("call_filldir: called with null fname?!?\n");
                 return 0;
         }
-        curr_pos = hash2pos(fname->hash, fname->minor_hash);
+        curr_pos = hash2pos(filp, fname->hash, fname->minor_hash);
         while (fname) {
                 error = filldir(dirent, fname->name,
                                 fname->name_len, curr_pos,
@@ -426,13 +491,13 @@ static int ext3_dx_readdir(struct file * filp,
         int     ret;
 
         if (!info) {
-                info = ext3_htree_create_dir_info(filp->f_pos);
+                info = ext3_htree_create_dir_info(filp, filp->f_pos);
                 if (!info)
                         return -ENOMEM;
                 filp->private_data = info;
         }
 
-        if (filp->f_pos == EXT3_HTREE_EOF)
+        if (filp->f_pos == ext3_get_htree_eof(filp))
                 return 0;       /* EOF */
 
         /* Some one has messed with f_pos; reset the world */
@@ -440,8 +505,8 @@ static int ext3_dx_readdir(struct file * filp,
                 free_rb_tree_fname(&info->root);
                 info->curr_node = NULL;
                 info->extra_fname = NULL;
-                info->curr_hash = pos2maj_hash(filp->f_pos);
-                info->curr_minor_hash = pos2min_hash(filp->f_pos);
+                info->curr_hash = pos2maj_hash(filp, filp->f_pos);
+                info->curr_minor_hash = pos2min_hash(filp, filp->f_pos);
         }
 
         /*
@@ -473,7 +538,7 @@ static int ext3_dx_readdir(struct file * filp,
                         if (ret < 0)
                                 return ret;
                         if (ret == 0) {
-                                filp->f_pos = EXT3_HTREE_EOF;
+                                filp->f_pos = ext3_get_htree_eof(filp);
                                 break;
                         }
                         info->curr_node = rb_first(&info->root);
@@ -493,7 +558,7 @@ static int ext3_dx_readdir(struct file * filp,
                         info->curr_minor_hash = fname->minor_hash;
                 } else {
                         if (info->next_hash == ~0) {
-                                filp->f_pos = EXT3_HTREE_EOF;
+                                filp->f_pos = ext3_get_htree_eof(filp);
                                 break;
                         }
                         info->curr_hash = info->next_hash;
@@ -512,3 +577,15 @@ static int ext3_release_dir (struct inode * inode, struct file * filp)
 
         return 0;
 }
+
+const struct file_operations ext3_dir_operations = {
+        .llseek         = ext3_dir_llseek,
+        .read           = generic_read_dir,
+        .readdir        = ext3_readdir,
+        .unlocked_ioctl = ext3_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ext3_compat_ioctl,
+#endif
+        .fsync          = ext3_sync_file,
+        .release        = ext3_release_dir,
+};
diff --git a/fs/ext3/ext3.h b/fs/ext3/ext3.h
index 7977973a24f0..e85ff15a060e 100644
--- a/fs/ext3/ext3.h
+++ b/fs/ext3/ext3.h
@@ -920,7 +920,11 @@ struct dx_hash_info
         u32             *seed;
 };
 
-#define EXT3_HTREE_EOF  0x7fffffff
+
+/* 32 and 64 bit signed EOF for dx directories */
+#define EXT3_HTREE_EOF_32BIT   ((1UL  << (32 - 1)) - 1)
+#define EXT3_HTREE_EOF_64BIT   ((1ULL << (64 - 1)) - 1)
+
 
 /*
  * Control parameters used by ext3_htree_next_block
diff --git a/fs/ext3/hash.c b/fs/ext3/hash.c
index d10231ddcf8a..ede315cdf126 100644
--- a/fs/ext3/hash.c
+++ b/fs/ext3/hash.c
@@ -198,8 +198,8 @@ int ext3fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
                 return -1;
         }
         hash = hash & ~1;
-        if (hash == (EXT3_HTREE_EOF << 1))
-                hash = (EXT3_HTREE_EOF-1) << 1;
+        if (hash == (EXT3_HTREE_EOF_32BIT << 1))
+                hash = (EXT3_HTREE_EOF_32BIT - 1) << 1;
         hinfo->hash = hash;
         hinfo->minor_hash = minor_hash;
         return 0;
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index e3c39e4cec19..082afd78b107 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -180,8 +180,7 @@ error_return:
  * It's OK to put directory into a group unless
  * it has too many directories already (max_dirs) or
  * it has too few free inodes left (min_inodes) or
- * it has too few free blocks left (min_blocks) or
- * it's already running too large debt (max_debt).
+ * it has too few free blocks left (min_blocks).
  * Parent's group is preferred, if it doesn't satisfy these
  * conditions we search cyclically through the rest. If none
  * of the groups look good we just look for a group with more
@@ -191,21 +190,16 @@ error_return:
  * when we allocate an inode, within 0--255.
  */
 
-#define INODE_COST 64
-#define BLOCK_COST 256
-
 static int find_group_orlov(struct super_block *sb, struct inode *parent)
 {
         int parent_group = EXT3_I(parent)->i_block_group;
         struct ext3_sb_info *sbi = EXT3_SB(sb);
-        struct ext3_super_block *es = sbi->s_es;
         int ngroups = sbi->s_groups_count;
         int inodes_per_group = EXT3_INODES_PER_GROUP(sb);
         unsigned int freei, avefreei;
         ext3_fsblk_t freeb, avefreeb;
-        ext3_fsblk_t blocks_per_dir;
         unsigned int ndirs;
-        int max_debt, max_dirs, min_inodes;
+        int max_dirs, min_inodes;
         ext3_grpblk_t min_blocks;
         int group = -1, i;
         struct ext3_group_desc *desc;
@@ -242,20 +236,10 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
                 goto fallback;
         }
 
-        blocks_per_dir = (le32_to_cpu(es->s_blocks_count) - freeb) / ndirs;
-
         max_dirs = ndirs / ngroups + inodes_per_group / 16;
         min_inodes = avefreei - inodes_per_group / 4;
         min_blocks = avefreeb - EXT3_BLOCKS_PER_GROUP(sb) / 4;
 
-        max_debt = EXT3_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, (ext3_fsblk_t)BLOCK_COST);
-        if (max_debt * INODE_COST > inodes_per_group)
-                max_debt = inodes_per_group / INODE_COST;
-        if (max_debt > 255)
-                max_debt = 255;
-        if (max_debt == 0)
-                max_debt = 1;
-
         for (i = 0; i < ngroups; i++) {
                 group = (parent_group + i) % ngroups;
                 desc = ext3_get_group_desc (sb, group, NULL);
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index a09790a412b1..9a4a5c48b1c9 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -272,18 +272,18 @@ void ext3_evict_inode (struct inode *inode)
         if (ext3_mark_inode_dirty(handle, inode)) {
                 /* If that failed, just dquot_drop() and be done with that */
                 dquot_drop(inode);
-                end_writeback(inode);
+                clear_inode(inode);
         } else {
                 ext3_xattr_delete_inode(handle, inode);
                 dquot_free_inode(inode);
                 dquot_drop(inode);
-                end_writeback(inode);
+                clear_inode(inode);
                 ext3_free_inode(handle, inode);
         }
         ext3_journal_stop(handle);
         return;
 no_delete:
-        end_writeback(inode);
+        clear_inode(inode);
         dquot_drop(inode);
 }
 
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 94ef7e616129..8c3a44b7c375 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -3015,7 +3015,6 @@ static ssize_t ext3_quota_write(struct super_block *sb, int type,
                         (unsigned long long)off, (unsigned long long)len);
                 return -EIO;
         }
-        mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
         bh = ext3_bread(handle, inode, blk, 1, &err);
         if (!bh)
                 goto out;
@@ -3039,10 +3038,8 @@ static ssize_t ext3_quota_write(struct super_block *sb, int type,
         }
         brelse(bh);
 out:
-        if (err) {
-                mutex_unlock(&inode->i_mutex);
+        if (err)
                 return err;
-        }
         if (inode->i_size < off + len) {
                 i_size_write(inode, off + len);
                 EXT3_I(inode)->i_disksize = inode->i_size;
@@ -3050,7 +3047,6 @@ out:
         inode->i_version++;
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         ext3_mark_inode_dirty(handle, inode);
-        mutex_unlock(&inode->i_mutex);
         return len;
 }