Merge branch 'for-3.4' of git://linux-nfs.org/~bfields/linux

Pull nfsd changes from Bruce Fields:

Highlights:
 - Benny Halevy and Tigran Mkrtchyan implemented some more 4.1 features,
   moving us closer to a complete 4.1 implementation.
 - Bernd Schubert fixed a long-standing problem with readdir cookies on
   ext2/3/4.
 - Jeff Layton performed a long-overdue overhaul of the server reboot
   recovery code which will allow us to deprecate the current code (a
   rather unusual user of the vfs), and give us some needed flexibility
   for further improvements.
 - Like the client, we now support numeric uid's and gid's in the
   auth_sys case, allowing easier upgrades from NFSv2/v3 to v4.x.

Plus miscellaneous bugfixes and cleanup.

Thanks to everyone!

There are also some delegation fixes waiting on vfs review that I
suppose will have to wait for 3.5.  With that done I think we'll finally
turn off the "EXPERIMENTAL" dependency for v4 (though that's mostly
symbolic as it's been on by default in distro's for a while).

And the list of 4.1 todo's should be achievable for 3.5 as well:

   http://wiki.linux-nfs.org/wiki/index.php/Server_4.0_and_4.1_issues

though we may still want a bit more experience with it before turning it
on by default.

* 'for-3.4' of git://linux-nfs.org/~bfields/linux: (55 commits)
  nfsd: only register cld pipe notifier when CONFIG_NFSD_V4 is enabled
  nfsd4: use auth_unix unconditionally on backchannel
  nfsd: fix NULL pointer dereference in cld_pipe_downcall
  nfsd4: memory corruption in numeric_name_to_id()
  sunrpc: skip portmap calls on sessions backchannel
  nfsd4: allow numeric idmapping
  nfsd: don't allow legacy client tracker init for anything but init_net
  nfsd: add notifier to handle mount/unmount of rpc_pipefs sb
  nfsd: add the infrastructure to handle the cld upcall
  nfsd: add a header describing upcall to nfsdcld
  nfsd: add a per-net-namespace struct for nfsd
  sunrpc: create nfsd dir in rpc_pipefs
  nfsd: add nfsd4_client_tracking_ops struct and a way to set it
  nfsd: convert nfs4_client->cl_cb_flags to a generic flags field
  NFSD: Fix nfs4_verifier memory alignment
  NFSD: Fix warnings when NFSD_DEBUG is not defined
  nfsd: vfs_llseek() with 32 or 64 bit offsets (hashes)
  nfsd: rename 'int access' to 'int may_flags' in nfsd_open()
  ext4: return 32/64-bit dir name hash according to usage type
  fs: add new FMODE flags: FMODE_32bithash and FMODE_64bithash
  ...

3 files changed, 176 insertions, 48 deletions

diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index ad56866d729..b8678620264 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -32,24 +32,8 @@ static unsigned char ext4_filetype_table[] = {
         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
 };
 
-static int ext4_readdir(struct file *, void *, filldir_t);
 static int ext4_dx_readdir(struct file *filp,
                            void *dirent, filldir_t filldir);
