Patchwork [U-Boot,2/2] ext4fs write support

login
register
mail settings
Submitter uma.shankar@samsung.com
Date Dec. 15, 2011, 5:39 p.m.
Message ID <1323970793-23858-1-git-send-email-uma.shankar@samsung.com>
Download mbox | patch
Permalink /patch/131519/
State Changes Requested
Headers show

Comments

uma.shankar@samsung.com - Dec. 15, 2011, 5:39 p.m.
From: Uma Shankar <uma.shankar@samsung.com>

Signed-off-by: Uma Shankar <uma.shankar@samsung.com>
Signed-off-by: Manjunatha C Achar <a.manjunatha@samsung.com>
Signed-off-by: Iqbal Shareef <iqbal.ams@samsung.com>
Signed-off-by: Hakgoo Lee <goodguy.lee@samsung.com>
---
 common/cmd_ext4.c      |  135 +++++
 fs/ext4/Makefile       |    2 +-
 fs/ext4/crc16.c        |   62 +++
 fs/ext4/crc16.h        |   16 +
 fs/ext4/ext4_common.c  | 1386 +++++++++++++++++++++++++++++++++++++++++++++++-
 fs/ext4/ext4_common.h  |   17 +
 fs/ext4/ext4_journal.c |  650 +++++++++++++++++++++++
 fs/ext4/ext4_journal.h |  147 +++++
 fs/ext4/ext4fs.c       | 1038 ++++++++++++++++++++++++++++++++++++-
 include/ext4fs.h       |    8 +
 10 files changed, 3457 insertions(+), 4 deletions(-)
 create mode 100644 fs/ext4/crc16.c
 create mode 100644 fs/ext4/crc16.h
 create mode 100644 fs/ext4/ext4_journal.c
 create mode 100644 fs/ext4/ext4_journal.h
Kim Phillips - Dec. 15, 2011, 10:20 p.m.
On Thu, 15 Dec 2011 23:09:53 +0530
<uma.shankar@samsung.com> wrote:

>  fs/ext4/crc16.c        |   62 +++
>  fs/ext4/crc16.h        |   16 +

there are already three crc16 implementations in u-boot according to
my count.  Please let's not add a fourth - hopefully the only thing
wrong with using lib/crc16.c was that you weren't aware it existed.

> +	/*get the filename */

> +	/*get the address in hexadecimal format (string to int) */

> +	/*get the filesize in base 10 format */

> +	/*set the device as block device */

> +	/*register the device and partition */

> +	/*get the partition information */

> +	/*mount the filesystem */

> +	/*start write */

space after the /*

> +	if (status)
> +		*ptr = *ptr & ~(operand);
> +	return;

> +	}
> +	return crc;

insert blank line before return statements

> +static int check_void_in_dentry(struct ext2_dirent *dir, char *filename)

> +	dentry_length = sizeof(struct ext2_dirent) +
> +	    dir->namelen + padding_factor;

alignment

> +	sizeof_void_space = dir->direntlen - dentry_length;
> +	if (sizeof_void_space == 0) {
> +		return 0;
> +	} else {
> +		padding_factor = 0;

if (sizeof_void_space == 0)
	return 0;

padding_factor = 0;
...

> +		new_entry_byte_reqd = strlen(filename) +
> +		    sizeof(struct ext2_dirent) + padding_factor;

alignment

> +		if (sizeof_void_space >= new_entry_byte_reqd) {
> +			dir->direntlen = dentry_length;
> +			return sizeof_void_space;
> +		} else
> +			return 0;

if (sizeof_void_space >= new_entry_byte_reqd) {
	dir->direntlen = dentry_length;
	return sizeof_void_space;
}

return 0;

> +	/*##START: Update the root directory entry block of root inode ### */
> +	/*since we are populating this file under  root
> +	 *directory take the root inode and its first block
> +	 *currently we are looking only in first block of root
> +	 *inode*/

/*
 * multi-line comments
 * are formatted
 * like this
 */


> +	zero_buffer = xzalloc(fs->blksz);
> +	if (!zero_buffer)
> +		return;

> +	root_first_block_buffer = (char *)xzalloc(fs->blksz);
> +	if (!root_first_block_buffer)
> +		return;

first time reviewing fs code, can this fn be modified to return an
error code?  If not, at least print something.

> +RESTART:

labels in lowercase

