vfs: allow custom EOF in generic_file_llseek code

For ext3/4 htree directories, using the vfs llseek function with
SEEK_END goes to i_size like for any other file, but in reality
we want the maximum possible hash value.  Recent changes
in ext4 have cut & pasted generic_file_llseek() back into fs/ext4/dir.c,
but replicating this core code seems like a bad idea, especially
since the copy has already diverged from the vfs.

This patch updates generic_file_llseek_size to accept
both a custom maximum offset, and a custom EOF position.  With this
in place, ext4_dir_llseek can pass in the appropriate maximum hash
position for both maxsize and eof, and get what it wants.

As far as I know, this does not fix any bugs - nfs in the kernel
doesn't use SEEK_END, and I don't know of any user who does.  But
some ext4 folks seem keen on doing the right thing here, and I can't
really argue.

(Patch also fixes up some comments slightly)

Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

3 files changed, 14 insertions, 10 deletions

diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 92490e9f85ca..901f67e37864 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -303,7 +303,8 @@ loff_t ext3_dir_llseek(struct file *file, loff_t offset, int origin)
 
         if (likely(dx_dir))
                 return generic_file_llseek_size(file, offset, origin,
-                                                ext3_get_htree_eof(file));
+                                                ext3_get_htree_eof(file),
+                                                i_size_read(inode));
         else
                 return generic_file_llseek(file, offset, origin);
 }
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 8c7642a00054..f3dadd0a0d51 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -225,7 +225,8 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
         else
                 maxbytes = inode->i_sb->s_maxbytes;
 
-        return generic_file_llseek_size(file, offset, origin, maxbytes);
+        return generic_file_llseek_size(file, offset, origin,
+                                        maxbytes, i_size_read(inode));
 }
 
 const struct file_operations ext4_file_operations = {
diff --git a/fs/read_write.c b/fs/read_write.c
index c20614f86c01..1adfb691e4f1 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -55,10 +55,11 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
  * @file:       file structure to seek on
  * @offset:     file offset to seek to
  * @origin:     type of seek
- * @size:       max size of file system
+ * @size:       max size of this file in file system
+ * @eof:        offset used for SEEK_END position
  *
  * This is a variant of generic_file_llseek that allows passing in a custom
- * file size.
+ * maximum file size and a custom EOF position, for e.g. hashed directories
  *
  * Synchronization:
  * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
@@ -67,13 +68,13 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
  */
 loff_t
 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
-                loff_t maxsize)
+                loff_t maxsize, loff_t eof)
 {
         struct inode *inode = file->f_mapping->host;
 
         switch (origin) {
         case SEEK_END:
-                offset += i_size_read(inode);
+                offset += eof;
                 break;
         case SEEK_CUR:
                 /*
@@ -99,7 +100,7 @@ generic_file_llseek_size(struct file *file, loff_t offset, int origin,
                  * In the generic case the entire file is data, so as long as
                  * offset isn't at the end of the file then the offset is data.
                  */
-                if (offset >= i_size_read(inode))
+                if (offset >= eof)
                         return -ENXIO;
                 break;
         case SEEK_HOLE:
@@ -107,9 +108,9 @@ generic_file_llseek_size(struct file *file, loff_t offset, int origin,
                  * There is a virtual hole at the end of the file, so as long as
                  * offset isn't i_size or larger, return i_size.
                  */
-                if (offset >= i_size_read(inode))
+                if (offset >= eof)
                         return -ENXIO;
-                offset = i_size_read(inode);
+                offset = eof;
                 break;
         }
 
@@ -132,7 +133,8 @@ loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
         struct inode *inode = file->f_mapping->host;
 
         return generic_file_llseek_size(file, offset, origin,
-                                        inode->i_sb->s_maxbytes);
+                                        inode->i_sb->s_maxbytes,
+                                        i_size_read(inode));
 }
 EXPORT_SYMBOL(generic_file_llseek);