Merge branch 'journal-v6'

This patchset adds journal support into simplefs using jbd2, the only available journal is external (you could create it using mke2fs -O journal_dev, for more info look into simple-test.sh), and the only spot that have start/write_access/dirty_metadata/stop is simplefs_write() (IOW no support for creation). This branch is compacted, for more verbose versions of this patchset please look into more older version (v4, v3, ...). Here is the example of records in journal: ==> final-jbd2-ext4.logdump <== logdump Journal starts at block 1, transaction 4 Found expected sequence 4, type 1 (descriptor block) at block 1 Found expected sequence 4, type 2 (commit block) at block 16 Found expected sequence 5, type 1 (descriptor block) at block 17 Found expected sequence 5, type 2 (commit block) at block 19 Found expected sequence 6, type 1 (descriptor block) at block 20 Found expected sequence 6, type 2 (commit block) at block 22 No magic number at block 23: end of journal. ==> final-jbd2-simplefs.logdump <== debugfs: logdump -f /dev/loop0 Ext2 superblock header found. Journal starts at block 2, transaction 2 Found expected sequence 2, type 1 (descriptor block) at block 2 Found expected sequence 2, type 2 (commit block) at block 4 Found expected sequence 3, type 1 (descriptor block) at block 5 Found expected sequence 3, type 2 (commit block) at block 7 Found expected sequence 4, type 1 (descriptor block) at block 8 Found expected sequence 4, type 2 (commit block) at block 10 Found expected sequence 5, type 1 (descriptor block) at block 11 Found expected sequence 5, type 2 (commit block) at block 13 Found expected sequence 6, type 1 (descriptor block) at block 14 Found expected sequence 6, type 2 (commit block) at block 16 Found expected sequence 7, type 1 (descriptor block) at block 17 Found expected sequence 7, type 2 (commit block) at block 19 Found expected sequence 8, type 1 (descriptor block) at block 20 Found expected sequence 8, type 2 (commit block) at block 22 No magic number at block 23: end of journal. * journal-v6: simplefs_write: install h_sync (sync on close) for jbd2 handle Use max available journal size with jbd2_journal_init_dev() simple-test: create journal with 4k block size simple-test: use losetup+journal_path=/dev/loopX for mounting with journal Handle bdevs for journal_path= mount flag Actually load journal by calling jbd2_journal_load() simple-test: mount fs with journal Implement journal_path option Add loader for internal journal (we need to update mkfs to support this) Add sfs_trace for lookup and compare inside it simple-test: enable jbd2-debug Check that journal was initialized successfully Write journal device name Implement external journal device instead of internal simplefs_write: add journaling using jbd2 Initial support of journaling
2025-07-27 07:54:15 +02:00 · 2014-10-02 02:22:29 +04:00 · 2014-10-02 02:22:29 +04:00 · 5d00eebd45
commit 5d00eebd45
parent 072ef5bff6 4c486f751b
4 changed files with 281 additions and 45 deletions
--- a/mkfs-simplefs.c
+++ b/mkfs-simplefs.c
@ -9,8 +9,8 @@

 #include "simple.h"

-const uint64_t WELCOMEFILE_DATABLOCK_NUMBER = 3;
-const uint64_t WELCOMEFILE_INODE_NUMBER = 2;
+#define WELCOMEFILE_DATABLOCK_NUMBER (SIMPLEFS_LAST_RESERVED_BLOCK + 1)
+#define WELCOMEFILE_INODE_NUMBER (SIMPLEFS_LAST_RESERVED_INODE + 1)

 static int write_superblock(int fd)
 {
@ -18,10 +18,9 @@ static int write_superblock(int fd)
 		.version = 1,
 		.magic = SIMPLEFS_MAGIC,
 		.block_size = SIMPLEFS_DEFAULT_BLOCK_SIZE,
-		/* One inode for rootdirectory and another for a welcome file that we are going to create */
-		.inodes_count = 2,
+		.inodes_count = WELCOMEFILE_INODE_NUMBER,
 		/* FIXME: Free blocks management is not implemented yet */
-		.free_blocks = (~0) & ~(1 << WELCOMEFILE_DATABLOCK_NUMBER),
+		.free_blocks = (~0) & ~(1 << SIMPLEFS_LAST_RESERVED_BLOCK),
 	};
 	ssize_t ret;