> +	status = ext2fs_devread(first_block_no_of_root
> +				* fs->sect_perblk,

operator at end of prior line

> +				0, fs->blksz, root_first_block_buffer);
> +	if (status == 0)
> +		goto fail;
> +	else {
> +		if (log_journal(root_first_block_buffer,

if (...)
	goto fail;

if (log_journal(...

this will save horizontal space for some tightly right-justified
code under it.

> +				last_entry_dirlen = dir->namelen +
> +				    sizeof(struct ext2_dirent) + padding_factor;

alignment

> +				if ((fs->blksz - totalbytes - last_entry_dirlen)
> +				    < new_entry_byte_reqd) {

operator on prior line

> +					printf("1st Block Full:"
> +					"allocating new block\n");

here,

> +					if (direct_blk_idx ==
> +					    INDIRECT_BLOCKS - 1) {
> +						printf("Directory capacity"
> +						"exceeds the limit\n");

here,

> +						goto fail;
> +					}
> +					g_parent_inode->b.blocks.dir_blocks
> +					    [direct_blk_idx] = get_new_blk_no();
> +					if (g_parent_inode->b.blocks.dir_blocks
> +					    [direct_blk_idx] == -1) {
> +						printf("no block"
> +							"left to assign\n");

and here, this prevents users trying to grep for this error text - I believe
it's allowed to exceed 80 columns in this case.

> +	/*END: Update the root directory entry block of root inode */

is some tool you're using supposed to correlate this with the above?:

/*##START: Update the root directory entry block of root inode ### */

If so, we (or certainly I) don't use it, and therefore don't care
for it - please remove it, and any other instances.

> +	/*get the first block of root */
> +	/*read the block no allocated to a file */

fix comment format

> +		status = ext2fs_devread(blknr * fs->sect_perblk,
> +					0, fs->blksz, (char *)block_buffer);
> +		if (status == 0)
> +			goto fail;
> +		else {

again, rm the else to avoid unnecessary indentation

> +			while (dir->direntlen >= 0) {
> +				/*blocksize-totalbytes because last directory
> +				 *length i.e.,*dir->direntlen is free availble
> +				 *space in the block that means
> +				 *it is a last entry of directory entry
> +				 */

fix comment format


> +	/*add root */
> +	arr[i] = xzalloc(strlen("/") + 1);
> +	if (!arr[i])
> +		return -1;

return -ENOMEM?

> +int iget(int inode_no, struct ext2_inode *inode)
> +{
> +	if (ext4fs_read_inode(ext4fs_root, inode_no, inode) == 0)
> +		return -1;
> +	else
> +		return 0;
> +}

rm else

> +fail:
> +	if (depth_dirname)
> +		free(depth_dirname);
> +	if (parse_dirname)
> +		free(parse_dirname);
> +	if (ptr)
> +		free(ptr);
> +	if (parent_inode)
> +		free(parent_inode);
> +	if (first_inode)
> +		free(first_inode);

free(0) is already protected for you

> +	/*single indirect */
> +	unsigned int *SI_buffer = NULL;
> +	long int SI_blockno;
> +	unsigned int *SI_start_addr = NULL;

no caps in variable names

> +	/*allocation of direct blocks */

this

> +	/*allocation of single indirect blocks */
> +	alloc_single_indirect_block(file_inode, &total_remaining_blocks,
> +				    &no_blks_reqd);
> +
> +	/*allocation of double indirect blocks */
> +	alloc_double_indirect_block(file_inode, &total_remaining_blocks,
> +				    &no_blks_reqd);
> +
> +	/*allocation of triple indirect blocks */
> +	alloc_triple_indirect_block(file_inode, &total_remaining_blocks,
> +				    &no_blks_reqd);

and these three comments don't seem to add any real value, given the
names of the functions.

> +	if (inode->b.blocks.tripple_indir_block != 0) {
> +		TIGP_buffer = (unsigned int *)xzalloc(fs->blksz);

s/tripple/triple/g

s/TIGP/tigp/g

also buy horizontal indentation space via

	if (inode->b.blocks.tripple_indir_block == 0)
		goto fail;
	TIGP_buffer = (unsigned int *)xzalloc(fs->blksz);
	...

> +				if (fs->blksz != 1024) {
> +					bg_idx = (*TIP_buffer) / (uint32_t)
> +					    ext4fs_root->sblock.
> +					    blocks_per_group;

also assign ext4fs_root->sblock.blocks_per_group to a function local
variable, to avoid tight right-justification like this.

This is a lot of code with recurring CodingStyle review patterns, so
I'm stopping my review here.  Please detect and fix the other
occurrences and resubmit.

Thank you for your contribution!

Kim
Mike Frysinger - Dec. 16, 2011, 4:10 p.m.
this needs to be behind a CONFIG_EXT4_WRITE or something similar.  most people 
want to read their fs's, not write them.
-mike

Patch

diff --git a/common/cmd_ext4.c b/common/cmd_ext4.c
index 7c2d541..781c6fe 100644
--- a/common/cmd_ext4.c
+++ b/common/cmd_ext4.c
@@ -47,11 +47,53 @@ 
 
 uint64_t total_sector;
 uint64_t part_offset;
+static unsigned long part_size;
+static int cur_part = 1;
 
 #define DOS_PART_MAGIC_OFFSET		0x1fe
 #define DOS_FS_TYPE_OFFSET		0x36
 #define DOS_FS32_TYPE_OFFSET		0x52
 
+static int ext4_register_device(block_dev_desc_t *dev_desc, int part_no)
+{
+	unsigned char buffer[SECTOR_SIZE];
+	disk_partition_t info;
+
+	if (!dev_desc->block_read)
+		return -1;
+
+	/* check if we have a MBR (on floppies we have only a PBR) */
+	if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) buffer) != 1) {
+		printf("** Can't read from device %d **\n", dev_desc->dev);
+		return -1;
+	}
+	if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
+	    buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) {
+		/* no signature found */
+		return -1;
+	}
+
+	/* First we assume there is a MBR */
+	if (!get_partition_info(dev_desc, part_no, &info)) {
+		part_offset = info.start;
+		cur_part = part_no;
+		part_size = info.size;
+	} else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET],
+			    "FAT", 3) == 0) || (strncmp((char *)&buffer
+							[DOS_FS32_TYPE_OFFSET],
+							"FAT32", 5) == 0)) {
+		/* ok, we assume we are on a PBR only */
+		cur_part = 1;
+		part_offset = 0;
+	} else {
+		printf("** Partition %d not valid on device %d **\n",
+		       part_no, dev_desc->dev);
+		return -1;
+	}
+
+	return 0;
+}
+
 int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 {
 	char *filename = NULL;
@@ -241,6 +283,94 @@  int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	return 0;
 }
 
+int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+{
+	char *filename = "/";
+	int part_length;
+	unsigned long part = 1;
+	int dev = 0;
+	char *ep;
+	unsigned long ram_address;
+	unsigned long file_size;
+	disk_partition_t info;
+	struct ext_filesystem *fs;
+
+	if (argc < 6)
+		return cmd_usage(cmdtp);
+
+	dev = (int)simple_strtoul(argv[2], &ep, 16);
+	ext4_dev_desc = get_dev(argv[1], dev);
+	if (ext4_dev_desc == NULL) {
+		printf("Block device %s %d not"
+			"supported\n", argv[1], dev);
+		return 1;
+	}
+	if (init_fs(ext4_dev_desc))
+		return 1;
+
+	fs = get_fs();
+	if (*ep) {
+		if (*ep != ':') {
+			puts("Invalid boot device, use `dev[:part]'\n");
+			goto fail;
+		}
+		(int)strict_strtoul(++ep, 16, &part);
+	}
+
+	/*get the filename */
+	filename = argv[3];
+
+	/*get the address in hexadecimal format (string to int) */
+	strict_strtoul(argv[4], 16, &ram_address);
+
+	/*get the filesize in base 10 format */
+	strict_strtoul(argv[5], 10, &file_size);
+
+	/*set the device as block device */
+	part_length = ext2fs_set_blk_dev(fs->dev_desc, part);
+	if (part_length == 0) {
+		printf("Bad partition - %s %d:%lu\n", argv[1], dev, part);
+		goto fail;
+	}
+
+	/*register the device and partition */
+	if (ext4_register_device(fs->dev_desc, part) != 0) {
+		printf("Unable to use %s %d:%lu for fattable\n",
+		       argv[1], dev, part);
+		goto fail;
+	}
+
+	/*get the partition information */
+	if (!get_partition_info(fs->dev_desc, part, &info)) {
+		total_sector = (info.size * info.blksz) / SECTOR_SIZE;
+		fs->total_sect = total_sector;
+	} else {
+		printf("error : get partition info\n");
+		goto fail;
+	}
+
+	/*mount the filesystem */
+	if (!ext4fs_mount(part_length)) {
+		printf("Bad ext4 partition %s %d:%lu\n", argv[1], dev, part);
+		goto fail;
+	}
+
+	/*start write */
+	if (ext4fs_write(filename, (unsigned char *)ram_address, file_size)) {
+		printf("** Error ext4fs_write() **\n");
+		goto fail;
+	}
+
+	ext4fs_close();
+	deinit_fs(fs->dev_desc);
+	return 0;
+
+fail:
+	ext4fs_close();
+	deinit_fs(fs->dev_desc);
+	return 1;
+}
+
 U_BOOT_CMD(ext4ls, 4, 1, do_ext4_ls,
 	   "list files in a directory (default /)",
 	   "<interface> <dev[:part]> [directory]\n"
@@ -251,3 +381,8 @@  U_BOOT_CMD(ext4load, 6, 0, do_ext4_load,
 	   "<interface> <dev[:part]> [addr] [filename] [bytes]\n"
 	   "	  - load binary file 'filename' from 'dev' on 'interface'\n"
 	   "		 to address 'addr' from ext2 filesystem");
+U_BOOT_CMD
+		(ext4write, 6, 1, do_ext4_write,
+		"create a file in the root directory",
+		"<interface> <dev[:part]> [Absolute filename path] [Address] [sizebytes]\n"
+		"	  - create a file in / directory");
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
index 850f821..1e7e7a8 100644
--- a/fs/ext4/Makefile
+++ b/fs/ext4/Makefile
@@ -30,7 +30,7 @@  include $(TOPDIR)/config.mk
 LIB	= $(obj)libext4fs.o
 
 AOBJS	=
-COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o
+COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o ext4_journal.o crc16.o
 
 SRCS	:= $(AOBJS:.o=.S) $(COBJS-y:.o=.c)
 OBJS	:= $(addprefix $(obj),$(AOBJS) $(COBJS-y))
diff --git a/fs/ext4/crc16.c b/fs/ext4/crc16.c
new file mode 100644
index 0000000..3afb34d
--- /dev/null
+++ b/fs/ext4/crc16.c
@@ -0,0 +1,62 @@ 
+/*
+ *      crc16.c
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2. See the file COPYING for more details.
+ */
+
+#include <common.h>
+#include <asm/byteorder.h>
+#include <linux/stat.h>
+#include "crc16.h"
+
+/** CRC table for the CRC-16. The poly is 0x8005 (x16 + x15 + x2 + 1) */
+static __u16 const crc16_table[256] = {
+	0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
+	0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
+	0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
+	0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
+	0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
+	0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
+	0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
+	0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
+	0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
+	0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
+	0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
+	0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
+	0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
+	0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
+	0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
+	0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
+	0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
+	0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
+	0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
+	0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
+	0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
+	0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
+	0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
+	0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
+	0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
+	0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
+	0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
+	0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
+	0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
+	0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
+	0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
+	0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+};
+
+/**
+ * Compute the CRC-16 for the data buffer
+*/
+
+unsigned int ext2fs_crc16(unsigned int crc,
+	const void *buffer, unsigned int len)
+{
+	const unsigned char *cp = buffer;
+
+	while (len--)
+		crc = (((crc >> 8) & 0xffU) ^
+		       crc16_table[(crc ^ *cp++) & 0xffU]) & 0x0000ffffU;
+	return crc;
+}
diff --git a/fs/ext4/crc16.h b/fs/ext4/crc16.h
new file mode 100644
index 0000000..5fd113a
--- /dev/null
+++ b/fs/ext4/crc16.h
@@ -0,0 +1,16 @@ 
+/*
+ * crc16.h - CRC-16 routine
+ * Implements the standard CRC-16:
+ *  Width 16
+ *  Poly  0x8005 (x16 + x15 + x2 + 1)
+ *  Init  0
+ *
+ * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com>
+ * This source code is licensed under the GNU General Public License,
+ * Version 2. See the file COPYING for more details.
+ */
+#ifndef __CRC16_H
+#define __CRC16_H
+extern unsigned int ext2fs_crc16(unsigned int crc,
+	const void *buffer, unsigned int len);
+#endif
diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
index 6f9351c..29b578d 100644
--- a/fs/ext4/ext4_common.c
+++ b/fs/ext4/ext4_common.c
@@ -22,7 +22,13 @@ 
 
 /*
  *  ext4load - based on code from GRUB2  fs/ext2.c
-*/
+ *
+ * ext4write - based on existing ext2 support in UBOOT and ext4
+ *				implementation in Linux Kernel
+ * Journaling feature of ext4 has been referred from JBD2
+ * (Journaling Block device 2) implementation in Linux Kernel
+ */
+
 #include <common.h>
 #include <ext_common.h>
 #include <ext4fs.h>
@@ -30,7 +36,8 @@ 
 #include <asm/byteorder.h>
 #include <linux/stat.h>
 #include <linux/time.h>
-#include "ext4_common.h"
+#include "crc16.h"
+#include "ext4_journal.h"
 
 struct ext2_data *ext4fs_root;
 struct ext2fs_node *ext4fs_file;
@@ -65,6 +72,834 @@  void *xzalloc(size_t size)
 	return ptr;
 }
 
+uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)
+{
+	uint32_t res = size / n;
+	if (res * n != size)
+		res++;
+	return res;
+}
+
+/* To convert big endian journal superblock entries to little endian */
+unsigned int be_le(unsigned int num)
+{
+	unsigned int swapped;
+	swapped = (((num >> 24) & 0xff) |
+		   ((num << 8) & 0xff0000) |
+		   ((num >> 8) & 0xff00) | ((num << 24) & 0xff000000));
+	return swapped;
+}
+
+/* 4-byte number*/
+unsigned int le_be(unsigned int num)
+{
+	return ((num & 0xff) << 24) + ((num & 0xff00) << 8)
+	    + ((num & 0xff0000) >> 8) + ((num >> 24) & 0xff);
+}
+
+void put_ext4(uint64_t off, void *buf, uint32_t size)
+{
+	uint64_t startblock, remainder;
+	short sector_size = 512;
+	unsigned char *temp_ptr = NULL;
+	char sec_buf[SECTOR_SIZE];
+	struct ext_filesystem *fs = get_fs();
+
+	startblock = off / (uint64_t) sector_size;
+	startblock += part_offset;
+	remainder = off % (uint64_t) sector_size;
+	remainder &= SECTOR_SIZE - 1;
+
+	if (fs->dev_desc == NULL)
+		return;
+
+	if ((startblock + (size / SECTOR_SIZE)) >
+	    (part_offset + fs->total_sect)) {
+		printf("part_offset is %lu\n", part_offset);
+		printf("total_sector is %llu\n", fs->total_sect);
+		printf("error: overflow occurs\n");
+		return;
+	}
+
+	if (remainder) {
+		if (fs->dev_desc->block_read) {
+			fs->dev_desc->block_read(fs->dev_desc->dev,
+						 startblock, 1,
+						 (unsigned char *)sec_buf);
+			temp_ptr = (unsigned char *)sec_buf;
+			memcpy((temp_ptr + remainder),
+			       (unsigned char *)buf, size);
+			fs->dev_desc->block_write(fs->dev_desc->dev,
+						  startblock, 1,
+						  (unsigned char *)sec_buf);
+		}
+	} else {
+		if (size / SECTOR_SIZE != 0) {
+			fs->dev_desc->block_write(fs->dev_desc->dev,
+						  startblock,
+						  size / SECTOR_SIZE,
+						  (unsigned long *)buf);
+		} else {
+			fs->dev_desc->block_read(fs->dev_desc->dev,
+						 startblock, 1,
+						 (unsigned char *)sec_buf);
+			temp_ptr = (unsigned char *)sec_buf;
+			memcpy(temp_ptr, buf, size);
+			fs->dev_desc->block_write(fs->dev_desc->dev,
+						  startblock, 1,
+						  (unsigned long *)sec_buf);
+		}
+	}
+	return;
+}
+
+static int _get_new_inode_no(unsigned char *buffer)
+{
+	struct ext_filesystem *fs = get_fs();
+	unsigned char input;
+	int operand, status, count = 1, j = 0;
+
+	/*get the blocksize of the filesystem */
+	unsigned char *ptr = buffer;
+	while (*ptr == 255) {
+		ptr++;
+		count += 8;
+		if (count > (uint32_t) ext4fs_root->sblock.inodes_per_group)
+			return -1;
+	}
+
+	for (j = 0; j < fs->blksz; j++) {
+		input = *ptr;
+		int i = 0;
+		while (i <= 7) {
+			operand = 1 << i;
+			status = input & operand;
+			if (status) {
+				i++;
+				count++;
+			} else {
+				*ptr |= operand;
+				return count;
+			}
+		}
+		ptr = ptr + 1;
+	}
+	return -1;
+}
+
+static int _get_new_blk_no(unsigned char *buffer)
+{
+	unsigned char input;
+	int operand, status, count = 0, j = 0;
+	unsigned char *ptr = buffer;
+	struct ext_filesystem *fs = get_fs();
+
+	if (fs->blksz != 1024)
+		count = 0;
+	else
+		count = 1;
+
+	while (*ptr == 255) {
+		ptr++;
+		count += 8;
+		if (count == (fs->blksz * 8))
+			return -1;
+	}
+
+	for (j = 0; j < fs->blksz; j++) {
+		input = *ptr;
+		int i = 0;
+		while (i <= 7) {
+			operand = 1 << i;
+			status = input & operand;
+			if (status) {
+				i++;
+				count++;
+			} else {
+				*ptr |= operand;
+				return count;
+			}
+		}
+		ptr = ptr + 1;
+	}
+	return -1;
+}
+
+int set_block_bmap(long int blockno, unsigned char *buffer, int index)
+{
+	int i, remainder, status;
+	unsigned char *ptr = buffer;
+	unsigned char operand;
+	i = blockno / 8;
+	remainder = blockno % 8;
+	int blocksize = EXT2_BLOCK_SIZE(ext4fs_root);
+
+	i = i - (index * blocksize);
+	if (blocksize != 1024) {
+		ptr = ptr + i;
+		operand = 1 << remainder;
+		status = *ptr & operand;
+		if (status)
+			return -1;
+		else {
+			*ptr = *ptr | operand;
+			return 0;
+		}
+	} else {
+		if (remainder == 0) {
+			ptr = ptr + i - 1;
+			operand = (1 << 7);
+		} else {
+			ptr = ptr + i;
+			operand = (1 << (remainder - 1));
+		}
+		status = *ptr & operand;
+		if (status)
+			return -1;
+		else {
+			*ptr = *ptr | operand;
+			return 0;
+		}
+	}
+}
+
+void reset_block_bmap(long int blockno, unsigned char *buffer, int index)
+{
+	int i, remainder, status;
+	unsigned char *ptr = buffer;
+	unsigned char operand;
+	i = blockno / 8;
+	remainder = blockno % 8;
+	int blocksize = EXT2_BLOCK_SIZE(ext4fs_root);
+
+	i = i - (index * blocksize);
+	if (blocksize != 1024) {
+		ptr = ptr + i;
+		operand = (1 << remainder);
+		status = *ptr & operand;
+		if (status)
+			*ptr = *ptr & ~(operand);
+	} else {
+		if (remainder == 0) {
+			ptr = ptr + i - 1;
+			operand = (1 << 7);
+		} else {
+			ptr = ptr + i;
+			operand = (1 << (remainder - 1));
+		}
+		status = *ptr & operand;
+		if (status)
+			*ptr = *ptr & ~(operand);
+	}
+	return;
+}
+
+int set_inode_bmap(int inode_no, unsigned char *buffer, int index)
+{
+	int i, remainder, status;
+	unsigned char *ptr = buffer;
+	unsigned char operand;
+
+	inode_no -= (index * (uint32_t) ext4fs_root->sblock.inodes_per_group);
+	i = inode_no / 8;
+	remainder = inode_no % 8;
+	if (remainder == 0) {
+		ptr = ptr + i - 1;
+		operand = (1 << 7);
+	} else {
+		ptr = ptr + i;
+		operand = (1 << (remainder - 1));
+	}
+	status = *ptr & operand;
+	if (status)
+		return -1;
+	else {
+		*ptr = *ptr | operand;
+		return 0;
+	}
+}
+
+void reset_inode_bmap(int inode_no, unsigned char *buffer, int index)
+{
+	int i, remainder, status;
+	unsigned char *ptr = buffer;
+	unsigned char operand;
+
+	inode_no -= (index * (uint32_t) ext4fs_root->sblock.inodes_per_group);
+	i = inode_no / 8;
+	remainder = inode_no % 8;
+	if (remainder == 0) {
+		ptr = ptr + i - 1;
+		operand = (1 << 7);
+	} else {
+		ptr = ptr + i;
+		operand = (1 << (remainder - 1));
+	}
+	status = *ptr & operand;
+	if (status)
+		*ptr = *ptr & ~(operand);
+	return;
+}
+
+int ext4fs_checksum_update(unsigned int i)
+{
+	struct ext2_block_group *desc;
+	struct ext_filesystem *fs = get_fs();
+	__u16 crc = 0;
+
+	desc = (struct ext2_block_group *)&fs->gd[i];
+	if (fs->sb->feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
+		int offset = offsetof(struct ext2_block_group, bg_checksum);
+
+		crc = ext2fs_crc16(~0, fs->sb->unique_id,
+				   sizeof(fs->sb->unique_id));
+		crc = ext2fs_crc16(crc, &i, sizeof(i));
+		crc = ext2fs_crc16(crc, desc, offset);
+		offset += sizeof(desc->bg_checksum);	/* skip checksum */
+		assert(offset == sizeof(*desc));
+	}
+	return crc;
+}
+
+static int check_void_in_dentry(struct ext2_dirent *dir, char *filename)
+{
+	int dentry_length = 0;
+	short padding_factor = 0;
+	int sizeof_void_space = 0;
+	int new_entry_byte_reqd = 0;
+
+	if (dir->namelen % 4 != 0)
+		padding_factor = 4 - (dir->namelen % 4);
+
+	dentry_length = sizeof(struct ext2_dirent) +
+	    dir->namelen + padding_factor;
+	sizeof_void_space = dir->direntlen - dentry_length;
+	if (sizeof_void_space == 0) {
+		return 0;
+	} else {
+		padding_factor = 0;
+		if (strlen(filename) % 4 != 0)
+			padding_factor = 4 - (strlen(filename) % 4);
+
+		new_entry_byte_reqd = strlen(filename) +
+		    sizeof(struct ext2_dirent) + padding_factor;
+		if (sizeof_void_space >= new_entry_byte_reqd) {
+			dir->direntlen = dentry_length;
+			return sizeof_void_space;
+		} else
+			return 0;
+	}
+}
+
+void update_parent_dentry(char *filename, int *p_ino, int file_type)
+{
+	unsigned int *zero_buffer = NULL;
+	char *root_first_block_buffer = NULL;
+	struct ext_filesystem *fs = get_fs();
+	int direct_blk_idx;
+	long int root_blknr;
+	long int first_block_no_of_root = 0;
+	long int previous_blknr = -1;
+	int totalbytes = 0;
+	short int padding_factor = 0;
+	unsigned int new_entry_byte_reqd;
+	unsigned int last_entry_dirlen;
+	int sizeof_void_space = 0;
+	int templength = 0, inodeno, status;
+	/*directory entry */
+	struct ext2_dirent *dir;
+	char *ptr = NULL;
+	char *temp_dir = NULL;
+
+	/*##START: Update the root directory entry block of root inode ### */
+	/*since we are populating this file under  root
+	 *directory take the root inode and its first block
+	 *currently we are looking only in first block of root
+	 *inode*/
+
+	zero_buffer = xzalloc(fs->blksz);
+	if (!zero_buffer)
+		return;
+	root_first_block_buffer = (char *)xzalloc(fs->blksz);
+	if (!root_first_block_buffer)
+		return;
+RESTART:
+
+	/*read the block no allocated to a file */
+	for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS;
+	     direct_blk_idx++) {
+		root_blknr = read_allocated_block(g_parent_inode,
+						  direct_blk_idx);
+		if (root_blknr == 0) {
+			first_block_no_of_root = previous_blknr;
+			break;
+		}
+		previous_blknr = root_blknr;
+	}
+
+	status = ext2fs_devread(first_block_no_of_root
+				* fs->sect_perblk,
+				0, fs->blksz, root_first_block_buffer);
+	if (status == 0)
+		goto fail;
+	else {
+		if (log_journal(root_first_block_buffer,
+				first_block_no_of_root))
+			goto fail;
+		dir = (struct ext2_dirent *)root_first_block_buffer;
+		ptr = (char *)dir;
+		totalbytes = 0;
+		while (dir->direntlen > 0) {
+			/* blocksize-totalbytes because last directory length
+			 * i.e. dir->direntlen is free availble space in the
+			 * block that means  it is a last entry of directory
+			 * entry
+			 */
+
+			/* traversing the each directory entry */
+			if (fs->blksz - totalbytes == dir->direntlen) {
+				if (strlen(filename) % 4 != 0)
+					padding_factor = 4 -
+					    (strlen(filename) % 4);
+
+				new_entry_byte_reqd = strlen(filename) +
+				    sizeof(struct ext2_dirent) + padding_factor;
+				padding_factor = 0;
+				/* update last directory entry length to its
+				 *  length because we are creating new directory
+				 *  entry */
+				if (dir->namelen % 4 != 0)
+					padding_factor = 4 - (dir->namelen % 4);
+
+				last_entry_dirlen = dir->namelen +
+				    sizeof(struct ext2_dirent) + padding_factor;
+				if ((fs->blksz - totalbytes - last_entry_dirlen)
+				    < new_entry_byte_reqd) {
+					printf("1st Block Full:"
+					"allocating new block\n");
+
+					if (direct_blk_idx ==
+					    INDIRECT_BLOCKS - 1) {
+						printf("Directory capacity"
+						"exceeds the limit\n");
+						goto fail;
+					}
+					g_parent_inode->b.blocks.dir_blocks
+					    [direct_blk_idx] = get_new_blk_no();
+					if (g_parent_inode->b.blocks.dir_blocks
+					    [direct_blk_idx] == -1) {
+						printf("no block"
+							"left to assign\n");
+						goto fail;
+					}
+					put_ext4(((uint64_t)
+						  (g_parent_inode->b.blocks.
+						   dir_blocks[direct_blk_idx] *
+						   fs->blksz)), zero_buffer,
+						 fs->blksz);
+					g_parent_inode->size =
+					    g_parent_inode->size + fs->blksz;
+					g_parent_inode->blockcnt =
+					    g_parent_inode->blockcnt +
+					    fs->sect_perblk;
+					if (put_metadata
+					    (root_first_block_buffer,
+					     first_block_no_of_root))
+						goto fail;
+					goto RESTART;
+				}
+				dir->direntlen = last_entry_dirlen;
+				break;
+			}
+
+			templength = dir->direntlen;
+			totalbytes = totalbytes + templength;
+			sizeof_void_space = check_void_in_dentry(dir, filename);
+			if (sizeof_void_space)
+				break;
+
+			dir = (struct ext2_dirent *)((char *)dir + templength);
+			ptr = (char *)dir;
+		}
+
+		/*make a pointer ready for creating next directory entry */
+		templength = dir->direntlen;
+		totalbytes = totalbytes + templength;
+		dir = (struct ext2_dirent *)((char *)dir + templength);
+		ptr = (char *)dir;
+
+		/*get the next available inode number */
+		inodeno = get_new_inode_no();
+		if (inodeno == -1) {
+			printf("no inode left to assign\n");
+			goto fail;
+		}
+		dir->inode = inodeno;
+		if (sizeof_void_space)
+			dir->direntlen = sizeof_void_space;
+		else
+			dir->direntlen = fs->blksz - totalbytes;
+		dir->namelen = strlen(filename);
+		dir->filetype = FILETYPE_REG;	/*regular file */
+		temp_dir = (char *)dir;
+		temp_dir = temp_dir + sizeof(struct ext2_dirent);
+		memcpy(temp_dir, filename, strlen(filename));
+	}
+	*p_ino = inodeno;
+
+	/*update or write  the 1st block of root inode */
+	if (put_metadata(root_first_block_buffer, first_block_no_of_root))
+		goto fail;
+
+fail:
+	if (zero_buffer)
+		free(zero_buffer);
+	if (root_first_block_buffer)
+		free(root_first_block_buffer);
+
+	/*END: Update the root directory entry block of root inode */
+}
+
+static int search_dir(struct ext2_inode *parent_inode, char *dirname)
+{
+	unsigned char *block_buffer;
+	struct ext_filesystem *fs = get_fs();
+	struct ext2_dirent *dir = NULL;
+	struct ext2_dirent *previous_dir = NULL;
+	int status, inodeno, totalbytes, templength, direct_blk_idx;
+	int found = 0;
+	char *ptr;
+	long int blknr;
+
+	/*get the first block of root */
+	/*read the block no allocated to a file */
+	for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS;
+	     direct_blk_idx++) {
+		blknr = read_allocated_block(parent_inode, direct_blk_idx);
+		if (blknr == 0)
+			goto fail;
+
+		/*read the blocks of parenet inode */
+		block_buffer = xzalloc(fs->blksz);
+		if (!block_buffer)
+			goto fail;
+
+		status = ext2fs_devread(blknr * fs->sect_perblk,
+					0, fs->blksz, (char *)block_buffer);
+		if (status == 0)
+			goto fail;
+		else {
+			dir = (struct ext2_dirent *)block_buffer;
+			ptr = (char *)dir;
+			totalbytes = 0;
+			while (dir->direntlen >= 0) {
+				/*blocksize-totalbytes because last directory
+				 *length i.e.,*dir->direntlen is free availble
+				 *space in the block that means
+				 *it is a last entry of directory entry
+				 */
+				if (strlen(dirname) == dir->namelen) {
+					if (strncmp(dirname, ptr +
+						    sizeof(struct ext2_dirent),
+						    dir->namelen) == 0) {
+						previous_dir->direntlen +=
+						    dir->direntlen;
+						inodeno = dir->inode;
+						dir->inode = 0;
+						found = 1;
+						break;
+					}
+				}
+
+				if (fs->blksz - totalbytes == dir->direntlen)
+					break;
+
+				/*traversing the each directory entry */
+				templength = dir->direntlen;
+				totalbytes = totalbytes + templength;
+				previous_dir = dir;
+				dir = (struct ext2_dirent *)((char *)dir
+							     + templength);
+				ptr = (char *)dir;
+			}
+		}
+
+		if (found == 1) {
+			if (block_buffer) {
+				free(block_buffer);
+				block_buffer = NULL;
+			}
+			return inodeno;
+		}
+
+		if (block_buffer) {
+			free(block_buffer);
+			block_buffer = NULL;
+		}
+	}
+
+fail:
+	if (block_buffer) {
+		free(block_buffer);
+		block_buffer = NULL;
+	}
+	return -1;
+}
+
+static int find_dir_depth(char *dirname)
+{
+	char *token = strtok(dirname, "/");
+	int count = 0;
+	while (token != NULL) {
+		token = strtok(NULL, "/");
+		count++;
+	}
+	return count + 1 + 1;
+	/*
+	 *for example  for string /home/temp
+	 *depth=home(1)+temp(1)+1 extra for NULL;
+	 *so count is 4;
+	 */
+}
+
+static int parse_path(char **arr, char *dirname)
+{
+	char *token = strtok(dirname, "/");
+	int i = 0;
+
+	/*add root */
+	arr[i] = xzalloc(strlen("/") + 1);
+	if (!arr[i])
+		return -1;
+
+	arr[i++] = "/";
+
+	/*add each path entry after root */
+	while (token != NULL) {
+		arr[i] = xzalloc(strlen(token) + 1);
+		if (!arr[i])
+			return -1;
+		memcpy(arr[i++], token, strlen(token));
+		token = strtok(NULL, "/");
+	}
+
+	arr[i] = NULL;
+	/*success */
+	return 0;
+}
+
+int iget(int inode_no, struct ext2_inode *inode)
+{
+	if (ext4fs_read_inode(ext4fs_root, inode_no, inode) == 0)
+		return -1;
+	else
+		return 0;
+}
+
+/*
+* Function:get_parent_inode_num
+* Return Value: inode Number of the parent directory of  file/Directory to be
+* created
+* dirname : Input parmater, input path name of the file/directory to be created
+* dname : Output parameter, to be filled with the name of the directory
+* extracted from dirname
+*/
+int get_parent_inode_num(char *dirname, char *dname, int flags)
+{
+	char **ptr = NULL;
+	int i, depth = 0;
+	char *depth_dirname = NULL;
+	char *parse_dirname = NULL;
+	struct ext2_inode *parent_inode = NULL;
+	struct ext2_inode *first_inode = NULL;
+	struct ext2_inode temp_inode;
+	int matched_inode_no;
+	int result_inode_no = -1;
+
+	if (*dirname != '/') {
+		printf("Please supply Absolute path\n");
+		return -1;
+	}
+
+	depth_dirname = (char *)xzalloc(strlen(dirname) + 1);
+	if (!depth_dirname)
+		return -1;
+
+	memcpy(depth_dirname, dirname, strlen(dirname));
+	depth = find_dir_depth(depth_dirname);
+	parse_dirname = (char *)xzalloc(strlen(dirname) + 1);
+	if (!parse_dirname)
+		goto fail;
+	memcpy(parse_dirname, dirname, strlen(dirname));
+
+	ptr = (char **)xzalloc((depth) * sizeof(char *));
+	if (!ptr)
+		goto fail;
+	if (parse_path(ptr, parse_dirname))
+		goto fail;
+	parent_inode = (struct ext2_inode *)
+	    xzalloc(sizeof(struct ext2_inode));
+	if (!parent_inode)
+		goto fail;
+	first_inode = (struct ext2_inode *)
+	    xzalloc(sizeof(struct ext2_inode));
+	if (!first_inode)
+		goto fail;
+	memcpy(parent_inode, ext4fs_root->inode, sizeof(struct ext2_inode));
+	memcpy(first_inode, parent_inode, sizeof(struct ext2_inode));
+	if (flags & F_FILE)
+		result_inode_no = EXT2_ROOT_INO;
+	for (i = 1; i < depth; i++) {
+		matched_inode_no = search_dir(parent_inode, ptr[i]);
+		if (matched_inode_no == -1) {
+			if (ptr[i + 1] == NULL && i == 1) {
+				result_inode_no = EXT2_ROOT_INO;
+				goto END;
+			} else {
+				if (ptr[i + 1] == NULL)
+					break;
+				printf("Invalid path\n");
+				result_inode_no = -1;
+				goto fail;
+			}
+		} else {
+			if (ptr[i + 1] != NULL) {
+				memset(parent_inode, '\0',
+				       sizeof(struct ext2_inode));
+				if (iget(matched_inode_no, parent_inode)) {
+					result_inode_no = -1;
+					goto fail;
+				}
+				result_inode_no = matched_inode_no;
+			} else
+				break;
+		}
+	}
+
+END:
+	if (i == 1)
+		matched_inode_no = search_dir(first_inode, ptr[i]);
+	else
+		matched_inode_no = search_dir(parent_inode, ptr[i]);
+
+	if (matched_inode_no != -1) {
+		iget(matched_inode_no, &temp_inode);
+		if (temp_inode.mode & S_IFDIR) {
+			printf("It is a Directory\n");
+			result_inode_no = -1;
+			goto fail;
+		}
+	}
+
+	if (strlen(ptr[i]) > 256) {
+		result_inode_no = -1;
+		goto fail;
+	}
+	memcpy(dname, ptr[i], strlen(ptr[i]));
+
+fail:
+	if (depth_dirname)
+		free(depth_dirname);
+	if (parse_dirname)
+		free(parse_dirname);
+	if (ptr)
+		free(ptr);
+	if (parent_inode)
+		free(parent_inode);
+	if (first_inode)
+		free(first_inode);
+
+	return result_inode_no;
+}
+
+static int check_filename(char *filename, unsigned int blknr)
+{
+	char *root_first_block_buffer, *root_first_block_addr;
+	unsigned int first_block_no_of_root;
+	struct ext_filesystem *fs = get_fs();
+	struct ext2_dirent *dir;
+	struct ext2_dirent *previous_dir = NULL;
+	int totalbytes = 0;
+	int templength = 0;
+	int status, inodeno;
+	int found = 0;
+	char *ptr;
+
+	first_block_no_of_root = blknr;
+	root_first_block_buffer = (char *)xzalloc(fs->blksz);
+	if (!root_first_block_buffer)
+		return -1;
+	root_first_block_addr = root_first_block_buffer;
+	status = ext2fs_devread(first_block_no_of_root *
+				fs->sect_perblk, 0,
+				fs->blksz, root_first_block_buffer);
+	if (status == 0) {
+		goto fail;
+	} else {
+		if (log_journal(root_first_block_buffer,
+				first_block_no_of_root))
+			goto fail;
+		dir = (struct ext2_dirent *)root_first_block_buffer;
+		ptr = (char *)dir;
+		totalbytes = 0;
+		while (dir->direntlen >= 0) {
+			if (strlen(filename) == dir->namelen) {
+				if (strncmp(filename,
+					    ptr + sizeof(struct ext2_dirent),
+					    dir->namelen) == 0) {
+					printf("file found deleting\n");
+					previous_dir->direntlen +=
+					    dir->direntlen;
+					inodeno = dir->inode;
+					dir->inode = 0;
+					found = 1;
+					break;
+				}
+			}
+
+			if (fs->blksz - totalbytes == dir->direntlen)
+				break;
+
+			/*traversing the each directory entry */
+			templength = dir->direntlen;
+			totalbytes = totalbytes + templength;
+			previous_dir = dir;
+			dir = (struct ext2_dirent *)((char *)dir + templength);
+			ptr = (char *)dir;
+		}
+	}
+
+	if (found == 1) {
+		if (put_metadata(root_first_block_addr, first_block_no_of_root))
+			goto fail;
+		return inodeno;
+	}
+
+fail:
+	if (root_first_block_buffer)
+		free(root_first_block_buffer);
+	return -1;
+}
+
+int ext4fs_filename_check(char *filename)
+{
+	short direct_blk_idx = 0;
+	long int blknr = -1;
+	int inodeno = -1;
+
+	/*read the block no allocated to a file */
+	for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS;
+	     direct_blk_idx++) {
+		blknr = read_allocated_block(g_parent_inode, direct_blk_idx);
+		if (blknr == 0)
+			break;
+		inodeno = check_filename(filename, blknr);
+		if (inodeno != -1)
+			return inodeno;
+	}
+	return -1;
+}
+
 static struct ext4_extent_header *ext4fs_find_leaf(struct ext2_data *data,
 	char *buf, struct ext4_extent_header *ext_block, uint32_t fileblock)
 {
@@ -152,6 +987,553 @@  int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode)
 	return 1;
 }
 
