ext4_trans: fix return value of ext4_trans_try_revoke_block

[lwext4.git] / lwext4 / ext4.c

diff --git a/lwext4/ext4.c b/lwext4/ext4.c
index 57cc00ffb7e31f12cb68fda313dcfaf63ae993db..86630013875916cefcb818fe09c711c273465963 100644 (file)
--- a/lwext4/ext4.c
+++ b/lwext4/ext4.c
@@ -83,6 +83,9 @@ struct ext4_mountpoint {
 
        /**@brief   Dynamic allocation cache flag.*/
        bool cache_dynamic;
+
+       struct jbd_fs jbd_fs;
+       struct jbd_journal jbd_journal;
 };
 
 /**@brief   Block devices descriptor.*/
@@ -248,7 +251,7 @@ static int ext4_link(struct ext4_mountpoint *mp, struct ext4_inode_ref *parent,
                                return EIO;
 
                        ext4_dir_en_set_inode(res.dentry, parent->index);
-                       ext4_bcache_set_dirty(res.block.buf);
+                       ext4_trans_set_block_dirty(res.block.buf);
                        r = ext4_dir_destroy_result(ch, &res);
                        if (r != EOK)
                                return r;
@@ -403,6 +406,7 @@ int ext4_mount(const char *dev_name, const char *mount_point)
        /*Bind block cache to block device*/
        r = ext4_block_bind_bcache(bd, bc);
        if (r != EOK) {
+               ext4_bcache_cleanup(bc);
                ext4_block_fini(bd);
                if (mp->cache_dynamic) {
                        ext4_bcache_fini_dynamic(bc);
@@ -410,6 +414,7 @@ int ext4_mount(const char *dev_name, const char *mount_point)
                }
                return r;
        }
+       bd->fs = &mp->fs;
 
        return r;
 }
@@ -433,16 +438,19 @@ int ext4_umount(const char *mount_point)
 
        r = ext4_fs_fini(&mp->fs);
        if (r != EOK)
-               return r;
+               goto Finish;
 
        mp->mounted = 0;
 
+       ext4_bcache_cleanup(mp->fs.bdev->bc);
        if (mp->cache_dynamic) {
                ext4_bcache_fini_dynamic(mp->fs.bdev->bc);
                free(mp->fs.bdev->bc);
        }
-
-       return ext4_block_fini(mp->fs.bdev);
+       r = ext4_block_fini(mp->fs.bdev);
+Finish:
+       mp->fs.bdev->fs = NULL;
+       return r;
 }
 
 static struct ext4_mountpoint *ext4_get_mount(const char *path)
@@ -459,6 +467,64 @@ static struct ext4_mountpoint *ext4_get_mount(const char *path)
        return 0;
 }
 
+int ext4_journal_start(const char *mount_point)
+{
+       int r = EOK;
+       struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
+       if (!mp)
+               return ENOENT;
+
+       if (ext4_sb_feature_com(&mp->fs.sb,
+                               EXT4_FCOM_HAS_JOURNAL)) {
+               r = jbd_get_fs(&mp->fs, &mp->jbd_fs);
+               if (r != EOK)
+                       goto Finish;
+
+               r = jbd_journal_start(&mp->jbd_fs, &mp->jbd_journal);
+               if (r != EOK) {
+                       mp->jbd_fs.dirty = false;
+                       jbd_put_fs(&mp->jbd_fs);
+                       goto Finish;
+               }
+               mp->fs.jbd_fs = &mp->jbd_fs;
+               mp->fs.jbd_journal = &mp->jbd_journal;
+       }
+Finish:
+       return r;
+}
+
+int ext4_journal_stop(const char *mount_point)
+{
+       int r = EOK;
+       struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
+       if (!mp)
+               return ENOENT;
+
+       if (ext4_sb_feature_com(&mp->fs.sb,
+                               EXT4_FCOM_HAS_JOURNAL)) {
+               r = jbd_journal_stop(&mp->jbd_journal);
+               if (r != EOK) {
+                       mp->jbd_fs.dirty = false;
+                       jbd_put_fs(&mp->jbd_fs);
+                       mp->fs.jbd_journal = NULL;
+                       mp->fs.jbd_fs = NULL;
+                       goto Finish;
+               }
+
+               r = jbd_put_fs(&mp->jbd_fs);
+               if (r != EOK) {
+                       mp->fs.jbd_journal = NULL;
+                       mp->fs.jbd_fs = NULL;
+                       goto Finish;
+               }
+
+               mp->fs.jbd_journal = NULL;
+               mp->fs.jbd_fs = NULL;
+       }
+Finish:
+       return r;
+}
+
 int ext4_recover(const char *mount_point)
 {
        struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
@@ -492,6 +558,44 @@ Finish:
        return r;
 }
 
