fs: add SEEK_HOLE and SEEK_DATA flags
authorJosef Bacik <josef@redhat.com>
Mon, 18 Jul 2011 17:21:35 +0000 (13:21 -0400)
committerAl Viro <viro@zeniv.linux.org.uk>
Thu, 21 Jul 2011 00:47:56 +0000 (20:47 -0400)
This just gets us ready to support the SEEK_HOLE and SEEK_DATA flags.  Turns out
using fiemap in things like cp cause more problems than it solves, so lets try
and give userspace an interface that doesn't suck.  We need to match solaris
here, and the definitions are

*o* If /whence/ is SEEK_HOLE, the offset of the start of the
next hole greater than or equal to the supplied offset
is returned. The definition of a hole is provided near
the end of the DESCRIPTION.

*o* If /whence/ is SEEK_DATA, the file pointer is set to the
start of the next non-hole file region greater than or
equal to the supplied offset.

So in the generic case the entire file is data and there is a virtual hole at
the end.  That means we will just return i_size for SEEK_HOLE and will return
the same offset for SEEK_DATA.  This is how Solaris does it so we have to do it
the same way.

Thanks,

Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Documentation/filesystems/porting
fs/read_write.c
include/linux/fs.h

index 0eeb3954dea3318e3db0aa179b71c1da38e629e1..6b96773e27cb2ef54bd736309e46e25b04aec0db 100644 (file)
@@ -411,3 +411,13 @@ to some pointer to returning that pointer.  On errors return ERR_PTR(...).
 argument; instead of passing IPERM_FLAG_RCU we add MAY_NOT_BLOCK into mask.
        generic_permission() has also lost the check_acl argument; if you want
 non-NULL to be used for that inode, put it into ->i_op->check_acl.
+
+--
+[mandatory]
+       If you implement your own ->llseek() you must handle SEEK_HOLE and
+SEEK_DATA.  You can hanle this by returning -EINVAL, but it would be nicer to
+support it in some way.  The generic handler assumes that the entire file is
+data and there is a virtual hole at the end of the file.  So if the provided
+offset is less than i_size and SEEK_DATA is specified, return the same offset.
+If the above is true for the offset and you are given SEEK_HOLE, return the end
+of the file.  If the offset is i_size or greater return -ENXIO in either case.
index 5520f8ad550446d095c6483e67acc0ca5522ff91..5907b49e4d7ee42bbf6c613802a0522e0827107a 100644 (file)
@@ -64,6 +64,23 @@ generic_file_llseek_unlocked(struct file *file, loff_t offset, int origin)
                        return file->f_pos;
                offset += file->f_pos;
                break;
+       case SEEK_DATA:
+               /*
+                * 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 >= inode->i_size)
+                       return -ENXIO;
+               break;
+       case SEEK_HOLE:
+               /*
+                * 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 >= inode->i_size)
+                       return -ENXIO;
+               offset = inode->i_size;
+               break;
        }
 
        if (offset < 0 && !unsigned_offsets(file))
@@ -128,12 +145,13 @@ EXPORT_SYMBOL(no_llseek);
 
 loff_t default_llseek(struct file *file, loff_t offset, int origin)
 {
+       struct inode *inode = file->f_path.dentry->d_inode;
        loff_t retval;
 
-       mutex_lock(&file->f_dentry->d_inode->i_mutex);
+       mutex_lock(&inode->i_mutex);
        switch (origin) {
                case SEEK_END:
-                       offset += i_size_read(file->f_path.dentry->d_inode);
+                       offset += i_size_read(inode);
                        break;
                case SEEK_CUR:
                        if (offset == 0) {
@@ -141,6 +159,26 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
                                goto out;
                        }
                        offset += file->f_pos;
+                       break;
+               case SEEK_DATA:
+                       /*
+                        * 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 >= inode->i_size)
+                               return -ENXIO;
+                       break;
+               case SEEK_HOLE:
+                       /*
+                        * 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 >= inode->i_size)
+                               return -ENXIO;
+                       offset = inode->i_size;
+                       break;
        }
        retval = -EINVAL;
        if (offset >= 0 || unsigned_offsets(file)) {
@@ -151,7 +189,7 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
                retval = offset;
        }
 out:
-       mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+       mutex_unlock(&inode->i_mutex);
        return retval;
 }
 EXPORT_SYMBOL(default_llseek);
index 824453be9feeb2653cabd7abd02e597fb2500d3e..4a61f98823a6edb581c61d10f015b33aeb1d0599 100644 (file)
@@ -32,7 +32,9 @@
 #define SEEK_SET       0       /* seek relative to beginning of file */
 #define SEEK_CUR       1       /* seek relative to current file position */
 #define SEEK_END       2       /* seek relative to end of file */
-#define SEEK_MAX       SEEK_END
+#define SEEK_DATA      3       /* seek to the next data */
+#define SEEK_HOLE      4       /* seek to the next hole */
+#define SEEK_MAX       SEEK_HOLE
 
 struct fstrim_range {
        __u64 start;