+long int get_new_blk_no(void)
+{
+	short i, status;
+	int remainder;
+	unsigned int bg_idx;
+	static int prev_bg_bitmap_index = -1;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	char *zero_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer || !zero_buffer)
+		goto fail;
+	struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable;
+
+	if (fs->first_pass_bbmap == 0) {
+		for (i = 0; i < fs->no_blkgrp; i++) {
+			if (gd[i].free_blocks) {
+				if (gd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
+					put_ext4(((uint64_t) (gd[i].block_id *
+							      fs->blksz)),
+						 zero_buffer, fs->blksz);
+					gd[i].bg_flags =
+					    gd[i].
+					    bg_flags & ~EXT4_BG_BLOCK_UNINIT;
+					memcpy(fs->blk_bmaps[i], zero_buffer,
+					       fs->blksz);
+				}
+				fs->curr_blkno =
+				    _get_new_blk_no(fs->blk_bmaps[i]);
+				if (fs->curr_blkno == -1) {
+					/*if block bitmap is completely fill */
+					continue;
+				}
+				fs->curr_blkno = fs->curr_blkno +
+				    (i * fs->blksz * 8);
+				fs->first_pass_bbmap++;
+				gd[i].free_blocks--;
+				fs->sb->free_blocks--;
+				status = ext2fs_devread(gd[i].block_id *
+							fs->sect_perblk, 0,
+							fs->blksz,
+							journal_buffer);
+				if (status == 0)
+					goto fail;
+				if (log_journal(journal_buffer, gd[i].block_id))
+					goto fail;
+				goto success;
+			} else {
+				debug("no space left on block group %d\n", i);
+			}
+		}
+		goto fail;
+	} else {
+restart:
+		fs->curr_blkno++;
+		/*get the blockbitmap index respective to blockno */
+		if (fs->blksz != 1024) {
+			bg_idx = fs->curr_blkno /
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+		} else {
+			bg_idx = fs->curr_blkno /
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+			remainder = fs->curr_blkno %
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+			if (!remainder)
+				bg_idx--;
+		}
+
+		if (bg_idx >= fs->no_blkgrp)
+			goto fail;
+
+		if (gd[bg_idx].free_blocks == 0) {
+			debug("block group %u is full. Skipping\n", bg_idx);
+			fs->curr_blkno = fs->curr_blkno +
+			    ext4fs_root->sblock.blocks_per_group;
+			fs->curr_blkno--;
+			goto restart;
+		}
+
+		if (gd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) {
+			memset(zero_buffer, '\0', fs->blksz);
+			put_ext4(((uint64_t) (gd[bg_idx].block_id * fs->blksz)),
+				 zero_buffer, fs->blksz);
+			memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz);
+			gd[bg_idx].bg_flags = gd[bg_idx].bg_flags &
+			    ~EXT4_BG_BLOCK_UNINIT;
+		}
+
+		if (set_block_bmap(fs->curr_blkno, fs->blk_bmaps[bg_idx],
+				   bg_idx) != 0) {
+			debug("going for restart for the block no %ld %u\n",
+			      fs->curr_blkno, bg_idx);
+			goto restart;
+		}
+
+		/*journal backup */
+		if (prev_bg_bitmap_index != bg_idx) {
+			memset(journal_buffer, '\0', fs->blksz);
+			status = ext2fs_devread(gd[bg_idx].block_id
+						* fs->sect_perblk,
+						0, fs->blksz, journal_buffer);
+			if (status == 0)
+				goto fail;
+			if (log_journal(journal_buffer, gd[bg_idx].block_id))
+				goto fail;
+
+			prev_bg_bitmap_index = bg_idx;
+		}
+		gd[bg_idx].free_blocks--;
+		fs->sb->free_blocks--;
+		goto success;
+	}
+success:
+	if (journal_buffer)
+		free(journal_buffer);
+	if (zero_buffer)
+		free(zero_buffer);
+	return fs->curr_blkno;
+fail:
+	if (journal_buffer)
+		free(journal_buffer);
+	if (zero_buffer)
+		free(zero_buffer);
+	return -1;
+}
+
+int get_new_inode_no(void)
+{
+	short i, status;
+	unsigned int ibmap_idx;
+	static int prev_inode_bitmap_index = -1;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	char *zero_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer || !zero_buffer)
+		goto fail;
+	struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable;
+
+	if (fs->first_pass_ibmap == 0) {
+		for (i = 0; i < fs->no_blkgrp; i++) {
+			if (gd[i].free_inodes) {
+				if (gd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
+					put_ext4(((uint64_t)
+						  (gd[i].inode_id * fs->blksz)),
+						 zero_buffer, fs->blksz);
+					gd[i].bg_flags = gd[i].bg_flags &
+					    ~EXT4_BG_INODE_UNINIT;
+					memcpy(fs->inode_bmaps[i],
+					       zero_buffer, fs->blksz);
+				}
+				fs->curr_inode_no =
+				    _get_new_inode_no(fs->inode_bmaps[i]);
+				if (fs->curr_inode_no == -1) {
+					/*if block bitmap is completely fill */
+					continue;
+				}
+				fs->curr_inode_no = fs->curr_inode_no +
+				    (i * ext4fs_root->sblock.inodes_per_group);
+				fs->first_pass_ibmap++;
+				gd[i].free_inodes--;
+				gd[i].bg_itable_unused--;
+				fs->sb->free_inodes--;
+				status = ext2fs_devread(gd[i].inode_id *
+							fs->sect_perblk, 0,
+							fs->blksz,
+							journal_buffer);
+				if (status == 0)
+					goto fail;
+				if (log_journal(journal_buffer, gd[i].inode_id))
+					goto fail;
+				goto success;
+			} else
+				debug("no inode left on block group %d\n", i);
+		}
+		goto fail;
+	} else {
+restart:
+		fs->curr_inode_no++;
+		/*get the blockbitmap index respective to blockno */
+		ibmap_idx = fs->curr_inode_no /
+		    (uint32_t) ext4fs_root->sblock.inodes_per_group;
+		if (gd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) {
+			memset(zero_buffer, '\0', fs->blksz);
+			put_ext4(((uint64_t) (gd[ibmap_idx].inode_id *
+					      fs->blksz)), zero_buffer,
+				 fs->blksz);
+			gd[ibmap_idx].bg_flags =
+			    gd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
+			memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer,
+			       fs->blksz);
+		}
+
+		if (set_inode_bmap(fs->curr_inode_no,
+				   fs->inode_bmaps[ibmap_idx],
+				   ibmap_idx) != 0) {
+			debug("going for restart for the block no %d %u\n",
+			      fs->curr_inode_no, ibmap_idx);
+			goto restart;
+		}
+
+		/*journal backup */
+		if (prev_inode_bitmap_index != ibmap_idx) {
+			memset(journal_buffer, '\0', fs->blksz);
+			status = ext2fs_devread(gd[ibmap_idx].inode_id
+						* fs->sect_perblk,
+						0, fs->blksz, journal_buffer);
+			if (status == 0)
+				goto fail;
+			if (log_journal(journal_buffer, gd[ibmap_idx].inode_id))
+				goto fail;
+			prev_inode_bitmap_index = ibmap_idx;
+		}
+
+		gd[ibmap_idx].free_inodes--;
+		gd[ibmap_idx].bg_itable_unused--;
+		fs->sb->free_inodes--;
+		goto success;
+	}
+
+success:
+	if (journal_buffer)
+		free(journal_buffer);
+	if (zero_buffer)
+		free(zero_buffer);
+	return fs->curr_inode_no;
+
+fail:
+	if (journal_buffer)
+		free(journal_buffer);
+	if (zero_buffer)
+		free(zero_buffer);
+	return -1;
+
+}
+
+/*allocation of single indirect blocks*/
+static void alloc_single_indirect_block(struct ext2_inode *file_inode,
+					unsigned int *total_remaining_blocks,
+					unsigned int *no_blks_reqd)
+{
+	short i, status;
+	long int actual_block_no;
+	/*single indirect */
+	unsigned int *SI_buffer = NULL;
+	long int SI_blockno;
+	unsigned int *SI_start_addr = NULL;
+	struct ext_filesystem *fs = get_fs();
+
+	if (*total_remaining_blocks != 0) {
+		SI_buffer = xzalloc(fs->blksz);
+		if (!SI_buffer)
+			return;
+		SI_start_addr = SI_buffer;
+		SI_blockno = get_new_blk_no();
+		if (SI_blockno == -1) {
+			printf("no block left to assign\n");
+			goto fail;
+		}
+		(*no_blks_reqd)++;
+		debug("SIPB %ld: %u\n", SI_blockno, *total_remaining_blocks);
+
+		status = ext2fs_devread(SI_blockno * fs->sect_perblk,
+					0, fs->blksz, (char *)SI_buffer);
+		memset(SI_buffer, '\0', fs->blksz);
+		if (status == 0)
+			goto fail;
+
+		for (i = 0; i < (fs->blksz / sizeof(int)); i++) {
+			actual_block_no = get_new_blk_no();
+			if (actual_block_no == -1) {
+				printf("no block left to assign\n");
+				goto fail;
+			}
+			*SI_buffer = actual_block_no;
+			debug("SIAB %u: %u\n", *SI_buffer,
+			      *total_remaining_blocks);
+
+			SI_buffer++;
+			(*total_remaining_blocks)--;
+			if (*total_remaining_blocks == 0)
+				break;
+		}
+
+		/*write the block to disk */
+		put_ext4(((uint64_t) (SI_blockno * fs->blksz)),
+			 SI_start_addr, fs->blksz);
+		file_inode->b.blocks.indir_block = SI_blockno;
+	}
+fail:
+	if (SI_start_addr)
+		free(SI_start_addr);
+	return;
+}
+
+/*allocation of double indirect blocks*/
+static void alloc_double_indirect_block(struct ext2_inode *file_inode,
+					unsigned int *total_remaining_blocks,
+					unsigned int *no_blks_reqd)
+{
+	short i, j, status;
+	long int actual_block_no;
+	/*double indirect */
+	long int DI_blockno_parent, DI_blockno_child;
+	unsigned int *DI_parent_buffer = NULL;
+	unsigned int *DI_child_buff = NULL;
+	unsigned int *DI_block_start_addr = NULL;
+	unsigned int *DI_child_buff_start = NULL;
+	struct ext_filesystem *fs = get_fs();
+
+	if (*total_remaining_blocks != 0) {
+		/*double indirect parent block connecting to inode */
+		DI_blockno_parent = get_new_blk_no();
+		if (DI_blockno_parent == -1) {
+			printf("no block left to assign\n");
+			goto fail;
+		}
+		DI_parent_buffer = xzalloc(fs->blksz);
+		if (!DI_parent_buffer)
+			goto fail;
+
+		DI_block_start_addr = DI_parent_buffer;
+		(*no_blks_reqd)++;
+		debug("DIPB %ld: %u\n", DI_blockno_parent,
+		      *total_remaining_blocks);
+
+		status = ext2fs_devread(DI_blockno_parent *
+					fs->sect_perblk, 0,
+					fs->blksz, (char *)DI_parent_buffer);
+		memset(DI_parent_buffer, '\0', fs->blksz);
+
+		/*START: for each double indirect parent
+		 *block create one more block*/
+		for (i = 0; i < (fs->blksz / sizeof(int)); i++) {
+			DI_blockno_child = get_new_blk_no();
+			if (DI_blockno_child == -1) {
+				printf("no block left to assign\n");
+				goto fail;
+			}
+			DI_child_buff = xzalloc(fs->blksz);
+			if (!DI_child_buff)
+				goto fail;
+
+			DI_child_buff_start = DI_child_buff;
+			*DI_parent_buffer = DI_blockno_child;
+			DI_parent_buffer++;
+			(*no_blks_reqd)++;
+			debug("DICB %ld: %u\n", DI_blockno_child,
+			      *total_remaining_blocks);
+
+			status = ext2fs_devread(DI_blockno_child *
+						fs->sect_perblk, 0,
+						fs->blksz,
+						(char *)DI_child_buff);
+			memset(DI_child_buff, '\0', fs->blksz);
+			/*END: for each double indirect parent block block */
+			/*filling of actual datablocks for each child */
+			for (j = 0; j < (fs->blksz / sizeof(int)); j++) {
+				actual_block_no = get_new_blk_no();
+				if (actual_block_no == -1) {
+					printf("no block left to assign\n");
+					goto fail;
+				}
+				*DI_child_buff = actual_block_no;
+				debug("DIAB %ld: %u\n", actual_block_no,
+				      *total_remaining_blocks);
+
+				DI_child_buff++;
+				(*total_remaining_blocks)--;
+				if (*total_remaining_blocks == 0)
+					break;
+			}
+			/*write the block  table */
+			put_ext4(((uint64_t) (DI_blockno_child * fs->blksz)),
+				 DI_child_buff_start, fs->blksz);
+			if (DI_child_buff_start)
+				free(DI_child_buff_start);
+
+			if (*total_remaining_blocks == 0)
+				break;
+		}
+		put_ext4(((uint64_t) (DI_blockno_parent * fs->blksz)),
+			 DI_block_start_addr, fs->blksz);
+		file_inode->b.blocks.double_indir_block = DI_blockno_parent;
+	}
+fail:
+	if (DI_block_start_addr)
+		free(DI_block_start_addr);
+	return;
+}
+
+/*allocation of triple indirect blocks*/
+static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
+					unsigned int *total_remaining_blocks,
+					unsigned int *no_blks_reqd)
+{
+	short i, j, k;
+	long int actual_block_no;
+	/*Triple Indirect */
+	long int TI_gp_blockno, TI_parent_blockno, TI_child_blockno;
+	unsigned int *TI_gp_buff = NULL;
+	unsigned int *TI_parent_buff = NULL;
+	unsigned int *TI_child_buff = NULL;
+	unsigned int *TI_gp_buff_start_addr = NULL;
+	unsigned int *TI_pbuff_start_addr = NULL;
+	unsigned int *TI_cbuff_start_addr = NULL;
+	struct ext_filesystem *fs = get_fs();
+	if (*total_remaining_blocks != 0) {
+		/*triple indirect grand parent block connecting to inode */
+		TI_gp_blockno = get_new_blk_no();
+		if (TI_gp_blockno == -1) {
+			printf("no block left to assign\n");
+			goto fail;
+		}
+		TI_gp_buff = xzalloc(fs->blksz);
+		if (!TI_gp_buff)
+			goto fail;
+
+		TI_gp_buff_start_addr = TI_gp_buff;
+		(*no_blks_reqd)++;
+		debug("TIGPB %ld: %u\n", TI_gp_blockno,
+		      *total_remaining_blocks);
+
+		/* for each 4 byte grand parent entry create one more block */
+		for (i = 0; i < (fs->blksz / sizeof(int)); i++) {
+			TI_parent_blockno = get_new_blk_no();
+			if (TI_parent_blockno == -1) {
+				printf("no block left to assign\n");
+				goto fail;
+			}
+			TI_parent_buff = xzalloc(fs->blksz);
+			if (!TI_parent_buff)
+				goto fail;
+
+			TI_pbuff_start_addr = TI_parent_buff;
+			*TI_gp_buff = TI_parent_blockno;
+			TI_gp_buff++;
+			(*no_blks_reqd)++;
+			debug("TIPB %ld: %u\n", TI_parent_blockno,
+			      *total_remaining_blocks);
+
+			/*for each 4 byte entry parent create one more block */
+			for (j = 0; j < (fs->blksz / sizeof(int)); j++) {
+				TI_child_blockno = get_new_blk_no();
+				if (TI_child_blockno == -1) {
+					printf("no block"
+						"left assign\n");
+					goto fail;
+				}
+				TI_child_buff = xzalloc(fs->blksz);
+				if (!TI_child_buff)
+					goto fail;
+
+				TI_cbuff_start_addr = TI_child_buff;
+				*TI_parent_buff = TI_child_blockno;
+				TI_parent_buff++;
+				(*no_blks_reqd)++;
+				debug("TICB %ld: %u\n", TI_parent_blockno,
+				      *total_remaining_blocks);
+
+				/*filling of actual datablocks for each child */
+				for (k = 0; k < (fs->blksz / sizeof(int));
+					k++) {
+					actual_block_no = get_new_blk_no();
+					if (actual_block_no == -1) {
+						printf("no block"
+						"left to assign\n");
+						goto fail;
+					}
+					*TI_child_buff = actual_block_no;
+					debug("TIAB %ld: %u\n", actual_block_no,
+					      *total_remaining_blocks);
+
+					TI_child_buff++;
+					(*total_remaining_blocks)--;
+					if (*total_remaining_blocks == 0)
+						break;
+				}
+				/*write the child block */
+				put_ext4(((uint64_t) (TI_child_blockno *
+						      fs->blksz)),
+					 TI_cbuff_start_addr, fs->blksz);
+				if (TI_cbuff_start_addr)
+					free(TI_cbuff_start_addr);
+
+				if (*total_remaining_blocks == 0)
+					break;
+			}
+			/*write the parent block */
+			put_ext4(((uint64_t) (TI_parent_blockno * fs->blksz)),
+				 TI_pbuff_start_addr, fs->blksz);
+			if (TI_pbuff_start_addr)
+				free(TI_pbuff_start_addr);
+
+			if (*total_remaining_blocks == 0)
+				break;
+		}
+		/*write the grand parent block */
+		put_ext4(((uint64_t) (TI_gp_blockno * fs->blksz)),
+			 TI_gp_buff_start_addr, fs->blksz);
+		file_inode->b.blocks.tripple_indir_block = TI_gp_blockno;
+	}
+fail:
+	if (TI_gp_buff_start_addr)
+		free(TI_gp_buff_start_addr);
+	return;
+}
+
+void allocate_blocks(struct ext2_inode *file_inode,
+		     unsigned int total_remaining_blocks,
+		     unsigned int *total_no_of_block)
+{
+	short i;
+	long int direct_blockno;
+	unsigned int no_blks_reqd = 0;
+
+	/*-------------START:Allocation of Blocks to Inode-------------*/
+	/*allocation of direct blocks */
+	for (i = 0; i < INDIRECT_BLOCKS; i++) {
+		direct_blockno = get_new_blk_no();
+		if (direct_blockno == -1) {
+			printf("no block left to assign\n");
+			return;
+		}
+		file_inode->b.blocks.dir_blocks[i] = direct_blockno;
+		debug("DB %ld: %u\n", direct_blockno, total_remaining_blocks);
+
+		total_remaining_blocks--;
+		if (total_remaining_blocks == 0)
+			break;
+	}
+
+	/*allocation of single indirect blocks */
+	alloc_single_indirect_block(file_inode, &total_remaining_blocks,
+				    &no_blks_reqd);
+
+	/*allocation of double indirect blocks */
+	alloc_double_indirect_block(file_inode, &total_remaining_blocks,
+				    &no_blks_reqd);
+
+	/*allocation of triple indirect blocks */
+	alloc_triple_indirect_block(file_inode, &total_remaining_blocks,
+				    &no_blks_reqd);
+
+	/*-----------------END:Allocation of Blocks to Inode-------------- */
+	*total_no_of_block += no_blks_reqd;
+	return;
+}
+
 long int read_allocated_block(struct ext2_inode *inode, int fileblock)
 {
 	long int blknr;
diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h
index 73f218d..a2a7e7a 100644
--- a/fs/ext4/ext4_common.h
+++ b/fs/ext4/ext4_common.h
@@ -41,4 +41,21 @@ 
 extern unsigned long part_offset;
 int ext4fs_read_inode(struct ext2_data *data, int ino,
 		      struct ext2_inode *inode);
+uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n);
+int ext4fs_checksum_update(unsigned int i);
+int get_parent_inode_num(char *dirname, char *dname, int flags);
+void update_parent_dentry(char *filename, int *p_ino, int file_type);
+long int get_new_blk_no(void);
+int get_new_inode_no(void);
+void reset_block_bmap(long int blockno, unsigned char *buffer, int index);
+int set_block_bmap(long int blockno, unsigned char *buffer, int index);
+int set_inode_bmap(int inode_no, unsigned char *buffer, int index);
+void reset_inode_bmap(int inode_no, unsigned char *buffer, int index);
+int iget(int inode_no, struct ext2_inode *inode);
+void allocate_blocks(struct ext2_inode *file_inode,
+		     unsigned int total_remaining_blocks,
+		     unsigned int *total_no_of_block);
+void put_ext4(uint64_t off, void *buf, uint32_t size);
+unsigned int be_le(unsigned int num);
+unsigned int le_be(unsigned int num);
 #endif