@ -37,7 +36,7 @@ static int write_superblock(int fd)
 	return 0;
 }

-static int write_inode_store(int fd)
+static int write_root_inode(int fd)
 {
 	ssize_t ret;

@ -59,8 +58,26 @@ static int write_inode_store(int fd)
 	printf("root directory inode written succesfully\n");
 	return 0;
 }
+static int write_journal_inode(int fd)
+{
+	ssize_t ret;

-static int write_inode(int fd, const struct simplefs_inode *i)
+	struct simplefs_inode journal;
+
+	journal.inode_no = SIMPLEFS_JOURNAL_INODE_NUMBER;
+	journal.data_block_number = SIMPLEFS_JOURNAL_BLOCK_NUMBER;
+
+	ret = write(fd, &journal, sizeof(journal));
+
+	if (ret != sizeof(journal)) {
+		printf("Error while writing journal inode. Retry your mkfs\n");
+		return -1;
+	}
+
+	printf("journal inode written succesfully\n");
+	return 0;
+}
+static int write_welcome_inode(int fd, const struct simplefs_inode *i)
 {
 	off_t nbytes;
 	ssize_t ret;
@ -73,7 +90,7 @@ static int write_inode(int fd, const struct simplefs_inode *i)
 	}
 	printf("welcomefile inode written succesfully\n");

-	nbytes = SIMPLEFS_DEFAULT_BLOCK_SIZE - sizeof(*i) - sizeof(*i);
+	nbytes = SIMPLEFS_DEFAULT_BLOCK_SIZE - (sizeof(*i) * 3);
 	ret = lseek(fd, nbytes, SEEK_CUR);
 	if (ret == (off_t)-1) {
 		printf
@ -82,9 +99,23 @@ static int write_inode(int fd, const struct simplefs_inode *i)
 	}

 	printf
-	    ("inode store padding bytes (after the two inodes) written sucessfully\n");
+	    ("inode store padding bytes (after the three inodes) written sucessfully\n");
 	return 0;
 }
