f2fs: introduce f2fs_seek_block to support SEEK_{DATA, HOLE} in llseek

In This patch we introduce f2fs_seek_block to support SEEK_{DATA,HOLE} of
lseek(2).

change log from v1:
 o fix bug when lseek from middle of page and fix wrong calculation of
PGOFS_OF_NEXT_DNODE macro.

Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 1ca958ab40e394191e2cc2e66c48c76e53fe977e..e77be7cb1e60f12e200fded7628c5e83690c3132 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1079,6 +1079,12 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)
        ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
         (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
 
+/* get offset of first page in next direct node */
+#define PGOFS_OF_NEXT_DNODE(pgofs, fi)                         \
+       ((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) :  \
+       (pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) /       \
+       ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi))
+
 /*
  * file.c
  */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index bb365c932555ab53f2e4ae739d2599f69dec42cd..d99d17325046fef8a9426a293d9adfecd8568e88 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -194,6 +194,96 @@ out:
        return ret;
 }
 
+static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
+{
+       struct inode *inode = file->f_mapping->host;
+       loff_t maxbytes = inode->i_sb->s_maxbytes;
+       struct dnode_of_data dn;
+       pgoff_t pgofs, end_offset;
+       loff_t data_ofs = offset, isize;
+       int err = 0;
+
+       mutex_lock(&inode->i_mutex);
+
+       isize = i_size_read(inode);
+       if (offset >= isize)
+               goto fail;
+
+       /* handle inline data case */
+       if (f2fs_has_inline_data(inode)) {
+               if (whence == SEEK_HOLE)
+                       data_ofs = isize;
+               goto found;
+       }
+
+       pgofs = (pgoff_t)(offset >> PAGE_CACHE_SHIFT);
+
+       for (; data_ofs < isize; data_ofs = pgofs << PAGE_CACHE_SHIFT) {
+               set_new_dnode(&dn, inode, NULL, NULL, 0);
+               err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA);
+               if (err && err != -ENOENT) {
+                       goto fail;
+               } else if (err == -ENOENT) {
+                       /* direct node is not exist */
+                       if (whence == SEEK_DATA) {
+                               pgofs = PGOFS_OF_NEXT_DNODE(pgofs,
+                                                       F2FS_I(inode));
+                               continue;
+                       } else {
+                               goto found;
+                       }
+               }
+
+               end_offset = IS_INODE(dn.node_page) ?
+                       ADDRS_PER_INODE(F2FS_I(inode)) : ADDRS_PER_BLOCK;
+
+               /* find data/hole in dnode block */
+               for (; dn.ofs_in_node < end_offset;
+                               dn.ofs_in_node++, pgofs++,
+                               data_ofs = pgofs << PAGE_CACHE_SHIFT) {
+                       block_t blkaddr;
+                       blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
+
+                       if ((whence == SEEK_DATA && blkaddr != NULL_ADDR) ||
+                               (whence == SEEK_HOLE && blkaddr == NULL_ADDR)) {
+                               f2fs_put_dnode(&dn);
+                               goto found;
+                       }
+               }
+               f2fs_put_dnode(&dn);
+       }
+
+       if (whence == SEEK_DATA)
+               goto fail;
+       else
+               data_ofs = isize;
+found:
+       mutex_unlock(&inode->i_mutex);
+       return vfs_setpos(file, data_ofs, maxbytes);
+fail:
+       mutex_unlock(&inode->i_mutex);
+       return -ENXIO;
+}
+
+static loff_t f2fs_llseek(struct file *file, loff_t offset, int whence)
+{
+       struct inode *inode = file->f_mapping->host;
+       loff_t maxbytes = inode->i_sb->s_maxbytes;
+
+       switch (whence) {
+       case SEEK_SET:
+       case SEEK_CUR:
+       case SEEK_END:
+               return generic_file_llseek_size(file, offset, whence,
+                                               maxbytes, i_size_read(inode));
+       case SEEK_DATA:
+       case SEEK_HOLE:
+               return f2fs_seek_block(file, offset, whence);
+       }
+
+       return -EINVAL;
+}
+
 static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
        file_accessed(file);
@@ -675,7 +765,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 #endif
 
 const struct file_operations f2fs_file_operations = {
-       .llseek         = generic_file_llseek,
+       .llseek         = f2fs_llseek,
        .read           = do_sync_read,
        .write          = do_sync_write,
        .aio_read       = generic_file_aio_read,