+static int ext4_trans_start(struct ext4_mountpoint *mp)
+{
+       int r = EOK;
+       if (mp->fs.jbd_journal && !mp->fs.curr_trans) {
+               struct jbd_journal *journal = mp->fs.jbd_journal;
+               struct jbd_trans *trans;
+               trans = jbd_journal_new_trans(journal);
+               if (!trans) {
+                       r = ENOMEM;
+                       goto Finish;
+               }
+               mp->fs.curr_trans = trans;
+       }
+Finish:
+       return r;
+}
+
+static int ext4_trans_stop(struct ext4_mountpoint *mp)
+{
+       int r = EOK;
+       if (mp->fs.jbd_journal && mp->fs.curr_trans) {
+               struct jbd_journal *journal = mp->fs.jbd_journal;
+               struct jbd_trans *trans = mp->fs.curr_trans;
+               r = jbd_journal_commit_trans(journal, trans);
+               mp->fs.curr_trans = NULL;
+       }
+       return r;
+}
+
+static void ext4_trans_abort(struct ext4_mountpoint *mp)
+{
+       if (mp->fs.jbd_journal && mp->fs.curr_trans) {
+               struct jbd_journal *journal = mp->fs.jbd_journal;
+               struct jbd_trans *trans = mp->fs.curr_trans;
+               jbd_journal_free_trans(journal, trans, true);
+               mp->fs.curr_trans = NULL;
+       }
+}
 
 int ext4_mount_point_stats(const char *mount_point,
                           struct ext4_mount_stats *stats)
@@ -945,6 +1049,7 @@ int ext4_flink(const char *path, const char *hardlink_path)
                return EINVAL;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN,
                               &parent_inode, &name_off);
@@ -974,6 +1079,11 @@ Finish:
        if (child_loaded)
                ext4_fs_put_inode_ref(&child_ref);
 
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 
@@ -993,6 +1103,7 @@ int ext4_frename(const char *path, const char *new_path)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN,
                                &parent_inode, &name_off);
@@ -1031,6 +1142,11 @@ Finish:
        if (child_loaded)
                ext4_fs_put_inode_ref(&child_ref);
 
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 
@@ -1078,9 +1194,12 @@ int ext4_fremove(const char *path)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN,
                               &parent_inode, &name_off);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1088,6 +1207,7 @@ int ext4_fremove(const char *path)
        /*Load parent*/
        r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1096,6 +1216,7 @@ int ext4_fremove(const char *path)
        r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &child);
        if (r != EOK) {
                ext4_fs_put_inode_ref(&parent);
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1130,6 +1251,12 @@ int ext4_fremove(const char *path)
 Finish:
        ext4_fs_put_inode_ref(&child);
        ext4_fs_put_inode_ref(&parent);
+
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1183,9 +1310,17 @@ int ext4_fopen(ext4_file *f, const char *path, const char *flags)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        ext4_block_cache_write_back(mp->fs.bdev, 1);
        r = ext4_generic_open(f, path, flags, true, 0, 0);
        ext4_block_cache_write_back(mp->fs.bdev, 0);
+
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1202,9 +1337,17 @@ int ext4_fopen2(ext4_file *f, const char *path, int flags)
         filetype = EXT4_DE_REG_FILE;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        ext4_block_cache_write_back(mp->fs.bdev, 1);
        r = ext4_generic_open2(f, path, flags, filetype, NULL, NULL);
        ext4_block_cache_write_back(mp->fs.bdev, 0);
+
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1274,7 +1417,14 @@ int ext4_ftruncate(ext4_file *f, uint64_t size)
                return EPERM;
 
        EXT4_MP_LOCK(f->mp);
+
+       ext4_trans_start(f->mp);
        r = ext4_ftruncate_no_lock(f, size);
+       if (r != EOK)
+               ext4_trans_abort(f->mp);
+       else
+               ext4_trans_stop(f->mp);
+
        EXT4_MP_UNLOCK(f->mp);
        return r;
 }