diff --git a/fs/ext4/ext4_journal.c b/fs/ext4/ext4_journal.c
new file mode 100644
index 0000000..fa9c89d
--- /dev/null
+++ b/fs/ext4/ext4_journal.c
@@ -0,0 +1,650 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+  * Journaling feature of ext4 has been referred from JBD2
+  * (Journaling Block device 2) implementation in Linux Kernel
+  */
+#include <common.h>
+#include "ext4_journal.h"
+#include <ext_common.h>
+#include <ext4fs.h>
+#include <malloc.h>
+
+static struct revoke_blk_list *revk_blk_list;
+static struct revoke_blk_list *prev_node;
+static int first_node = TRUE;
+
+int gindex;
+int gd_index;
+int jrnl_blk_idx;
+struct journal_log *journal_ptr[MAX_JOURNAL_ENTRIES];
+struct dirty_blocks *dirty_block_ptr[MAX_JOURNAL_ENTRIES];
+
+int init_journal(void)
+{
+	int i;
+	char *temp = NULL;
+	struct ext_filesystem *fs = get_fs();
+
+	/*init globals */
+	revk_blk_list = NULL;
+	prev_node = NULL;
+	gindex = 0;
+	gd_index = 0;
+	jrnl_blk_idx = 1;
+
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		journal_ptr[i] = (struct journal_log *)xzalloc
+		    (sizeof(struct journal_log));
+		if (!journal_ptr[i])
+			goto fail;
+		dirty_block_ptr[i] = (struct dirty_blocks *)
+		    xzalloc(sizeof(struct dirty_blocks));
+		if (!dirty_block_ptr[i])
+			goto fail;
+		journal_ptr[i]->buf = NULL;
+		journal_ptr[i]->blknr = -1;
+
+		dirty_block_ptr[i]->buf = NULL;
+		dirty_block_ptr[i]->blknr = -1;
+	}
+
+	if (fs->blksz == 4096) {
+		temp = (char *)xzalloc(fs->blksz);
+		if (!temp)
+			goto fail;
+		journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz);
+		if (!journal_ptr[gindex]->buf)
+			goto fail;
+		ext2fs_devread(0, 0, fs->blksz, temp);
+		memcpy(temp + SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE);
+		memcpy(journal_ptr[gindex]->buf, temp, fs->blksz);
+		journal_ptr[gindex++]->blknr = 0;
+		free(temp);
+	} else {
+		journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz);
+		if (!journal_ptr[gindex]->buf)
+			goto fail;
+		memcpy(journal_ptr[gindex]->buf, fs->sb, SUPERBLOCK_SIZE);
+		journal_ptr[gindex++]->blknr = 1;
+	}
+
+	/* Check the file system state using journal super block */
+	if (check_journal_state(SCAN))
+		goto fail;
+	if (check_journal_state(RECOVER))
+		goto fail;
+	return 0;
+fail:
+	return -1;
+}
+
+void dump_metadata(void)
+{
+	struct ext_filesystem *fs = get_fs();
+	int i;
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (dirty_block_ptr[i]->blknr == -1)
+			break;
+		put_ext4((uint64_t) (dirty_block_ptr[i]->blknr * fs->blksz),
+			 dirty_block_ptr[i]->buf, (uint32_t) fs->blksz);
+	}
+	return;
+}
+
+void free_journal(void)
+{
+	int i;
+	jrnl_blk_idx = 1;
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (dirty_block_ptr[i]->blknr == -1)
+			break;
+		if (dirty_block_ptr[i]->buf)
+			free(dirty_block_ptr[i]->buf);
+	}
+
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (journal_ptr[i]->blknr == -1)
+			break;
+		if (journal_ptr[i]->buf)
+			free(journal_ptr[i]->buf);
+	}
+
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (journal_ptr[i])
+			free(journal_ptr[i]);
+		if (dirty_block_ptr[i])
+			free(dirty_block_ptr[i]);
+	}
+	gindex = 0;
+	gd_index = 0;
+	return;
+}
+
+int log_gdt(char *gd_table)
+{
+	struct ext_filesystem *fs = get_fs();
+	short i;
+	long int var = fs->gdtable_blkno;
+	for (i = 0; i < fs->no_blk_pergdt; i++) {
+		journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz);
+		if (!journal_ptr[gindex]->buf)
+			return -1;
+		memcpy(journal_ptr[gindex]->buf, gd_table, fs->blksz);
+		gd_table += fs->blksz;
+		journal_ptr[gindex++]->blknr = var++;
+	}
+	return 0;
+}
+
+/* This function stores the backup copy of meta data in RAM
+*  journal_buffer -- Buffer containing meta data
+*  blknr -- Block number on disk of the meta data buffer
+*/
+int log_journal(char *journal_buffer, long int blknr)
+{
+	struct ext_filesystem *fs = get_fs();
+	short i;
+
+	if (!journal_buffer) {
+		printf("Invalid input arguments %s\n", __func__);
+		return -1;
+	}
+
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (journal_ptr[i]->blknr == -1)
+			break;
+		if (journal_ptr[i]->blknr == blknr)
+			return 0;
+	}
+
+	journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz);
+	if (!journal_ptr[gindex]->buf)
+		return -1;
+
+	memcpy(journal_ptr[gindex]->buf, journal_buffer, fs->blksz);
+	journal_ptr[gindex++]->blknr = blknr;
+	return 0;
+}
+
+/* This function stores the modified meta data in RAM
+*  metadata_buffer -- Buffer containing meta data
+*  blknr -- Block number on disk of the meta data buffer
+*/
+int put_metadata(char *metadata_buffer, long int blknr)
+{
+	struct ext_filesystem *fs = get_fs();
+	if (!metadata_buffer) {
+		printf("Invalid input arguments %s\n", __func__);
+		return -1;
+	}
+	dirty_block_ptr[gd_index]->buf = (char *)xzalloc(fs->blksz);
+	if (!dirty_block_ptr[gd_index]->buf)
+		return -1;
+	memcpy(dirty_block_ptr[gd_index]->buf, metadata_buffer, fs->blksz);
+	dirty_block_ptr[gd_index++]->blknr = blknr;
+	return 0;
+}
+
+/*------------------------------------*/
+/*Revoke block handling functions*/
+void print_revoke_blks(char *revk_blk)
+{
+	struct journal_revoke_header_t *header;
+	int offset, max;
+	long int blocknr;
+
+	if (revk_blk == NULL)
+		return;
+
+	header = (struct journal_revoke_header_t *) revk_blk;
+	offset = sizeof(struct journal_revoke_header_t);
+	max = be_le(header->r_count);
+	printf("total bytes %d\n", max);
+
+	while (offset < max) {
+		blocknr = be_le(*((long int *)(revk_blk + offset)));
+		printf("revoke blknr is %ld\n", blocknr);
+		offset += 4;
+	}
+	return;
+}
+
+static struct revoke_blk_list *_get_node(void)
+{
+	struct revoke_blk_list *tmp_node;
+	tmp_node = (struct revoke_blk_list *)
+		malloc(sizeof(struct revoke_blk_list));
+	if (tmp_node == NULL)
+		return NULL;
+	tmp_node->content = NULL;
+	tmp_node->next = NULL;
+	return tmp_node;
+}
+
+void push_revoke_blk(char *buffer)
+{
+	struct revoke_blk_list *node;
+	struct ext_filesystem *fs = get_fs();
+	if (buffer == NULL) {
+		printf("buffer ptr is NULL\n");
+		return;
+	}
+	node = _get_node();
+	if (!node) {
+		printf("_get_node: malloc failed\n");
+		return;
+	}
+
+	node->content = (char *)malloc(fs->blksz);
+	memcpy(node->content, buffer, fs->blksz);
+
+	if (first_node == TRUE) {
+		revk_blk_list = node;
+		prev_node = node;
+		first_node = FALSE;
+	} else {
+		prev_node->next = node;
+		prev_node = node;
+	}
+	return;
+}
+
+void free_revoke_blks()
+{
+	struct revoke_blk_list *tmp_node = revk_blk_list;
+	struct revoke_blk_list *next_node = NULL;
+
+	while (tmp_node != NULL) {
+		if (tmp_node->content)
+			free(tmp_node->content);
+		tmp_node = tmp_node->next;
+	}
+
+	tmp_node = revk_blk_list;
+	while (tmp_node != NULL) {
+		next_node = tmp_node->next;
+		free(tmp_node);
+		tmp_node = next_node;
+	}
+
+	revk_blk_list = NULL;
+	prev_node = NULL;
+	first_node = TRUE;
+	return;
+}
+
+int check_blknr_for_revoke(long int blknr, int sequence_no)
+{
+	struct journal_revoke_header_t *header;
+	int offset, max;
+	long int blocknr;
+	char *revk_blk;
+	struct revoke_blk_list *tmp_revk_node = revk_blk_list;
+	while (tmp_revk_node != NULL) {
+		revk_blk = tmp_revk_node->content;
+
+		header = (struct journal_revoke_header_t *) revk_blk;
+		if (sequence_no <= be_le(header->r_header.h_sequence)) {
+			offset = sizeof(struct journal_revoke_header_t);
+			max = be_le(header->r_count);
+
+			while (offset < max) {
+				blocknr = be_le(*((long int *)
+						  (revk_blk + offset)));
+				if (blocknr == blknr)
+					goto found;
+				offset += 4;
+			}
+		}
+		tmp_revk_node = tmp_revk_node->next;
+	}
+	return -1;
+
+found:
+	return 0;
+}
+
+/*
+* This function parses the journal blocks and replays the
+* suceessful transactions. A transaction is successfull
+* if commit block is found for a descriptor block
+* The tags in descriptor block contain the disk block
+* numbers of the metadata  to be replayed
+*/
+void recover_transaction(int prev_desc_logical_no)
+{
+	struct ext2_inode inode_journal;
+	struct ext_filesystem *fs = get_fs();
+	struct journal_header_t *jdb;
+	long int blknr;
+	char *p_jdb;
+	int ofs, flags;
+	int i;
+	struct ext3_journal_block_tag *tag;
+	char *temp_buff = (char *)xzalloc(fs->blksz);
+	char *metadata_buff = (char *)xzalloc(fs->blksz);
+	if (!temp_buff || !metadata_buff)
+		goto fail;
+	i = prev_desc_logical_no;
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
+			  (struct ext2_inode *)&inode_journal);
+	blknr = read_allocated_block((struct ext2_inode *)
+				     &inode_journal, i);
+	ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	p_jdb = (char *)temp_buff;
+	jdb = (struct journal_header_t *) temp_buff;
+	ofs = sizeof(struct journal_header_t);
+
+	do {
+		tag = (struct ext3_journal_block_tag *)&p_jdb[ofs];
+		ofs += sizeof(struct ext3_journal_block_tag);
+
+		if (ofs > fs->blksz)
+			break;
+
+		flags = be_le(tag->flags);
+		if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
+			ofs += 16;
+
+		i++;
+		debug("\t\ttag %u\n", be_le(tag->block));
+		if (revk_blk_list != NULL) {
+			if (check_blknr_for_revoke(be_le(tag->block),
+						   be_le(jdb->h_sequence)) ==
+			    0) {
+				continue;
+			}
+		}
+		blknr = read_allocated_block(&inode_journal, i);
+		ext2fs_devread(blknr * fs->sect_perblk, 0,
+			       fs->blksz, metadata_buff);
+		put_ext4((uint64_t) (be_le(tag->block) * fs->blksz),
+			 metadata_buff, (uint32_t) fs->blksz);
+	} while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
+fail:
+	if (temp_buff)
+		free(temp_buff);
+	if (metadata_buff)
+		free(metadata_buff);
+}
+
+void print_jrnl_status(int recovery_flag)
+{
+	if (recovery_flag == RECOVER)
+		printf("Journal Recovery Completed\n");
+	else
+		printf("Journal Scan Completed\n");
+	return;
+}
+
+int check_journal_state(int recovery_flag)
+{
+	struct ext2_inode inode_journal;
+	struct ext_filesystem *fs = get_fs();
+	struct journal_superblock_t *jsb;
+	struct journal_header_t *jdb;
+	char *p_jdb;
+	int i;
+	int DB_FOUND = NO;
+	long int blknr;
+	int transaction_state = TRANSACTION_COMPLETE;
+	int prev_desc_logical_no = 0;
+	int curr_desc_logical_no = 0;
+	int ofs, flags, block;
+	struct ext3_journal_block_tag *tag;
+	char *temp_buff, *temp_buff1;
+
+	temp_buff = (char *)xzalloc(fs->blksz);
+	if (!temp_buff)
+		return -1;
+	temp_buff1 = (char *)xzalloc(fs->blksz);
+	if (!temp_buff1) {
+		free(temp_buff);
+		return -1;
+	}
+
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
+	blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK);
+	ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	jsb = (struct journal_superblock_t *) temp_buff;
+
+	if (fs->sb->feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
+		if (recovery_flag == RECOVER)
+			printf("Recovery required\n");
+	} else {
+		if (recovery_flag == RECOVER)
+			printf("File System is consistent\n");
+		goto END;
+	}
+
+	if (be_le(jsb->s_start) == 0)
+		goto END;
+
+	if (!(jsb->s_feature_compat & le_be(JBD2_FEATURE_COMPAT_CHECKSUM)))
+		jsb->s_feature_compat |= le_be(JBD2_FEATURE_COMPAT_CHECKSUM);
+
+	i = be_le(jsb->s_first);
+	while (1) {
+		block = be_le(jsb->s_first);
+		blknr = read_allocated_block(&inode_journal, i);
+		memset(temp_buff1, '\0', fs->blksz);
+		ext2fs_devread(blknr * fs->sect_perblk,
+			       0, fs->blksz, temp_buff1);
+		jdb = (struct journal_header_t *) temp_buff1;
+
+		if (be_le(jdb->h_blocktype) == EXT3_JOURNAL_DESCRIPTOR_BLOCK) {
+			if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) {
+				print_jrnl_status(recovery_flag);
+				break;
+			}
+
+			curr_desc_logical_no = i;
+			if (transaction_state == TRANSACTION_COMPLETE)
+				transaction_state = TRANSACTION_RUNNING;
+			else
+				return -1;
+			p_jdb = (char *)temp_buff1;
+			ofs = sizeof(struct journal_header_t);
+			do {
+				tag = (struct ext3_journal_block_tag *)
+				    &p_jdb[ofs];
+				ofs += sizeof(struct ext3_journal_block_tag);
+				if (ofs > fs->blksz)
+					break;
+				flags = be_le(tag->flags);
+				if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
+					ofs += 16;
+				i++;
+				debug("\t\ttag %u\n", be_le(tag->block));
+			} while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
+			i++;
+			DB_FOUND = YES;
+		} else if (be_le(jdb->h_blocktype) ==
+				EXT3_JOURNAL_COMMIT_BLOCK) {
+			if ((be_le(jdb->h_sequence) != be_le(jsb->s_sequence))
+			    || (DB_FOUND == NO)) {
+				print_jrnl_status(recovery_flag);
+				break;
+			}
+
+			if (transaction_state == TRANSACTION_RUNNING) {
+				transaction_state = TRANSACTION_COMPLETE;
+				i++;
+				jsb->s_sequence =
+				    le_be(be_le(jsb->s_sequence) + 1);
+			}
+			prev_desc_logical_no = curr_desc_logical_no;
+			recover_transaction(prev_desc_logical_no);
+			DB_FOUND = NO;
+		} else if (be_le(jdb->h_blocktype) ==
+				EXT3_JOURNAL_REVOKE_BLOCK) {
+			if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) {
+				print_jrnl_status(recovery_flag);
+				break;
+			}
+			if (recovery_flag == SCAN)
+				push_revoke_blk((char *)jdb);
+			i++;
+		} else {
+			debug("Else Case\n");
+			if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) {
+				print_jrnl_status(recovery_flag);
+				break;
+			}
+		}
+	}
+
+END:
+	if (recovery_flag == RECOVER) {
+		jsb->s_start = le_be(1);
+		jsb->s_sequence = le_be(be_le(jsb->s_sequence) + 1);
+		ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE,
+			       (char *)fs->sb);
+		fs->sb->feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER;
+
+		put_ext4((uint64_t) (SUPERBLOCK_SIZE),
+			 (struct ext2_sblock *)fs->sb,
+			 (uint32_t) SUPERBLOCK_SIZE);
+		ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE,
+			       (char *)fs->sb);
+
+		blknr =
+		    read_allocated_block(&inode_journal,
+					 EXT2_JOURNAL_SUPERBLOCK);
+		put_ext4((uint64_t) (blknr * fs->blksz),
+			 (struct journal_superblock_t *)temp_buff,
+			 (uint32_t) fs->blksz);
+		free_revoke_blks();
+	}
+	free(temp_buff);
+	free(temp_buff1);
+
+	return 0;
+}
+
+static void update_descriptor_block(long int blknr)
+{
+	struct journal_header_t jdb;
+	struct ext3_journal_block_tag tag;
+	struct ext2_inode inode_journal;
+	struct journal_superblock_t *jsb;
+	long int jsb_blknr;
+	struct ext_filesystem *fs = get_fs();
+	char *buf = NULL, *temp = NULL;
+	int i;
+	char *temp_buff = (char *)xzalloc(fs->blksz);
+	if (!temp_buff)
+		return;
+
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
+	jsb_blknr = read_allocated_block(&inode_journal,
+					 EXT2_JOURNAL_SUPERBLOCK);
+	ext2fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	jsb = (struct journal_superblock_t *) temp_buff;
+
+	jdb.h_blocktype = le_be(EXT3_JOURNAL_DESCRIPTOR_BLOCK);
+	jdb.h_magic = le_be(EXT3_JOURNAL_MAGIC_NUMBER);
+	jdb.h_sequence = jsb->s_sequence;
+	buf = (char *)xzalloc(fs->blksz);
+	if (!buf) {
+		free(temp_buff);
+		return;
+	}
+	temp = buf;
+	memcpy(buf, &jdb, sizeof(struct journal_header_t));
+	temp += sizeof(struct journal_header_t);
+
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (journal_ptr[i]->blknr == -1)
+			break;
+
+		tag.block = le_be(journal_ptr[i]->blknr);
+		tag.flags = le_be(EXT3_JOURNAL_FLAG_SAME_UUID);
+		memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag));
+		temp = temp + sizeof(struct ext3_journal_block_tag);
+	}
+
+	tag.block = le_be(journal_ptr[--i]->blknr);
+	tag.flags = le_be(EXT3_JOURNAL_FLAG_LAST_TAG);
+	memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag,
+	       sizeof(struct ext3_journal_block_tag));
+	put_ext4((uint64_t) (blknr * fs->blksz), buf, (uint32_t) fs->blksz);
+
+	free(temp_buff);
+	free(buf);
+}
+
+static void update_commit_block(long int blknr)
+{
+	struct journal_header_t jdb;
+	struct ext_filesystem *fs = get_fs();
+	char *buf = NULL;
+	struct ext2_inode inode_journal;
+	struct journal_superblock_t *jsb;
+	long int jsb_blknr;
+	char *temp_buff = (char *)xzalloc(fs->blksz);
+	if (!temp_buff)
+		return;
+
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
+	jsb_blknr = read_allocated_block(&inode_journal,
+					 EXT2_JOURNAL_SUPERBLOCK);
+	ext2fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	jsb = (struct journal_superblock_t *) temp_buff;
+
+	jdb.h_blocktype = le_be(EXT3_JOURNAL_COMMIT_BLOCK);
+	jdb.h_magic = le_be(EXT3_JOURNAL_MAGIC_NUMBER);
+	jdb.h_sequence = jsb->s_sequence;
+	buf = (char *)xzalloc(fs->blksz);
+	if (!buf) {
+		free(temp_buff);
+		return;
+	}
+	memcpy(buf, &jdb, sizeof(struct journal_header_t));
+	put_ext4((uint64_t) (blknr * fs->blksz), buf, (uint32_t) fs->blksz);
+
+	free(temp_buff);
+	free(buf);
+}
+
+void update_journal(void)
+{
+	struct ext2_inode inode_journal;
+	struct ext_filesystem *fs = get_fs();
+	long int blknr;
+	int i;
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
+	blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++);
+	update_descriptor_block(blknr);
+	for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
+		if (journal_ptr[i]->blknr == -1)
+			break;
+		blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++);
+		put_ext4((uint64_t) (blknr * fs->blksz),
+			 journal_ptr[i]->buf, (uint32_t) fs->blksz);
+	}
+	blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++);
+	update_commit_block(blknr);
+	printf("update journal finished\n");
+}
diff --git a/fs/ext4/ext4_journal.h b/fs/ext4/ext4_journal.h
new file mode 100644
index 0000000..e4413d2
--- /dev/null
+++ b/fs/ext4/ext4_journal.h
@@ -0,0 +1,147 @@ 
+/*
+ * (C) Copyright 2011 Samsung Electronics
+ * EXT4 filesystem implementation in Uboot by
+ * Uma Shankar <uma.shankar@samsung.com>
+ * Manjunatha C Achar <a.manjunatha@samsung.com>
+ *
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Journaling feature of ext4 has been referred from JBD2
+ * (Journaling Block device 2) implementation in Linux Kernel
+ */
+
+#ifndef __EXT4_JRNL__
+#define __EXT4_JRNL__
+
+#include "ext4_common.h"
+
+#define EXT2_JOURNAL_INO		8 /* Journal inode */
+#define EXT2_JOURNAL_SUPERBLOCK	0 /* Journal  Superblock number */
+
+#define JBD2_FEATURE_COMPAT_CHECKSUM	0x00000001
+#define EXT3_JOURNAL_MAGIC_NUMBER	0xc03b3998U
+#define TRANSACTION_RUNNING		1
+#define TRANSACTION_COMPLETE		0
+#define EXT3_FEATURE_INCOMPAT_RECOVER	0x0004	/* Needs recovery */
+#define EXT3_JOURNAL_DESCRIPTOR_BLOCK	1
+#define EXT3_JOURNAL_COMMIT_BLOCK	2
+#define EXT3_JOURNAL_SUPERBLOCK_V1	3
+#define EXT3_JOURNAL_SUPERBLOCK_V2	4
+#define EXT3_JOURNAL_REVOKE_BLOCK	5
+#define EXT3_JOURNAL_FLAG_ESCAPE	1
+#define EXT3_JOURNAL_FLAG_SAME_UUID	2
+#define EXT3_JOURNAL_FLAG_DELETED	4
+#define EXT3_JOURNAL_FLAG_LAST_TAG	8
+
+/* Maximum entries in 1 journal transaction */
+#define MAX_JOURNAL_ENTRIES		100
+struct journal_log {
+	char *buf;
+	int blknr;
+};
+
+struct dirty_blocks {
+	char *buf;
+	int blknr;
+};
+
+/*
+ * Standard header for all descriptor blocks:
+ */
+struct journal_header_t {
+	__u32 h_magic;
+	__u32 h_blocktype;
+	__u32 h_sequence;
+};
+
+/*
+ * The journal superblock.  All fields are in big-endian byte order.
+ */
+struct journal_superblock_t {
+	/* 0x0000 */
+	struct journal_header_t s_header;
+
+	/* 0x000C */
+	/* Static information describing the journal */
+	__u32 s_blocksize;	/* journal device blocksize */
+	__u32 s_maxlen;		/* total blocks in journal file */
+	__u32 s_first;		/* first block of log information */
+
+	/* 0x0018 */
+	/* Dynamic information describing the current state of the log */
+	__u32 s_sequence;	/* first commit ID expected in log */
+	__u32 s_start;		/* blocknr of start of log */
+
+	/* 0x0020 */
+	/* Error value, as set by journal_abort(). */
+	__s32 s_errno;
+
+	/* 0x0024 */
+	/* Remaining fields are only valid in a version-2 superblock */
+	__u32 s_feature_compat;	/* compatible feature set */
+	__u32 s_feature_incompat;	/* incompatible feature set */
+	__u32 s_feature_ro_compat;	/* readonly-compatible feature set */
+	/* 0x0030 */
+	__u8 s_uuid[16];	/* 128-bit uuid for journal */
+
+	/* 0x0040 */
+	__u32 s_nr_users;	/* Nr of filesystems sharing log */
+
+	__u32 s_dynsuper;	/* Blocknr of dynamic superblock copy */
+
+	/* 0x0048 */
+	__u32 s_max_transaction;	/* Limit of journal blocks per trans. */
+	__u32 s_max_trans_data;	/* Limit of data blocks per trans. */
+
+	/* 0x0050 */
+	__u32 s_padding[44];
+
+	/* 0x0100 */
+	__u8 s_users[16 * 48];	/* ids of all fs'es sharing the log */
+	/* 0x0400 */
+} ;
+
+struct ext3_journal_block_tag {
+	uint32_t block;
+	uint32_t flags;
+};
+
+struct journal_revoke_header_t {
+	struct journal_header_t r_header;
+	int r_count;		/* Count of bytes used in the block */
+};
+
+struct revoke_blk_list {
+	char *content;		/*revoke block itself */
+	struct revoke_blk_list *next;
+};
+
+extern struct ext2_data *ext4fs_root;
+
+int init_journal(void);
+void deinit_journal(void);
+int log_gdt(char *gd_table);
+void update_journal(void);
+int check_journal_state(int recovery_flag);
+int log_journal(char *journal_buffer, long int blknr);
+int put_metadata(char *metadata_buffer, long int blknr);
+void dump_metadata(void);
+void free_journal(void);
+void free_revoke_blks(void);
+void push_revoke_blk(char *buffer);
+#endif
diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c
index d4faa16..0a033aa 100644
--- a/fs/ext4/ext4fs.c
+++ b/fs/ext4/ext4fs.c
@@ -22,7 +22,13 @@ 
 
 /*
  *  ext4load - based on code from GRUB2  fs/ext2.c
-*/
+ *
+ * ext4write - based on existing ext2 support in UBOOT and ext4
+ * implementation in Linux Kernel.
+ * Journaling feature of ext4 has been referred from JBD2
+ * (Journaling Block device 2) implementation in Linux Kernel
+ */
+
 #include <common.h>
 #include <malloc.h>
 #include <asm/byteorder.h>