-static int ext4_release_dir(struct inode *inode,
-                                struct file *filp);
-
-const struct file_operations ext4_dir_operations = {
-        .llseek         = ext4_llseek,
-        .read           = generic_read_dir,
-        .readdir        = ext4_readdir,         /* we take BKL. needed?*/
-        .unlocked_ioctl = ext4_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = ext4_compat_ioctl,
-#endif
-        .fsync          = ext4_sync_file,
-        .release        = ext4_release_dir,
-};
-
 
 static unsigned char get_dtype(struct super_block *sb, int filetype)
 {
@@ -60,6 +44,26 @@ static unsigned char get_dtype(struct super_block *sb, int filetype)
         return (ext4_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 (EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
+                     EXT4_FEATURE_COMPAT_DIR_INDEX) &&
+            ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) ||
+             ((inode->i_size >> sb->s_blocksize_bits) == 1)))
+                return 1;
+
+        return 0;
+}
+
 /*
  * Return 0 if the directory entry is OK, and 1 if there is a problem
  *
@@ -115,18 +119,13 @@ static int ext4_readdir(struct file *filp,
         unsigned int offset;
         int i, stored;
         struct ext4_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 (EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
-                                    EXT4_FEATURE_COMPAT_DIR_INDEX) &&
-            ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) ||
-             ((inode->i_size >> sb->s_blocksize_bits) == 1))) {
+        if (is_dx_dir(inode)) {
                 err = ext4_dx_readdir(filp, dirent, filldir);
                 if (err != ERR_BAD_DX_DIR) {
                         ret = err;
@@ -254,22 +253,134 @@ 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
+ *
+ * Upper layer (for example NFS) should specify FMODE_32BITHASH or
+ * FMODE_64BITHASH explicitly. On the other hand, we allow ext4 to be mounted
+ * directly on both 32-bit and 64-bit nodes, under such case, neither
+ * FMODE_32BITHASH nor FMODE_64BITHASH is specified.
+ */
+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 ext4_get_htree_eof(struct file *filp)
+{
+        if ((filp->f_mode & FMODE_32BITHASH) ||
+            (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
+                return EXT4_HTREE_EOF_32BIT;
+        else
+                return EXT4_HTREE_EOF_64BIT;
+}
+
+
+/*
+ * ext4_dir_llseek() based on generic_file_llseek() to handle both
+ * non-htree and htree directories, where the "offset" is in terms
+ * of the filename hash value instead of the byte offset.
  *
- * 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.
+ * NOTE: offsets obtained *before* ext4_set_inode_flag(dir, EXT4_INODE_INDEX)
+ *       will be invalid once the directory was converted into a dx directory
  */
-#define hash2pos(major, minor)  (major >> 1)
-#define pos2maj_hash(pos)       ((pos << 1) & 0xffffffff)
-#define pos2min_hash(pos)       (0)
+loff_t ext4_dir_llseek(struct file *file, loff_t offset, int origin)
+{
+        struct inode *inode = file->f_mapping->host;
+        loff_t ret = -EINVAL;
+        int dx_dir = is_dx_dir(inode);
+
+        mutex_lock(&inode->i_mutex);
+
+        /* NOTE: relative offsets with dx directories might not work
+         *       as expected, as it is difficult to figure out the
+         *       correct offset between dx hashes */
+
+        switch (origin) {
+        case SEEK_END:
+                if (unlikely(offset > 0))
+                        goto out_err; /* not supported for directories */
+
+                /* so only negative offsets are left, does that have a
+                 * meaning for directories at all? */
+                if (dx_dir)
+                        offset += ext4_get_htree_eof(file);
+                else
+                        offset += inode->i_size;
+                break;
+        case SEEK_CUR:
+                /*
+                 * Here we special-case the lseek(fd, 0, SEEK_CUR)
+                 * position-querying operation.  Avoid rewriting the "same"
+                 * f_pos value back to the file because a concurrent read(),
+                 * write() or lseek() might have altered it
+                 */
+                if (offset == 0) {
+                        offset = file->f_pos;
+                        goto out_ok;
+                }
+
+                offset += file->f_pos;
+                break;
+        }
+
+        if (unlikely(offset < 0))
+                goto out_err;
+
+        if (!dx_dir) {
+                if (offset > inode->i_sb->s_maxbytes)
+                        goto out_err;
+        } else if (offset > ext4_get_htree_eof(file))
+                goto out_err;
+
+        /* Special lock needed here? */
+        if (offset != file->f_pos) {
+                file->f_pos = offset;
+                file->f_version = 0;
+        }
+
+out_ok:
+        ret = offset;
+out_err:
+        mutex_unlock(&inode->i_mutex);
+
+        return ret;
+}
 
 /*
  * This structure holds the nodes of the red-black tree used to store
@@ -330,15 +441,16 @@ static void free_rb_tree_fname(struct rb_root *root)
 }
 
 
-static struct dir_private_info *ext4_htree_create_dir_info(loff_t pos)
+static struct dir_private_info *ext4_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;
 }
 
@@ -430,7 +542,7 @@ static int call_filldir(struct file *filp, void *dirent,
                          inode->i_ino, current->comm);
                 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,
@@ -455,13 +567,13 @@ static int ext4_dx_readdir(struct file *filp,
         int     ret;
 
         if (!info) {
-                info = ext4_htree_create_dir_info(filp->f_pos);
+                info = ext4_htree_create_dir_info(filp, filp->f_pos);
                 if (!info)
                         return -ENOMEM;
                 filp->private_data = info;
         }
 
-        if (filp->f_pos == EXT4_HTREE_EOF)
+        if (filp->f_pos == ext4_get_htree_eof(filp))
                 return 0;       /* EOF */
 
         /* Some one has messed with f_pos; reset the world */
@@ -469,8 +581,8 @@ static int ext4_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);
         }
 
         /*
@@ -502,7 +614,7 @@ static int ext4_dx_readdir(struct file *filp,
                         if (ret < 0)
                                 return ret;
                         if (ret == 0) {
-                                filp->f_pos = EXT4_HTREE_EOF;
+                                filp->f_pos = ext4_get_htree_eof(filp);
                                 break;
                         }
                         info->curr_node = rb_first(&info->root);
@@ -522,7 +634,7 @@ static int ext4_dx_readdir(struct file *filp,
                         info->curr_minor_hash = fname->minor_hash;
                 } else {
                         if (info->next_hash == ~0) {
-                                filp->f_pos = EXT4_HTREE_EOF;
+                                filp->f_pos = ext4_get_htree_eof(filp);
                                 break;
                         }
                         info->curr_hash = info->next_hash;
@@ -541,3 +653,15 @@ static int ext4_release_dir(struct inode *inode, struct file *filp)
 
         return 0;
 }
+
+const struct file_operations ext4_dir_operations = {
+        .llseek         = ext4_dir_llseek,
+        .read           = generic_read_dir,
+        .readdir        = ext4_readdir,
+        .unlocked_ioctl = ext4_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ext4_compat_ioctl,
+#endif
+        .fsync          = ext4_sync_file,
+        .release        = ext4_release_dir,
+};
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index ded731ac8a3..ab2594a30f8 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1623,7 +1623,11 @@ struct dx_hash_info
         u32             *seed;
 };
 
-#define EXT4_HTREE_EOF  0x7fffffff
+
+/* 32 and 64 bit signed EOF for dx directories */
+#define EXT4_HTREE_EOF_32BIT   ((1UL  << (32 - 1)) - 1)
+#define EXT4_HTREE_EOF_64BIT   ((1ULL << (64 - 1)) - 1)
+
 
 /*
  * Control parameters used by ext4_htree_next_block
diff --git a/fs/ext4/hash.c b/fs/ext4/hash.c
index ac8f168c8ab..fa8e4911d35 100644
--- a/fs/ext4/hash.c
+++ b/fs/ext4/hash.c
@@ -200,8 +200,8 @@ int ext4fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
                 return -1;
         }
         hash = hash & ~1;
-        if (hash == (EXT4_HTREE_EOF << 1))
-                hash = (EXT4_HTREE_EOF-1) << 1;
+        if (hash == (EXT4_HTREE_EOF_32BIT << 1))
+                hash = (EXT4_HTREE_EOF_32BIT - 1) << 1;
         hinfo->hash = hash;
         hinfo->minor_hash = minor_hash;
         return 0;