@@ -1292,7 +1442,6 @@ int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
 
        uint8_t *u8_buf = buf;
        int r;
-       struct ext4_block b;
        struct ext4_inode_ref ref;
 
        ext4_assert(f && f->mp);
@@ -1359,15 +1508,11 @@ int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
 
                /* Do we get an unwritten range? */
                if (fblock != 0) {
-                       r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+                       uint64_t off = fblock * block_size + unalg;
+                       r = ext4_block_readbytes(f->mp->fs.bdev, off, u8_buf, len);
                        if (r != EOK)
                                goto Finish;
 
-                       memcpy(u8_buf, b.data + unalg, len);
-
-                       r = ext4_block_set(f->mp->fs.bdev, &b);
-                       if (r != EOK)
-                               goto Finish;
                } else {
                        /* Yes, we do. */
                        memset(u8_buf, 0, len);
@@ -1420,17 +1565,13 @@ int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
        }
 
        if (size) {
+               uint64_t off;
                r = ext4_fs_get_inode_dblk_idx(&ref, iblock_idx, &fblock, true);
                if (r != EOK)
                        goto Finish;
 
-               r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
-               if (r != EOK)
-                       goto Finish;
-
-               memcpy(u8_buf, b.data, size);
-
-               r = ext4_block_set(f->mp->fs.bdev, &b);
+               off = fblock * block_size;
+               r = ext4_block_readbytes(f->mp->fs.bdev, off, u8_buf, size);
                if (r != EOK)
                        goto Finish;
 
@@ -1458,7 +1599,6 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
        ext4_fsblk_t fblk;
        ext4_fsblk_t fblock_start;
 
-       struct ext4_block b;
        struct ext4_inode_ref ref;
        const uint8_t *u8_buf = buf;
        int r, rr = EOK;
@@ -1472,6 +1612,7 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
                return EOK;
 
        EXT4_MP_LOCK(f->mp);
+       ext4_trans_start(f->mp);
 
        struct ext4_fs *const fs = &f->mp->fs;
        struct ext4_sblock *const sb = &f->mp->fs.sb;
@@ -1481,6 +1622,7 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
 
        r = ext4_fs_get_inode_ref(fs, f->inode, &ref);
        if (r != EOK) {
+               ext4_trans_abort(f->mp);
                EXT4_MP_UNLOCK(f->mp);
                return r;
        }
@@ -1497,6 +1639,7 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
 
        if (unalg) {
                size_t len =  size;
+               uint64_t off;
                if (size > (block_size - unalg))
                        len = block_size - unalg;
 
@@ -1504,14 +1647,8 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
                if (r != EOK)
                        goto Finish;
 
-               r = ext4_block_get(f->mp->fs.bdev, &b, fblk);
-               if (r != EOK)
-                       goto Finish;
-
-               memcpy(b.data + unalg, u8_buf, len);
-               ext4_bcache_set_dirty(b.buf);
-
-               r = ext4_block_set(f->mp->fs.bdev, &b);
+               off = fblk * block_size + unalg;
+               r = ext4_block_writebytes(f->mp->fs.bdev, off, u8_buf, len);
                if (r != EOK)
                        goto Finish;
 
@@ -1594,6 +1731,7 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
                goto Finish;
 
        if (size) {
+               uint64_t off;
                if (iblk_idx < ifile_blocks) {
                        r = ext4_fs_init_inode_dblk_idx(&ref, iblk_idx, &fblk);
                        if (r != EOK)
@@ -1605,14 +1743,8 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
                                goto out_fsize;
                }
 
-               r = ext4_block_get(f->mp->fs.bdev, &b, fblk);
-               if (r != EOK)
-                       goto Finish;
-
-               memcpy(b.data, u8_buf, size);
-               ext4_bcache_set_dirty(b.buf);
-
-               r = ext4_block_set(f->mp->fs.bdev, &b);
+               off = fblk * block_size;
+               r = ext4_block_writebytes(f->mp->fs.bdev, off, u8_buf, size);
                if (r != EOK)
                        goto Finish;
 
@@ -1630,7 +1762,13 @@ out_fsize:
        }
 
 Finish:
-       ext4_fs_put_inode_ref(&ref);
+       r = ext4_fs_put_inode_ref(&ref);
+
+       if (r != EOK)
+               ext4_trans_abort(f->mp);
+       else
+               ext4_trans_stop(f->mp);
+
        EXT4_MP_UNLOCK(f->mp);
        return r;
 }
@@ -1683,9 +1821,11 @@ int ext4_chmod(const char *path, uint32_t mode)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1694,6 +1834,7 @@ int ext4_chmod(const char *path, uint32_t mode)
        ext4_fclose(&f);
        r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1701,7 +1842,12 @@ int ext4_chmod(const char *path, uint32_t mode)
        ext4_inode_set_mode(sb, inode_ref.inode, mode);
        inode_ref.dirty = true;
 
-       ext4_fs_put_inode_ref(&inode_ref);
+       r = ext4_fs_put_inode_ref(&inode_ref);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1718,9 +1864,11 @@ int ext4_chown(const char *path, uint32_t uid, uint32_t gid)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1728,6 +1876,7 @@ int ext4_chown(const char *path, uint32_t uid, uint32_t gid)
        ext4_fclose(&f);
        r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1736,7 +1885,12 @@ int ext4_chown(const char *path, uint32_t uid, uint32_t gid)
        ext4_inode_set_gid(inode_ref.inode, gid);
        inode_ref.dirty = true;
 
-       ext4_fs_put_inode_ref(&inode_ref);
+       r = ext4_fs_put_inode_ref(&inode_ref);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1753,9 +1907,11 @@ int ext4_file_set_atime(const char *path, uint32_t atime)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1763,6 +1919,7 @@ int ext4_file_set_atime(const char *path, uint32_t atime)
        ext4_fclose(&f);
        r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1770,7 +1927,12 @@ int ext4_file_set_atime(const char *path, uint32_t atime)
        ext4_inode_set_access_time(inode_ref.inode, atime);
        inode_ref.dirty = true;
 
-       ext4_fs_put_inode_ref(&inode_ref);
+       r = ext4_fs_put_inode_ref(&inode_ref);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1787,9 +1949,11 @@ int ext4_file_set_mtime(const char *path, uint32_t mtime)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1797,6 +1961,7 @@ int ext4_file_set_mtime(const char *path, uint32_t mtime)
        ext4_fclose(&f);
        r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1804,7 +1969,12 @@ int ext4_file_set_mtime(const char *path, uint32_t mtime)
        ext4_inode_set_modif_time(inode_ref.inode, mtime);
        inode_ref.dirty = true;
 
-       ext4_fs_put_inode_ref(&inode_ref);
+       r = ext4_fs_put_inode_ref(&inode_ref);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1821,9 +1991,11 @@ int ext4_file_set_ctime(const char *path, uint32_t ctime)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1831,6 +2003,7 @@ int ext4_file_set_ctime(const char *path, uint32_t ctime)
        ext4_fclose(&f);
        r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -1838,14 +2011,18 @@ int ext4_file_set_ctime(const char *path, uint32_t ctime)
        ext4_inode_set_change_inode_time(inode_ref.inode, ctime);
        inode_ref.dirty = true;
 
-       ext4_fs_put_inode_ref(&inode_ref);
+       r = ext4_fs_put_inode_ref(&inode_ref);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
 
 static int ext4_fsymlink_set(ext4_file *f, const void *buf, uint32_t size)
 {
-       struct ext4_block b;
        struct ext4_inode_ref ref;
        uint32_t sblock;
        ext4_fsblk_t fblock;
@@ -1858,10 +2035,8 @@ static int ext4_fsymlink_set(ext4_file *f, const void *buf, uint32_t size)
                return EOK;
 
        r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
-       if (r != EOK) {
-               EXT4_MP_UNLOCK(f->mp);
+       if (r != EOK)
                return r;
-       }
 
        /*Sync file size*/
        block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
@@ -1889,15 +2064,10 @@ static int ext4_fsymlink_set(ext4_file *f, const void *buf, uint32_t size)
                if (r != EOK)
                        goto Finish;
 
-               r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+               r = ext4_block_writebytes(f->mp->fs.bdev, 0, buf, size);
                if (r != EOK)
                        goto Finish;
 
-               memcpy(b.data, buf, size);
-               ext4_bcache_set_dirty(b.buf);
-               r = ext4_block_set(f->mp->fs.bdev, &b);
-               if (r != EOK)
-                       goto Finish;
        }
 
        /*Stop write back cache mode*/
@@ -1931,6 +2101,8 @@ int ext4_fsymlink(const char *target, const char *path)
        filetype = EXT4_DE_SYMLINK;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        ext4_block_cache_write_back(mp->fs.bdev, 1);
        r = ext4_generic_open2(&f, path, O_RDWR|O_CREAT, filetype, NULL, NULL);
        if (r == EOK)
@@ -1942,6 +2114,12 @@ int ext4_fsymlink(const char *target, const char *path)
 
 Finish:
        ext4_block_cache_write_back(mp->fs.bdev, 0);
+
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1973,6 +2151,11 @@ int ext4_readlink(const char *path, char *buf, size_t bufsize, size_t *rcnt)
 
 Finish:
        ext4_block_cache_write_back(mp->fs.bdev, 0);
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -1998,6 +2181,8 @@ int ext4_setxattr(const char *path, const char *name, size_t name_len,
                return EINVAL;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK)
                goto Finish;
@@ -2020,6 +2205,11 @@ int ext4_setxattr(const char *path, const char *name, size_t name_len,
        ext4_fs_put_xattr_ref(&xattr_ref);
        ext4_fs_put_inode_ref(&inode_ref);
 Finish:
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -2180,6 +2370,8 @@ int ext4_removexattr(const char *path, const char *name, size_t name_len)
                return EINVAL;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
+
        r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
        if (r != EOK)
                goto Finish;
@@ -2202,6 +2394,11 @@ int ext4_removexattr(const char *path, const char *name, size_t name_len)
        ext4_fs_put_xattr_ref(&xattr_ref);
        ext4_fs_put_inode_ref(&inode_ref);
 Finish:
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        EXT4_MP_UNLOCK(mp);
        return r;
 
@@ -2233,12 +2430,14 @@ int ext4_dir_rm(const char *path)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        struct ext4_fs *const fs = &mp->fs;
 
        /*Check if exist.*/
        r = ext4_generic_open(&f, path, "r", false, &inode_up, &name_off);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -2404,6 +2603,12 @@ int ext4_dir_rm(const char *path)
 
        ext4_block_cache_write_back(mp->fs.bdev, 0);
        EXT4_MP_UNLOCK(mp);
+
+       if (r != EOK)
+               ext4_trans_abort(mp);
+       else
+               ext4_trans_stop(mp);
+
        return r;
 }
 
@@ -2418,11 +2623,13 @@ int ext4_dir_mk(const char *path)
                return ENOENT;
 
        EXT4_MP_LOCK(mp);
+       ext4_trans_start(mp);
 
        /*Check if exist.*/
        r = ext4_generic_open(&f, path, "r", false, 0, 0);
        if (r == EOK) {
                /*Directory already created*/
+               ext4_trans_stop(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
@@ -2430,10 +2637,12 @@ int ext4_dir_mk(const char *path)
        /*Create new dir*/
        r = ext4_generic_open(&f, path, "w", false, 0, 0);
        if (r != EOK) {
+               ext4_trans_abort(mp);
                EXT4_MP_UNLOCK(mp);
                return r;
        }
 
+       ext4_trans_stop(mp);
        EXT4_MP_UNLOCK(mp);
        return r;
 }
@@ -2502,7 +2711,7 @@ Finish:
 
 void ext4_dir_entry_rewind(ext4_dir *d)
 {
-    d->next_off = 0;
+       d->next_off = 0;
 }
 
 int ext4_test_journal(const char *mount_point)
@@ -2513,6 +2722,7 @@ int ext4_test_journal(const char *mount_point)
 
        int r = ENOTSUP;
        EXT4_MP_LOCK(mp);
+       ext4_block_cache_write_back(mp->fs.bdev, 1);
        if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_HAS_JOURNAL)) {
                struct jbd_fs *jbd_fs = calloc(1, sizeof(struct jbd_fs));
                struct jbd_journal *journal;
@@ -2540,36 +2750,65 @@ int ext4_test_journal(const char *mount_point)
                        goto Finish;
                }
 