@@ -31,6 +37,7 @@ 
 #include <ext_common.h>
 #include <ext4fs.h>
 #include "ext4_common.h"
+#include "ext4_journal.h"
 
 int ext4fs_symlinknest;
 block_dev_desc_t *ext4_dev_desc;
@@ -213,3 +220,1032 @@  int ext4fs_read(char *buf, unsigned len)
 		return 0;
 	return  ext4fs_read_file(ext4fs_file, 0, len, buf);
 }
+
+static void ext4fs_update(void)
+{
+	short i;
+	update_journal();
+	struct ext_filesystem *fs = get_fs();
+
+	/*Update the super block */
+	put_ext4((uint64_t) (SUPERBLOCK_SIZE),
+		 (struct ext2_sblock *)fs->sb, (uint32_t) SUPERBLOCK_SIZE);
+
+	/*update the block group */
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		fs->gd[i].bg_checksum = ext4fs_checksum_update(i);
+		put_ext4((uint64_t) (fs->gd[i].block_id * fs->blksz),
+			 fs->blk_bmaps[i], (uint32_t) fs->blksz);
+	}
+
+	/*update the inode table group */
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		put_ext4((uint64_t) (fs->gd[i].inode_id * fs->blksz),
+			 fs->inode_bmaps[i], (uint32_t) fs->blksz);
+	}
+
+	/*update the block group descriptor table */
+	put_ext4((uint64_t) (fs->gdtable_blkno * fs->blksz),
+		 (struct ext2_block_group *)fs->gdtable, (uint32_t)
+		 (fs->blksz * fs->no_blk_pergdt));
+
+	dump_metadata();
+
+	gindex = 0;
+	gd_index = 0;
+}
+
+int ext4fs_get_bgdtable(void)
+{
+	int status;
+	int grp_desc_size;
+	struct ext_filesystem *fs = get_fs();
+	grp_desc_size = sizeof(struct ext2_block_group);
+	fs->no_blk_pergdt = (fs->no_blkgrp * grp_desc_size) / fs->blksz;
+	if ((fs->no_blkgrp * grp_desc_size) % fs->blksz)
+		fs->no_blk_pergdt++;
+
+	/*allocate mem for gdtable */
+	fs->gdtable = (char *)xzalloc(fs->blksz * fs->no_blk_pergdt);
+	if (!fs->gdtable)
+		return -1;
+	/*Read the first group descriptor table */
+	status = ext2fs_devread(fs->gdtable_blkno * fs->sect_perblk, 0,
+				fs->blksz * fs->no_blk_pergdt, fs->gdtable);
+	if (status == 0)
+		goto fail;
+
+	if (log_gdt(fs->gdtable)) {
+		printf("Error in log_gdt\n");
+		return -1;
+	}
+
+	return 0;
+fail:
+	if (fs->gdtable) {
+		free(fs->gdtable);
+		fs->gdtable = NULL;
+	}
+	return -1;
+}
+
+static void delete_single_indirect_block(struct ext2_inode *inode)
+{
+	struct ext2_block_group *gd;
+	static int prev_bg_bitmap_index = -1;
+	long int blknr;
+	int remainder;
+	int bg_idx;
+	int status;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer)
+		return;
+	/*get the block group descriptor table */
+	gd = (struct ext2_block_group *)fs->gdtable;
+
+	/*deleting the single indirect block associated with inode */
+	if (inode->b.blocks.indir_block != 0) {
+		debug("SIPB releasing %u\n", inode->b.blocks.indir_block);
+		blknr = inode->b.blocks.indir_block;
+		if (fs->blksz != 1024) {
+			bg_idx = blknr / (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+		} else {
+			bg_idx = blknr /
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+			remainder = blknr % (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+			if (!remainder)
+				bg_idx--;
+		}
+		reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
+		gd[bg_idx].free_blocks++;
+		fs->sb->free_blocks++;
+		/*journal backup */
+		if (prev_bg_bitmap_index != bg_idx) {
+			status =
+			    ext2fs_devread(gd[bg_idx].block_id *
+					   fs->sect_perblk, 0, fs->blksz,
+					   journal_buffer);
+			if (status == 0)
+				goto fail;
+			if (log_journal(journal_buffer, gd[bg_idx].block_id))
+				goto fail;
+			prev_bg_bitmap_index = bg_idx;
+		}
+	}
+fail:
+	if (journal_buffer)
+		free(journal_buffer);
+	return;
+
+}
+
+/*deleting the double indirect blocks */
+static void delete_double_indirect_block(struct ext2_inode *inode)
+{
+	int i;
+	short status;
+	static int prev_bg_bitmap_index = -1;
+	long int blknr;
+	int remainder;
+	int bg_idx;
+	unsigned int *double_indirect_buffer;
+	unsigned int *DIB_start_addr = NULL;
+	struct ext2_block_group *gd;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer)
+		return;
+	/*get the block group descriptor table */
+	gd = (struct ext2_block_group *)fs->gdtable;
+
+	if (inode->b.blocks.double_indir_block != 0) {
+		double_indirect_buffer = (unsigned int *)xzalloc(fs->blksz);
+		if (!double_indirect_buffer)
+			return;
+		DIB_start_addr = (unsigned int *)double_indirect_buffer;
+		blknr = inode->b.blocks.double_indir_block;
+		status = ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+					(char *)double_indirect_buffer);
+		for (i = 0; i < fs->blksz / sizeof(int); i++) {
+			if (*double_indirect_buffer == 0)
+				break;
+
+			debug("DICB releasing %u\n", *double_indirect_buffer);
+			if (fs->blksz != 1024) {
+				bg_idx = (*double_indirect_buffer) /
+				    (uint32_t) ext4fs_root->sblock.
+				    blocks_per_group;
+			} else {
+				bg_idx = (*double_indirect_buffer) /
+				    (uint32_t) ext4fs_root->sblock.
+				    blocks_per_group;
+				remainder =
+				    (*double_indirect_buffer) %
+				    (uint32_t) ext4fs_root->sblock.
+				    blocks_per_group;
+				if (!remainder)
+					bg_idx--;
+			}
+			reset_block_bmap(*double_indirect_buffer,
+					 fs->blk_bmaps[bg_idx], bg_idx);
+			double_indirect_buffer++;
+			gd[bg_idx].free_blocks++;
+			fs->sb->free_blocks++;
+			/*journal backup */
+			if (prev_bg_bitmap_index != bg_idx) {
+				status = ext2fs_devread(gd[bg_idx].block_id
+							* fs->sect_perblk, 0,
+							fs->blksz,
+							journal_buffer);
+				if (status == 0)
+					goto fail;
+
+				if (log_journal(journal_buffer,
+						gd[bg_idx].block_id))
+					goto fail;
+				prev_bg_bitmap_index = bg_idx;
+			}
+		}
+
+		/*removing the parent double indirect block */
+		/*find the bitmap index */
+		blknr = inode->b.blocks.double_indir_block;
+		if (fs->blksz != 1024) {
+			bg_idx = blknr / (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+		} else {
+			bg_idx = blknr /
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+			remainder =
+			    blknr %
+			    (uint32_t) ext4fs_root->sblock.blocks_per_group;
+			if (!remainder)
+				bg_idx--;
+		}
+		reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
+		gd[bg_idx].free_blocks++;
+		fs->sb->free_blocks++;
+		/*journal backup */
+		if (prev_bg_bitmap_index != bg_idx) {
+			memset(journal_buffer, '\0', fs->blksz);
+			status = ext2fs_devread(gd[bg_idx].block_id *
+						fs->sect_perblk, 0, fs->blksz,
+						journal_buffer);
+			if (status == 0)
+				goto fail;
+
+			if (log_journal(journal_buffer, gd[bg_idx].block_id))
+				goto fail;
+			prev_bg_bitmap_index = bg_idx;
+		}
+		debug("DIPB releasing %ld\n", blknr);
+	}
+fail:
+	if (DIB_start_addr)
+		free(DIB_start_addr);
+	if (journal_buffer)
+		free(journal_buffer);
+	return;
+}
+
+/*deleting the triple indirect blocks */
+static void delete_triple_indirect_block(struct ext2_inode *inode)
+{
+	int i, j;
+	short status;
+	static int prev_bg_bitmap_index = -1;
+	long int blknr;
+	int remainder;
+	int bg_idx;
+	unsigned int *TIGP_buffer = NULL;
+	unsigned int *TIB_start_addr = NULL;
+	unsigned int *TIP_buffer = NULL;
+	unsigned int *TIPB_start_addr = NULL;
+	struct ext2_block_group *gd;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer)
+		return;
+	/*get the block group descriptor table */
+	gd = (struct ext2_block_group *)fs->gdtable;
+
+	if (inode->b.blocks.tripple_indir_block != 0) {
+		TIGP_buffer = (unsigned int *)xzalloc(fs->blksz);
+		if (!TIGP_buffer)
+			return;
+		TIB_start_addr = (unsigned int *)TIGP_buffer;
+		blknr = inode->b.blocks.tripple_indir_block;
+		status = ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+					(char *)TIGP_buffer);
+		for (i = 0; i < fs->blksz / sizeof(int); i++) {
+			if (*TIGP_buffer == 0)
+				break;
+			debug("TIGPB releasing %u\n", *TIGP_buffer);
+
+			TIP_buffer = (unsigned int *)xzalloc(fs->blksz);
+			if (!TIP_buffer)
+				goto fail;
+			TIPB_start_addr = (unsigned int *)TIP_buffer;
+			status = ext2fs_devread((*TIGP_buffer) *
+						fs->sect_perblk, 0, fs->blksz,
+						(char *)TIP_buffer);
+			for (j = 0; j < fs->blksz / sizeof(int); j++) {
+				if (*TIP_buffer == 0)
+					break;
+				if (fs->blksz != 1024) {
+					bg_idx = (*TIP_buffer) / (uint32_t)
+					    ext4fs_root->sblock.
+					    blocks_per_group;
+				} else {
+					bg_idx = (*TIP_buffer) / (uint32_t)
+					    ext4fs_root->sblock.
+					    blocks_per_group;
+
+					remainder = (*TIP_buffer) % (uint32_t)
+					    ext4fs_root->sblock.
+					    blocks_per_group;
+					if (!remainder)
+						bg_idx--;
+				}
+
+				reset_block_bmap(*TIP_buffer,
+						 fs->blk_bmaps[bg_idx], bg_idx);
+
+				TIP_buffer++;
+				gd[bg_idx].free_blocks++;
+				fs->sb->free_blocks++;
+				/*journal backup */
+				if (prev_bg_bitmap_index != bg_idx) {
+					status =
+					    ext2fs_devread(gd[bg_idx].block_id *
+							   fs->sect_perblk, 0,
+							   fs->blksz,
+							   journal_buffer);
+					if (status == 0)
+						goto fail;
+
+					if (log_journal(journal_buffer,
+							gd[bg_idx].block_id))
+						goto fail;
+					prev_bg_bitmap_index = bg_idx;
+				}
+			}
+			if (TIPB_start_addr) {
+				free(TIPB_start_addr);
+				TIPB_start_addr = NULL;
+			}
+
+			/*removing the grand parent blocks
+			 *which is connected to inode
+			 */
+			if (fs->blksz != 1024) {
+				bg_idx = (*TIGP_buffer) / (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+			} else {
+				bg_idx = (*TIGP_buffer) / (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+
+				remainder = (*TIGP_buffer) % (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+				if (!remainder)
+					bg_idx--;
+			}
+			reset_block_bmap(*TIGP_buffer,
+					 fs->blk_bmaps[bg_idx], bg_idx);
+
+			TIGP_buffer++;
+			gd[bg_idx].free_blocks++;
+			fs->sb->free_blocks++;
+			/*journal backup */
+			if (prev_bg_bitmap_index != bg_idx) {
+				memset(journal_buffer, '\0', fs->blksz);
+				status =
+				    ext2fs_devread(gd[bg_idx].block_id *
+						   fs->sect_perblk, 0,
+						   fs->blksz, journal_buffer);
+				if (status == 0)
+					goto fail;
+
+				if (log_journal(journal_buffer,
+						gd[bg_idx].block_id))
+					goto fail;
+				prev_bg_bitmap_index = bg_idx;
+			}
+		}
+
+		/*removing the grand parent triple indirect block */
+		/*find the bitmap index */
+		blknr = inode->b.blocks.tripple_indir_block;
+		if (fs->blksz != 1024) {
+			bg_idx = blknr / (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+		} else {
+			bg_idx = blknr / (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+			remainder = blknr % (uint32_t)
+			    ext4fs_root->sblock.blocks_per_group;
+			if (!remainder)
+				bg_idx--;
+		}
+		reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
+		gd[bg_idx].free_blocks++;
+		fs->sb->free_blocks++;
+		/*journal backup */
+		if (prev_bg_bitmap_index != bg_idx) {
+			memset(journal_buffer, '\0', fs->blksz);
+			status = ext2fs_devread(gd[bg_idx].block_id
+						* fs->sect_perblk, 0, fs->blksz,
+						journal_buffer);
+			if (status == 0)
+				goto fail;
+
+			if (log_journal(journal_buffer, gd[bg_idx].block_id))
+				goto fail;
+			prev_bg_bitmap_index = bg_idx;
+		}
+		debug("TIGPB iteself releasing %ld\n", blknr);
+	}
+fail:
+	if (TIB_start_addr)
+		free(TIB_start_addr);
+	if (TIPB_start_addr)
+		free(TIPB_start_addr);
+	if (journal_buffer)
+		free(journal_buffer);
+	return;
+}
+
+static int ext4fs_delete_file(int inodeno)
+{
+	struct ext2_inode inode;
+	short status;
+	int i;
+	int remainder;
+	long int blknr;
+	int bg_idx;
+	int inode_bitmap_index;
+	char *read_buffer;
+	char *start_block_address = NULL;
+	unsigned int no_blocks;
+
+	static int prev_bg_bitmap_index = -1;
+	unsigned int inodes_per_block;
+	long int blkno;
+	unsigned int blkoff;
+	struct ext2_inode *inode_buffer;
+	struct ext2_block_group *gd;
+	struct ext_filesystem *fs = get_fs();
+	char *journal_buffer = (char *)xzalloc(fs->blksz);
+	if (!journal_buffer)
+		return -1;
+	/*get the block group descriptor table */
+	gd = (struct ext2_block_group *)fs->gdtable;
+	status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
+	if (status == 0)
+		goto fail;
+
+	/*read the block no allocated to a file */
+	no_blocks = inode.size / fs->blksz;
+	if (inode.size % fs->blksz)
+		no_blocks++;
+
+	if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FLAG) {
+		struct ext2fs_node *node_inode =
+		    (struct ext2fs_node *) xzalloc(sizeof(struct ext2fs_node));
+		if (!node_inode)
+			goto fail;
+		node_inode->data = ext4fs_root;
+		node_inode->ino = inodeno;
+		node_inode->inode_read = 0;
+		memcpy(&(node_inode->inode), &inode, sizeof(struct ext2_inode));
+
+		for (i = 0; i < no_blocks; i++) {
+			blknr = read_allocated_block(&(node_inode->inode), i);
+			if (fs->blksz != 1024) {
+				bg_idx = blknr / (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+			} else {
+				bg_idx = blknr / (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+				remainder = blknr % (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+				if (!remainder)
+					bg_idx--;
+			}
+			reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
+			debug("EXT4_EXTENTS Block releasing %ld: %d\n",
+			      blknr, bg_idx);
+
+			gd[bg_idx].free_blocks++;
+			fs->sb->free_blocks++;
+
+			/*journal backup */
+			if (prev_bg_bitmap_index != bg_idx) {
+				status =
+				    ext2fs_devread(gd[bg_idx].block_id *
+						   fs->sect_perblk, 0,
+						   fs->blksz, journal_buffer);
+				if (status == 0)
+					goto fail;
+				if (log_journal(journal_buffer,
+						gd[bg_idx].block_id))
+					goto fail;
+				prev_bg_bitmap_index = bg_idx;
+			}
+		}
+		if (node_inode) {
+			free(node_inode);
+			node_inode = NULL;
+		}
+	} else {
+		/*deleting the single indirect block associated with inode */
+		delete_single_indirect_block(&inode);
+
+		/*deleting the double indirect blocks */
+		delete_double_indirect_block(&inode);
+
+		/*deleting the triple indirect blocks */
+		delete_triple_indirect_block(&inode);
+
+		/*read the block no allocated to a file */
+		no_blocks = inode.size / fs->blksz;
+		if (inode.size % fs->blksz)
+			no_blocks++;
+		for (i = 0; i < no_blocks; i++) {
+			blknr = read_allocated_block(&inode, i);
+			if (fs->blksz != 1024) {
+				bg_idx = blknr /
+				    (uint32_t) ext4fs_root->sblock.
+				    blocks_per_group;
+			} else {
+				bg_idx =
+				    blknr /
+				    (uint32_t) ext4fs_root->sblock.
+				    blocks_per_group;
+				remainder = blknr % (uint32_t)
+				    ext4fs_root->sblock.blocks_per_group;
+				if (!remainder)
+					bg_idx--;
+			}
+			reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
+			debug("ActualB releasing %ld: %d\n", blknr, bg_idx);
+
+			gd[bg_idx].free_blocks++;
+			fs->sb->free_blocks++;
+			/*journal backup */
+			if (prev_bg_bitmap_index != bg_idx) {
+				memset(journal_buffer, '\0', fs->blksz);
+				status = ext2fs_devread(gd[bg_idx].block_id
+							* fs->sect_perblk,
+							0, fs->blksz,
+							journal_buffer);
+				if (status == 0) {
+					free(journal_buffer);
+					goto fail;
+				}
+				if (log_journal(journal_buffer,
+						gd[bg_idx].block_id))
+					goto fail;
+				prev_bg_bitmap_index = bg_idx;
+			}
+		}
+	}
+
+	/*from the inode no to blockno */
+	inodes_per_block = EXT2_BLOCK_SIZE(ext4fs_root) / fs->inodesz;
+	inode_bitmap_index = inodeno /
+	    (uint32_t) ext4fs_root->sblock.inodes_per_group;
+
+	/*get the block no */
+	inodeno--;
+	blkno = __le32_to_cpu(gd[inode_bitmap_index].inode_table_id) +
+	    (inodeno % __le32_to_cpu(ext4fs_root->sblock.inodes_per_group))
+	    / inodes_per_block;
+
+	/*get the offset of the inode */
+	blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
+
+	/*read the block no containing the inode */
+	read_buffer = (char *)xzalloc(fs->blksz);
+	if (!read_buffer)
+		goto fail;
+	start_block_address = read_buffer;
+	status = ext2fs_devread(blkno * fs->sect_perblk,
+				0, fs->blksz, read_buffer);
+	if (status == 0)
+		goto fail;
+
+	if (log_journal(read_buffer, blkno))
+		goto fail;
+
+	read_buffer = read_buffer + blkoff;
+	inode_buffer = (struct ext2_inode *)read_buffer;
+	memset(inode_buffer, '\0', sizeof(struct ext2_inode));
+
+	/*write the inode to original position in inode table */
+	if (put_metadata(start_block_address, blkno))
+		goto fail;
+
+	/*update the respective inode bitmaps */
+	inodeno++;
+	reset_inode_bmap(inodeno, fs->inode_bmaps
+			 [inode_bitmap_index], inode_bitmap_index);
+	gd[inode_bitmap_index].free_inodes++;
+	fs->sb->free_inodes++;
+	/*journal backup */
+	memset(journal_buffer, '\0', fs->blksz);
+	status = ext2fs_devread(gd[inode_bitmap_index].inode_id *
+				fs->sect_perblk, 0, fs->blksz, journal_buffer);
+	if (status == 0)
+		goto fail;
+	if (log_journal(journal_buffer, gd[inode_bitmap_index].inode_id))
+		goto fail;
+
+	ext4fs_update();
+	ext4fs_deinit();
+
+	if (ext4fs_init() != 0) {
+		printf("error in File System init\n");
+		goto fail;
+	}
+
+	/*free */
+	if (start_block_address)
+		free(start_block_address);
+	if (journal_buffer)
+		free(journal_buffer);
+	return 0;
+
+fail:
+	if (start_block_address)
+		free(start_block_address);
+	if (journal_buffer)
+		free(journal_buffer);
+	return -1;
+}
+
+int ext4fs_init(void)
+{
+	short status;
+	int i;
+	int sector_per_block;
+	unsigned int real_free_blocks = 0;
+	struct ext_filesystem *fs = get_fs();
+
+	/*populate fs */
+	fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
+	fs->inodesz = INODE_SIZE_FILESYSTEM(ext4fs_root);
+	fs->sect_perblk = fs->blksz / SECTOR_SIZE;
+
+	sector_per_block = fs->sect_perblk;
+	/*get the superblock */
+	fs->sb = (struct ext2_sblock *)xzalloc(SUPERBLOCK_SIZE);
+	if (!fs->sb)
+		return -1;
+	status = ext2fs_devread(SUPERBLOCK_SECTOR, 0,
+				SUPERBLOCK_SIZE, (char *)fs->sb);
+	if (status == 0)
+		goto fail;
+
+	/*init journal */
+	if (init_journal())
+		goto fail;
+
+	/*get the no of blockgroups */
+
+	fs->no_blkgrp = (uint32_t) ext4fs_div_roundup
+	    ((uint32_t) (ext4fs_root->sblock.total_blocks
+			 - ext4fs_root->sblock.first_data_block),
+	     (uint32_t) ext4fs_root->sblock.blocks_per_group);
+
+	/*get the block group descriptor table */
+	fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
+	if (ext4fs_get_bgdtable() == -1) {
+		printf("*Eror in getting the block group descriptor table\n");
+		goto fail;
+	} else {
+		fs->gd = (struct ext2_block_group *)fs->gdtable;
+	}
+
+	/*load all the available bitmap block of the partition */
+	fs->blk_bmaps = (unsigned char **)xzalloc
+	    (fs->no_blkgrp * sizeof(unsigned char *));
+	if (!fs->blk_bmaps)
+		goto fail;
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		fs->blk_bmaps[i] = (unsigned char *)xzalloc(fs->blksz);
+		if (!fs->blk_bmaps[i])
+			goto fail;
+	}
+
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		status =
+		    ext2fs_devread(fs->gd[i].block_id * sector_per_block, 0,
+				   fs->blksz, (char *)fs->blk_bmaps[i]);
+		if (status == 0)
+			goto fail;
+	}
+
+	/*load all the available inode bitmap of the partition */
+	fs->inode_bmaps = (unsigned char **)xzalloc
+	    (fs->no_blkgrp * sizeof(unsigned char *));
+	if (!fs->inode_bmaps)
+		goto fail;
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		fs->inode_bmaps[i] = (unsigned char *)xzalloc(fs->blksz);
+		if (!fs->inode_bmaps[i])
+			goto fail;
+	}
+
+	for (i = 0; i < fs->no_blkgrp; i++) {
+		status = ext2fs_devread(fs->gd[i].inode_id * sector_per_block,
+					0, fs->blksz,
+					(char *)fs->inode_bmaps[i]);
+		if (status == 0)
+			goto fail;
+	}
+
+	/*
+	 *check filesystem consistency with free blocks of file system
+	 *some time we observed that superblock freeblocks does not match
+	 *with the  blockgroups freeblocks when improper
+	 *reboot of a linux kernel
+	 */
+	for (i = 0; i < fs->no_blkgrp; i++)
+		real_free_blocks = real_free_blocks + fs->gd[i].free_blocks;
+	if (real_free_blocks != fs->sb->free_blocks)
+		fs->sb->free_blocks = real_free_blocks;
+	return 0;
+
+fail:
+	ext4fs_deinit();
+	return -1;
+}
+
+void ext4fs_deinit(void)
+{
+	int i;
+	struct ext2_inode inode_journal;
+	struct journal_superblock_t *jsb;
+	long int blknr;
+	struct ext_filesystem *fs = get_fs();
+	/*free journal */
+	char *temp_buff = (char *)xzalloc(fs->blksz);
+	if (temp_buff) {
+		ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
+				  &inode_journal);
+		blknr =
+		    read_allocated_block(&inode_journal,
+					 EXT2_JOURNAL_SUPERBLOCK);
+		ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+			       temp_buff);
+		jsb = (struct journal_superblock_t *)temp_buff;
+		jsb->s_start = le_be(0);
+		put_ext4((uint64_t) (blknr * fs->blksz),
+			 (struct journal_superblock_t *)temp_buff,
+			 (uint32_t) fs->blksz);
+		free(temp_buff);
+	}
+	free_journal();
+	/*get the superblock */
+	ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE, (char *)fs->sb);
+	fs->sb->feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
+	put_ext4((uint64_t) (SUPERBLOCK_SIZE),
+		 (struct ext2_sblock *)fs->sb, (uint32_t) SUPERBLOCK_SIZE);
+	if (fs->sb) {
+		free(fs->sb);
+		fs->sb = NULL;
+	}
+
+	if (fs->blk_bmaps) {
+		for (i = 0; i < fs->no_blkgrp; i++) {
+			if (fs->blk_bmaps[i]) {
+				free(fs->blk_bmaps[i]);
+				fs->blk_bmaps[i] = NULL;
+			}
+		}
+		free(fs->blk_bmaps);
+		fs->blk_bmaps = NULL;
+	}
+
+	if (fs->inode_bmaps) {
+		for (i = 0; i < fs->no_blkgrp; i++) {
+			if (fs->inode_bmaps[i]) {
+				free(fs->inode_bmaps[i]);
+				fs->inode_bmaps[i] = NULL;
+			}
+		}
+		free(fs->inode_bmaps);
+		fs->inode_bmaps = NULL;
+	}
+
+	if (fs->gdtable) {
+		free(fs->gdtable);
+		fs->gdtable = NULL;
+	}
+	fs->gd = NULL;
+	/*
+	 *Reinitiliazed the global inode and
+	 *block bitmap first execution check variables
+	 */
+	fs->first_pass_ibmap = 0;
+	fs->first_pass_bbmap = 0;
+	fs->curr_inode_no = 0;
+	fs->curr_blkno = 0;
+
+	return;
+}
+
+static int ext4fs_write_file(struct ext2_inode *file_inode,
+			     int pos, unsigned int len, char *buf)
+{
+	int i;
+	int blockcnt;
+	int log2blocksize = LOG2_EXT2_BLOCK_SIZE(ext4fs_root);
+	unsigned int filesize = __le32_to_cpu(file_inode->size);
+	struct ext_filesystem *fs = get_fs();
+	int previous_block_number = -1;
+	int delayed_start = 0;
+	int delayed_extent = 0;
+	int delayed_skipfirst = 0;
+	int delayed_next = 0;
+	char *delayed_buf = NULL;
+
+	/* Adjust len so it we can't read past the end of the file. */
+	if (len > filesize)
+		len = filesize;
+
+	blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
+
+	for (i = pos / fs->blksz; i < blockcnt; i++) {
+		long int blknr;
+		int blockend = fs->blksz;
+		int skipfirst = 0;
+		blknr = read_allocated_block(file_inode, i);
+		if (blknr < 0)
+			return -1;
+
+		blknr = blknr << log2blocksize;
+
+		if (blknr) {
+			if (previous_block_number != -1) {
+				if (delayed_next == blknr) {
+					delayed_extent += blockend;
+					delayed_next += blockend >> SECTOR_BITS;
+				} else {	/* spill */
+					put_ext4((uint64_t) (delayed_start *
+							     SECTOR_SIZE),
+						 delayed_buf,
+						 (uint32_t) delayed_extent);
+					previous_block_number = blknr;
+					delayed_start = blknr;
+					delayed_extent = blockend;
+					delayed_skipfirst = skipfirst;
+					delayed_buf = buf;
+					delayed_next = blknr +
+					    (blockend >> SECTOR_BITS);
+				}
+			} else {
+				previous_block_number = blknr;
+				delayed_start = blknr;
+				delayed_extent = blockend;
+				delayed_skipfirst = skipfirst;
+				delayed_buf = buf;
+				delayed_next = blknr +
+				    (blockend >> SECTOR_BITS);
+			}
+		} else {
+			if (previous_block_number != -1) {
+				/* spill */
+				put_ext4((uint64_t) (delayed_start *
+						     SECTOR_SIZE), delayed_buf,
+					 (uint32_t) delayed_extent);
+				previous_block_number = -1;
+			}
+			memset(buf, 0, fs->blksz - skipfirst);
+		}
+		buf += fs->blksz - skipfirst;
+	}
+	if (previous_block_number != -1) {
+		/* spill */
+		put_ext4((uint64_t) (delayed_start * SECTOR_SIZE),
+			 delayed_buf, (uint32_t) delayed_extent);
+		previous_block_number = -1;
+	}
+	return len;
+}
+
+int ext4fs_write(char *fname, unsigned char *buffer, unsigned long sizebytes)
+{
+	int ret = 0;
+	/*inode */
+	struct ext2_inode *file_inode = NULL;
+	unsigned char *inode_buffer = NULL;
+	int parent_inodeno;
+	int inodeno;
+	time_t timestamp = 0;
+
+	/*filesize */
+	uint64_t total_no_of_bytes_for_file;
+	unsigned int total_no_of_block_for_file;
+	unsigned int total_remaining_blocks;
+	int existing_file_inodeno;
+	char filename[256];
+
+	char *temp_ptr = NULL;
+	long int itable_blkno, parent_itable_blkno, blkoff;
+	struct ext2_sblock *sblock = &(ext4fs_root->sblock);
+	unsigned int inodes_per_block;
+	unsigned int inode_bitmap_index;
+	struct ext_filesystem *fs = get_fs();
+
+	g_parent_inode = (struct ext2_inode *)
+	    xzalloc(sizeof(struct ext2_inode));
+	if (!g_parent_inode)
+		goto fail;
+
+	if (ext4fs_init() != 0) {
+		printf("error in File System init\n");
+		return -1;
+	}
+	inodes_per_block = fs->blksz / fs->inodesz;
+	parent_inodeno = get_parent_inode_num(fname, filename, F_FILE);
+	if (parent_inodeno == -1)
+		goto fail;
+	if (iget(parent_inodeno, g_parent_inode))
+		goto fail;
+	/*check if the filename is already present in root */
+	existing_file_inodeno = ext4fs_filename_check(filename);
+	if (existing_file_inodeno != -1) {
+		ret = ext4fs_delete_file(existing_file_inodeno);
+		fs->first_pass_bbmap = 0;
+		fs->curr_blkno = 0;
+
+		fs->first_pass_ibmap = 0;
+		fs->curr_inode_no = 0;
+		if (ret)
+			goto fail;
+	}
+	/*calucalate how many blocks required */
+	total_no_of_bytes_for_file = sizebytes;
+	total_no_of_block_for_file = total_no_of_bytes_for_file / fs->blksz;
+	if (total_no_of_bytes_for_file % fs->blksz != 0) {
+		total_no_of_block_for_file++;
+		debug("total bytes for a file %u\n",
+		      total_no_of_block_for_file);
+	}
+	total_remaining_blocks = total_no_of_block_for_file;
+	/*Test for available space in partition */
+	if (fs->sb->free_blocks < total_no_of_block_for_file) {
+		printf("Not enough space on partition !!!\n");
+		goto fail;
+	}
+
+	update_parent_dentry(filename, &inodeno, FILETYPE_REG);
+	/*prepare file inode */
+	inode_buffer = xmalloc(fs->inodesz);
+	memset(inode_buffer, '\0', fs->inodesz);
+	file_inode = (struct ext2_inode *)inode_buffer;
+	file_inode->mode = S_IFREG | S_IRWXU |
+	    S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH;
+	/* ToDo: Update correct time */
+	file_inode->mtime = timestamp;
+	file_inode->atime = timestamp;
+	file_inode->ctime = timestamp;
+	file_inode->nlinks = 1;
+	file_inode->size = sizebytes;
+
+	/* Allocate data blocks */
+	allocate_blocks(file_inode, total_remaining_blocks,
+			&total_no_of_block_for_file);
+	/*
+	 *write the inode to inode table after last filled inode in inode table
+	 *we are using hardcoded  gd[0].inode_table_id becuase 0th blockgroup
+	 *is suffcient to create more than 1000 file.TODO exapnd the logic to
+	 *all blockgroup
+	 */
+	file_inode->blockcnt = (total_no_of_block_for_file * fs->blksz)
+	    / SECTOR_SIZE;
+
+	temp_ptr = (char *)xzalloc(fs->blksz);
+	if (!temp_ptr)
+		goto fail;
+	inode_bitmap_index = inodeno /
+	    (uint32_t) ext4fs_root->sblock.inodes_per_group;
+	inodeno--;
+	itable_blkno =
+	    __le32_to_cpu(fs->gd[inode_bitmap_index].inode_table_id) +
+	    (inodeno % __le32_to_cpu(sblock->inodes_per_group))
+	    / inodes_per_block;
+	blkoff = (inodeno % inodes_per_block) * fs->inodesz;
+	ext2fs_devread(itable_blkno * fs->sect_perblk, 0, fs->blksz, temp_ptr);
+	if (log_journal(temp_ptr, itable_blkno))
+		goto fail;
+
+	memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
+	if (put_metadata(temp_ptr, itable_blkno))
+		goto fail;
+	/*Copy the file content into data blocks */
+	if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) {
+		printf("Error in copying content\n");
+		goto fail;
+	}
+	inode_bitmap_index = parent_inodeno /
+	    (uint32_t) ext4fs_root->sblock.inodes_per_group;
+	parent_inodeno--;
+	parent_itable_blkno =
+	    __le32_to_cpu(fs->gd[inode_bitmap_index].inode_table_id) +
+	    (parent_inodeno % __le32_to_cpu(sblock->inodes_per_group)) /
+	    inodes_per_block;
+	blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
+	if (parent_itable_blkno != itable_blkno) {
+		memset(temp_ptr, '\0', fs->blksz);
+		ext2fs_devread(parent_itable_blkno * fs->sect_perblk,
+			       0, fs->blksz, temp_ptr);
+		if (log_journal(temp_ptr, parent_itable_blkno))
+			goto fail;
+
+		memcpy(temp_ptr + blkoff, g_parent_inode,
+		       sizeof(struct ext2_inode));
+		if (put_metadata(temp_ptr, parent_itable_blkno))
+			goto fail;
+		free(temp_ptr);
+	} else {
+		/* If parent and child fall in same inode table block
+		 * both should be kept in 1 buffer
+		 */
+		memcpy(temp_ptr + blkoff, g_parent_inode,
+		       sizeof(struct ext2_inode));
+		gd_index--;
+		if (put_metadata(temp_ptr, itable_blkno))
+			goto fail;
+		free(temp_ptr);
+	}
+	ext4fs_update();
+	ext4fs_deinit();
+
+	fs->first_pass_bbmap = 0;
+	fs->curr_blkno = 0;
+	fs->first_pass_ibmap = 0;
+	fs->curr_inode_no = 0;
+	if (inode_buffer)
+		free(inode_buffer);
+	if (g_parent_inode) {
+		free(g_parent_inode);
+		g_parent_inode = NULL;
+	}
+	return 0;
+
+fail:
+	ext4fs_deinit();
+	if (inode_buffer)
+		free(inode_buffer);
+	if (g_parent_inode) {
+		free(g_parent_inode);
+		g_parent_inode = NULL;
+	}
+	return -1;
+}
diff --git a/include/ext4fs.h b/include/ext4fs.h
index fd7bd47..e4e2c3e 100644
--- a/include/ext4fs.h
+++ b/include/ext4fs.h
@@ -102,9 +102,17 @@  extern block_dev_desc_t *ext4_dev_desc;
 
 extern struct ext2_data *ext4fs_root;
 extern struct ext2fs_node *ext4fs_file;
+extern struct ext2_inode *g_parent_inode;
+extern int gd_index;
+extern int gindex;
+
 struct ext_filesystem *get_fs(void);
 int init_fs(block_dev_desc_t *);
 void deinit_fs(block_dev_desc_t *);
+int ext4fs_init(void);
+void ext4fs_deinit(void);
+int ext4fs_write(char *fname, unsigned char *buffer, unsigned long sizebytes);
+int ext4fs_filename_check(char *filename);
 int ext4fs_open(const char *filename);
 int ext4fs_read(char *buf, unsigned len);
 int ext4fs_mount(unsigned part_length);