+
+int write_journal(int fd)
+{
+	ssize_t ret;
+	ret = lseek(fd, SIMPLEFS_DEFAULT_BLOCK_SIZE * SIMPLEFS_JOURNAL_BLOCKS, SEEK_CUR);
+	if (ret == (off_t)-1) {
+		printf("Can't write journal. Retry you mkfs\n");
+		return -1;
+	}
+
+	printf("Journal written successfully\n");
+	return 0;
+}
+
 int write_dirent(int fd, const struct simplefs_dir_record *record)
 {
 	ssize_t nbytes = sizeof(*record), ret;
@ -154,11 +185,17 @@ int main(int argc, char *argv[])
 	do {
 		if (write_superblock(fd))
 			break;
-		if (write_inode_store(fd))
+
+		if (write_root_inode(fd))
+			break;
+		if (write_journal_inode(fd))
+			break;
+		if (write_welcome_inode(fd, &welcome))
 			break;

-		if (write_inode(fd, &welcome))
+		if (write_journal(fd))
 			break;
+
 		if (write_dirent(fd, &record))
 			break;
 		if (write_block(fd, welcomefile_body, welcome.file_size))
--- a/simple-test.sh
+++ b/simple-test.sh
@ -15,10 +15,18 @@

 set -e

+echo 1 >| /sys/module/jbd2/parameters/jbd2_debug
+
 root_pwd="$PWD"
 test_dir="test-dir-$RANDOM"
 test_mount_point="test-mount-point-$RANDOM"
+test_journal_dev=""

+function create_journal()
+{
+    dd bs=1M count=10 if=/dev/zero of="$1"
+    mke2fs -b 4096 -O journal_dev "$1"
+}
 function create_test_image()
 {
    dd bs=4096 count=100 if=/dev/zero of="$1"
@ -27,12 +35,14 @@ function create_test_image()
 function mount_fs_image()
 {
    insmod simplefs.ko
-    mount -o loop,owner,group,users -t simplefs "$1" "$2"
+    test_journal_dev=$(losetup -f --show "$1")
+    mount -o loop,owner,group,users,journal_path="$test_journal_dev" -t simplefs "$2" "$3"
    dmesg | tail -n20
 }
 function unmount_fs()
 {
    umount "$1"
+    losetup -d $test_journal_dev
    rmmod simplefs.ko
    dmesg | tail -n20
 }
@ -106,15 +116,16 @@ cleanup
 trap cleanup SIGINT EXIT
 mkdir "$test_dir" "$test_mount_point"
 create_test_image "$test_dir/image"
+create_journal "$test_dir/journal"

 # 1
-mount_fs_image "$test_dir/image" "$test_mount_point"
+mount_fs_image "$test_dir/journal" "$test_dir/image" "$test_mount_point"
 do_some_operations "$test_mount_point"
 cd "$root_pwd"
 unmount_fs "$test_mount_point"

 # 2
-mount_fs_image "$test_dir/image" "$test_mount_point"
+mount_fs_image "$test_dir/journal" "$test_dir/image" "$test_mount_point"
 do_read_operations "$test_mount_point"
 cd "$root_pwd"
 unmount_fs "$test_mount_point"
--- a/simple.c
+++ b/simple.c
@ -10,10 +10,14 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/namei.h>
 #include <linux/buffer_head.h>
 #include <linux/slab.h>
 #include <linux/random.h>
 #include <linux/version.h>
+#include <linux/jbd2.h>
+#include <linux/parser.h>
+#include <linux/blkdev.h>

 #include "super.h"

@ -358,19 +362,25 @@ ssize_t simplefs_write(struct file * filp, const char __user * buf, size_t len,
 	struct simplefs_inode *sfs_inode;
 	struct buffer_head *bh;
 	struct super_block *sb;
+	struct simplefs_super_block *sfs_sb;
+	handle_t *handle;

 	char *buffer;

 	int retval;

+	sb = filp->f_path.dentry->d_inode->i_sb;
+	sfs_sb = SIMPLEFS_SB(sb);
+
+	handle = jbd2_journal_start(sfs_sb->journal, 1);
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
 	retval = generic_write_checks(filp, ppos, &len, 0);
-	if (retval) {
+	if (retval)
 		return retval;
-	}

 	inode = filp->f_path.dentry->d_inode;
 	sfs_inode = SIMPLEFS_INODE(inode);
-	sb = inode->i_sb;

 	bh = sb_bread(filp->f_path.dentry->d_inode->i_sb,
 					    sfs_inode->data_block_number);
@ -385,6 +395,13 @@ ssize_t simplefs_write(struct file * filp, const char __user * buf, size_t len,
 	/* Move the pointer until the required byte offset */
 	buffer += *ppos;

+	retval = jbd2_journal_get_write_access(handle, bh);
+	if (WARN_ON(retval)) {
+		brelse(bh);
+		sfs_trace("Can't get write access for bh\n");
+		return retval;
+	}
+
 	if (copy_from_user(buffer, buf, len)) {
 		brelse(bh);
 		printk(KERN_ERR
@ -393,6 +410,18 @@ ssize_t simplefs_write(struct file * filp, const char __user * buf, size_t len,
 	}
 	*ppos += len;

+	retval = jbd2_journal_dirty_metadata(handle, bh);
+	if (WARN_ON(retval)) {
+		brelse(bh);
+		return retval;
+	}
+	handle->h_sync = 1;
+	retval = jbd2_journal_stop(handle);
+	if (WARN_ON(retval)) {
+		brelse(bh);
+		return retval;
+	}
+
 	mark_buffer_dirty(bh);
 	sync_dirty_buffer(bh);
 	brelse(bh);
@ -584,41 +613,21 @@ static int simplefs_create(struct inode *dir, struct dentry *dentry,
 	return simplefs_create_fs_object(dir, dentry, mode);
 }

-struct dentry *simplefs_lookup(struct inode *parent_inode,
-			       struct dentry *child_dentry, unsigned int flags)
+static struct inode *simplefs_iget(struct super_block *sb, int ino)
 {
-	struct simplefs_inode *parent = SIMPLEFS_INODE(parent_inode);
-	struct super_block *sb = parent_inode->i_sb;
-	struct buffer_head *bh;
-	struct simplefs_dir_record *record;
-	int i;
-
-	bh = sb_bread(sb, parent->data_block_number);
-	BUG_ON(!bh);
-
-	record = (struct simplefs_dir_record *)bh->b_data;
-	for (i = 0; i < parent->dir_children_count; i++) {
-		if (!strcmp(record->filename, child_dentry->d_name.name)) {
-			/* FIXME: There is a corner case where if an allocated inode,
-			 * is not written to the inode store, but the inodes_count is
-			 * incremented. Then if the random string on the disk matches
-			 * with the filename that we are comparing above, then we
-			 * will use an invalid uninitialized inode */
-
 	struct inode *inode;
 	struct simplefs_inode *sfs_inode;

-			sfs_inode = simplefs_get_inode(sb, record->inode_no);
+	sfs_inode = simplefs_get_inode(sb, ino);

 	inode = new_inode(sb);
-			inode->i_ino = record->inode_no;
-			inode_init_owner(inode, parent_inode, sfs_inode->mode);
+	inode->i_ino = ino;
 	inode->i_sb = sb;
 	inode->i_op = &simplefs_inode_ops;

-			if (S_ISDIR(inode->i_mode))
+	if (S_ISDIR(sfs_inode->mode))
 		inode->i_fop = &simplefs_dir_operations;
-			else if (S_ISREG(inode->i_mode))
+	else if (S_ISREG(sfs_inode->mode) || ino == SIMPLEFS_JOURNAL_INODE_NUMBER)
 		inode->i_fop = &simplefs_file_operations;
 	else
 		printk(KERN_ERR
@ -630,6 +639,37 @@ struct dentry *simplefs_lookup(struct inode *parent_inode,

 	inode->i_private = sfs_inode;

+	return inode;
+}
+
+struct dentry *simplefs_lookup(struct inode *parent_inode,
+			       struct dentry *child_dentry, unsigned int flags)
+{
+	struct simplefs_inode *parent = SIMPLEFS_INODE(parent_inode);
+	struct super_block *sb = parent_inode->i_sb;
+	struct buffer_head *bh;
+	struct simplefs_dir_record *record;
+	int i;
+
+	bh = sb_bread(sb, parent->data_block_number);
+	BUG_ON(!bh);
+	sfs_trace("Lookup in: ino=%llu, b=%llu\n",
+				parent->inode_no, parent->data_block_number);
+
+	record = (struct simplefs_dir_record *)bh->b_data;
+	for (i = 0; i < parent->dir_children_count; i++) {
+		sfs_trace("Have file: '%s' (ino=%llu)\n",
+					record->filename, record->inode_no);
+
+		if (!strcmp(record->filename, child_dentry->d_name.name)) {
+			/* FIXME: There is a corner case where if an allocated inode,
+			 * is not written to the inode store, but the inodes_count is
+			 * incremented. Then if the random string on the disk matches
+			 * with the filename that we are comparing above, then we
+			 * will use an invalid uninitialized inode */
+
+			struct inode *inode = simplefs_iget(sb, record->inode_no);
+			inode_init_owner(inode, parent_inode, SIMPLEFS_INODE(inode)->mode);
 			d_add(child_dentry, inode);
 			return NULL;
 		}
@ -656,10 +696,130 @@ void simplefs_destory_inode(struct inode *inode)
 	kmem_cache_free(sfs_inode_cachep, sfs_inode);
 }

+static void simplefs_put_super(struct super_block *sb)
+{
+	struct simplefs_super_block *sfs_sb = SIMPLEFS_SB(sb);
+	if (sfs_sb->journal)
+		WARN_ON(jbd2_journal_destroy(sfs_sb->journal) < 0);
+	sfs_sb->journal = NULL;
+}
+
 static const struct super_operations simplefs_sops = {
 	.destroy_inode = simplefs_destory_inode,
+	.put_super = simplefs_put_super,
 };

+static int simplefs_load_journal(struct super_block *sb, int devnum)
+{
+	struct journal_s *journal;
+	char b[BDEVNAME_SIZE];
+	dev_t dev;
+	struct block_device *bdev;
+	int hblock, blocksize, len;
+	struct simplefs_super_block *sfs_sb = SIMPLEFS_SB(sb);
+
+	dev = new_decode_dev(devnum);
+	printk(KERN_INFO "Journal device is: %s\n", __bdevname(dev, b));
+
+	bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
+	if (IS_ERR(bdev))
+		return 1;
+	blocksize = sb->s_blocksize;
+	hblock = bdev_logical_block_size(bdev);
+	len = SIMPLEFS_MAX_FILESYSTEM_OBJECTS_SUPPORTED;
+
+	journal = jbd2_journal_init_dev(bdev, sb->s_bdev, 1, -1, blocksize);
+	if (!journal) {
+		printk(KERN_ERR "Can't load journal\n");
+		return 1;
+	}
+	journal->j_private = sb;
+
+	sfs_sb->journal = journal;
+
+	return 0;
+}
+static int simplefs_sb_load_journal(struct super_block *sb, struct inode *inode)
+{
+	struct journal_s *journal;
+	struct simplefs_super_block *sfs_sb = SIMPLEFS_SB(sb);
+
+	journal = jbd2_journal_init_inode(inode);
+	if (!journal) {
+		printk(KERN_ERR "Can't load journal\n");
+		return 1;
+	}
+	journal->j_private = sb;
+
+	sfs_sb->journal = journal;
+
+	return 0;
+}
+
+#define SIMPLEFS_OPT_JOURNAL_DEV 1
+#define SIMPLEFS_OPT_JOURNAL_PATH 2
+static const match_table_t tokens = {
+	{SIMPLEFS_OPT_JOURNAL_DEV, "journal_dev=%u"},
+	{SIMPLEFS_OPT_JOURNAL_PATH, "journal_path=%s"},
+};
+static int simplefs_parse_options(struct super_block *sb, char *options)
+{
+	substring_t args[MAX_OPT_ARGS];
+	int token, ret, arg;
+	char *p;
+
+	while ((p = strsep(&options, ",")) != NULL) {
+		if (!*p)
+			continue;
+
+		args[0].to = args[0].from = NULL;
+		token = match_token(p, tokens, args);
+
+		switch (token) {
+			case SIMPLEFS_OPT_JOURNAL_DEV:
+				if (args->from && match_int(args, &arg))
+					return 1;
+				printk(KERN_INFO "Loading journal devnum: %i\n", arg);
+				if ((ret = simplefs_load_journal(sb, arg)))
+					return ret;
+				break;
+
+			case SIMPLEFS_OPT_JOURNAL_PATH:
+			{
+				char *journal_path;
+				struct inode *journal_inode;
+				struct path path;
+
+				BUG_ON(!(journal_path = match_strdup(&args[0])));
+				ret = kern_path(journal_path, LOOKUP_FOLLOW, &path);
+				if (ret) {
+					printk(KERN_ERR "could not find journal device path: error %d\n", ret);
+					kfree(journal_path);
+				}
+
+				journal_inode = path.dentry->d_inode;
+
+				path_put(&path);
+				kfree(journal_path);
+
+				if (S_ISBLK(journal_inode->i_mode)) {
+					unsigned long journal_devnum = new_encode_dev(journal_inode->i_rdev);
+					if ((ret = simplefs_load_journal(sb, journal_devnum)))
+						return ret;
+				} else {
+					/** Seems didn't work properly */
+					if ((ret = simplefs_sb_load_journal(sb, journal_inode)))
+						return ret;
+				}
+
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+
 /* This function, as the name implies, Makes the super_block valid and
 * fills filesystem specific information in the super block */
 int simplefs_fill_super(struct super_block *sb, void *data, int silent)
@ -688,6 +848,8 @@ int simplefs_fill_super(struct super_block *sb, void *data, int silent)
 		       "simplefs seem to be formatted using a non-standard block size.");
 		goto release;
 	}
+	/** XXX: Avoid this hack, by adding one more sb wrapper, but non-disk */
+	sb_disk->journal = NULL;

 	printk(KERN_INFO
 	       "simplefs filesystem of version [%llu] formatted with a block size of [%llu] detected in the device.\n",
@ -728,7 +890,18 @@ int simplefs_fill_super(struct super_block *sb, void *data, int silent)
 		goto release;
 	}

-	ret = 0;
+	if ((ret = simplefs_parse_options(sb, data)))
+		goto release;
+
+	if (!sb_disk->journal) {
+		struct inode *journal_inode;
+		journal_inode = simplefs_iget(sb, SIMPLEFS_JOURNAL_INODE_NUMBER);
+
+		ret = simplefs_sb_load_journal(sb, journal_inode);
+		goto release;
+	}
+	ret = jbd2_journal_load(sb_disk->journal);
+
 release:
 	brelse(bh);

--- a/simple.h
+++ b/simple.h
@ -1,6 +1,8 @@


 #define SIMPLEFS_MAGIC 0x10032013
+#define SIMPLEFS_JOURNAL_MAGIC = 0x20032013
+
 #define SIMPLEFS_DEFAULT_BLOCK_SIZE 4096
 #define SIMPLEFS_FILENAME_MAXLEN 255
 #define SIMPLEFS_START_INO 10
@ -32,9 +34,17 @@ const int SIMPLEFS_SUPERBLOCK_BLOCK_NUMBER = 0;
 /* The disk block where the inodes are stored */
 const int SIMPLEFS_INODESTORE_BLOCK_NUMBER = 1;

+/** Journal settings */
+const int SIMPLEFS_JOURNAL_INODE_NUMBER = 2;
+const int SIMPLEFS_JOURNAL_BLOCK_NUMBER = 2;
+const int SIMPLEFS_JOURNAL_BLOCKS = 2;
+
 /* The disk block where the name+inode_number pairs of the
 * contents of the root directory are stored */
-const int SIMPLEFS_ROOTDIR_DATABLOCK_NUMBER = 2;
+const int SIMPLEFS_ROOTDIR_DATABLOCK_NUMBER = 4;
+
+#define SIMPLEFS_LAST_RESERVED_BLOCK SIMPLEFS_ROOTDIR_DATABLOCK_NUMBER
+#define SIMPLEFS_LAST_RESERVED_INODE SIMPLEFS_JOURNAL_INODE_NUMBER

 /* The name+inode_number pair for each file in a directory.
 * This gets stored as the data for a directory */
@ -63,6 +73,8 @@ const int SIMPLEFS_MAX_FILESYSTEM_OBJECTS_SUPPORTED = 64;
 /* FIXME: Move the struct to its own file and not expose the members
 * Always access using the simplefs_sb_* functions and
 * do not access the members directly */
+
+struct journal_s;
 struct simplefs_super_block {
 	uint64_t version;
 	uint64_t magic;
@ -73,5 +85,8 @@ struct simplefs_super_block {

 	uint64_t free_blocks;

-	char padding[SIMPLEFS_DEFAULT_BLOCK_SIZE - (5 * sizeof(uint64_t))];
+	/** FIXME: move this into separate struct */
+	struct journal_s *journal;
+
+	char padding[4048];
 };