-               ext4_fsblk_t rand_block = rand() % 4096;
-               if (!rand_block)
-                       rand_block = 1;
-               struct ext4_block block;
-               r = ext4_block_get(mp->fs.bdev, &block, rand_block);
-               if (r != EOK)
-                       goto out;
+               int i;
+               for (i = 0;i < 50;i++) {
+                       ext4_fsblk_t rand_block = rand() % 4096;
+                       if (!rand_block)
+                               rand_block = 1;
+                       struct ext4_block block;
+                       r = ext4_block_get(mp->fs.bdev, &block, rand_block);
+                       if (r != EOK)
+                               goto out;
 
-               struct jbd_trans *trans = jbd_journal_new_trans(journal);
-               if (!trans) {
-                       ext4_block_set(mp->fs.bdev, &block);
-                       r = ENOMEM;
-                       goto out;
-               }
-               r = jbd_trans_add_block(trans, &block);
-               if (r != EOK) {
-                       jbd_journal_free_trans(journal, trans, true);
+                       struct jbd_trans *t = jbd_journal_new_trans(journal);
+                       if (!t) {
+                               ext4_block_set(mp->fs.bdev, &block);
+                               r = ENOMEM;
+                               goto out;
+                       }
+
+                       switch (rand() % 2) {
+                       case 0:
+                               r = jbd_trans_get_access(journal, t, &block);
+                               if (r != EOK) {
+                                       jbd_journal_free_trans(journal, t,
+                                                              true);
+                                       ext4_block_set(mp->fs.bdev, &block);
+                                       r = ENOMEM;
+                                       goto out;
+                               }
+                               r = jbd_trans_set_block_dirty(t, &block);
+                               if (r != EOK) {
+                                       jbd_journal_free_trans(journal, t,
+                                                              true);
+                                       ext4_block_set(mp->fs.bdev, &block);
+                                       r = ENOMEM;
+                                       goto out;
+                               }
+                               break;
+                       case 1:
+                               r = jbd_trans_try_revoke_block(t, rand_block);
+                               if (r != EOK) {
+                                       jbd_journal_free_trans(journal, t,
+                                                              true);
+                                       ext4_block_set(mp->fs.bdev, &block);
+                                       r = ENOMEM;
+                                       goto out;
+                               }
+                       }
                        ext4_block_set(mp->fs.bdev, &block);
-                       r = ENOMEM;
-                       goto out;
+                       jbd_journal_submit_trans(journal, t);
+                       jbd_journal_commit_one(journal);
                }
-               jbd_journal_submit_trans(journal, trans);
-               jbd_journal_commit_one(journal);
 out:
+               jbd_journal_stop(journal);
                jbd_put_fs(jbd_fs);
                free(journal);
                free(jbd_fs);
        }
 
 Finish:
+       ext4_block_cache_write_back(mp->fs.bdev, 0);
        EXT4_MP_UNLOCK(mp);
        return r;
 }