1 files changed, 44 insertions, 37 deletions

diff --git a/fs/logfs/readwrite.c b/fs/logfs/readwrite.c
index 3159db6958e5..6127baf0e188 100644
--- a/fs/logfs/readwrite.c
+++ b/fs/logfs/readwrite.c
@@ -892,6 +892,8 @@ u64 logfs_seek_hole(struct inode *inode, u64 bix)
                 return bix;
         else if (li->li_data[INDIRECT_INDEX] & LOGFS_FULLY_POPULATED)
                 bix = maxbix(li->li_height);
+        else if (bix >= maxbix(li->li_height))
+                return bix;
         else {
                 bix = seek_holedata_loop(inode, bix, 0);
                 if (bix < maxbix(li->li_height))
@@ -1093,17 +1095,25 @@ static int logfs_reserve_bytes(struct inode *inode, int bytes)
 int get_page_reserve(struct inode *inode, struct page *page)
 {
         struct logfs_super *super = logfs_super(inode->i_sb);
+        struct logfs_block *block = logfs_block(page);
         int ret;
 
-        if (logfs_block(page) && logfs_block(page)->reserved_bytes)
+        if (block && block->reserved_bytes)
                 return 0;
 
         logfs_get_wblocks(inode->i_sb, page, WF_LOCK);
-        ret = logfs_reserve_bytes(inode, 6 * LOGFS_MAX_OBJECTSIZE);
+        while ((ret = logfs_reserve_bytes(inode, 6 * LOGFS_MAX_OBJECTSIZE)) &&
+                        !list_empty(&super->s_writeback_list)) {
+                block = list_entry(super->s_writeback_list.next,
+                                struct logfs_block, alias_list);
+                block->ops->write_block(block);
+        }
         if (!ret) {
                 alloc_data_block(inode, page);
-                logfs_block(page)->reserved_bytes += 6 * LOGFS_MAX_OBJECTSIZE;
+                block = logfs_block(page);
+                block->reserved_bytes += 6 * LOGFS_MAX_OBJECTSIZE;
                 super->s_dirty_pages += 6 * LOGFS_MAX_OBJECTSIZE;
+                list_move_tail(&block->alias_list, &super->s_writeback_list);
         }
         logfs_put_wblocks(inode->i_sb, page, WF_LOCK);
         return ret;
@@ -1861,7 +1871,7 @@ int logfs_truncate(struct inode *inode, u64 target)
                         size = target;
 
                 logfs_get_wblocks(sb, NULL, 1);
-                err = __logfs_truncate(inode, target);
+                err = __logfs_truncate(inode, size);
                 if (!err)
                         err = __logfs_write_inode(inode, 0);
                 logfs_put_wblocks(sb, NULL, 1);
@@ -1962,31 +1972,6 @@ static struct page *inode_to_page(struct inode *inode)
         return page;
 }
 
-/* Cheaper version of write_inode.  All changes are concealed in
- * aliases, which are moved back.  No write to the medium happens.
- */
-void logfs_clear_inode(struct inode *inode)
-{
-        struct super_block *sb = inode->i_sb;
-        struct logfs_inode *li = logfs_inode(inode);
-        struct logfs_block *block = li->li_block;
-        struct page *page;
-
-        /* Only deleted files may be dirty at this point */
-        BUG_ON(inode->i_state & I_DIRTY && inode->i_nlink);
-        if (!block)
-                return;
-        if ((logfs_super(sb)->s_flags & LOGFS_SB_FLAG_SHUTDOWN)) {
-                block->ops->free_block(inode->i_sb, block);
-                return;
-        }
-
-        BUG_ON(inode->i_ino < LOGFS_RESERVED_INOS);
-        page = inode_to_page(inode);
-        BUG_ON(!page); /* FIXME: Use emergency page */
-        logfs_put_write_page(page);
-}
-
 static int do_write_inode(struct inode *inode)
 {
         struct super_block *sb = inode->i_sb;
@@ -2154,18 +2139,40 @@ static int do_delete_inode(struct inode *inode)
  * ZOMBIE inodes have already been deleted before and should remain dead,
  * if it weren't for valid checking.  No need to kill them again here.
  */
-void logfs_delete_inode(struct inode *inode)
+void logfs_evict_inode(struct inode *inode)
 {
+        struct super_block *sb = inode->i_sb;
         struct logfs_inode *li = logfs_inode(inode);
+        struct logfs_block *block = li->li_block;
+        struct page *page;
 
-        if (!(li->li_flags & LOGFS_IF_ZOMBIE)) {
-                li->li_flags |= LOGFS_IF_ZOMBIE;
-                if (i_size_read(inode) > 0)
-                        logfs_truncate(inode, 0);
-                do_delete_inode(inode);
+        if (!inode->i_nlink) {
+                if (!(li->li_flags & LOGFS_IF_ZOMBIE)) {
+                        li->li_flags |= LOGFS_IF_ZOMBIE;
+                        if (i_size_read(inode) > 0)
+                                logfs_truncate(inode, 0);
+                        do_delete_inode(inode);
+                }
         }
         truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
+        end_writeback(inode);
+
+        /* Cheaper version of write_inode.  All changes are concealed in
+         * aliases, which are moved back.  No write to the medium happens.
+         */
+        /* Only deleted files may be dirty at this point */
+        BUG_ON(inode->i_state & I_DIRTY && inode->i_nlink);
+        if (!block)
+                return;
+        if ((logfs_super(sb)->s_flags & LOGFS_SB_FLAG_SHUTDOWN)) {
+                block->ops->free_block(inode->i_sb, block);
+                return;
+        }
+
+        BUG_ON(inode->i_ino < LOGFS_RESERVED_INOS);
+        page = inode_to_page(inode);
+        BUG_ON(!page); /* FIXME: Use emergency page */
+        logfs_put_write_page(page);
 }
 
 void btree_write_block(struct logfs_block *block)
@@ -2249,6 +2256,7 @@ int logfs_init_rw(struct super_block *sb)
         int min_fill = 3 * super->s_no_blocks;
 
         INIT_LIST_HEAD(&super->s_object_alias);
+        INIT_LIST_HEAD(&super->s_writeback_list);
         mutex_init(&super->s_write_mutex);
         super->s_block_pool = mempool_create_kmalloc_pool(min_fill,
                         sizeof(struct logfs_block));
@@ -2261,7 +2269,6 @@ void logfs_cleanup_rw(struct super_block *sb)
 {
         struct logfs_super *super = logfs_super(sb);
 
-        destroy_meta_inode(super->s_segfile_inode);
         logfs_mempool_destroy(super->s_block_pool);
         logfs_mempool_destroy(super->s_shadow_pool);
 }