Eric Lee / smarc-uboot | Embedian Git Server

Commit 04735e9c5578dd4f3584be5454b9779e8e5c2af9

Authored by Frederic Leroy 2013-06-27 00:11:25 +0800

Committed by Tom Rini 2013-07-16 05:06:13 +0800

Exists in master and in 53 other branches

Fix ext2/ext4 filesystem accesses beyond 2TiB

With CONFIG_SYS_64BIT_LBA, lbaint_t gets defined as a 64-bit type,
which is required to represent block numbers for storage devices that
exceed 2TiB (the block size usually is 512B), e.g. recent hard drives

We now use lbaint_t for partition offset to reflect the lbaint_t change,
and access partitions beyond or crossing the 2.1TiB limit.
This required changes to signature of ext4fs_devread(), and type of all
variables relatives to block sector.

ext2/ext4 fs uses logical block represented by a 32 bit value. Logical
block is a multiple of device block sector. To avoid overflow problem
when calling ext4fs_devread(), we need to cast the sector parameter.

Signed-off-by: Frédéric Leroy <fredo@starox.org>

Showing 12 changed files with 93 additions and 70 deletions Inline Diff

common/cmd_disk.c
disk/part_efi.c
disk/part_iso.c
fs/ext4/dev.c
fs/ext4/ext4_common.c
fs/ext4/ext4_journal.c
fs/ext4/ext4_write.c
fs/ext4/ext4fs.c
include/ext4fs.h
include/ext_common.h
include/ide.h
include/part.h

common/cmd_disk.c

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2000-2011
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * 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., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  *
  */
 #include <common.h>
 #include <command.h>
 #include <part.h>
 #if defined(CONFIG_CMD_IDE) || defined(CONFIG_CMD_SCSI) || \
 	defined(CONFIG_USB_STORAGE)
 int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
 		    char *const argv[])
 {
 	int dev, part;
 	ulong addr = CONFIG_SYS_LOAD_ADDR;
 	ulong cnt;
 	disk_partition_t info;
 	image_header_t *hdr;
 	block_dev_desc_t *dev_desc;
 #if defined(CONFIG_FIT)
 	const void *fit_hdr = NULL;
 #endif
 	bootstage_mark(BOOTSTAGE_ID_IDE_START);
 	if (argc > 3) {
 		bootstage_error(BOOTSTAGE_ID_IDE_ADDR);
 		return CMD_RET_USAGE;
 	}
 	bootstage_mark(BOOTSTAGE_ID_IDE_ADDR);
 	if (argc > 1)
 		addr = simple_strtoul(argv[1], NULL, 16);
 	bootstage_mark(BOOTSTAGE_ID_IDE_BOOT_DEVICE);
 	part = get_device_and_partition(intf, (argc == 3) ? argv[2] : NULL,
 					&dev_desc, &info, 1);
 	if (part < 0) {
 		bootstage_error(BOOTSTAGE_ID_IDE_TYPE);
 		return 1;
 	}
 	dev = dev_desc->dev;
 	bootstage_mark(BOOTSTAGE_ID_IDE_TYPE);
 	printf("\nLoading from %s device %d, partition %d: "
 	       "Name: %.32s  Type: %.32s\n", intf, dev, part, info.name,
 	       info.type);
-	debug("First Block: %ld,  # of blocks: %ld, Block Size: %ld\n",
+	debug("First Block: " LBAFU ",  # of blocks: " LBAFU
+	      ", Block Size: %ld\n",
 	      info.start, info.size, info.blksz);
 	if (dev_desc->block_read(dev, info.start, 1, (ulong *) addr) != 1) {
 		printf("** Read error on %d:%d\n", dev, part);
 		bootstage_error(BOOTSTAGE_ID_IDE_PART_READ);
 		return 1;
 	}
 	bootstage_mark(BOOTSTAGE_ID_IDE_PART_READ);
 	switch (genimg_get_format((void *) addr)) {
 	case IMAGE_FORMAT_LEGACY:
 		hdr = (image_header_t *) addr;
 		bootstage_mark(BOOTSTAGE_ID_IDE_FORMAT);
 		if (!image_check_hcrc(hdr)) {
 			puts("\n** Bad Header Checksum **\n");
 			bootstage_error(BOOTSTAGE_ID_IDE_CHECKSUM);
 			return 1;
 		}
 		bootstage_mark(BOOTSTAGE_ID_IDE_CHECKSUM);
 		image_print_contents(hdr);
 		cnt = image_get_image_size(hdr);
 		break;
 #if defined(CONFIG_FIT)
 	case IMAGE_FORMAT_FIT:
 		fit_hdr = (const void *) addr;
 		puts("Fit image detected...\n");
 		cnt = fit_get_size(fit_hdr);
 		break;
 #endif
 	default:
 		bootstage_error(BOOTSTAGE_ID_IDE_FORMAT);
 		puts("** Unknown image type\n");
 		return 1;
 	}
 	cnt += info.blksz - 1;
 	cnt /= info.blksz;
 	cnt -= 1;
 	if (dev_desc->block_read(dev, info.start + 1, cnt,
 					 (ulong *)(addr + info.blksz)) != cnt) {
 		printf("** Read error on %d:%d\n", dev, part);
 		bootstage_error(BOOTSTAGE_ID_IDE_READ);
 		return 1;
 	}
 	bootstage_mark(BOOTSTAGE_ID_IDE_READ);
 #if defined(CONFIG_FIT)
 	/* This cannot be done earlier,
 	 * we need complete FIT image in RAM first */
 	if (genimg_get_format((void *) addr) == IMAGE_FORMAT_FIT) {
 		if (!fit_check_format(fit_hdr)) {
 			bootstage_error(BOOTSTAGE_ID_IDE_FIT_READ);
 			puts("** Bad FIT image format\n");
 			return 1;
 		}
 		bootstage_mark(BOOTSTAGE_ID_IDE_FIT_READ_OK);
 		fit_print_contents(fit_hdr);
 	}
 #endif
 	flush_cache(addr, (cnt+1)*info.blksz);
 	/* Loading ok, update default load address */
 	load_addr = addr;
 	return bootm_maybe_autostart(cmdtp, argv[0]);
 }
 #endif

disk/part_efi.c

Diff comments View file @ 04735e9

disk/part_iso.c

Diff comments View file @ 04735e9

1	/*	1	/*
2	* (C) Copyright 2001	2	* (C) Copyright 2001
3	* Denis Peter, MPL AG Switzerland, d.peter@mpl.ch.	3	* Denis Peter, MPL AG Switzerland, d.peter@mpl.ch.
4	*	4	*
5	* See file CREDITS for list of people who contributed to this	5	* See file CREDITS for list of people who contributed to this
6	* project.	6	* project.
7	*	7	*
8	* This program is free software; you can redistribute it and/or	8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License as	9	* modify it under the terms of the GNU General Public License as
10	* published by the Free Software Foundation; either version 2 of	10	* published by the Free Software Foundation; either version 2 of
11	* the License, or (at your option) any later version.	11	* the License, or (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21	* MA 02111-1307 USA	21	* MA 02111-1307 USA
22	*/	22	*/
23		23
24	#include <common.h>	24	#include <common.h>
25	#include <command.h>	25	#include <command.h>
26	#include "part_iso.h"	26	#include "part_iso.h"
27		27
28	#ifdef HAVE_BLOCK_DEVICE	28	#ifdef HAVE_BLOCK_DEVICE
29		29
30	/* #define ISO_PART_DEBUG */	30	/* #define ISO_PART_DEBUG */
31		31
32	#ifdef ISO_PART_DEBUG	32	#ifdef ISO_PART_DEBUG
33	#define PRINTF(fmt,args...) printf (fmt ,##args)	33	#define PRINTF(fmt,args...) printf (fmt ,##args)
34	#else	34	#else
35	#define PRINTF(fmt,args...)	35	#define PRINTF(fmt,args...)
36	#endif	36	#endif
37		37
38	/* enable this if CDs are written with the PowerPC Platform ID */	38	/* enable this if CDs are written with the PowerPC Platform ID */
39	#undef CHECK_FOR_POWERPC_PLATTFORM	39	#undef CHECK_FOR_POWERPC_PLATTFORM
40	#define CD_SECTSIZE 2048	40	#define CD_SECTSIZE 2048
41		41
42	static unsigned char tmpbuf[CD_SECTSIZE];	42	static unsigned char tmpbuf[CD_SECTSIZE];
43		43
44	/* Convert char[4] in little endian format to the host format integer	44	/* Convert char[4] in little endian format to the host format integer
45	*/	45	*/
46	static inline unsigned long le32_to_int(unsigned char *le32)	46	static inline unsigned long le32_to_int(unsigned char *le32)
47	{	47	{
48	return ((le32[3] << 24) +	48	return ((le32[3] << 24) +
49	(le32[2] << 16) +	49	(le32[2] << 16) +
50	(le32[1] << 8) +	50	(le32[1] << 8) +
51	le32[0]	51	le32[0]
52	);	52	);
53	}	53	}
54	/* Convert char[2] in little endian format to the host format integer	54	/* Convert char[2] in little endian format to the host format integer
55	*/	55	*/
56	static inline unsigned short le16_to_int(unsigned char *le16)	56	static inline unsigned short le16_to_int(unsigned char *le16)
57	{	57	{
58	return ((le16[1] << 8) +	58	return ((le16[1] << 8) +
59	le16[0]	59	le16[0]
60	);	60	);
61	}	61	}
62		62
63		63
64	/* only boot records will be listed as valid partitions */	64	/* only boot records will be listed as valid partitions */
65	int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info, int verb)	65	int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info, int verb)
66	{	66	{
67	int i,offset,entry_num;	67	int i,offset,entry_num;
68	unsigned short *chksumbuf;	68	unsigned short *chksumbuf;
69	unsigned short chksum;	69	unsigned short chksum;
70	unsigned long newblkaddr,blkaddr,lastsect,bootaddr;	70	unsigned long newblkaddr,blkaddr,lastsect,bootaddr;
71	iso_boot_rec_t pbr = (iso_boot_rec_t )tmpbuf; /* boot record */	71	iso_boot_rec_t pbr = (iso_boot_rec_t )tmpbuf; /* boot record */
72	iso_pri_rec_t ppr = (iso_pri_rec_t )tmpbuf; /* primary desc */	72	iso_pri_rec_t ppr = (iso_pri_rec_t )tmpbuf; /* primary desc */
73	iso_val_entry_t pve = (iso_val_entry_t )tmpbuf;	73	iso_val_entry_t pve = (iso_val_entry_t )tmpbuf;
74	iso_init_def_entry_t *pide;	74	iso_init_def_entry_t *pide;
75		75
76	if (dev_desc->blksz != CD_SECTSIZE)	76	if (dev_desc->blksz != CD_SECTSIZE)
77	return -1;	77	return -1;
78		78
79	/* the first sector (sector 0x10) must be a primary volume desc */	79	/* the first sector (sector 0x10) must be a primary volume desc */
80	blkaddr=PVD_OFFSET;	80	blkaddr=PVD_OFFSET;
81	if (dev_desc->block_read (dev_desc->dev, PVD_OFFSET, 1, (ulong *) tmpbuf) != 1)	81	if (dev_desc->block_read (dev_desc->dev, PVD_OFFSET, 1, (ulong *) tmpbuf) != 1)
82	return (-1);	82	return (-1);
83	if(ppr->desctype!=0x01) {	83	if(ppr->desctype!=0x01) {
84	if(verb)	84	if(verb)
85	printf (" First descriptor is NOT a primary desc on %d:%d \n",	85	printf (" First descriptor is NOT a primary desc on %d:%d \n",
86	dev_desc->dev, part_num);	86	dev_desc->dev, part_num);
87	return (-1);	87	return (-1);
88	}	88	}
89	if(strncmp((char *)ppr->stand_ident,"CD001",5)!=0) {	89	if(strncmp((char *)ppr->stand_ident,"CD001",5)!=0) {
90	if(verb)	90	if(verb)
91	printf (" Wrong ISO Ident: %s on %d:%d \n",	91	printf (" Wrong ISO Ident: %s on %d:%d \n",
92	ppr->stand_ident,dev_desc->dev, part_num);	92	ppr->stand_ident,dev_desc->dev, part_num);
93	return (-1);	93	return (-1);
94	}	94	}
95	lastsect= ((ppr->firstsek_LEpathtab1_LE & 0x000000ff)<<24) +	95	lastsect= ((ppr->firstsek_LEpathtab1_LE & 0x000000ff)<<24) +
96	((ppr->firstsek_LEpathtab1_LE & 0x0000ff00)<< 8) +	96	((ppr->firstsek_LEpathtab1_LE & 0x0000ff00)<< 8) +
97	((ppr->firstsek_LEpathtab1_LE & 0x00ff0000)>> 8) +	97	((ppr->firstsek_LEpathtab1_LE & 0x00ff0000)>> 8) +
98	((ppr->firstsek_LEpathtab1_LE & 0xff000000)>>24) ;	98	((ppr->firstsek_LEpathtab1_LE & 0xff000000)>>24) ;
99	info->blksz=ppr->secsize_BE; /* assuming same block size for all entries */	99	info->blksz=ppr->secsize_BE; /* assuming same block size for all entries */
100	PRINTF(" Lastsect:%08lx\n",lastsect);	100	PRINTF(" Lastsect:%08lx\n",lastsect);
101	for(i=blkaddr;i<lastsect;i++) {	101	for(i=blkaddr;i<lastsect;i++) {
102	PRINTF("Reading block %d\n", i);	102	PRINTF("Reading block %d\n", i);
103	if (dev_desc->block_read (dev_desc->dev, i, 1, (ulong *) tmpbuf) != 1)	103	if (dev_desc->block_read (dev_desc->dev, i, 1, (ulong *) tmpbuf) != 1)
104	return (-1);	104	return (-1);
105	if(ppr->desctype==0x00)	105	if(ppr->desctype==0x00)
106	break; /* boot entry found */	106	break; /* boot entry found */
107	if(ppr->desctype==0xff) {	107	if(ppr->desctype==0xff) {
108	if(verb)	108	if(verb)
109	printf (" No valid boot catalog found on %d:%d \n",	109	printf (" No valid boot catalog found on %d:%d \n",
110	dev_desc->dev, part_num);	110	dev_desc->dev, part_num);
111	return (-1);	111	return (-1);
112	}	112	}
113	}	113	}
114	/* boot entry found */	114	/* boot entry found */
115	if(strncmp(pbr->ident_str,"EL TORITO SPECIFICATION",23)!=0) {	115	if(strncmp(pbr->ident_str,"EL TORITO SPECIFICATION",23)!=0) {
116	if(verb)	116	if(verb)
117	printf (" Wrong El Torito ident: %s on %d:%d \n",	117	printf (" Wrong El Torito ident: %s on %d:%d \n",
118	pbr->ident_str,dev_desc->dev, part_num);	118	pbr->ident_str,dev_desc->dev, part_num);
119	return (-1);	119	return (-1);
120	}	120	}
121	bootaddr=le32_to_int(pbr->pointer);	121	bootaddr=le32_to_int(pbr->pointer);
122	PRINTF(" Boot Entry at: %08lX\n",bootaddr);	122	PRINTF(" Boot Entry at: %08lX\n",bootaddr);
123	if (dev_desc->block_read (dev_desc->dev, bootaddr, 1, (ulong *) tmpbuf) != 1) {	123	if (dev_desc->block_read (dev_desc->dev, bootaddr, 1, (ulong *) tmpbuf) != 1) {
124	if(verb)	124	if(verb)
125	printf (" Can't read Boot Entry at %lX on %d:%d \n",	125	printf (" Can't read Boot Entry at %lX on %d:%d \n",
126	bootaddr,dev_desc->dev, part_num);	126	bootaddr,dev_desc->dev, part_num);
127	return (-1);	127	return (-1);
128	}	128	}
129	chksum=0;	129	chksum=0;
130	chksumbuf = (unsigned short *)tmpbuf;	130	chksumbuf = (unsigned short *)tmpbuf;
131	for(i=0;i<0x10;i++)	131	for(i=0;i<0x10;i++)
132	chksum+=((chksumbuf[i] &0xff)<<8)+((chksumbuf[i] &0xff00)>>8);	132	chksum+=((chksumbuf[i] &0xff)<<8)+((chksumbuf[i] &0xff00)>>8);
133	if(chksum!=0) {	133	if(chksum!=0) {
134	if(verb)	134	if(verb)
135	printf (" Checksum Error in booting catalog validation entry on %d:%d \n",	135	printf (" Checksum Error in booting catalog validation entry on %d:%d \n",
136	dev_desc->dev, part_num);	136	dev_desc->dev, part_num);
137	return (-1);	137	return (-1);
138	}	138	}
139	if((pve->key[0]!=0x55)\|\|(pve->key[1]!=0xAA)) {	139	if((pve->key[0]!=0x55)\|\|(pve->key[1]!=0xAA)) {
140	if(verb)	140	if(verb)
141	printf (" Key 0x55 0xAA error on %d:%d \n",	141	printf (" Key 0x55 0xAA error on %d:%d \n",
142	dev_desc->dev, part_num);	142	dev_desc->dev, part_num);
143	return(-1);	143	return(-1);
144	}	144	}
145	#ifdef CHECK_FOR_POWERPC_PLATTFORM	145	#ifdef CHECK_FOR_POWERPC_PLATTFORM
146	if(pve->platform!=0x01) {	146	if(pve->platform!=0x01) {
147	if(verb)	147	if(verb)
148	printf (" No PowerPC platform CD on %d:%d \n",	148	printf (" No PowerPC platform CD on %d:%d \n",
149	dev_desc->dev, part_num);	149	dev_desc->dev, part_num);
150	return(-1);	150	return(-1);
151	}	151	}
152	#endif	152	#endif
153	/* the validation entry seems to be ok, now search the "partition" */	153	/* the validation entry seems to be ok, now search the "partition" */
154	entry_num=0;	154	entry_num=0;
155	offset=0x20;	155	offset=0x20;
156	sprintf ((char *)info->type, "U-Boot");	156	sprintf ((char *)info->type, "U-Boot");
157	switch(dev_desc->if_type) {	157	switch(dev_desc->if_type) {
158	case IF_TYPE_IDE:	158	case IF_TYPE_IDE:
159	case IF_TYPE_SATA:	159	case IF_TYPE_SATA:
160	case IF_TYPE_ATAPI:	160	case IF_TYPE_ATAPI:
161	sprintf ((char *)info->name, "hd%c%d",	161	sprintf ((char *)info->name, "hd%c%d",
162	'a' + dev_desc->dev, part_num);	162	'a' + dev_desc->dev, part_num);
163	break;	163	break;
164	case IF_TYPE_SCSI:	164	case IF_TYPE_SCSI:
165	sprintf ((char *)info->name, "sd%c%d",	165	sprintf ((char *)info->name, "sd%c%d",
166	'a' + dev_desc->dev, part_num);	166	'a' + dev_desc->dev, part_num);
167	break;	167	break;
168	case IF_TYPE_USB:	168	case IF_TYPE_USB:
169	sprintf ((char *)info->name, "usbd%c%d",	169	sprintf ((char *)info->name, "usbd%c%d",
170	'a' + dev_desc->dev, part_num);	170	'a' + dev_desc->dev, part_num);
171	break;	171	break;
172	case IF_TYPE_DOC:	172	case IF_TYPE_DOC:
173	sprintf ((char *)info->name, "docd%c%d",	173	sprintf ((char *)info->name, "docd%c%d",
174	'a' + dev_desc->dev, part_num);	174	'a' + dev_desc->dev, part_num);
175	break;	175	break;
176	default:	176	default:
177	sprintf ((char *)info->name, "xx%c%d",	177	sprintf ((char *)info->name, "xx%c%d",
178	'a' + dev_desc->dev, part_num);	178	'a' + dev_desc->dev, part_num);
179	break;	179	break;
180	}	180	}
181	/* the bootcatalog (including validation Entry) is limited to 2048Bytes	181	/* the bootcatalog (including validation Entry) is limited to 2048Bytes
182	* (63 boot entries + validation entry) */	182	* (63 boot entries + validation entry) */
183	while(offset<2048) {	183	while(offset<2048) {
184	pide=(iso_init_def_entry_t *)&tmpbuf[offset];	184	pide=(iso_init_def_entry_t *)&tmpbuf[offset];
185	if ((pide->boot_ind==0x88) \|\|	185	if ((pide->boot_ind==0x88) \|\|
186	(pide->boot_ind==0x00)) { /* Header Id for default Sections Entries */	186	(pide->boot_ind==0x00)) { /* Header Id for default Sections Entries */
187	if(entry_num==part_num) { /* part found */	187	if(entry_num==part_num) { /* part found */
188	goto found;	188	goto found;
189	}	189	}
190	entry_num++; /* count partitions Entries (boot and non bootables */	190	entry_num++; /* count partitions Entries (boot and non bootables */
191	offset+=0x20;	191	offset+=0x20;
192	continue;	192	continue;
193	}	193	}
194	if ((pide->boot_ind==0x90) \|\| /* Section Header Entry */	194	if ((pide->boot_ind==0x90) \|\| /* Section Header Entry */
195	(pide->boot_ind==0x91) \|\| /* Section Header Entry (last) */	195	(pide->boot_ind==0x91) \|\| /* Section Header Entry (last) */
196	(pide->boot_ind==0x44)) { /* Extension Indicator */	196	(pide->boot_ind==0x44)) { /* Extension Indicator */
197	offset+=0x20; /* skip unused entries */	197	offset+=0x20; /* skip unused entries */
198	}	198	}
199	else {	199	else {
200	if(verb)	200	if(verb)
201	printf (" Partition %d not found on device %d \n",	201	printf (" Partition %d not found on device %d \n",
202	part_num,dev_desc->dev);	202	part_num,dev_desc->dev);
203	return(-1);	203	return(-1);
204	}	204	}
205	}	205	}
206	/* if we reach this point entire sector has been	206	/* if we reach this point entire sector has been
207	* searched w/o succsess */	207	* searched w/o succsess */
208	if(verb)	208	if(verb)
209	printf (" Partition %d not found on device %d \n",	209	printf (" Partition %d not found on device %d \n",
210	part_num,dev_desc->dev);	210	part_num,dev_desc->dev);
211	return(-1);	211	return(-1);
212	found:	212	found:
213	if(pide->boot_ind!=0x88) {	213	if(pide->boot_ind!=0x88) {
214	if(verb)	214	if(verb)
215	printf (" Partition %d is not bootable on device %d \n",	215	printf (" Partition %d is not bootable on device %d \n",
216	part_num,dev_desc->dev);	216	part_num,dev_desc->dev);
217	return (-1);	217	return (-1);
218	}	218	}
219	switch(pide->boot_media) {	219	switch(pide->boot_media) {
220	case 0x00: /* no emulation */	220	case 0x00: /* no emulation */
221	info->size=le16_to_int(pide->sec_cnt)>>2;	221	info->size=le16_to_int(pide->sec_cnt)>>2;
222	break;	222	break;
223	case 0x01: info->size=2400>>2; break; /* 1.2MByte Floppy */	223	case 0x01: info->size=2400>>2; break; /* 1.2MByte Floppy */
224	case 0x02: info->size=2880>>2; break; /* 1.44MByte Floppy */	224	case 0x02: info->size=2880>>2; break; /* 1.44MByte Floppy */
225	case 0x03: info->size=5760>>2; break; /* 2.88MByte Floppy */	225	case 0x03: info->size=5760>>2; break; /* 2.88MByte Floppy */
226	case 0x04: info->size=2880>>2; break; /* dummy (HD Emulation) */	226	case 0x04: info->size=2880>>2; break; /* dummy (HD Emulation) */
227	default: info->size=0; break;	227	default: info->size=0; break;
228	}	228	}
229	newblkaddr=le32_to_int(pide->rel_block_addr);	229	newblkaddr=le32_to_int(pide->rel_block_addr);
230	info->start=newblkaddr;	230	info->start=newblkaddr;
231	PRINTF(" part %d found @ %lx size %lx\n",part_num,newblkaddr,info->size);	231	PRINTF(" part %d found @ %lx size %lx\n",part_num,newblkaddr,info->size);
232	return 0;	232	return 0;
233	}	233	}
234		234
235	int get_partition_info_iso(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info)	235	int get_partition_info_iso(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info)
236	{	236	{
237	return(get_partition_info_iso_verb(dev_desc, part_num, info, 1));	237	return(get_partition_info_iso_verb(dev_desc, part_num, info, 1));
238	}	238	}
239		239
240		240
241	void print_part_iso(block_dev_desc_t * dev_desc)	241	void print_part_iso(block_dev_desc_t * dev_desc)
242	{	242	{
243	disk_partition_t info;	243	disk_partition_t info;
244	int i;	244	int i;
245	if(get_partition_info_iso_verb(dev_desc,0,&info,0)==-1) {	245	if(get_partition_info_iso_verb(dev_desc,0,&info,0)==-1) {
246	printf(" No boot partition found on device %d \n",dev_desc->dev);	246	printf(" No boot partition found on device %d \n",dev_desc->dev);
247	return;	247	return;
248	}	248	}
249	printf("Part Start Sect x Size Type\n");	249	printf("Part Start Sect x Size Type\n");
250	i=0;	250	i=0;
251	do {	251	do {
252	printf (" %2d %8ld %8ld %6ld %.32s\n",	252	printf(" %2d " LBAFU " " LBAFU " %6ld %.32s\n",
253	i, info.start, info.size, info.blksz, info.type);	253	i, info.start, info.size, info.blksz, info.type);
254	i++;	254	i++;
255	} while (get_partition_info_iso_verb(dev_desc,i,&info,0)!=-1);	255	} while (get_partition_info_iso_verb(dev_desc,i,&info,0)!=-1);
256	}	256	}
257		257
258	int test_part_iso (block_dev_desc_t *dev_desc)	258	int test_part_iso (block_dev_desc_t *dev_desc)
259	{	259	{
260	disk_partition_t info;	260	disk_partition_t info;
261		261
262	return(get_partition_info_iso_verb(dev_desc,0,&info,0));	262	return(get_partition_info_iso_verb(dev_desc,0,&info,0));
263	}	263	}
264		264
265	#endif	265	#endif
266		266

fs/ext4/dev.c

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2011 - 2012 Samsung Electronics
  * EXT4 filesystem implementation in Uboot by
  * Uma Shankar <uma.shankar@samsung.com>
  * Manjunatha C Achar <a.manjunatha@samsung.com>
  *
  * made from existing ext2/dev.c file of Uboot
  * (C) Copyright 2004
  * esd gmbh <www.esd-electronics.com>
  * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
  *
  * based on code of fs/reiserfs/dev.c by
  *
  * (C) Copyright 2003 - 2004
  * Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com>
  *
  * 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.
  *
  */
 /*
  * Changelog:
  *	0.1 - Newly created file for ext4fs support. Taken from
  *		fs/ext2/dev.c file in uboot.
  */
 #include <common.h>
 #include <config.h>
 #include <ext4fs.h>
 #include <ext_common.h>
 #include "ext4_common.h"
-unsigned long part_offset;
+lbaint_t part_offset;
 static block_dev_desc_t *ext4fs_block_dev_desc;
 static disk_partition_t *part_info;
 void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
 {
 	assert(rbdd->blksz == (1 << rbdd->log2blksz));
 	ext4fs_block_dev_desc = rbdd;
 	get_fs()->dev_desc = rbdd;
 	part_info = info;
 	part_offset = info->start;
 	get_fs()->total_sect = (info->size * info->blksz) >>
 		get_fs()->dev_desc->log2blksz;
 }
-int ext4fs_devread(int sector, int byte_offset, int byte_len, char *buf)
+int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
 {
 	unsigned block_len;
 	int log2blksz = ext4fs_block_dev_desc->log2blksz;
 	ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, (ext4fs_block_dev_desc ?
 						 ext4fs_block_dev_desc->blksz :
 						 0));
 	if (ext4fs_block_dev_desc == NULL) {
 		printf("** Invalid Block Device Descriptor (NULL)\n");
 		return 0;
 	}
 	/* Check partition boundaries */
 	if ((sector < 0) ||
 	    ((sector + ((byte_offset + byte_len - 1) >> log2blksz))
 	     >= part_info->size)) {
-		printf("%s read outside partition %d\n", __func__, sector);
+		printf("%s read outside partition " LBAFU "\n", __func__,
+		       sector);
 		return 0;
 	}
 	/* Get the read to the beginning of a partition */
 	sector += byte_offset >> log2blksz;
 	byte_offset &= ext4fs_block_dev_desc->blksz - 1;
-	debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len);
+	debug(" <" LBAFU ", %d, %d>\n", sector, byte_offset, byte_len);
 	if (byte_offset != 0) {
 		/* read first part which isn't aligned with start of sector */
 		if (ext4fs_block_dev_desc->
 		    block_read(ext4fs_block_dev_desc->dev,
 				part_info->start + sector, 1,
 				(unsigned long *) sec_buf) != 1) {
 			printf(" ** ext2fs_devread() read error **\n");
 			return 0;
 		}
 		memcpy(buf, sec_buf + byte_offset,
 			min(ext4fs_block_dev_desc->blksz
 			    - byte_offset, byte_len));
 		buf += min(ext4fs_block_dev_desc->blksz
 			   - byte_offset, byte_len);
 		byte_len -= min(ext4fs_block_dev_desc->blksz
 				- byte_offset, byte_len);
 		sector++;
 	}
 	if (byte_len == 0)
 		return 1;
 	/* read sector aligned part */
 	block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1);
 	if (block_len == 0) {
 		ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_block_dev_desc->blksz);
 		block_len = ext4fs_block_dev_desc->blksz;
 		ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc->dev,
 						  part_info->start + sector,
 						  1, (unsigned long *)p);
 		memcpy(buf, p, byte_len);
 		return 1;
 	}
 	if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc->dev,
 					       part_info->start + sector,
 					       block_len >> log2blksz,
 					       (unsigned long *) buf) !=
 					       block_len >> log2blksz) {
 		printf(" ** %s read error - block\n", __func__);
 		return 0;
 	}
 	block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1);
 	buf += block_len;
 	byte_len -= block_len;
 	sector += block_len / ext4fs_block_dev_desc->blksz;
 	if (byte_len != 0) {
 		/* read rest of data which are not in whole sector */
 		if (ext4fs_block_dev_desc->
 		    block_read(ext4fs_block_dev_desc->dev,
 				part_info->start + sector, 1,
 				(unsigned long *) sec_buf) != 1) {
 			printf("* %s read error - last part\n", __func__);
 			return 0;
 		}
 		memcpy(buf, sec_buf, byte_len);
 	}
 	return 1;
 }
 int ext4_read_superblock(char *buffer)
 {
 	struct ext_filesystem *fs = get_fs();
 	int sect = SUPERBLOCK_START >> fs->dev_desc->log2blksz;
 	int off = SUPERBLOCK_START % fs->dev_desc->blksz;
 	return ext4fs_devread(sect, off, SUPERBLOCK_SIZE,
 				buffer);
 }

fs/ext4/ext4_common.c

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2011 - 2012 Samsung Electronics
  * EXT4 filesystem implementation in Uboot by
  * Uma Shankar <uma.shankar@samsung.com>
  * Manjunatha C Achar <a.manjunatha@samsung.com>
  *
  * ext4ls and ext4load : Based on ext2 ls load support in Uboot.
  *
  * (C) Copyright 2004
  * esd gmbh <www.esd-electronics.com>
  * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
  *
  * based on code from grub2 fs/ext2.c and fs/fshelp.c by
  * GRUB  --  GRand Unified Bootloader
  * Copyright (C) 2003, 2004  Free Software Foundation, Inc.
  *
  * ext4write : Based on generic ext4 protocol.
  *
  * 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.
  */
 #include <common.h>
 #include <ext_common.h>
 #include <ext4fs.h>
 #include <malloc.h>
 #include <stddef.h>
 #include <linux/stat.h>
 #include <linux/time.h>
 #include <asm/byteorder.h>
 #include "ext4_common.h"
 struct ext2_data *ext4fs_root;
 struct ext2fs_node *ext4fs_file;
 uint32_t *ext4fs_indir1_block;
 int ext4fs_indir1_size;
 int ext4fs_indir1_blkno = -1;
 uint32_t *ext4fs_indir2_block;
 int ext4fs_indir2_size;
 int ext4fs_indir2_blkno = -1;
 uint32_t *ext4fs_indir3_block;
 int ext4fs_indir3_size;
 int ext4fs_indir3_blkno = -1;
 struct ext2_inode *g_parent_inode;
 static int symlinknest;
 #if defined(CONFIG_EXT4_WRITE)
 uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)
 {
 	uint32_t res = size / n;
 	if (res * n != size)
 		res++;
 	return res;
 }
 void put_ext4(uint64_t off, void *buf, uint32_t size)
 {
 	uint64_t startblock;
 	uint64_t remainder;
 	unsigned char *temp_ptr = NULL;
 	struct ext_filesystem *fs = get_fs();
 	int log2blksz = fs->dev_desc->log2blksz;
 	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, sec_buf, fs->dev_desc->blksz);
 	startblock = off >> log2blksz;
 	startblock += part_offset;
 	remainder = off & (uint64_t)(fs->dev_desc->blksz - 1);
 	if (fs->dev_desc == NULL)
 		return;
 	if ((startblock + (size >> log2blksz)) >
 	    (part_offset + fs->total_sect)) {
-		printf("part_offset is %lu\n", part_offset);
+		printf("part_offset is " LBAFU "\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, sec_buf);
 			temp_ptr = sec_buf;
 			memcpy((temp_ptr + remainder),
 			       (unsigned char *)buf, size);
 			fs->dev_desc->block_write(fs->dev_desc->dev,
 						  startblock, 1, sec_buf);
 		}
 	} else {
 		if (size >> log2blksz != 0) {
 			fs->dev_desc->block_write(fs->dev_desc->dev,
 						  startblock,
 						  size >> log2blksz,
 						  (unsigned long *)buf);
 		} else {
 			fs->dev_desc->block_read(fs->dev_desc->dev,
 						 startblock, 1, sec_buf);
 			temp_ptr = sec_buf;
 			memcpy(temp_ptr, buf, size);
 			fs->dev_desc->block_write(fs->dev_desc->dev,
 						  startblock, 1,
 						  (unsigned long *)sec_buf);
 		}
 	}
 }
 static int _get_new_inode_no(unsigned char *buffer)
 {
 	struct ext_filesystem *fs = get_fs();
 	unsigned char input;
 	int operand, status;
 	int count = 1;
 	int j = 0;
 	/* get the blocksize of the filesystem */
 	unsigned char *ptr = buffer;
 	while (*ptr == 255) {
 		ptr++;
 		count += 8;
 		if (count > 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;
 	int count = 0;
 	int 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 ext4fs_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;
 		*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;
 		*ptr = *ptr | operand;
 		return 0;
 	}
 }
 void ext4fs_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);
 	}
 }
 int ext4fs_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 * 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;
 	*ptr = *ptr | operand;
 	return 0;
 }
 void ext4fs_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 * 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);
 }
 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->bgd[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;
 	int sizeof_void_space;
 	int new_entry_byte_reqd;
 	short padding_factor = 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;
 	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;
 	}
 	return 0;
 }
 void ext4fs_update_parent_dentry(char *filename, int *p_ino, int file_type)
 {
 	unsigned int *zero_buffer = NULL;
 	char *root_first_block_buffer = NULL;
 	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;
 	int inodeno;
 	int status;
 	struct ext_filesystem *fs = get_fs();
 	/* directory entry */
 	struct ext2_dirent *dir;
 	char *temp_dir = NULL;
 	zero_buffer = zalloc(fs->blksz);
 	if (!zero_buffer) {
 		printf("No Memory\n");
 		return;
 	}
 	root_first_block_buffer = zalloc(fs->blksz);
 	if (!root_first_block_buffer) {
 		free(zero_buffer);
 		printf("No Memory\n");
 		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 = ext4fs_devread(first_block_no_of_root
+	status = ext4fs_devread((lbaint_t)first_block_no_of_root
 				* fs->sect_perblk,
 				0, fs->blksz, root_first_block_buffer);
 	if (status == 0)
 		goto fail;
 	if (ext4fs_log_journal(root_first_block_buffer, first_block_no_of_root))
 		goto fail;
 	dir = (struct ext2_dirent *)root_first_block_buffer;
 	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:Allocate new block\n");
 				if (direct_blk_idx == INDIRECT_BLOCKS - 1) {
 					printf("Directory exceeds limit\n");
 					goto fail;
 				}
 				g_parent_inode->b.blocks.dir_blocks
 				    [direct_blk_idx] = ext4fs_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 (ext4fs_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);
 	}
 	/* make a pointer ready for creating next directory entry */
 	templength = dir->direntlen;
 	totalbytes = totalbytes + templength;
 	dir = (struct ext2_dirent *)((char *)dir + templength);
 	/* get the next available inode number */
 	inodeno = ext4fs_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 (ext4fs_put_metadata(root_first_block_buffer,
 				first_block_no_of_root))
 		goto fail;
 fail:
 	free(zero_buffer);
 	free(root_first_block_buffer);
 }
 static int search_dir(struct ext2_inode *parent_inode, char *dirname)
 {
 	int status;
 	int inodeno;
 	int totalbytes;
 	int templength;
 	int direct_blk_idx;
 	long int blknr;
 	int found = 0;
 	char *ptr = NULL;
 	unsigned char *block_buffer = NULL;
 	struct ext2_dirent *dir = NULL;
 	struct ext2_dirent *previous_dir = NULL;
 	struct ext_filesystem *fs = get_fs();
 	/* 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 = zalloc(fs->blksz);
 		if (!block_buffer)
 			goto fail;
-		status = ext4fs_devread(blknr * fs->sect_perblk,
+		status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk,
 					0, fs->blksz, (char *)block_buffer);
 		if (status == 0)
 			goto fail;
 		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) {
 			free(block_buffer);
 			block_buffer = NULL;
 			return inodeno;
 		}
 		free(block_buffer);
 		block_buffer = NULL;
 	}
 fail:
 	free(block_buffer);
 	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] = zalloc(strlen("/") + 1);
 	if (!arr[i])
 		return -ENOMEM;
 	arr[i++] = "/";
 	/* add each path entry after root */
 	while (token != NULL) {
 		arr[i] = zalloc(strlen(token) + 1);
 		if (!arr[i])
 			return -ENOMEM;
 		memcpy(arr[i++], token, strlen(token));
 		token = strtok(NULL, "/");
 	}
 	arr[i] = NULL;
 	return 0;
 }
 int ext4fs_iget(int inode_no, struct ext2_inode *inode)
 {
 	if (ext4fs_read_inode(ext4fs_root, inode_no, inode) == 0)
 		return -1;
 	return 0;
 }
 /*
  * Function: ext4fs_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 ext4fs_get_parent_inode_num(const char *dirname, char *dname, int flags)
 {
 	int i;
 	int depth = 0;
 	int matched_inode_no;
 	int result_inode_no = -1;
 	char **ptr = NULL;
 	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;
 	if (*dirname != '/') {
 		printf("Please supply Absolute path\n");
 		return -1;
 	}
 	/* TODO: input validation make equivalent to linux */
 	depth_dirname = zalloc(strlen(dirname) + 1);
 	if (!depth_dirname)
 		return -ENOMEM;
 	memcpy(depth_dirname, dirname, strlen(dirname));
 	depth = find_dir_depth(depth_dirname);
 	parse_dirname = zalloc(strlen(dirname) + 1);
 	if (!parse_dirname)
 		goto fail;
 	memcpy(parse_dirname, dirname, strlen(dirname));
 	/* allocate memory for each directory level */
 	ptr = zalloc((depth) * sizeof(char *));
 	if (!ptr)
 		goto fail;
 	if (parse_path(ptr, parse_dirname))
 		goto fail;
 	parent_inode = zalloc(sizeof(struct ext2_inode));
 	if (!parent_inode)
 		goto fail;
 	first_inode = zalloc(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 (ext4fs_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) {
 		ext4fs_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:
 	free(depth_dirname);
 	free(parse_dirname);
 	free(ptr);
 	free(parent_inode);
 	free(first_inode);
 	return result_inode_no;
 }
 static int check_filename(char *filename, unsigned int blknr)
 {
 	unsigned int first_block_no_of_root;
 	int totalbytes = 0;
 	int templength = 0;
 	int status, inodeno;
 	int found = 0;
 	char *root_first_block_buffer = NULL;
 	char *root_first_block_addr = NULL;
 	struct ext2_dirent *dir = NULL;
 	struct ext2_dirent *previous_dir = NULL;
 	char *ptr = NULL;
 	struct ext_filesystem *fs = get_fs();
 	/* get the first block of root */
 	first_block_no_of_root = blknr;
 	root_first_block_buffer = zalloc(fs->blksz);
 	if (!root_first_block_buffer)
 		return -ENOMEM;
 	root_first_block_addr = root_first_block_buffer;
-	status = ext4fs_devread(first_block_no_of_root *
+	status = ext4fs_devread((lbaint_t)first_block_no_of_root *
 				fs->sect_perblk, 0,
 				fs->blksz, root_first_block_buffer);
 	if (status == 0)
 		goto fail;
 	if (ext4fs_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
 		 */
 		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 (ext4fs_put_metadata(root_first_block_addr,
 					first_block_no_of_root))
 			goto fail;
 		return inodeno;
 	}
 fail:
 	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;
 }
 long int ext4fs_get_new_blk_no(void)
 {
 	short i;
 	short status;
 	int remainder;
 	unsigned int bg_idx;
 	static int prev_bg_bitmap_index = -1;
 	unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	char *zero_buffer = zalloc(fs->blksz);
 	if (!journal_buffer || !zero_buffer)
 		goto fail;
 	struct ext2_block_group *bgd = (struct ext2_block_group *)fs->gdtable;
 	if (fs->first_pass_bbmap == 0) {
 		for (i = 0; i < fs->no_blkgrp; i++) {
 			if (bgd[i].free_blocks) {
 				if (bgd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
 					put_ext4(((uint64_t) (bgd[i].block_id *
 							      fs->blksz)),
 						 zero_buffer, fs->blksz);
 					bgd[i].bg_flags =
 					    bgd[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++;
 				bgd[i].free_blocks--;
 				fs->sb->free_blocks--;
-				status = ext4fs_devread(bgd[i].block_id *
+				status = ext4fs_devread((lbaint_t)
+							bgd[i].block_id *
 							fs->sect_perblk, 0,
 							fs->blksz,
 							journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 							bgd[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 / blk_per_grp;
 		} else {
 			bg_idx = fs->curr_blkno / blk_per_grp;
 			remainder = fs->curr_blkno % blk_per_grp;
 			if (!remainder)
 				bg_idx--;
 		}
 		/*
 		 * To skip completely filled block group bitmaps
 		 * Optimize the block allocation
 		 */
 		if (bg_idx >= fs->no_blkgrp)
 			goto fail;
 		if (bgd[bg_idx].free_blocks == 0) {
 			debug("block group %u is full. Skipping\n", bg_idx);
 			fs->curr_blkno = fs->curr_blkno + blk_per_grp;
 			fs->curr_blkno--;
 			goto restart;
 		}
 		if (bgd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) {
 			memset(zero_buffer, '\0', fs->blksz);
 			put_ext4(((uint64_t) (bgd[bg_idx].block_id *
 					fs->blksz)), zero_buffer, fs->blksz);
 			memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz);
 			bgd[bg_idx].bg_flags = bgd[bg_idx].bg_flags &
 						~EXT4_BG_BLOCK_UNINIT;
 		}
 		if (ext4fs_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 = ext4fs_devread(bgd[bg_idx].block_id
+			status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id
 						* fs->sect_perblk,
 						0, fs->blksz, journal_buffer);
 			if (status == 0)
 				goto fail;
 			if (ext4fs_log_journal(journal_buffer,
 						bgd[bg_idx].block_id))
 				goto fail;
 			prev_bg_bitmap_index = bg_idx;
 		}
 		bgd[bg_idx].free_blocks--;
 		fs->sb->free_blocks--;
 		goto success;
 	}
 success:
 	free(journal_buffer);
 	free(zero_buffer);
 	return fs->curr_blkno;
 fail:
 	free(journal_buffer);
 	free(zero_buffer);
 	return -1;
 }
 int ext4fs_get_new_inode_no(void)
 {
 	short i;
 	short status;
 	unsigned int ibmap_idx;
 	static int prev_inode_bitmap_index = -1;
 	unsigned int inodes_per_grp = ext4fs_root->sblock.inodes_per_group;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	char *zero_buffer = zalloc(fs->blksz);
 	if (!journal_buffer || !zero_buffer)
 		goto fail;
 	struct ext2_block_group *bgd = (struct ext2_block_group *)fs->gdtable;
 	if (fs->first_pass_ibmap == 0) {
 		for (i = 0; i < fs->no_blkgrp; i++) {
 			if (bgd[i].free_inodes) {
 				if (bgd[i].bg_itable_unused !=
 						bgd[i].free_inodes)
 					bgd[i].bg_itable_unused =
 						bgd[i].free_inodes;
 				if (bgd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
 					put_ext4(((uint64_t)
 						  (bgd[i].inode_id *
 							fs->blksz)),
 						 zero_buffer, fs->blksz);
 					bgd[i].bg_flags = bgd[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 * inodes_per_grp);
 				fs->first_pass_ibmap++;
 				bgd[i].free_inodes--;
 				bgd[i].bg_itable_unused--;
 				fs->sb->free_inodes--;
-				status = ext4fs_devread(bgd[i].inode_id *
+				status = ext4fs_devread((lbaint_t)
+							bgd[i].inode_id *
 							fs->sect_perblk, 0,
 							fs->blksz,
 							journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 							bgd[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 / inodes_per_grp;
 		if (bgd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) {
 			memset(zero_buffer, '\0', fs->blksz);
 			put_ext4(((uint64_t) (bgd[ibmap_idx].inode_id *
 					      fs->blksz)), zero_buffer,
 				 fs->blksz);
 			bgd[ibmap_idx].bg_flags =
 			    bgd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
 			memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer,
 				fs->blksz);
 		}
 		if (ext4fs_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 = ext4fs_devread(bgd[ibmap_idx].inode_id
+			status = ext4fs_devread((lbaint_t)
+						bgd[ibmap_idx].inode_id
 						* fs->sect_perblk,
 						0, fs->blksz, journal_buffer);
 			if (status == 0)
 				goto fail;
 			if (ext4fs_log_journal(journal_buffer,
 						bgd[ibmap_idx].inode_id))
 				goto fail;
 			prev_inode_bitmap_index = ibmap_idx;
 		}
 		if (bgd[ibmap_idx].bg_itable_unused !=
 				bgd[ibmap_idx].free_inodes)
 			bgd[ibmap_idx].bg_itable_unused =
 					bgd[ibmap_idx].free_inodes;
 		bgd[ibmap_idx].free_inodes--;
 		bgd[ibmap_idx].bg_itable_unused--;
 		fs->sb->free_inodes--;
 		goto success;
 	}
 success:
 	free(journal_buffer);
 	free(zero_buffer);
 	return fs->curr_inode_no;
 fail:
 	free(journal_buffer);
 	free(zero_buffer);
 	return -1;
 }
 static void alloc_single_indirect_block(struct ext2_inode *file_inode,
 					unsigned int *total_remaining_blocks,
 					unsigned int *no_blks_reqd)
 {
 	short i;
 	short status;
 	long int actual_block_no;
 	long int si_blockno;
 	/* si :single indirect */
 	unsigned int *si_buffer = NULL;
 	unsigned int *si_start_addr = NULL;
 	struct ext_filesystem *fs = get_fs();
 	if (*total_remaining_blocks != 0) {
 		si_buffer = zalloc(fs->blksz);
 		if (!si_buffer) {
 			printf("No Memory\n");
 			return;
 		}
 		si_start_addr = si_buffer;
 		si_blockno = ext4fs_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 = ext4fs_devread(si_blockno * fs->sect_perblk,
+		status = ext4fs_devread((lbaint_t)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 = ext4fs_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:
 	free(si_start_addr);
 }
 static void alloc_double_indirect_block(struct ext2_inode *file_inode,
 					unsigned int *total_remaining_blocks,
 					unsigned int *no_blks_reqd)
 {
 	short i;
 	short j;
 	short status;
 	long int actual_block_no;
 	/* di:double indirect */
 	long int di_blockno_parent;
 	long int 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 = ext4fs_get_new_blk_no();
 		if (di_blockno_parent == -1) {
 			printf("no block left to assign\n");
 			goto fail;
 		}
 		di_parent_buffer = zalloc(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 = ext4fs_devread(di_blockno_parent *
+		status = ext4fs_devread((lbaint_t)di_blockno_parent *
 					fs->sect_perblk, 0,
 					fs->blksz, (char *)di_parent_buffer);
 		if (!status) {
 			printf("%s: Device read error!\n", __func__);
 			goto fail;
 		}
 		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 = ext4fs_get_new_blk_no();
 			if (di_blockno_child == -1) {
 				printf("no block left to assign\n");
 				goto fail;
 			}
 			di_child_buff = zalloc(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 = ext4fs_devread(di_blockno_child *
+			status = ext4fs_devread((lbaint_t)di_blockno_child *
 						fs->sect_perblk, 0,
 						fs->blksz,
 						(char *)di_child_buff);
 			if (!status) {
 				printf("%s: Device read error!\n", __func__);
 				goto fail;
 			}
 			memset(di_child_buff, '\0', fs->blksz);
 			/* filling of actual datablocks for each child */
 			for (j = 0; j < (fs->blksz / sizeof(int)); j++) {
 				actual_block_no = ext4fs_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);
 			free(di_child_buff_start);
 			di_child_buff_start = NULL;
 			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:
 	free(di_block_start_addr);
 }
 static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
 					unsigned int *total_remaining_blocks,
 					unsigned int *no_blks_reqd)
 {
 	short i;
 	short j;
 	short k;
 	long int actual_block_no;
 	/* ti: Triple Indirect */
 	long int ti_gp_blockno;
 	long int ti_parent_blockno;
 	long int 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 = ext4fs_get_new_blk_no();
 		if (ti_gp_blockno == -1) {
 			printf("no block left to assign\n");
 			goto fail;
 		}
 		ti_gp_buff = zalloc(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 = ext4fs_get_new_blk_no();
 			if (ti_parent_blockno == -1) {
 				printf("no block left to assign\n");
 				goto fail;
 			}
 			ti_parent_buff = zalloc(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 = ext4fs_get_new_blk_no();
 				if (ti_child_blockno == -1) {
 					printf("no block left assign\n");
 					goto fail;
 				}
 				ti_child_buff = zalloc(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);
 				/* fill actual datablocks for each child */
 				for (k = 0; k < (fs->blksz / sizeof(int));
 					k++) {
 					actual_block_no =
 					    ext4fs_get_new_blk_no();
 					if (actual_block_no == -1) {
 						printf("no block left\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);
 				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);
 			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.triple_indir_block = ti_gp_blockno;
 	}
 fail:
 	free(ti_gp_buff_start_addr);
 }
 void ext4fs_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;
 	/* allocation of direct blocks */
 	for (i = 0; i < INDIRECT_BLOCKS; i++) {
 		direct_blockno = ext4fs_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;
 	}
 	alloc_single_indirect_block(file_inode, &total_remaining_blocks,
 				    &no_blks_reqd);
 	alloc_double_indirect_block(file_inode, &total_remaining_blocks,
 				    &no_blks_reqd);
 	alloc_triple_indirect_block(file_inode, &total_remaining_blocks,
 				    &no_blks_reqd);
 	*total_no_of_block += no_blks_reqd;
 }
 #endif
 static struct ext4_extent_header *ext4fs_get_extent_block
 	(struct ext2_data *data, char *buf,
 		struct ext4_extent_header *ext_block,
 		uint32_t fileblock, int log2_blksz)
 {
 	struct ext4_extent_idx *index;
 	unsigned long long block;
 	struct ext_filesystem *fs = get_fs();
 	int i;
 	while (1) {
 		index = (struct ext4_extent_idx *)(ext_block + 1);
 		if (le32_to_cpu(ext_block->eh_magic) != EXT4_EXT_MAGIC)
 			return 0;
 		if (ext_block->eh_depth == 0)
 			return ext_block;
 		i = -1;
 		do {
 			i++;
 			if (i >= le32_to_cpu(ext_block->eh_entries))
 				break;
 		} while (fileblock > le32_to_cpu(index[i].ei_block));
 		if (--i < 0)
 			return 0;
 		block = le32_to_cpu(index[i].ei_leaf_hi);
 		block = (block << 32) + le32_to_cpu(index[i].ei_leaf_lo);
-		if (ext4fs_devread(block << log2_blksz, 0, fs->blksz, buf))
+		if (ext4fs_devread((lbaint_t)block << log2_blksz, 0, fs->blksz,
+				   buf))
 			ext_block = (struct ext4_extent_header *)buf;
 		else
 			return 0;
 	}
 }
 static int ext4fs_blockgroup
 	(struct ext2_data *data, int group, struct ext2_block_group *blkgrp)
 {
 	long int blkno;
 	unsigned int blkoff, desc_per_blk;
 	int log2blksz = get_fs()->dev_desc->log2blksz;
 	desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
 	blkno = __le32_to_cpu(data->sblock.first_data_block) + 1 +
 			group / desc_per_blk;
 	blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
 	debug("ext4fs read %d group descriptor (blkno %ld blkoff %u)\n",
 	      group, blkno, blkoff);
-	return ext4fs_devread(blkno << (LOG2_BLOCK_SIZE(data) - log2blksz),
+	return ext4fs_devread((lbaint_t)blkno <<
+			      (LOG2_BLOCK_SIZE(data) - log2blksz),
 			      blkoff, sizeof(struct ext2_block_group),
 			      (char *)blkgrp);
 }
 int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode)
 {
 	struct ext2_block_group blkgrp;
 	struct ext2_sblock *sblock = &data->sblock;
 	struct ext_filesystem *fs = get_fs();
 	int log2blksz = get_fs()->dev_desc->log2blksz;
 	int inodes_per_block, status;
 	long int blkno;
 	unsigned int blkoff;
 	/* It is easier to calculate if the first inode is 0. */
 	ino--;
 	status = ext4fs_blockgroup(data, ino / __le32_to_cpu
 				   (sblock->inodes_per_group), &blkgrp);
 	if (status == 0)
 		return 0;
 	inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz;
 	blkno = __le32_to_cpu(blkgrp.inode_table_id) +
 	    (ino % __le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
 	blkoff = (ino % inodes_per_block) * fs->inodesz;
 	/* Read the inode. */
-	status = ext4fs_devread(blkno << (LOG2_BLOCK_SIZE(data) - log2blksz),
+	status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) -
-				blkoff,
+				log2blksz), blkoff,
 				sizeof(struct ext2_inode), (char *)inode);
 	if (status == 0)
 		return 0;
 	return 1;
 }
 long int read_allocated_block(struct ext2_inode *inode, int fileblock)
 {
 	long int blknr;
 	int blksz;
 	int log2_blksz;
 	int status;
 	long int rblock;
 	long int perblock_parent;
 	long int perblock_child;
 	unsigned long long start;
 	/* get the blocksize of the filesystem */
 	blksz = EXT2_BLOCK_SIZE(ext4fs_root);
 	log2_blksz = LOG2_BLOCK_SIZE(ext4fs_root)
 		- get_fs()->dev_desc->log2blksz;
 	if (le32_to_cpu(inode->flags) & EXT4_EXTENTS_FL) {
 		char *buf = zalloc(blksz);
 		if (!buf)
 			return -ENOMEM;
 		struct ext4_extent_header *ext_block;
 		struct ext4_extent *extent;
 		int i = -1;
 		ext_block =
 			ext4fs_get_extent_block(ext4fs_root, buf,
 						(struct ext4_extent_header *)
 						inode->b.blocks.dir_blocks,
 						fileblock, log2_blksz);
 		if (!ext_block) {
 			printf("invalid extent block\n");
 			free(buf);
 			return -EINVAL;
 		}
 		extent = (struct ext4_extent *)(ext_block + 1);
 		do {
 			i++;
 			if (i >= le32_to_cpu(ext_block->eh_entries))
 				break;
 		} while (fileblock >= le32_to_cpu(extent[i].ee_block));
 		if (--i >= 0) {
 			fileblock -= le32_to_cpu(extent[i].ee_block);
 			if (fileblock >= le32_to_cpu(extent[i].ee_len)) {
 				free(buf);
 				return 0;
 			}
 			start = le32_to_cpu(extent[i].ee_start_hi);
 			start = (start << 32) +
 					le32_to_cpu(extent[i].ee_start_lo);
 			free(buf);
 			return fileblock + start;
 		}
 		printf("Extent Error\n");
 		free(buf);
 		return -1;
 	}
 	/* Direct blocks. */
 	if (fileblock < INDIRECT_BLOCKS)
 		blknr = __le32_to_cpu(inode->b.blocks.dir_blocks[fileblock]);
 	/* Indirect. */
 	else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
 		if (ext4fs_indir1_block == NULL) {
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** SI ext2fs read block (indir 1)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 			ext4fs_indir1_blkno = -1;
 		}
 		if (blksz != ext4fs_indir1_size) {
 			free(ext4fs_indir1_block);
 			ext4fs_indir1_block = NULL;
 			ext4fs_indir1_size = 0;
 			ext4fs_indir1_blkno = -1;
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** SI ext2fs read block (indir 1):"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 		}
 		if ((__le32_to_cpu(inode->b.blocks.indir_block) <<
 		     log2_blksz) != ext4fs_indir1_blkno) {
 			status =
-			    ext4fs_devread(__le32_to_cpu
+			    ext4fs_devread((lbaint_t)__le32_to_cpu
 					   (inode->b.blocks.
 					    indir_block) << log2_blksz, 0,
 					   blksz, (char *)ext4fs_indir1_block);
 			if (status == 0) {
 				printf("** SI ext2fs read block (indir 1)"
 					"failed. **\n");
 				return 0;
 			}
 			ext4fs_indir1_blkno =
 				__le32_to_cpu(inode->b.blocks.
 					       indir_block) << log2_blksz;
 		}
 		blknr = __le32_to_cpu(ext4fs_indir1_block
 				      [fileblock - INDIRECT_BLOCKS]);
 	}
 	/* Double indirect. */
 	else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4 *
 					(blksz / 4 + 1)))) {
 		long int perblock = blksz / 4;
 		long int rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4);
 		if (ext4fs_indir1_block == NULL) {
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** DI ext2fs read block (indir 2 1)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 			ext4fs_indir1_blkno = -1;
 		}
 		if (blksz != ext4fs_indir1_size) {
 			free(ext4fs_indir1_block);
 			ext4fs_indir1_block = NULL;
 			ext4fs_indir1_size = 0;
 			ext4fs_indir1_blkno = -1;
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** DI ext2fs read block (indir 2 1)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 		}
 		if ((__le32_to_cpu(inode->b.blocks.double_indir_block) <<
 		     log2_blksz) != ext4fs_indir1_blkno) {
 			status =
-			    ext4fs_devread(__le32_to_cpu
+			    ext4fs_devread((lbaint_t)__le32_to_cpu
 					   (inode->b.blocks.
 					    double_indir_block) << log2_blksz,
 					   0, blksz,
 					   (char *)ext4fs_indir1_block);
 			if (status == 0) {
 				printf("** DI ext2fs read block (indir 2 1)"
 					"failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_blkno =
 			    __le32_to_cpu(inode->b.blocks.double_indir_block) <<
 			    log2_blksz;
 		}
 		if (ext4fs_indir2_block == NULL) {
 			ext4fs_indir2_block = zalloc(blksz);
 			if (ext4fs_indir2_block == NULL) {
 				printf("** DI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_size = blksz;
 			ext4fs_indir2_blkno = -1;
 		}
 		if (blksz != ext4fs_indir2_size) {
 			free(ext4fs_indir2_block);
 			ext4fs_indir2_block = NULL;
 			ext4fs_indir2_size = 0;
 			ext4fs_indir2_blkno = -1;
 			ext4fs_indir2_block = zalloc(blksz);
 			if (ext4fs_indir2_block == NULL) {
 				printf("** DI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_size = blksz;
 		}
 		if ((__le32_to_cpu(ext4fs_indir1_block[rblock / perblock]) <<
 		     log2_blksz) != ext4fs_indir2_blkno) {
-			status = ext4fs_devread(__le32_to_cpu
+			status = ext4fs_devread((lbaint_t)__le32_to_cpu
 						(ext4fs_indir1_block
 						 [rblock /
 						  perblock]) << log2_blksz, 0,
 						blksz,
 						(char *)ext4fs_indir2_block);
 			if (status == 0) {
 				printf("** DI ext2fs read block (indir 2 2)"
 					"failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_blkno =
 			    __le32_to_cpu(ext4fs_indir1_block[rblock
 							      /
 							      perblock]) <<
 			    log2_blksz;
 		}
 		blknr = __le32_to_cpu(ext4fs_indir2_block[rblock % perblock]);
 	}
 	/* Tripple indirect. */
 	else {
 		rblock = fileblock - (INDIRECT_BLOCKS + blksz / 4 +
 				      (blksz / 4 * blksz / 4));
 		perblock_child = blksz / 4;
 		perblock_parent = ((blksz / 4) * (blksz / 4));
 		if (ext4fs_indir1_block == NULL) {
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 1)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 			ext4fs_indir1_blkno = -1;
 		}
 		if (blksz != ext4fs_indir1_size) {
 			free(ext4fs_indir1_block);
 			ext4fs_indir1_block = NULL;
 			ext4fs_indir1_size = 0;
 			ext4fs_indir1_blkno = -1;
 			ext4fs_indir1_block = zalloc(blksz);
 			if (ext4fs_indir1_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 1)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_size = blksz;
 		}
 		if ((__le32_to_cpu(inode->b.blocks.triple_indir_block) <<
 		     log2_blksz) != ext4fs_indir1_blkno) {
 			status = ext4fs_devread
-			    (__le32_to_cpu(inode->b.blocks.triple_indir_block)
+			    ((lbaint_t)
+			     __le32_to_cpu(inode->b.blocks.triple_indir_block)
 			     << log2_blksz, 0, blksz,
 			     (char *)ext4fs_indir1_block);
 			if (status == 0) {
 				printf("** TI ext2fs read block (indir 2 1)"
 					"failed. **\n");
 				return -1;
 			}
 			ext4fs_indir1_blkno =
 			    __le32_to_cpu(inode->b.blocks.triple_indir_block) <<
 			    log2_blksz;
 		}
 		if (ext4fs_indir2_block == NULL) {
 			ext4fs_indir2_block = zalloc(blksz);
 			if (ext4fs_indir2_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_size = blksz;
 			ext4fs_indir2_blkno = -1;
 		}
 		if (blksz != ext4fs_indir2_size) {
 			free(ext4fs_indir2_block);
 			ext4fs_indir2_block = NULL;
 			ext4fs_indir2_size = 0;
 			ext4fs_indir2_blkno = -1;
 			ext4fs_indir2_block = zalloc(blksz);
 			if (ext4fs_indir2_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_size = blksz;
 		}
 		if ((__le32_to_cpu(ext4fs_indir1_block[rblock /
 						       perblock_parent]) <<
 		     log2_blksz)
 		    != ext4fs_indir2_blkno) {
-			status = ext4fs_devread(__le32_to_cpu
+			status = ext4fs_devread((lbaint_t)__le32_to_cpu
 						(ext4fs_indir1_block
 						 [rblock /
 						  perblock_parent]) <<
 						log2_blksz, 0, blksz,
 						(char *)ext4fs_indir2_block);
 			if (status == 0) {
 				printf("** TI ext2fs read block (indir 2 2)"
 					"failed. **\n");
 				return -1;
 			}
 			ext4fs_indir2_blkno =
 			    __le32_to_cpu(ext4fs_indir1_block[rblock /
 							      perblock_parent])
 			    << log2_blksz;
 		}
 		if (ext4fs_indir3_block == NULL) {
 			ext4fs_indir3_block = zalloc(blksz);
 			if (ext4fs_indir3_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir3_size = blksz;
 			ext4fs_indir3_blkno = -1;
 		}
 		if (blksz != ext4fs_indir3_size) {
 			free(ext4fs_indir3_block);
 			ext4fs_indir3_block = NULL;
 			ext4fs_indir3_size = 0;
 			ext4fs_indir3_blkno = -1;
 			ext4fs_indir3_block = zalloc(blksz);
 			if (ext4fs_indir3_block == NULL) {
 				printf("** TI ext2fs read block (indir 2 2)"
 					"malloc failed. **\n");
 				return -1;
 			}
 			ext4fs_indir3_size = blksz;
 		}
 		if ((__le32_to_cpu(ext4fs_indir2_block[rblock
 						       /
 						       perblock_child]) <<
 		     log2_blksz) != ext4fs_indir3_blkno) {
 			status =
-			    ext4fs_devread(__le32_to_cpu
+			    ext4fs_devread((lbaint_t)__le32_to_cpu
 					   (ext4fs_indir2_block
 					    [(rblock / perblock_child)
 					     % (blksz / 4)]) << log2_blksz, 0,
 					   blksz, (char *)ext4fs_indir3_block);
 			if (status == 0) {
 				printf("** TI ext2fs read block (indir 2 2)"
 				       "failed. **\n");
 				return -1;
 			}
 			ext4fs_indir3_blkno =
 			    __le32_to_cpu(ext4fs_indir2_block[(rblock /
 							       perblock_child) %
 							      (blksz /
 							       4)]) <<
 			    log2_blksz;
 		}
 		blknr = __le32_to_cpu(ext4fs_indir3_block
 				      [rblock % perblock_child]);
 	}
 	debug("read_allocated_block %ld\n", blknr);
 	return blknr;
 }
 void ext4fs_close(void)
 {
 	if ((ext4fs_file != NULL) && (ext4fs_root != NULL)) {
 		ext4fs_free_node(ext4fs_file, &ext4fs_root->diropen);
 		ext4fs_file = NULL;
 	}
 	if (ext4fs_root != NULL) {
 		free(ext4fs_root);
 		ext4fs_root = NULL;
 	}
 	if (ext4fs_indir1_block != NULL) {
 		free(ext4fs_indir1_block);
 		ext4fs_indir1_block = NULL;
 		ext4fs_indir1_size = 0;
 		ext4fs_indir1_blkno = -1;
 	}
 	if (ext4fs_indir2_block != NULL) {
 		free(ext4fs_indir2_block);
 		ext4fs_indir2_block = NULL;
 		ext4fs_indir2_size = 0;
 		ext4fs_indir2_blkno = -1;
 	}
 	if (ext4fs_indir3_block != NULL) {
 		free(ext4fs_indir3_block);
 		ext4fs_indir3_block = NULL;
 		ext4fs_indir3_size = 0;
 		ext4fs_indir3_blkno = -1;
 	}
 }
 int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
 				struct ext2fs_node **fnode, int *ftype)
 {
 	unsigned int fpos = 0;
 	int status;
 	struct ext2fs_node *diro = (struct ext2fs_node *) dir;
 #ifdef DEBUG
 	if (name != NULL)
 		printf("Iterate dir %s\n", name);
 #endif /* of DEBUG */
 	if (!diro->inode_read) {
 		status = ext4fs_read_inode(diro->data, diro->ino, &diro->inode);
 		if (status == 0)
 			return 0;
 	}
 	/* Search the file.  */
 	while (fpos < __le32_to_cpu(diro->inode.size)) {
 		struct ext2_dirent dirent;
 		status = ext4fs_read_file(diro, fpos,
 					   sizeof(struct ext2_dirent),
 					   (char *) &dirent);
 		if (status < 1)
 			return 0;
 		if (dirent.namelen != 0) {
 			char filename[dirent.namelen + 1];
 			struct ext2fs_node *fdiro;
 			int type = FILETYPE_UNKNOWN;
 			status = ext4fs_read_file(diro,
 						  fpos +
 						  sizeof(struct ext2_dirent),
 						  dirent.namelen, filename);
 			if (status < 1)
 				return 0;
 			fdiro = zalloc(sizeof(struct ext2fs_node));
 			if (!fdiro)
 				return 0;
 			fdiro->data = diro->data;
 			fdiro->ino = __le32_to_cpu(dirent.inode);
 			filename[dirent.namelen] = '\0';
 			if (dirent.filetype != FILETYPE_UNKNOWN) {
 				fdiro->inode_read = 0;
 				if (dirent.filetype == FILETYPE_DIRECTORY)
 					type = FILETYPE_DIRECTORY;
 				else if (dirent.filetype == FILETYPE_SYMLINK)
 					type = FILETYPE_SYMLINK;
 				else if (dirent.filetype == FILETYPE_REG)
 					type = FILETYPE_REG;
 			} else {
 				status = ext4fs_read_inode(diro->data,
 							   __le32_to_cpu
 							   (dirent.inode),
 							   &fdiro->inode);
 				if (status == 0) {
 					free(fdiro);
 					return 0;
 				}
 				fdiro->inode_read = 1;
 				if ((__le16_to_cpu(fdiro->inode.mode) &
 				     FILETYPE_INO_MASK) ==
 				    FILETYPE_INO_DIRECTORY) {
 					type = FILETYPE_DIRECTORY;
 				} else if ((__le16_to_cpu(fdiro->inode.mode)
 					    & FILETYPE_INO_MASK) ==
 					   FILETYPE_INO_SYMLINK) {
 					type = FILETYPE_SYMLINK;
 				} else if ((__le16_to_cpu(fdiro->inode.mode)
 					    & FILETYPE_INO_MASK) ==
 					   FILETYPE_INO_REG) {
 					type = FILETYPE_REG;
 				}
 			}
 #ifdef DEBUG
 			printf("iterate >%s<\n", filename);
 #endif /* of DEBUG */
 			if ((name != NULL) && (fnode != NULL)
 			    && (ftype != NULL)) {
 				if (strcmp(filename, name) == 0) {
 					*ftype = type;
 					*fnode = fdiro;
 					return 1;
 				}
 			} else {
 				if (fdiro->inode_read == 0) {
 					status = ext4fs_read_inode(diro->data,
 								 __le32_to_cpu(
 								 dirent.inode),
 								 &fdiro->inode);
 					if (status == 0) {
 						free(fdiro);
 						return 0;
 					}
 					fdiro->inode_read = 1;
 				}
 				switch (type) {
 				case FILETYPE_DIRECTORY:
 					printf("<DIR> ");
 					break;
 				case FILETYPE_SYMLINK:
 					printf("<SYM> ");
 					break;
 				case FILETYPE_REG:
 					printf("      ");
 					break;
 				default:
 					printf("< ? > ");
 					break;
 				}
 				printf("%10d %s\n",
 					__le32_to_cpu(fdiro->inode.size),
 					filename);
 			}
 			free(fdiro);
 		}
 		fpos += __le16_to_cpu(dirent.direntlen);
 	}
 	return 0;
 }
 static char *ext4fs_read_symlink(struct ext2fs_node *node)
 {
 	char *symlink;
 	struct ext2fs_node *diro = node;
 	int status;
 	if (!diro->inode_read) {
 		status = ext4fs_read_inode(diro->data, diro->ino, &diro->inode);
 		if (status == 0)
 			return 0;
 	}
 	symlink = zalloc(__le32_to_cpu(diro->inode.size) + 1);
 	if (!symlink)
 		return 0;
 	if (__le32_to_cpu(diro->inode.size) <= 60) {
 		strncpy(symlink, diro->inode.b.symlink,
 			 __le32_to_cpu(diro->inode.size));
 	} else {
 		status = ext4fs_read_file(diro, 0,
 					   __le32_to_cpu(diro->inode.size),
 					   symlink);
 		if (status == 0) {
 			free(symlink);
 			return 0;
 		}
 	}
 	symlink[__le32_to_cpu(diro->inode.size)] = '\0';
 	return symlink;
 }
 static int ext4fs_find_file1(const char *currpath,
 			     struct ext2fs_node *currroot,
 			     struct ext2fs_node **currfound, int *foundtype)
 {
 	char fpath[strlen(currpath) + 1];
 	char *name = fpath;
 	char *next;
 	int status;
 	int type = FILETYPE_DIRECTORY;
 	struct ext2fs_node *currnode = currroot;
 	struct ext2fs_node *oldnode = currroot;
 	strncpy(fpath, currpath, strlen(currpath) + 1);
 	/* Remove all leading slashes. */
 	while (*name == '/')
 		name++;
 	if (!*name) {
 		*currfound = currnode;
 		return 1;
 	}
 	for (;;) {
 		int found;
 		/* Extract the actual part from the pathname. */
 		next = strchr(name, '/');
 		if (next) {
 			/* Remove all leading slashes. */
 			while (*next == '/')
 				*(next++) = '\0';
 		}
 		if (type != FILETYPE_DIRECTORY) {
 			ext4fs_free_node(currnode, currroot);
 			return 0;
 		}
 		oldnode = currnode;
 		/* Iterate over the directory. */
 		found = ext4fs_iterate_dir(currnode, name, &currnode, &type);
 		if (found == 0)
 			return 0;
 		if (found == -1)
 			break;
 		/* Read in the symlink and follow it. */
 		if (type == FILETYPE_SYMLINK) {
 			char *symlink;
 			/* Test if the symlink does not loop. */
 			if (++symlinknest == 8) {
 				ext4fs_free_node(currnode, currroot);
 				ext4fs_free_node(oldnode, currroot);
 				return 0;
 			}
 			symlink = ext4fs_read_symlink(currnode);
 			ext4fs_free_node(currnode, currroot);
 			if (!symlink) {
 				ext4fs_free_node(oldnode, currroot);
 				return 0;
 			}
 			debug("Got symlink >%s<\n", symlink);
 			if (symlink[0] == '/') {
 				ext4fs_free_node(oldnode, currroot);
 				oldnode = &ext4fs_root->diropen;
 			}
 			/* Lookup the node the symlink points to. */
 			status = ext4fs_find_file1(symlink, oldnode,
 						    &currnode, &type);
 			free(symlink);
 			if (status == 0) {
 				ext4fs_free_node(oldnode, currroot);
 				return 0;
 			}
 		}
 		ext4fs_free_node(oldnode, currroot);
 		/* Found the node! */
 		if (!next || *next == '\0') {
 			*currfound = currnode;
 			*foundtype = type;
 			return 1;
 		}
 		name = next;
 	}
 	return -1;
 }
 int ext4fs_find_file(const char *path, struct ext2fs_node *rootnode,
 	struct ext2fs_node **foundnode, int expecttype)
 {
 	int status;
 	int foundtype = FILETYPE_DIRECTORY;
 	symlinknest = 0;
 	if (!path)
 		return 0;
 	status = ext4fs_find_file1(path, rootnode, foundnode, &foundtype);
 	if (status == 0)
 		return 0;
 	/* Check if the node that was found was of the expected type. */
 	if ((expecttype == FILETYPE_REG) && (foundtype != expecttype))
 		return 0;
 	else if ((expecttype == FILETYPE_DIRECTORY)
 		   && (foundtype != expecttype))
 		return 0;
 	return 1;
 }
 int ext4fs_open(const char *filename)
 {
 	struct ext2fs_node *fdiro = NULL;
 	int status;
 	int len;
 	if (ext4fs_root == NULL)
 		return -1;
 	ext4fs_file = NULL;
 	status = ext4fs_find_file(filename, &ext4fs_root->diropen, &fdiro,
 				  FILETYPE_REG);
 	if (status == 0)
 		goto fail;
 	if (!fdiro->inode_read) {
 		status = ext4fs_read_inode(fdiro->data, fdiro->ino,
 				&fdiro->inode);
 		if (status == 0)
 			goto fail;
 	}
 	len = __le32_to_cpu(fdiro->inode.size);
 	ext4fs_file = fdiro;
 	return len;
 fail:
 	ext4fs_free_node(fdiro, &ext4fs_root->diropen);
 	return -1;
 }
 int ext4fs_mount(unsigned part_length)
 {
 	struct ext2_data *data;
 	int status;
 	struct ext_filesystem *fs = get_fs();
 	data = zalloc(SUPERBLOCK_SIZE);
 	if (!data)
 		return 0;
 	/* Read the superblock. */
 	status = ext4_read_superblock((char *)&data->sblock);
 	if (status == 0)
 		goto fail;
 	/* Make sure this is an ext2 filesystem. */
 	if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC)
 		goto fail;
 	if (__le32_to_cpu(data->sblock.revision_level == 0))
 		fs->inodesz = 128;
 	else
 		fs->inodesz = __le16_to_cpu(data->sblock.inode_size);
 	debug("EXT2 rev %d, inode_size %d\n",
 	       __le32_to_cpu(data->sblock.revision_level), fs->inodesz);
 	data->diropen.data = data;
 	data->diropen.ino = 2;
 	data->diropen.inode_read = 1;
 	data->inode = &data->diropen.inode;
 	status = ext4fs_read_inode(data, 2, data->inode);
 	if (status == 0)
 		goto fail;
 	ext4fs_root = data;
 	return 1;
 fail:
 	printf("Failed to mount ext2 filesystem...\n");
 	free(data);
 	ext4fs_root = NULL;
 	return 0;
 }

fs/ext4/ext4_journal.c

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2011 - 2012 Samsung Electronics
  * EXT4 filesystem implementation in Uboot by
  * Uma Shankar <uma.shankar@samsung.com>
  * Manjunatha C Achar <a.manjunatha@samsung.com>
  *
  * Journal data structures and headers for Journaling feature of ext4
  * have been referred from JBD2 (Journaling Block device 2)
  * implementation in Linux Kernel.
  * Written by Stephen C. Tweedie <sct@redhat.com>
  *
  * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
  * option, any later version, incorporated herein by reference.
  *
  * 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.
  */
 #include <common.h>
 #include <ext4fs.h>
 #include <malloc.h>
 #include <ext_common.h>
 #include "ext4_common.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 ext4fs_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] = zalloc(sizeof(struct journal_log));
 		if (!journal_ptr[i])
 			goto fail;
 		dirty_block_ptr[i] = zalloc(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 = zalloc(fs->blksz);
 		if (!temp)
 			goto fail;
 		journal_ptr[gindex]->buf = zalloc(fs->blksz);
 		if (!journal_ptr[gindex]->buf)
 			goto fail;
 		ext4fs_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 = zalloc(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 (ext4fs_check_journal_state(SCAN))
 		goto fail;
 	/* Check the file system state using journal super block */
 	if (ext4fs_check_journal_state(RECOVER))
 		goto fail;
 	return 0;
 fail:
 	return -1;
 }
 void ext4fs_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) ((uint64_t)dirty_block_ptr[i]->blknr *
 				(uint64_t)fs->blksz), dirty_block_ptr[i]->buf,
 								fs->blksz);
 	}
 }
 void ext4fs_free_journal(void)
 {
 	int i;
 	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;
 	jrnl_blk_idx = 1;
 }
 int ext4fs_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 = zalloc(fs->blksz);
 		if (!journal_ptr[gindex]->buf)
 			return -ENOMEM;
 		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 ext4fs_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 -EINVAL;
 	}
 	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 = zalloc(fs->blksz);
 	if (!journal_ptr[gindex]->buf)
 		return -ENOMEM;
 	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 ext4fs_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 -EINVAL;
 	}
 	dirty_block_ptr[gd_index]->buf = zalloc(fs->blksz);
 	if (!dirty_block_ptr[gd_index]->buf)
 		return -ENOMEM;
 	memcpy(dirty_block_ptr[gd_index]->buf, metadata_buffer, fs->blksz);
 	dirty_block_ptr[gd_index++]->blknr = blknr;
 	return 0;
 }
 void print_revoke_blks(char *revk_blk)
 {
 	int offset;
 	int max;
 	long int blocknr;
 	struct journal_revoke_header_t *header;
 	if (revk_blk == NULL)
 		return;
 	header = (struct journal_revoke_header_t *) revk_blk;
 	offset = sizeof(struct journal_revoke_header_t);
 	max = be32_to_cpu(header->r_count);
 	printf("total bytes %d\n", max);
 	while (offset < max) {
 		blocknr = be32_to_cpu(*((long int *)(revk_blk + offset)));
 		printf("revoke blknr is %ld\n", blocknr);
 		offset += 4;
 	}
 }
 static struct revoke_blk_list *_get_node(void)
 {
 	struct revoke_blk_list *tmp_node;
 	tmp_node = zalloc(sizeof(struct revoke_blk_list));
 	if (tmp_node == NULL)
 		return NULL;
 	tmp_node->content = NULL;
 	tmp_node->next = NULL;
 	return tmp_node;
 }
 void ext4fs_push_revoke_blk(char *buffer)
 {
 	struct revoke_blk_list *node = NULL;
 	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 = zalloc(fs->blksz);
 	if (node->content == NULL)
 		return;
 	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;
 	}
 }
 void ext4fs_free_revoke_blks(void)
 {
 	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;
 }
 int check_blknr_for_revoke(long int blknr, int sequence_no)
 {
 	struct journal_revoke_header_t *header;
 	int offset;
 	int 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 < be32_to_cpu(header->r_header.h_sequence)) {
 			offset = sizeof(struct journal_revoke_header_t);
 			max = be32_to_cpu(header->r_count);
 			while (offset < max) {
 				blocknr = be32_to_cpu(*((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 = zalloc(fs->blksz);
 	char *metadata_buff = zalloc(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);
-	ext4fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	ext4fs_devread((lbaint_t)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 = be32_to_cpu(tag->flags);
 		if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
 			ofs += 16;
 		i++;
 		debug("\t\ttag %u\n", be32_to_cpu(tag->block));
 		if (revk_blk_list != NULL) {
 			if (check_blknr_for_revoke(be32_to_cpu(tag->block),
 				be32_to_cpu(jdb->h_sequence)) == 0)
 				continue;
 		}
 		blknr = read_allocated_block(&inode_journal, i);
-		ext4fs_devread(blknr * fs->sect_perblk, 0,
+		ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
 			       fs->blksz, metadata_buff);
 		put_ext4((uint64_t)(be32_to_cpu(tag->block) * fs->blksz),
 			 metadata_buff, (uint32_t) fs->blksz);
 	} while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
 fail:
 	free(temp_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");
 }
 int ext4fs_check_journal_state(int recovery_flag)
 {
 	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;
 	struct ext2_inode inode_journal;
 	struct journal_superblock_t *jsb = NULL;
 	struct journal_header_t *jdb = NULL;
 	char *p_jdb = NULL;
 	struct ext3_journal_block_tag *tag = NULL;
 	char *temp_buff = NULL;
 	char *temp_buff1 = NULL;
 	struct ext_filesystem *fs = get_fs();
 	temp_buff = zalloc(fs->blksz);
 	if (!temp_buff)
 		return -ENOMEM;
 	temp_buff1 = zalloc(fs->blksz);
 	if (!temp_buff1) {
 		free(temp_buff);
 		return -ENOMEM;
 	}
 	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
 	blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK);
-	ext4fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	ext4fs_devread((lbaint_t)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 (be32_to_cpu(jsb->s_start) == 0)
 		goto end;
 	if (!(jsb->s_feature_compat &
 				cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM)))
 		jsb->s_feature_compat |=
 				cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
 	i = be32_to_cpu(jsb->s_first);
 	while (1) {
 		blknr = read_allocated_block(&inode_journal, i);
 		memset(temp_buff1, '\0', fs->blksz);
-		ext4fs_devread(blknr * fs->sect_perblk,
+		ext4fs_devread((lbaint_t)blknr * fs->sect_perblk,
 			       0, fs->blksz, temp_buff1);
 		jdb = (struct journal_header_t *) temp_buff1;
 		if (be32_to_cpu(jdb->h_blocktype) ==
 		    EXT3_JOURNAL_DESCRIPTOR_BLOCK) {
 			if (be32_to_cpu(jdb->h_sequence) !=
 			    be32_to_cpu(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 = be32_to_cpu(tag->flags);
 				if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
 					ofs += 16;
 				i++;
 				debug("\t\ttag %u\n", be32_to_cpu(tag->block));
 			} while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
 			i++;
 			DB_FOUND = YES;
 		} else if (be32_to_cpu(jdb->h_blocktype) ==
 				EXT3_JOURNAL_COMMIT_BLOCK) {
 			if (be32_to_cpu(jdb->h_sequence) !=
 			     be32_to_cpu(jsb->s_sequence)) {
 				print_jrnl_status(recovery_flag);
 				break;
 			}
 			if (transaction_state == TRANSACTION_RUNNING ||
 					(DB_FOUND == NO)) {
 				transaction_state = TRANSACTION_COMPLETE;
 				i++;
 				jsb->s_sequence =
 					cpu_to_be32(be32_to_cpu(
 						jsb->s_sequence) + 1);
 			}
 			prev_desc_logical_no = curr_desc_logical_no;
 			if ((recovery_flag == RECOVER) && (DB_FOUND == YES))
 				recover_transaction(prev_desc_logical_no);
 			DB_FOUND = NO;
 		} else if (be32_to_cpu(jdb->h_blocktype) ==
 				EXT3_JOURNAL_REVOKE_BLOCK) {
 			if (be32_to_cpu(jdb->h_sequence) !=
 			    be32_to_cpu(jsb->s_sequence)) {
 				print_jrnl_status(recovery_flag);
 				break;
 			}
 			if (recovery_flag == SCAN)
 				ext4fs_push_revoke_blk((char *)jdb);
 			i++;
 		} else {
 			debug("Else Case\n");
 			if (be32_to_cpu(jdb->h_sequence) !=
 			    be32_to_cpu(jsb->s_sequence)) {
 				print_jrnl_status(recovery_flag);
 				break;
 			}
 		}
 	}
 end:
 	if (recovery_flag == RECOVER) {
 		jsb->s_start = cpu_to_be32(1);
 		jsb->s_sequence = cpu_to_be32(be32_to_cpu(jsb->s_sequence) + 1);
 		/* get the superblock */
 		ext4_read_superblock((char *)fs->sb);
 		fs->sb->feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER;
 		/* Update the super block */
 		put_ext4((uint64_t) (SUPERBLOCK_SIZE),
 			 (struct ext2_sblock *)fs->sb,
 			 (uint32_t) SUPERBLOCK_SIZE);
 		ext4_read_superblock((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);
 		ext4fs_free_revoke_blks();
 	}
 	free(temp_buff);
 	free(temp_buff1);
 	return 0;
 }
 static void update_descriptor_block(long int blknr)
 {
 	int i;
 	long int jsb_blknr;
 	struct journal_header_t jdb;
 	struct ext3_journal_block_tag tag;
 	struct ext2_inode inode_journal;
 	struct journal_superblock_t *jsb = NULL;
 	char *buf = NULL;
 	char *temp = NULL;
 	struct ext_filesystem *fs = get_fs();
 	char *temp_buff = zalloc(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);
-	ext4fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz,
+		       temp_buff);
 	jsb = (struct journal_superblock_t *) temp_buff;
 	jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_DESCRIPTOR_BLOCK);
 	jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER);
 	jdb.h_sequence = jsb->s_sequence;
 	buf = zalloc(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 = cpu_to_be32(journal_ptr[i]->blknr);
 		tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_SAME_UUID);
 		memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag));
 		temp = temp + sizeof(struct ext3_journal_block_tag);
 	}
 	tag.block = cpu_to_be32(journal_ptr[--i]->blknr);
 	tag.flags = cpu_to_be32(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 = zalloc(fs->blksz);
 	if (!temp_buff)
 		return;
-	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
+	ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
+			  &inode_journal);
 	jsb_blknr = read_allocated_block(&inode_journal,
 					 EXT2_JOURNAL_SUPERBLOCK);
-	ext4fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff);
+	ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz,
+		       temp_buff);
 	jsb = (struct journal_superblock_t *) temp_buff;
 	jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_COMMIT_BLOCK);
 	jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER);
 	jdb.h_sequence = jsb->s_sequence;
 	buf = zalloc(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 ext4fs_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) ((uint64_t)blknr * (uint64_t)fs->blksz),
 			 journal_ptr[i]->buf, fs->blksz);
 	}
 	blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++);
 	update_commit_block(blknr);
 	printf("update journal finished\n");
 }

fs/ext4/ext4_write.c

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2011 - 2012 Samsung Electronics
  * EXT4 filesystem implementation in Uboot by
  * Uma Shankar <uma.shankar@samsung.com>
  * Manjunatha C Achar <a.manjunatha@samsung.com>
  *
  * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
  *		       Ext4 read optimization taken from Open-Moko
  *		       Qi bootloader
  *
  * (C) Copyright 2004
  * esd gmbh <www.esd-electronics.com>
  * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
  *
  * based on code from grub2 fs/ext2.c and fs/fshelp.c by
  * GRUB  --  GRand Unified Bootloader
  * Copyright (C) 2003, 2004  Free Software Foundation, Inc.
  *
  * ext4write : Based on generic ext4 protocol.
  *
  * 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.
  */
 #include <common.h>
 #include <linux/stat.h>
 #include <div64.h>
 #include "ext4_common.h"
 static void ext4fs_update(void)
 {
 	short i;
 	ext4fs_update_journal();
 	struct ext_filesystem *fs = get_fs();
 	/* update  super block */
 	put_ext4((uint64_t)(SUPERBLOCK_SIZE),
 		 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
 	/* update block groups */
 	for (i = 0; i < fs->no_blkgrp; i++) {
 		fs->bgd[i].bg_checksum = ext4fs_checksum_update(i);
 		put_ext4((uint64_t)(fs->bgd[i].block_id * fs->blksz),
 			 fs->blk_bmaps[i], fs->blksz);
 	}
 	/* update inode table groups */
 	for (i = 0; i < fs->no_blkgrp; i++) {
 		put_ext4((uint64_t) (fs->bgd[i].inode_id * fs->blksz),
 			 fs->inode_bmaps[i], fs->blksz);
 	}
 	/* update the block group descriptor table */
 	put_ext4((uint64_t)(fs->gdtable_blkno * fs->blksz),
 		 (struct ext2_block_group *)fs->gdtable,
 		 (fs->blksz * fs->no_blk_pergdt));
 	ext4fs_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 memory for gdtable */
 	fs->gdtable = zalloc(fs->blksz * fs->no_blk_pergdt);
 	if (!fs->gdtable)
 		return -ENOMEM;
 	/* read the group descriptor table */
-	status = ext4fs_devread(fs->gdtable_blkno * fs->sect_perblk, 0,
+	status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk,
-				fs->blksz * fs->no_blk_pergdt, fs->gdtable);
+				0, fs->blksz * fs->no_blk_pergdt, fs->gdtable);
 	if (status == 0)
 		goto fail;
 	if (ext4fs_log_gdt(fs->gdtable)) {
 		printf("Error in ext4fs_log_gdt\n");
 		return -1;
 	}
 	return 0;
 fail:
 	free(fs->gdtable);
 	fs->gdtable = NULL;
 	return -1;
 }
 static void delete_single_indirect_block(struct ext2_inode *inode)
 {
 	struct ext2_block_group *bgd = NULL;
 	static int prev_bg_bmap_idx = -1;
 	long int blknr;
 	int remainder;
 	int bg_idx;
 	int status;
 	unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	if (!journal_buffer) {
 		printf("No memory\n");
 		return;
 	}
 	/* get  block group descriptor table */
 	bgd = (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 / blk_per_grp;
 		} else {
 			bg_idx = blknr / blk_per_grp;
 			remainder = blknr % blk_per_grp;
 			if (!remainder)
 				bg_idx--;
 		}
 		ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
 		bgd[bg_idx].free_blocks++;
 		fs->sb->free_blocks++;
 		/* journal backup */
 		if (prev_bg_bmap_idx != bg_idx) {
 			status =
-			    ext4fs_devread(bgd[bg_idx].block_id *
+			    ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
 					   fs->sect_perblk, 0, fs->blksz,
 					   journal_buffer);
 			if (status == 0)
 				goto fail;
 			if (ext4fs_log_journal
 			    (journal_buffer, bgd[bg_idx].block_id))
 				goto fail;
 			prev_bg_bmap_idx = bg_idx;
 		}
 	}
 fail:
 	free(journal_buffer);
 }
 static void delete_double_indirect_block(struct ext2_inode *inode)
 {
 	int i;
 	short status;
 	static int prev_bg_bmap_idx = -1;
 	long int blknr;
 	int remainder;
 	int bg_idx;
 	unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
 	unsigned int *di_buffer = NULL;
 	unsigned int *DIB_start_addr = NULL;
 	struct ext2_block_group *bgd = NULL;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	if (!journal_buffer) {
 		printf("No memory\n");
 		return;
 	}
 	/* get the block group descriptor table */
 	bgd = (struct ext2_block_group *)fs->gdtable;
 	if (inode->b.blocks.double_indir_block != 0) {
 		di_buffer = zalloc(fs->blksz);
 		if (!di_buffer) {
 			printf("No memory\n");
 			return;
 		}
 		DIB_start_addr = (unsigned int *)di_buffer;
 		blknr = inode->b.blocks.double_indir_block;
-		status = ext4fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+		status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
-					(char *)di_buffer);
+					fs->blksz, (char *)di_buffer);
 		for (i = 0; i < fs->blksz / sizeof(int); i++) {
 			if (*di_buffer == 0)
 				break;
 			debug("DICB releasing %u\n", *di_buffer);
 			if (fs->blksz != 1024) {
 				bg_idx = (*di_buffer) / blk_per_grp;
 			} else {
 				bg_idx = (*di_buffer) / blk_per_grp;
 				remainder = (*di_buffer) % blk_per_grp;
 				if (!remainder)
 					bg_idx--;
 			}
 			ext4fs_reset_block_bmap(*di_buffer,
 					fs->blk_bmaps[bg_idx], bg_idx);
 			di_buffer++;
 			bgd[bg_idx].free_blocks++;
 			fs->sb->free_blocks++;
 			/* journal backup */
 			if (prev_bg_bmap_idx != bg_idx) {
-				status = ext4fs_devread(bgd[bg_idx].block_id
+				status = ext4fs_devread((lbaint_t)
+							bgd[bg_idx].block_id
 							* fs->sect_perblk, 0,
 							fs->blksz,
 							journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 							bgd[bg_idx].block_id))
 					goto fail;
 				prev_bg_bmap_idx = bg_idx;
 			}
 		}
 		/* removing the parent double indirect block */
 		blknr = inode->b.blocks.double_indir_block;
 		if (fs->blksz != 1024) {
 			bg_idx = blknr / blk_per_grp;
 		} else {
 			bg_idx = blknr / blk_per_grp;
 			remainder = blknr % blk_per_grp;
 			if (!remainder)
 				bg_idx--;
 		}
 		ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
 		bgd[bg_idx].free_blocks++;
 		fs->sb->free_blocks++;
 		/* journal backup */
 		if (prev_bg_bmap_idx != bg_idx) {
 			memset(journal_buffer, '\0', fs->blksz);
-			status = ext4fs_devread(bgd[bg_idx].block_id *
+			status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
 						fs->sect_perblk, 0, fs->blksz,
 						journal_buffer);
 			if (status == 0)
 				goto fail;
 			if (ext4fs_log_journal(journal_buffer,
 						bgd[bg_idx].block_id))
 				goto fail;
 			prev_bg_bmap_idx = bg_idx;
 		}
 		debug("DIPB releasing %ld\n", blknr);
 	}
 fail:
 	free(DIB_start_addr);
 	free(journal_buffer);
 }
 static void delete_triple_indirect_block(struct ext2_inode *inode)
 {
 	int i, j;
 	short status;
 	static int prev_bg_bmap_idx = -1;
 	long int blknr;
 	int remainder;
 	int bg_idx;
 	unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
 	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 *bgd = NULL;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	if (!journal_buffer) {
 		printf("No memory\n");
 		return;
 	}
 	/* get block group descriptor table */
 	bgd = (struct ext2_block_group *)fs->gdtable;
 	if (inode->b.blocks.triple_indir_block != 0) {
 		tigp_buffer = zalloc(fs->blksz);
 		if (!tigp_buffer) {
 			printf("No memory\n");
 			return;
 		}
 		tib_start_addr = (unsigned int *)tigp_buffer;
 		blknr = inode->b.blocks.triple_indir_block;
-		status = ext4fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+		status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
-					(char *)tigp_buffer);
+					fs->blksz, (char *)tigp_buffer);
 		for (i = 0; i < fs->blksz / sizeof(int); i++) {
 			if (*tigp_buffer == 0)
 				break;
 			debug("tigp buffer releasing %u\n", *tigp_buffer);
 			tip_buffer = zalloc(fs->blksz);
 			if (!tip_buffer)
 				goto fail;
 			tipb_start_addr = (unsigned int *)tip_buffer;
-			status = ext4fs_devread((*tigp_buffer) *
+			status = ext4fs_devread((lbaint_t)(*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) / blk_per_grp;
 				} else {
 					bg_idx = (*tip_buffer) / blk_per_grp;
 					remainder = (*tip_buffer) % blk_per_grp;
 					if (!remainder)
 						bg_idx--;
 				}
 				ext4fs_reset_block_bmap(*tip_buffer,
 							fs->blk_bmaps[bg_idx],
 							bg_idx);
 				tip_buffer++;
 				bgd[bg_idx].free_blocks++;
 				fs->sb->free_blocks++;
 				/* journal backup */
 				if (prev_bg_bmap_idx != bg_idx) {
 					status =
 					    ext4fs_devread(
+							(lbaint_t)
 							bgd[bg_idx].block_id *
 							fs->sect_perblk, 0,
 							fs->blksz,
 							journal_buffer);
 					if (status == 0)
 						goto fail;
 					if (ext4fs_log_journal(journal_buffer,
 							       bgd[bg_idx].
 							       block_id))
 						goto fail;
 					prev_bg_bmap_idx = bg_idx;
 				}
 			}
 			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) / blk_per_grp;
 			} else {
 				bg_idx = (*tigp_buffer) / blk_per_grp;
 				remainder = (*tigp_buffer) % blk_per_grp;
 				if (!remainder)
 					bg_idx--;
 			}
 			ext4fs_reset_block_bmap(*tigp_buffer,
 						fs->blk_bmaps[bg_idx], bg_idx);
 			tigp_buffer++;
 			bgd[bg_idx].free_blocks++;
 			fs->sb->free_blocks++;
 			/* journal backup */
 			if (prev_bg_bmap_idx != bg_idx) {
 				memset(journal_buffer, '\0', fs->blksz);
 				status =
-				    ext4fs_devread(bgd[bg_idx].block_id *
+				    ext4fs_devread((lbaint_t)
+						   bgd[bg_idx].block_id *
 						   fs->sect_perblk, 0,
 						   fs->blksz, journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 							bgd[bg_idx].block_id))
 					goto fail;
 				prev_bg_bmap_idx = bg_idx;
 			}
 		}
 		/* removing the grand parent triple indirect block */
 		blknr = inode->b.blocks.triple_indir_block;
 		if (fs->blksz != 1024) {
 			bg_idx = blknr / blk_per_grp;
 		} else {
 			bg_idx = blknr / blk_per_grp;
 			remainder = blknr % blk_per_grp;
 			if (!remainder)
 				bg_idx--;
 		}
 		ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
 		bgd[bg_idx].free_blocks++;
 		fs->sb->free_blocks++;
 		/* journal backup */
 		if (prev_bg_bmap_idx != bg_idx) {
 			memset(journal_buffer, '\0', fs->blksz);
-			status = ext4fs_devread(bgd[bg_idx].block_id *
+			status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
 						fs->sect_perblk, 0, fs->blksz,
 						journal_buffer);
 			if (status == 0)
 				goto fail;
 			if (ext4fs_log_journal(journal_buffer,
 						bgd[bg_idx].block_id))
 				goto fail;
 			prev_bg_bmap_idx = bg_idx;
 		}
 		debug("tigp buffer itself releasing %ld\n", blknr);
 	}
 fail:
 	free(tib_start_addr);
 	free(tipb_start_addr);
 	free(journal_buffer);
 }
 static int ext4fs_delete_file(int inodeno)
 {
 	struct ext2_inode inode;
 	short status;
 	int i;
 	int remainder;
 	long int blknr;
 	int bg_idx;
 	int ibmap_idx;
 	char *read_buffer = NULL;
 	char *start_block_address = NULL;
 	unsigned int no_blocks;
 	static int prev_bg_bmap_idx = -1;
 	unsigned int inodes_per_block;
 	long int blkno;
 	unsigned int blkoff;
 	unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
 	unsigned int inode_per_grp = ext4fs_root->sblock.inodes_per_group;
 	struct ext2_inode *inode_buffer = NULL;
 	struct ext2_block_group *bgd = NULL;
 	struct ext_filesystem *fs = get_fs();
 	char *journal_buffer = zalloc(fs->blksz);
 	if (!journal_buffer)
 		return -ENOMEM;
 	/* get the block group descriptor table */
 	bgd = (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_FL) {
 		struct ext2fs_node *node_inode =
 		    zalloc(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 / blk_per_grp;
 			} else {
 				bg_idx = blknr / blk_per_grp;
 				remainder = blknr % blk_per_grp;
 				if (!remainder)
 					bg_idx--;
 			}
 			ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
 						bg_idx);
 			debug("EXT4_EXTENTS Block releasing %ld: %d\n",
 			      blknr, bg_idx);
 			bgd[bg_idx].free_blocks++;
 			fs->sb->free_blocks++;
 			/* journal backup */
 			if (prev_bg_bmap_idx != bg_idx) {
 				status =
-				    ext4fs_devread(bgd[bg_idx].block_id *
+				    ext4fs_devread((lbaint_t)
+						   bgd[bg_idx].block_id *
 						   fs->sect_perblk, 0,
 						   fs->blksz, journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 							bgd[bg_idx].block_id))
 					goto fail;
 				prev_bg_bmap_idx = bg_idx;
 			}
 		}
 		if (node_inode) {
 			free(node_inode);
 			node_inode = NULL;
 		}
 	} else {
 		delete_single_indirect_block(&inode);
 		delete_double_indirect_block(&inode);
 		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 / blk_per_grp;
 			} else {
 				bg_idx = blknr / blk_per_grp;
 				remainder = blknr % blk_per_grp;
 				if (!remainder)
 					bg_idx--;
 			}
 			ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
 						bg_idx);
 			debug("ActualB releasing %ld: %d\n", blknr, bg_idx);
 			bgd[bg_idx].free_blocks++;
 			fs->sb->free_blocks++;
 			/* journal backup */
 			if (prev_bg_bmap_idx != bg_idx) {
 				memset(journal_buffer, '\0', fs->blksz);
-				status = ext4fs_devread(bgd[bg_idx].block_id
+				status = ext4fs_devread((lbaint_t)
+							bgd[bg_idx].block_id
 							* fs->sect_perblk,
 							0, fs->blksz,
 							journal_buffer);
 				if (status == 0)
 					goto fail;
 				if (ext4fs_log_journal(journal_buffer,
 						bgd[bg_idx].block_id))
 					goto fail;
 				prev_bg_bmap_idx = bg_idx;
 			}
 		}
 	}
 	/* from the inode no to blockno */
 	inodes_per_block = fs->blksz / fs->inodesz;
 	ibmap_idx = inodeno / inode_per_grp;
 	/* get the block no */
 	inodeno--;
 	blkno = __le32_to_cpu(bgd[ibmap_idx].inode_table_id) +
 		(inodeno % __le32_to_cpu(inode_per_grp)) / 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 = zalloc(fs->blksz);
 	if (!read_buffer)
 		goto fail;
 	start_block_address = read_buffer;
-	status = ext4fs_devread(blkno * fs->sect_perblk,
+	status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
 				0, fs->blksz, read_buffer);
 	if (status == 0)
 		goto fail;
 	if (ext4fs_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 (ext4fs_put_metadata(start_block_address, blkno))
 		goto fail;
 	/* update the respective inode bitmaps */
 	inodeno++;
 	ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
 	bgd[ibmap_idx].free_inodes++;
 	fs->sb->free_inodes++;
 	/* journal backup */
 	memset(journal_buffer, '\0', fs->blksz);
-	status = ext4fs_devread(bgd[ibmap_idx].inode_id *
+	status = ext4fs_devread((lbaint_t)bgd[ibmap_idx].inode_id *
 				fs->sect_perblk, 0, fs->blksz, journal_buffer);
 	if (status == 0)
 		goto fail;
 	if (ext4fs_log_journal(journal_buffer, bgd[ibmap_idx].inode_id))
 		goto fail;
 	ext4fs_update();
 	ext4fs_deinit();
 	if (ext4fs_init() != 0) {
 		printf("error in File System init\n");
 		goto fail;
 	}
 	free(start_block_address);
 	free(journal_buffer);
 	return 0;
 fail:
 	free(start_block_address);
 	free(journal_buffer);
 	return -1;
 }
 int ext4fs_init(void)
 {
 	short status;
 	int i;
 	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 >> fs->dev_desc->log2blksz;
 	/* get the superblock */
 	fs->sb = zalloc(SUPERBLOCK_SIZE);
 	if (!fs->sb)
 		return -ENOMEM;
 	if (!ext4_read_superblock((char *)fs->sb))
 		goto fail;
 	/* init journal */
 	if (ext4fs_init_journal())
 		goto fail;
 	/* get total no of blockgroups */
 	fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
 			(ext4fs_root->sblock.total_blocks -
 			ext4fs_root->sblock.first_data_block),
 			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("Error in getting the block group descriptor table\n");
 		goto fail;
 	}
 	fs->bgd = (struct ext2_block_group *)fs->gdtable;
 	/* load all the available bitmap block of the partition */
 	fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
 	if (!fs->blk_bmaps)
 		goto fail;
 	for (i = 0; i < fs->no_blkgrp; i++) {
 		fs->blk_bmaps[i] = zalloc(fs->blksz);
 		if (!fs->blk_bmaps[i])
 			goto fail;
 	}
 	for (i = 0; i < fs->no_blkgrp; i++) {
 		status =
-		    ext4fs_devread(fs->bgd[i].block_id * fs->sect_perblk, 0,
+		    ext4fs_devread((lbaint_t)fs->bgd[i].block_id *
+				   fs->sect_perblk, 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 = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
 	if (!fs->inode_bmaps)
 		goto fail;
 	for (i = 0; i < fs->no_blkgrp; i++) {
 		fs->inode_bmaps[i] = zalloc(fs->blksz);
 		if (!fs->inode_bmaps[i])
 			goto fail;
 	}
 	for (i = 0; i < fs->no_blkgrp; i++) {
-		status = ext4fs_devread(fs->bgd[i].inode_id * fs->sect_perblk,
+		status = ext4fs_devread((lbaint_t)fs->bgd[i].inode_id *
+					fs->sect_perblk,
 					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->bgd[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 = zalloc(fs->blksz);
 	if (temp_buff) {
 		ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
 				  &inode_journal);
 		blknr = read_allocated_block(&inode_journal,
 					EXT2_JOURNAL_SUPERBLOCK);
-		ext4fs_devread(blknr * fs->sect_perblk, 0, fs->blksz,
+		ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
 			       temp_buff);
 		jsb = (struct journal_superblock_t *)temp_buff;
 		jsb->s_start = cpu_to_be32(0);
 		put_ext4((uint64_t) (blknr * fs->blksz),
 			 (struct journal_superblock_t *)temp_buff, fs->blksz);
 		free(temp_buff);
 	}
 	ext4fs_free_journal();
 	/* get the superblock */
 	ext4_read_superblock((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);
 	free(fs->sb);
 	fs->sb = NULL;
 	if (fs->blk_bmaps) {
 		for (i = 0; i < fs->no_blkgrp; 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++) {
 			free(fs->inode_bmaps[i]);
 			fs->inode_bmaps[i] = NULL;
 		}
 		free(fs->inode_bmaps);
 		fs->inode_bmaps = NULL;
 	}
 	free(fs->gdtable);
 	fs->gdtable = NULL;
 	fs->bgd = 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;
 }
 static int ext4fs_write_file(struct ext2_inode *file_inode,
 			     int pos, unsigned int len, char *buf)
 {
 	int i;
 	int blockcnt;
 	unsigned int filesize = __le32_to_cpu(file_inode->size);
 	struct ext_filesystem *fs = get_fs();
 	int log2blksz = fs->dev_desc->log2blksz;
 	int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
 	int previous_block_number = -1;
 	int delayed_start = 0;
 	int delayed_extent = 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 << log2_fs_blocksize;
 		if (blknr) {
 			if (previous_block_number != -1) {
 				if (delayed_next == blknr) {
 					delayed_extent += blockend;
 					delayed_next += blockend >> log2blksz;
 				} else {	/* spill */
 					put_ext4((uint64_t)
 						 (delayed_start << log2blksz),
 						 delayed_buf,
 						 (uint32_t) delayed_extent);
 					previous_block_number = blknr;
 					delayed_start = blknr;
 					delayed_extent = blockend;
 					delayed_buf = buf;
 					delayed_next = blknr +
 					    (blockend >> log2blksz);
 				}
 			} else {
 				previous_block_number = blknr;
 				delayed_start = blknr;
 				delayed_extent = blockend;
 				delayed_buf = buf;
 				delayed_next = blknr +
 				    (blockend >> log2blksz);
 			}
 		} else {
 			if (previous_block_number != -1) {
 				/* spill */
 				put_ext4((uint64_t) (delayed_start <<
 						     log2blksz),
 					 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 << log2blksz),
 			 delayed_buf, (uint32_t) delayed_extent);
 		previous_block_number = -1;
 	}
 	return len;
 }
 int ext4fs_write(const char *fname, unsigned char *buffer,
 					unsigned long sizebytes)
 {
 	int ret = 0;
 	struct ext2_inode *file_inode = NULL;
 	unsigned char *inode_buffer = NULL;
 	int parent_inodeno;
 	int inodeno;
 	time_t timestamp = 0;
 	uint64_t bytes_reqd_for_file;
 	unsigned int blks_reqd_for_file;
 	unsigned int blocks_remaining;
 	int existing_file_inodeno;
 	char *temp_ptr = NULL;
 	long int itable_blkno;
 	long int parent_itable_blkno;
 	long int blkoff;
 	struct ext2_sblock *sblock = &(ext4fs_root->sblock);
 	unsigned int inodes_per_block;
 	unsigned int ibmap_idx;
 	struct ext_filesystem *fs = get_fs();
 	ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
 	memset(filename, 0x00, sizeof(filename));
 	g_parent_inode = zalloc(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 = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
 	if (parent_inodeno == -1)
 		goto fail;
 	if (ext4fs_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 */
 	bytes_reqd_for_file = sizebytes;
 	blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
 	if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
 		blks_reqd_for_file++;
 		debug("total bytes for a file %u\n", blks_reqd_for_file);
 	}
 	blocks_remaining = blks_reqd_for_file;
 	/* test for available space in partition */
 	if (fs->sb->free_blocks < blks_reqd_for_file) {
 		printf("Not enough space on partition !!!\n");
 		goto fail;
 	}
 	ext4fs_update_parent_dentry(filename, &inodeno, FILETYPE_REG);
 	/* prepare file inode */
 	inode_buffer = zalloc(fs->inodesz);
 	if (!inode_buffer)
 		goto fail;
 	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 */
 	ext4fs_allocate_blocks(file_inode, blocks_remaining,
 			       &blks_reqd_for_file);
 	file_inode->blockcnt = (blks_reqd_for_file * fs->blksz) >>
 		fs->dev_desc->log2blksz;
 	temp_ptr = zalloc(fs->blksz);
 	if (!temp_ptr)
 		goto fail;
 	ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group;
 	inodeno--;
 	itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
 			(inodeno % __le32_to_cpu(sblock->inodes_per_group)) /
 			inodes_per_block;
 	blkoff = (inodeno % inodes_per_block) * fs->inodesz;
-	ext4fs_devread(itable_blkno * fs->sect_perblk, 0, fs->blksz, temp_ptr);
+	ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
+		       temp_ptr);
 	if (ext4fs_log_journal(temp_ptr, itable_blkno))
 		goto fail;
 	memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
 	if (ext4fs_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;
 	}
 	ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group;
 	parent_inodeno--;
 	parent_itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].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);
-		ext4fs_devread(parent_itable_blkno * fs->sect_perblk,
+		ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
 			       0, fs->blksz, temp_ptr);
 		if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
 			goto fail;
 		memcpy(temp_ptr + blkoff, g_parent_inode,
 			sizeof(struct ext2_inode));
 		if (ext4fs_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 (ext4fs_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;
 	free(inode_buffer);
 	free(g_parent_inode);
 	g_parent_inode = NULL;
 	return 0;
 fail:
 	ext4fs_deinit();
 	free(inode_buffer);
 	free(g_parent_inode);
 	g_parent_inode = NULL;
 	return -1;
 }

fs/ext4/ext4fs.c

Diff comments View file @ 04735e9

1	/*	1	/*
2	* (C) Copyright 2011 - 2012 Samsung Electronics	2	* (C) Copyright 2011 - 2012 Samsung Electronics
3	* EXT4 filesystem implementation in Uboot by	3	* EXT4 filesystem implementation in Uboot by
4	* Uma Shankar <uma.shankar@samsung.com>	4	* Uma Shankar <uma.shankar@samsung.com>
5	* Manjunatha C Achar <a.manjunatha@samsung.com>	5	* Manjunatha C Achar <a.manjunatha@samsung.com>
6	*	6	*
7	* ext4ls and ext4load : Based on ext2 ls and load support in Uboot.	7	* ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
8	* Ext4 read optimization taken from Open-Moko	8	* Ext4 read optimization taken from Open-Moko
9	* Qi bootloader	9	* Qi bootloader
10	*	10	*
11	* (C) Copyright 2004	11	* (C) Copyright 2004
12	* esd gmbh <www.esd-electronics.com>	12	* esd gmbh <www.esd-electronics.com>
13	* Reinhard Arlt <reinhard.arlt@esd-electronics.com>	13	* Reinhard Arlt <reinhard.arlt@esd-electronics.com>
14	*	14	*
15	* based on code from grub2 fs/ext2.c and fs/fshelp.c by	15	* based on code from grub2 fs/ext2.c and fs/fshelp.c by
16	* GRUB -- GRand Unified Bootloader	16	* GRUB -- GRand Unified Bootloader
17	* Copyright (C) 2003, 2004 Free Software Foundation, Inc.	17	* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
18	*	18	*
19	* ext4write : Based on generic ext4 protocol.	19	* ext4write : Based on generic ext4 protocol.
20	*	20	*
21	* This program is free software; you can redistribute it and/or modify	21	* This program is free software; you can redistribute it and/or modify
22	* it under the terms of the GNU General Public License as published by	22	* it under the terms of the GNU General Public License as published by
23	* the Free Software Foundation; either version 2 of the License, or	23	* the Free Software Foundation; either version 2 of the License, or
24	* (at your option) any later version.	24	* (at your option) any later version.
25	*	25	*
26	* This program is distributed in the hope that it will be useful,	26	* This program is distributed in the hope that it will be useful,
27	* but WITHOUT ANY WARRANTY; without even the implied warranty of	27	* but WITHOUT ANY WARRANTY; without even the implied warranty of
28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29	* GNU General Public License for more details.	29	* GNU General Public License for more details.
30	*	30	*
31	* You should have received a copy of the GNU General Public License	31	* You should have received a copy of the GNU General Public License
32	* along with this program; if not, write to the Free Software	32	* along with this program; if not, write to the Free Software
33	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	33	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34	*/	34	*/
35		35
36	#include <common.h>	36	#include <common.h>
37	#include <ext_common.h>	37	#include <ext_common.h>
38	#include <ext4fs.h>	38	#include <ext4fs.h>
39	#include "ext4_common.h"	39	#include "ext4_common.h"
40		40
41	int ext4fs_symlinknest;	41	int ext4fs_symlinknest;
42	struct ext_filesystem ext_fs;	42	struct ext_filesystem ext_fs;
43		43
44	struct ext_filesystem *get_fs(void)	44	struct ext_filesystem *get_fs(void)
45	{	45	{
46	return &ext_fs;	46	return &ext_fs;
47	}	47	}
48		48
49	void ext4fs_free_node(struct ext2fs_node node, struct ext2fs_node currroot)	49	void ext4fs_free_node(struct ext2fs_node node, struct ext2fs_node currroot)
50	{	50	{
51	if ((node != &ext4fs_root->diropen) && (node != currroot))	51	if ((node != &ext4fs_root->diropen) && (node != currroot))
52	free(node);	52	free(node);
53	}	53	}
54		54
55	/*	55	/*
56	* Taken from openmoko-kernel mailing list: By Andy green	56	* Taken from openmoko-kernel mailing list: By Andy green
57	* Optimized read file API : collects and defers contiguous sector	57	* Optimized read file API : collects and defers contiguous sector
58	* reads into one potentially more efficient larger sequential read action	58	* reads into one potentially more efficient larger sequential read action
59	*/	59	*/
60	int ext4fs_read_file(struct ext2fs_node *node, int pos,	60	int ext4fs_read_file(struct ext2fs_node *node, int pos,
61	unsigned int len, char *buf)	61	unsigned int len, char *buf)
62	{	62	{
63	struct ext_filesystem *fs = get_fs();	63	struct ext_filesystem *fs = get_fs();
64	int i;	64	int i;
65	int blockcnt;	65	lbaint_t blockcnt;
66	int log2blksz = fs->dev_desc->log2blksz;	66	int log2blksz = fs->dev_desc->log2blksz;
67	int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;	67	int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;
68	int blocksize = (1 << (log2_fs_blocksize + log2blksz));	68	int blocksize = (1 << (log2_fs_blocksize + log2blksz));
69	unsigned int filesize = __le32_to_cpu(node->inode.size);	69	unsigned int filesize = __le32_to_cpu(node->inode.size);
70	int previous_block_number = -1;	70	lbaint_t previous_block_number = -1;
71	int delayed_start = 0;	71	lbaint_t delayed_start = 0;
72	int delayed_extent = 0;	72	lbaint_t delayed_extent = 0;
73	int delayed_skipfirst = 0;	73	lbaint_t delayed_skipfirst = 0;
74	int delayed_next = 0;	74	lbaint_t delayed_next = 0;
75	char *delayed_buf = NULL;	75	char *delayed_buf = NULL;
76	short status;	76	short status;
77		77
78	/* Adjust len so it we can't read past the end of the file. */	78	/* Adjust len so it we can't read past the end of the file. */
79	if (len > filesize)	79	if (len > filesize)
80	len = filesize;	80	len = filesize;
81		81
82	blockcnt = ((len + pos) + blocksize - 1) / blocksize;	82	blockcnt = ((len + pos) + blocksize - 1) / blocksize;
83		83
84	for (i = pos / blocksize; i < blockcnt; i++) {	84	for (i = pos / blocksize; i < blockcnt; i++) {
85	int blknr;	85	lbaint_t blknr;
86	int blockoff = pos % blocksize;	86	int blockoff = pos % blocksize;
87	int blockend = blocksize;	87	int blockend = blocksize;
88	int skipfirst = 0;	88	int skipfirst = 0;
89	blknr = read_allocated_block(&(node->inode), i);	89	blknr = read_allocated_block(&(node->inode), i);
90	if (blknr < 0)	90	if (blknr < 0)
91	return -1;	91	return -1;
92		92
93	blknr = blknr << log2_fs_blocksize;	93	blknr = blknr << log2_fs_blocksize;
94		94
95	/* Last block. */	95	/* Last block. */
96	if (i == blockcnt - 1) {	96	if (i == blockcnt - 1) {
97	blockend = (len + pos) % blocksize;	97	blockend = (len + pos) % blocksize;
98		98
99	/* The last portion is exactly blocksize. */	99	/* The last portion is exactly blocksize. */
100	if (!blockend)	100	if (!blockend)
101	blockend = blocksize;	101	blockend = blocksize;
102	}	102	}
103		103
104	/* First block. */	104	/* First block. */
105	if (i == pos / blocksize) {	105	if (i == pos / blocksize) {
106	skipfirst = blockoff;	106	skipfirst = blockoff;
107	blockend -= skipfirst;	107	blockend -= skipfirst;
108	}	108	}
109	if (blknr) {	109	if (blknr) {
110	int status;	110	int status;
111		111
112	if (previous_block_number != -1) {	112	if (previous_block_number != -1) {
113	if (delayed_next == blknr) {	113	if (delayed_next == blknr) {
114	delayed_extent += blockend;	114	delayed_extent += blockend;
115	delayed_next += blockend >> log2blksz;	115	delayed_next += blockend >> log2blksz;
116	} else { /* spill */	116	} else { /* spill */
117	status = ext4fs_devread(delayed_start,	117	status = ext4fs_devread(delayed_start,
118	delayed_skipfirst,	118	delayed_skipfirst,
119	delayed_extent,	119	delayed_extent,
120	delayed_buf);	120	delayed_buf);
121	if (status == 0)	121	if (status == 0)
122	return -1;	122	return -1;
123	previous_block_number = blknr;	123	previous_block_number = blknr;
124	delayed_start = blknr;	124	delayed_start = blknr;
125	delayed_extent = blockend;	125	delayed_extent = blockend;
126	delayed_skipfirst = skipfirst;	126	delayed_skipfirst = skipfirst;
127	delayed_buf = buf;	127	delayed_buf = buf;
128	delayed_next = blknr +	128	delayed_next = blknr +
129	(blockend >> log2blksz);	129	(blockend >> log2blksz);
130	}	130	}
131	} else {	131	} else {
132	previous_block_number = blknr;	132	previous_block_number = blknr;
133	delayed_start = blknr;	133	delayed_start = blknr;
134	delayed_extent = blockend;	134	delayed_extent = blockend;
135	delayed_skipfirst = skipfirst;	135	delayed_skipfirst = skipfirst;
136	delayed_buf = buf;	136	delayed_buf = buf;
137	delayed_next = blknr +	137	delayed_next = blknr +
138	(blockend >> log2blksz);	138	(blockend >> log2blksz);
139	}	139	}
140	} else {	140	} else {
141	if (previous_block_number != -1) {	141	if (previous_block_number != -1) {
142	/* spill */	142	/* spill */
143	status = ext4fs_devread(delayed_start,	143	status = ext4fs_devread(delayed_start,
144	delayed_skipfirst,	144	delayed_skipfirst,
145	delayed_extent,	145	delayed_extent,
146	delayed_buf);	146	delayed_buf);
147	if (status == 0)	147	if (status == 0)
148	return -1;	148	return -1;
149	previous_block_number = -1;	149	previous_block_number = -1;
150	}	150	}
151	memset(buf, 0, blocksize - skipfirst);	151	memset(buf, 0, blocksize - skipfirst);
152	}	152	}
153	buf += blocksize - skipfirst;	153	buf += blocksize - skipfirst;
154	}	154	}
155	if (previous_block_number != -1) {	155	if (previous_block_number != -1) {
156	/* spill */	156	/* spill */
157	status = ext4fs_devread(delayed_start,	157	status = ext4fs_devread(delayed_start,
158	delayed_skipfirst, delayed_extent,	158	delayed_skipfirst, delayed_extent,
159	delayed_buf);	159	delayed_buf);
160	if (status == 0)	160	if (status == 0)
161	return -1;	161	return -1;
162	previous_block_number = -1;	162	previous_block_number = -1;
163	}	163	}
164		164
165	return len;	165	return len;
166	}	166	}
167		167
168	int ext4fs_ls(const char *dirname)	168	int ext4fs_ls(const char *dirname)
169	{	169	{
170	struct ext2fs_node *dirnode;	170	struct ext2fs_node *dirnode;
171	int status;	171	int status;
172		172
173	if (dirname == NULL)	173	if (dirname == NULL)
174	return 0;	174	return 0;
175		175
176	status = ext4fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,	176	status = ext4fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
177	FILETYPE_DIRECTORY);	177	FILETYPE_DIRECTORY);
178	if (status != 1) {	178	if (status != 1) {
179	printf(" Can not find directory. \n");	179	printf(" Can not find directory. \n");
180	return 1;	180	return 1;
181	}	181	}
182		182
183	ext4fs_iterate_dir(dirnode, NULL, NULL, NULL);	183	ext4fs_iterate_dir(dirnode, NULL, NULL, NULL);
184	ext4fs_free_node(dirnode, &ext4fs_root->diropen);	184	ext4fs_free_node(dirnode, &ext4fs_root->diropen);
185		185
186	return 0;	186	return 0;
187	}	187	}
188		188
189	int ext4fs_read(char *buf, unsigned len)	189	int ext4fs_read(char *buf, unsigned len)
190	{	190	{
191	if (ext4fs_root == NULL \|\| ext4fs_file == NULL)	191	if (ext4fs_root == NULL \|\| ext4fs_file == NULL)
192	return 0;	192	return 0;
193		193
194	return ext4fs_read_file(ext4fs_file, 0, len, buf);	194	return ext4fs_read_file(ext4fs_file, 0, len, buf);
195	}	195	}
196		196
197	int ext4fs_probe(block_dev_desc_t *fs_dev_desc,	197	int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
198	disk_partition_t *fs_partition)	198	disk_partition_t *fs_partition)
199	{	199	{
200	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);	200	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
201		201
202	if (!ext4fs_mount(fs_partition->size)) {	202	if (!ext4fs_mount(fs_partition->size)) {
203	ext4fs_close();	203	ext4fs_close();
204	return -1;	204	return -1;
205	}	205	}
206		206
207	return 0;	207	return 0;
208	}	208	}
209		209
210	int ext4_read_file(const char filename, void buf, int offset, int len)	210	int ext4_read_file(const char filename, void buf, int offset, int len)
211	{	211	{
212	int file_len;	212	int file_len;
213	int len_read;	213	int len_read;
214		214
215	if (offset != 0) {	215	if (offset != 0) {
216	printf(" Cannot support non-zero offset \n");	216	printf(" Cannot support non-zero offset \n");
217	return -1;	217	return -1;
218	}	218	}
219		219
220	file_len = ext4fs_open(filename);	220	file_len = ext4fs_open(filename);
221	if (file_len < 0) {	221	if (file_len < 0) {
222	printf(" File not found %s \n", filename);	222	printf(" File not found %s \n", filename);
223	return -1;	223	return -1;
224	}	224	}
225		225
226	if (len == 0)	226	if (len == 0)
227	len = file_len;	227	len = file_len;
228		228
229	len_read = ext4fs_read(buf, len);	229	len_read = ext4fs_read(buf, len);
230		230
231	return len_read;	231	return len_read;
232	}	232	}
233		233

include/ext4fs.h

Diff comments View file @ 04735e9

include/ext_common.h

Diff comments View file @ 04735e9

1	/*	1	/*
2	* (C) Copyright 2011 - 2012 Samsung Electronics	2	* (C) Copyright 2011 - 2012 Samsung Electronics
3	* EXT4 filesystem implementation in Uboot by	3	* EXT4 filesystem implementation in Uboot by
4	* Uma Shankar <uma.shankar@samsung.com>	4	* Uma Shankar <uma.shankar@samsung.com>
5	* Manjunatha C Achar <a.manjunatha@samsung.com>	5	* Manjunatha C Achar <a.manjunatha@samsung.com>
6	*	6	*
7	* Data structures and headers for ext4 support have been taken from	7	* Data structures and headers for ext4 support have been taken from
8	* ext2 ls load support in Uboot	8	* ext2 ls load support in Uboot
9	*	9	*
10	* (C) Copyright 2004	10	* (C) Copyright 2004
11	* esd gmbh <www.esd-electronics.com>	11	* esd gmbh <www.esd-electronics.com>
12	* Reinhard Arlt <reinhard.arlt@esd-electronics.com>	12	* Reinhard Arlt <reinhard.arlt@esd-electronics.com>
13	*	13	*
14	* based on code from grub2 fs/ext2.c and fs/fshelp.c by	14	* based on code from grub2 fs/ext2.c and fs/fshelp.c by
15	* GRUB -- GRand Unified Bootloader	15	* GRUB -- GRand Unified Bootloader
16	* Copyright (C) 2003, 2004 Free Software Foundation, Inc.	16	* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
17	*	17	*
18	* This program is free software; you can redistribute it and/or modify	18	* This program is free software; you can redistribute it and/or modify
19	* it under the terms of the GNU General Public License as published by	19	* it under the terms of the GNU General Public License as published by
20	* the Free Software Foundation; either version 2 of the License, or	20	* the Free Software Foundation; either version 2 of the License, or
21	* (at your option) any later version.	21	* (at your option) any later version.
22	*	22	*
23	* This program is distributed in the hope that it will be useful,	23	* This program is distributed in the hope that it will be useful,
24	* but WITHOUT ANY WARRANTY; without even the implied warranty of	24	* but WITHOUT ANY WARRANTY; without even the implied warranty of
25	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	25	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26	* GNU General Public License for more details.	26	* GNU General Public License for more details.
27	*	27	*
28	* You should have received a copy of the GNU General Public License	28	* You should have received a copy of the GNU General Public License
29	* along with this program; if not, write to the Free Software	29	* along with this program; if not, write to the Free Software
30	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	30	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31	*/	31	*/
32		32
33	#ifndef __EXT_COMMON__	33	#ifndef __EXT_COMMON__
34	#define __EXT_COMMON__	34	#define __EXT_COMMON__
35	#include <command.h>	35	#include <command.h>
36	#define SECTOR_SIZE 0x200	36	#define SECTOR_SIZE 0x200
37		37
38	/* Magic value used to identify an ext2 filesystem. */	38	/* Magic value used to identify an ext2 filesystem. */
39	#define EXT2_MAGIC 0xEF53	39	#define EXT2_MAGIC 0xEF53
40	/* Amount of indirect blocks in an inode. */	40	/* Amount of indirect blocks in an inode. */
41	#define INDIRECT_BLOCKS 12	41	#define INDIRECT_BLOCKS 12
42	/* Maximum lenght of a pathname. */	42	/* Maximum lenght of a pathname. */
43	#define EXT2_PATH_MAX 4096	43	#define EXT2_PATH_MAX 4096
44	/* Maximum nesting of symlinks, used to prevent a loop. */	44	/* Maximum nesting of symlinks, used to prevent a loop. */
45	#define EXT2_MAX_SYMLINKCNT 8	45	#define EXT2_MAX_SYMLINKCNT 8
46		46
47	/* Filetype used in directory entry. */	47	/* Filetype used in directory entry. */
48	#define FILETYPE_UNKNOWN 0	48	#define FILETYPE_UNKNOWN 0
49	#define FILETYPE_REG 1	49	#define FILETYPE_REG 1
50	#define FILETYPE_DIRECTORY 2	50	#define FILETYPE_DIRECTORY 2
51	#define FILETYPE_SYMLINK 7	51	#define FILETYPE_SYMLINK 7
52		52
53	/* Filetype information as used in inodes. */	53	/* Filetype information as used in inodes. */
54	#define FILETYPE_INO_MASK 0170000	54	#define FILETYPE_INO_MASK 0170000
55	#define FILETYPE_INO_REG 0100000	55	#define FILETYPE_INO_REG 0100000
56	#define FILETYPE_INO_DIRECTORY 0040000	56	#define FILETYPE_INO_DIRECTORY 0040000
57	#define FILETYPE_INO_SYMLINK 0120000	57	#define FILETYPE_INO_SYMLINK 0120000
58	#define EXT2_ROOT_INO 2 /* Root inode */	58	#define EXT2_ROOT_INO 2 /* Root inode */
59		59
60	/* The size of an ext2 block in bytes. */	60	/* The size of an ext2 block in bytes. */
61	#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data))	61	#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data))
62		62
63	/* Log2 size of ext2 block in bytes. */	63	/* Log2 size of ext2 block in bytes. */
64	#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu \	64	#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu \
65	(data->sblock.log2_block_size) \	65	(data->sblock.log2_block_size) \
66	+ EXT2_MIN_BLOCK_LOG_SIZE)	66	+ EXT2_MIN_BLOCK_LOG_SIZE)
67	#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \	67	#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \
68	(data->sblock.inode_size))	68	(data->sblock.inode_size))
69		69
70	#define EXT2_FT_DIR 2	70	#define EXT2_FT_DIR 2
71	#define SUCCESS 1	71	#define SUCCESS 1
72		72
73	/* Macro-instructions used to manage several block sizes */	73	/* Macro-instructions used to manage several block sizes */
74	#define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */	74	#define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */
75	#define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */	75	#define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */
76	#define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE)	76	#define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE)
77	#define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE)	77	#define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE)
78		78
79	/* The ext2 superblock. */	79	/* The ext2 superblock. */
80	struct ext2_sblock {	80	struct ext2_sblock {
81	uint32_t total_inodes;	81	uint32_t total_inodes;
82	uint32_t total_blocks;	82	uint32_t total_blocks;
83	uint32_t reserved_blocks;	83	uint32_t reserved_blocks;
84	uint32_t free_blocks;	84	uint32_t free_blocks;
85	uint32_t free_inodes;	85	uint32_t free_inodes;
86	uint32_t first_data_block;	86	uint32_t first_data_block;
87	uint32_t log2_block_size;	87	uint32_t log2_block_size;
88	uint32_t log2_fragment_size;	88	uint32_t log2_fragment_size;
89	uint32_t blocks_per_group;	89	uint32_t blocks_per_group;
90	uint32_t fragments_per_group;	90	uint32_t fragments_per_group;
91	uint32_t inodes_per_group;	91	uint32_t inodes_per_group;
92	uint32_t mtime;	92	uint32_t mtime;
93	uint32_t utime;	93	uint32_t utime;
94	uint16_t mnt_count;	94	uint16_t mnt_count;
95	uint16_t max_mnt_count;	95	uint16_t max_mnt_count;
96	uint16_t magic;	96	uint16_t magic;
97	uint16_t fs_state;	97	uint16_t fs_state;
98	uint16_t error_handling;	98	uint16_t error_handling;
99	uint16_t minor_revision_level;	99	uint16_t minor_revision_level;
100	uint32_t lastcheck;	100	uint32_t lastcheck;
101	uint32_t checkinterval;	101	uint32_t checkinterval;
102	uint32_t creator_os;	102	uint32_t creator_os;
103	uint32_t revision_level;	103	uint32_t revision_level;
104	uint16_t uid_reserved;	104	uint16_t uid_reserved;
105	uint16_t gid_reserved;	105	uint16_t gid_reserved;
106	uint32_t first_inode;	106	uint32_t first_inode;
107	uint16_t inode_size;	107	uint16_t inode_size;
108	uint16_t block_group_number;	108	uint16_t block_group_number;
109	uint32_t feature_compatibility;	109	uint32_t feature_compatibility;
110	uint32_t feature_incompat;	110	uint32_t feature_incompat;
111	uint32_t feature_ro_compat;	111	uint32_t feature_ro_compat;
112	uint32_t unique_id[4];	112	uint32_t unique_id[4];
113	char volume_name[16];	113	char volume_name[16];
114	char last_mounted_on[64];	114	char last_mounted_on[64];
115	uint32_t compression_info;	115	uint32_t compression_info;
116	};	116	};
117		117
118	struct ext2_block_group {	118	struct ext2_block_group {
119	__u32 block_id; /* Blocks bitmap block */	119	__u32 block_id; /* Blocks bitmap block */
120	__u32 inode_id; /* Inodes bitmap block */	120	__u32 inode_id; /* Inodes bitmap block */
121	__u32 inode_table_id; /* Inodes table block */	121	__u32 inode_table_id; /* Inodes table block */
122	__u16 free_blocks; /* Free blocks count */	122	__u16 free_blocks; /* Free blocks count */
123	__u16 free_inodes; /* Free inodes count */	123	__u16 free_inodes; /* Free inodes count */
124	__u16 used_dir_cnt; /* Directories count */	124	__u16 used_dir_cnt; /* Directories count */
125	__u16 bg_flags;	125	__u16 bg_flags;
126	__u32 bg_reserved[2];	126	__u32 bg_reserved[2];
127	__u16 bg_itable_unused; /* Unused inodes count */	127	__u16 bg_itable_unused; /* Unused inodes count */
128	__u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/	128	__u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/
129	};	129	};
130		130
131	/* The ext2 inode. */	131	/* The ext2 inode. */
132	struct ext2_inode {	132	struct ext2_inode {
133	uint16_t mode;	133	uint16_t mode;
134	uint16_t uid;	134	uint16_t uid;
135	uint32_t size;	135	uint32_t size;
136	uint32_t atime;	136	uint32_t atime;
137	uint32_t ctime;	137	uint32_t ctime;
138	uint32_t mtime;	138	uint32_t mtime;
139	uint32_t dtime;	139	uint32_t dtime;
140	uint16_t gid;	140	uint16_t gid;
141	uint16_t nlinks;	141	uint16_t nlinks;
142	uint32_t blockcnt; /* Blocks of 512 bytes!! */	142	uint32_t blockcnt; /* Blocks of 512 bytes!! */
143	uint32_t flags;	143	uint32_t flags;
144	uint32_t osd1;	144	uint32_t osd1;
145	union {	145	union {
146	struct datablocks {	146	struct datablocks {
147	uint32_t dir_blocks[INDIRECT_BLOCKS];	147	uint32_t dir_blocks[INDIRECT_BLOCKS];
148	uint32_t indir_block;	148	uint32_t indir_block;
149	uint32_t double_indir_block;	149	uint32_t double_indir_block;
150	uint32_t triple_indir_block;	150	uint32_t triple_indir_block;
151	} blocks;	151	} blocks;
152	char symlink[60];	152	char symlink[60];
153	} b;	153	} b;
154	uint32_t version;	154	uint32_t version;
155	uint32_t acl;	155	uint32_t acl;
156	uint32_t dir_acl;	156	uint32_t dir_acl;
157	uint32_t fragment_addr;	157	uint32_t fragment_addr;
158	uint32_t osd2[3];	158	uint32_t osd2[3];
159	};	159	};
160		160
161	/* The header of an ext2 directory entry. */	161	/* The header of an ext2 directory entry. */
162	struct ext2_dirent {	162	struct ext2_dirent {
163	uint32_t inode;	163	uint32_t inode;
164	uint16_t direntlen;	164	uint16_t direntlen;
165	uint8_t namelen;	165	uint8_t namelen;
166	uint8_t filetype;	166	uint8_t filetype;
167	};	167	};
168		168
169	struct ext2fs_node {	169	struct ext2fs_node {
170	struct ext2_data *data;	170	struct ext2_data *data;
171	struct ext2_inode inode;	171	struct ext2_inode inode;
172	int ino;	172	int ino;
173	int inode_read;	173	int inode_read;
174	};	174	};
175		175
176	/* Information about a "mounted" ext2 filesystem. */	176	/* Information about a "mounted" ext2 filesystem. */
177	struct ext2_data {	177	struct ext2_data {
178	struct ext2_sblock sblock;	178	struct ext2_sblock sblock;
179	struct ext2_inode *inode;	179	struct ext2_inode *inode;
180	struct ext2fs_node diropen;	180	struct ext2fs_node diropen;
181	};	181	};
182		182
183	extern unsigned long part_offset;	183	extern lbaint_t part_offset;
184		184
185	int do_ext2ls(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);	185	int do_ext2ls(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);
186	int do_ext2load(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);	186	int do_ext2load(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);
187	int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc,	187	int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc,
188	char *const argv[]);	188	char *const argv[]);
189	int do_ext4_ls(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);	189	int do_ext4_ls(cmd_tbl_t cmdtp, int flag, int argc, char const argv[]);
190	int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc,	190	int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc,
191	char *const argv[]);	191	char *const argv[]);
192	#endif	192	#endif
193		193

include/ide.h

Diff comments View file @ 04735e9

 /*
  * (C) Copyright 2000
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * 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., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #ifndef	_IDE_H
 #define _IDE_H
 #define IDE_BUS(dev)	(dev / (CONFIG_SYS_IDE_MAXDEVICE / CONFIG_SYS_IDE_MAXBUS))
 #define	ATA_CURR_BASE(dev)	(CONFIG_SYS_ATA_BASE_ADDR+ide_bus_offset[IDE_BUS(dev)])
 extern ulong ide_bus_offset[];
 #ifdef CONFIG_IDE_LED
 /*
  * LED Port
  */
 #define	LED_PORT	((uchar *)(PER8_BASE + 0x3000))
 #define LED_IDE1	0x01
 #define LED_IDE2	0x02
 #define	DEVICE_LED(d)	((d & 2) | ((d & 2) == 0)) /* depends on bit positions! */
 #endif /* CONFIG_IDE_LED */
 #ifdef CONFIG_SYS_64BIT_LBA
 typedef uint64_t lbaint_t;
 #define LBAF "%llx"
+#define LBAFU "%llu"
 #else
 typedef ulong lbaint_t;
 #define LBAF "%lx"
+#define LBAFU "%lu"
 #endif
 /*
  * Function Prototypes
  */
 void ide_init(void);
 ulong ide_read(int device, lbaint_t blknr, lbaint_t blkcnt, void *buffer);
 ulong ide_write(int device, lbaint_t blknr, lbaint_t blkcnt,
 		const void *buffer);
 #ifdef CONFIG_IDE_PREINIT
 int ide_preinit(void);
 #endif
 #ifdef CONFIG_IDE_INIT_POSTRESET
 int ide_init_postreset(void);
 #endif
 #if defined(CONFIG_OF_IDE_FIXUP)
 int ide_device_present(int dev);
 #endif
 #if defined(CONFIG_IDE_AHB)
 unsigned char ide_read_register(int dev, unsigned int port);
 void ide_write_register(int dev, unsigned int port, unsigned char val);
 void ide_read_data(int dev, ulong *sect_buf, int words);
 void ide_write_data(int dev, ulong *sect_buf, int words);
 #endif
 /*
  * I/O function overrides
  */
 void ide_input_swap_data(int dev, ulong *sect_buf, int words);
 void ide_input_data(int dev, ulong *sect_buf, int words);
 void ide_output_data(int dev, const ulong *sect_buf, int words);
 void ide_input_data_shorts(int dev, ushort *sect_buf, int shorts);
 void ide_output_data_shorts(int dev, ushort *sect_buf, int shorts);
 /**
  * board_start_ide() - Start up the board IDE interfac
  *
  * @return 0 if ok
  */
 int board_start_ide(void);
 #endif /* _IDE_H */

include/part.h

Diff comments View file @ 04735e9

1	/*	1	/*
2	* (C) Copyright 2000-2004	2	* (C) Copyright 2000-2004
3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4	*	4	*
5	* See file CREDITS for list of people who contributed to this	5	* See file CREDITS for list of people who contributed to this
6	* project.	6	* project.
7	*	7	*
8	* This program is free software; you can redistribute it and/or	8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License as	9	* modify it under the terms of the GNU General Public License as
10	* published by the Free Software Foundation; either version 2 of	10	* published by the Free Software Foundation; either version 2 of
11	* the License, or (at your option) any later version.	11	* the License, or (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21	* MA 02111-1307 USA	21	* MA 02111-1307 USA
22	*/	22	*/
23	#ifndef _PART_H	23	#ifndef _PART_H
24	#define _PART_H	24	#define _PART_H
25		25
26	#include <ide.h>	26	#include <ide.h>
27		27
28	typedef struct block_dev_desc {	28	typedef struct block_dev_desc {
29	int if_type; /* type of the interface */	29	int if_type; /* type of the interface */
30	int dev; /* device number */	30	int dev; /* device number */
31	unsigned char part_type; /* partition type */	31	unsigned char part_type; /* partition type */
32	unsigned char target; /* target SCSI ID */	32	unsigned char target; /* target SCSI ID */
33	unsigned char lun; /* target LUN */	33	unsigned char lun; /* target LUN */
34	unsigned char type; /* device type */	34	unsigned char type; /* device type */
35	unsigned char removable; /* removable device */	35	unsigned char removable; /* removable device */
36	#ifdef CONFIG_LBA48	36	#ifdef CONFIG_LBA48
37	unsigned char lba48; /* device can use 48bit addr (ATA/ATAPI v7) */	37	unsigned char lba48; /* device can use 48bit addr (ATA/ATAPI v7) */
38	#endif	38	#endif
39	lbaint_t lba; /* number of blocks */	39	lbaint_t lba; /* number of blocks */
40	unsigned long blksz; /* block size */	40	unsigned long blksz; /* block size */
41	int log2blksz; /* for convenience: log2(blksz) */	41	int log2blksz; /* for convenience: log2(blksz) */
42	char vendor [40+1]; /* IDE model, SCSI Vendor */	42	char vendor [40+1]; /* IDE model, SCSI Vendor */
43	char product[20+1]; /* IDE Serial no, SCSI product */	43	char product[20+1]; /* IDE Serial no, SCSI product */
44	char revision[8+1]; /* firmware revision */	44	char revision[8+1]; /* firmware revision */
45	unsigned long (*block_read)(int dev,	45	unsigned long (*block_read)(int dev,
46	lbaint_t start,	46	lbaint_t start,
47	lbaint_t blkcnt,	47	lbaint_t blkcnt,
48	void *buffer);	48	void *buffer);
49	unsigned long (*block_write)(int dev,	49	unsigned long (*block_write)(int dev,
50	lbaint_t start,	50	lbaint_t start,
51	lbaint_t blkcnt,	51	lbaint_t blkcnt,
52	const void *buffer);	52	const void *buffer);
53	unsigned long (*block_erase)(int dev,	53	unsigned long (*block_erase)(int dev,
54	lbaint_t start,	54	lbaint_t start,
55	lbaint_t blkcnt);	55	lbaint_t blkcnt);
56	void priv; / driver private struct pointer */	56	void priv; / driver private struct pointer */
57	}block_dev_desc_t;	57	}block_dev_desc_t;
58		58
59	#define BLOCK_CNT(size, block_dev_desc) (PAD_COUNT(size, block_dev_desc->blksz))	59	#define BLOCK_CNT(size, block_dev_desc) (PAD_COUNT(size, block_dev_desc->blksz))
60	#define PAD_TO_BLOCKSIZE(size, block_dev_desc) \	60	#define PAD_TO_BLOCKSIZE(size, block_dev_desc) \
61	(PAD_SIZE(size, block_dev_desc->blksz))	61	(PAD_SIZE(size, block_dev_desc->blksz))
62	#define LOG2(x) (((x & 0xaaaaaaaa) ? 1 : 0) + ((x & 0xcccccccc) ? 2 : 0) + \	62	#define LOG2(x) (((x & 0xaaaaaaaa) ? 1 : 0) + ((x & 0xcccccccc) ? 2 : 0) + \
63	((x & 0xf0f0f0f0) ? 4 : 0) + ((x & 0xff00ff00) ? 8 : 0) + \	63	((x & 0xf0f0f0f0) ? 4 : 0) + ((x & 0xff00ff00) ? 8 : 0) + \
64	((x & 0xffff0000) ? 16 : 0))	64	((x & 0xffff0000) ? 16 : 0))
65	#define LOG2_INVALID(type) ((type)((sizeof(type)<<3)-1))	65	#define LOG2_INVALID(type) ((type)((sizeof(type)<<3)-1))
66		66
67	/* Interface types: */	67	/* Interface types: */
68	#define IF_TYPE_UNKNOWN 0	68	#define IF_TYPE_UNKNOWN 0
69	#define IF_TYPE_IDE 1	69	#define IF_TYPE_IDE 1
70	#define IF_TYPE_SCSI 2	70	#define IF_TYPE_SCSI 2
71	#define IF_TYPE_ATAPI 3	71	#define IF_TYPE_ATAPI 3
72	#define IF_TYPE_USB 4	72	#define IF_TYPE_USB 4
73	#define IF_TYPE_DOC 5	73	#define IF_TYPE_DOC 5
74	#define IF_TYPE_MMC 6	74	#define IF_TYPE_MMC 6
75	#define IF_TYPE_SD 7	75	#define IF_TYPE_SD 7
76	#define IF_TYPE_SATA 8	76	#define IF_TYPE_SATA 8
77		77
78	/* Part types */	78	/* Part types */
79	#define PART_TYPE_UNKNOWN 0x00	79	#define PART_TYPE_UNKNOWN 0x00
80	#define PART_TYPE_MAC 0x01	80	#define PART_TYPE_MAC 0x01
81	#define PART_TYPE_DOS 0x02	81	#define PART_TYPE_DOS 0x02
82	#define PART_TYPE_ISO 0x03	82	#define PART_TYPE_ISO 0x03
83	#define PART_TYPE_AMIGA 0x04	83	#define PART_TYPE_AMIGA 0x04
84	#define PART_TYPE_EFI 0x05	84	#define PART_TYPE_EFI 0x05
85		85
86	/*	86	/*
87	* Type string for U-Boot bootable partitions	87	* Type string for U-Boot bootable partitions
88	*/	88	*/
89	#define BOOT_PART_TYPE "U-Boot" /* primary boot partition type */	89	#define BOOT_PART_TYPE "U-Boot" /* primary boot partition type */
90	#define BOOT_PART_COMP "PPCBoot" /* PPCBoot compatibility type */	90	#define BOOT_PART_COMP "PPCBoot" /* PPCBoot compatibility type */
91		91
92	/* device types */	92	/* device types */
93	#define DEV_TYPE_UNKNOWN 0xff /* not connected */	93	#define DEV_TYPE_UNKNOWN 0xff /* not connected */
94	#define DEV_TYPE_HARDDISK 0x00 /* harddisk */	94	#define DEV_TYPE_HARDDISK 0x00 /* harddisk */
95	#define DEV_TYPE_TAPE 0x01 /* Tape */	95	#define DEV_TYPE_TAPE 0x01 /* Tape */
96	#define DEV_TYPE_CDROM 0x05 /* CD-ROM */	96	#define DEV_TYPE_CDROM 0x05 /* CD-ROM */
97	#define DEV_TYPE_OPDISK 0x07 /* optical disk */	97	#define DEV_TYPE_OPDISK 0x07 /* optical disk */
98		98
99	typedef struct disk_partition {	99	typedef struct disk_partition {
100	ulong start; /* # of first block in partition */	100	lbaint_t start; /* # of first block in partition */
101	ulong size; /* number of blocks in partition */	101	lbaint_t size; /* number of blocks in partition */
102	ulong blksz; /* block size in bytes */	102	ulong blksz; /* block size in bytes */
103	uchar name[32]; /* partition name */	103	uchar name[32]; /* partition name */
104	uchar type[32]; /* string type description */	104	uchar type[32]; /* string type description */
105	int bootable; /* Active/Bootable flag is set */	105	int bootable; /* Active/Bootable flag is set */
106	#ifdef CONFIG_PARTITION_UUIDS	106	#ifdef CONFIG_PARTITION_UUIDS
107	char uuid[37]; /* filesystem UUID as string, if exists */	107	char uuid[37]; /* filesystem UUID as string, if exists */
108	#endif	108	#endif
109	} disk_partition_t;	109	} disk_partition_t;
110		110
111	/* Misc _get_dev functions */	111	/* Misc _get_dev functions */
112	#ifdef CONFIG_PARTITIONS	112	#ifdef CONFIG_PARTITIONS
113	block_dev_desc_t get_dev(const char ifname, int dev);	113	block_dev_desc_t get_dev(const char ifname, int dev);
114	block_dev_desc_t* ide_get_dev(int dev);	114	block_dev_desc_t* ide_get_dev(int dev);
115	block_dev_desc_t* sata_get_dev(int dev);	115	block_dev_desc_t* sata_get_dev(int dev);
116	block_dev_desc_t* scsi_get_dev(int dev);	116	block_dev_desc_t* scsi_get_dev(int dev);
117	block_dev_desc_t* usb_stor_get_dev(int dev);	117	block_dev_desc_t* usb_stor_get_dev(int dev);
118	block_dev_desc_t* mmc_get_dev(int dev);	118	block_dev_desc_t* mmc_get_dev(int dev);
119	block_dev_desc_t* systemace_get_dev(int dev);	119	block_dev_desc_t* systemace_get_dev(int dev);
120	block_dev_desc_t* mg_disk_get_dev(int dev);	120	block_dev_desc_t* mg_disk_get_dev(int dev);
121		121
122	/* disk/part.c */	122	/* disk/part.c */
123	int get_partition_info (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	123	int get_partition_info (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
124	void print_part (block_dev_desc_t *dev_desc);	124	void print_part (block_dev_desc_t *dev_desc);
125	void init_part (block_dev_desc_t *dev_desc);	125	void init_part (block_dev_desc_t *dev_desc);
126	void dev_print(block_dev_desc_t *dev_desc);	126	void dev_print(block_dev_desc_t *dev_desc);
127	int get_device(const char ifname, const char dev_str,	127	int get_device(const char ifname, const char dev_str,
128	block_dev_desc_t **dev_desc);	128	block_dev_desc_t **dev_desc);
129	int get_device_and_partition(const char ifname, const char dev_part_str,	129	int get_device_and_partition(const char ifname, const char dev_part_str,
130	block_dev_desc_t **dev_desc,	130	block_dev_desc_t **dev_desc,
131	disk_partition_t *info, int allow_whole_dev);	131	disk_partition_t *info, int allow_whole_dev);
132	#else	132	#else
133	static inline block_dev_desc_t get_dev(const char ifname, int dev)	133	static inline block_dev_desc_t get_dev(const char ifname, int dev)
134	{ return NULL; }	134	{ return NULL; }
135	static inline block_dev_desc_t* ide_get_dev(int dev) { return NULL; }	135	static inline block_dev_desc_t* ide_get_dev(int dev) { return NULL; }
136	static inline block_dev_desc_t* sata_get_dev(int dev) { return NULL; }	136	static inline block_dev_desc_t* sata_get_dev(int dev) { return NULL; }
137	static inline block_dev_desc_t* scsi_get_dev(int dev) { return NULL; }	137	static inline block_dev_desc_t* scsi_get_dev(int dev) { return NULL; }
138	static inline block_dev_desc_t* usb_stor_get_dev(int dev) { return NULL; }	138	static inline block_dev_desc_t* usb_stor_get_dev(int dev) { return NULL; }
139	static inline block_dev_desc_t* mmc_get_dev(int dev) { return NULL; }	139	static inline block_dev_desc_t* mmc_get_dev(int dev) { return NULL; }
140	static inline block_dev_desc_t* systemace_get_dev(int dev) { return NULL; }	140	static inline block_dev_desc_t* systemace_get_dev(int dev) { return NULL; }
141	static inline block_dev_desc_t* mg_disk_get_dev(int dev) { return NULL; }	141	static inline block_dev_desc_t* mg_disk_get_dev(int dev) { return NULL; }
142		142
143	static inline int get_partition_info (block_dev_desc_t * dev_desc, int part,	143	static inline int get_partition_info (block_dev_desc_t * dev_desc, int part,
144	disk_partition_t *info) { return -1; }	144	disk_partition_t *info) { return -1; }
145	static inline void print_part (block_dev_desc_t *dev_desc) {}	145	static inline void print_part (block_dev_desc_t *dev_desc) {}
146	static inline void init_part (block_dev_desc_t *dev_desc) {}	146	static inline void init_part (block_dev_desc_t *dev_desc) {}
147	static inline void dev_print(block_dev_desc_t *dev_desc) {}	147	static inline void dev_print(block_dev_desc_t *dev_desc) {}
148	static inline int get_device(const char ifname, const char dev_str,	148	static inline int get_device(const char ifname, const char dev_str,
149	block_dev_desc_t **dev_desc)	149	block_dev_desc_t **dev_desc)
150	{ return -1; }	150	{ return -1; }
151	static inline int get_device_and_partition(const char *ifname,	151	static inline int get_device_and_partition(const char *ifname,
152	const char *dev_part_str,	152	const char *dev_part_str,
153	block_dev_desc_t **dev_desc,	153	block_dev_desc_t **dev_desc,
154	disk_partition_t *info,	154	disk_partition_t *info,
155	int allow_whole_dev)	155	int allow_whole_dev)
156	{ *dev_desc = NULL; return -1; }	156	{ *dev_desc = NULL; return -1; }
157	#endif	157	#endif
158		158
159	#ifdef CONFIG_MAC_PARTITION	159	#ifdef CONFIG_MAC_PARTITION
160	/* disk/part_mac.c */	160	/* disk/part_mac.c */
161	int get_partition_info_mac (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	161	int get_partition_info_mac (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
162	void print_part_mac (block_dev_desc_t *dev_desc);	162	void print_part_mac (block_dev_desc_t *dev_desc);
163	int test_part_mac (block_dev_desc_t *dev_desc);	163	int test_part_mac (block_dev_desc_t *dev_desc);
164	#endif	164	#endif
165		165
166	#ifdef CONFIG_DOS_PARTITION	166	#ifdef CONFIG_DOS_PARTITION
167	/* disk/part_dos.c */	167	/* disk/part_dos.c */
168	int get_partition_info_dos (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	168	int get_partition_info_dos (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
169	void print_part_dos (block_dev_desc_t *dev_desc);	169	void print_part_dos (block_dev_desc_t *dev_desc);
170	int test_part_dos (block_dev_desc_t *dev_desc);	170	int test_part_dos (block_dev_desc_t *dev_desc);
171	#endif	171	#endif
172		172
173	#ifdef CONFIG_ISO_PARTITION	173	#ifdef CONFIG_ISO_PARTITION
174	/* disk/part_iso.c */	174	/* disk/part_iso.c */
175	int get_partition_info_iso (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	175	int get_partition_info_iso (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
176	void print_part_iso (block_dev_desc_t *dev_desc);	176	void print_part_iso (block_dev_desc_t *dev_desc);
177	int test_part_iso (block_dev_desc_t *dev_desc);	177	int test_part_iso (block_dev_desc_t *dev_desc);
178	#endif	178	#endif
179		179
180	#ifdef CONFIG_AMIGA_PARTITION	180	#ifdef CONFIG_AMIGA_PARTITION
181	/* disk/part_amiga.c */	181	/* disk/part_amiga.c */
182	int get_partition_info_amiga (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	182	int get_partition_info_amiga (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
183	void print_part_amiga (block_dev_desc_t *dev_desc);	183	void print_part_amiga (block_dev_desc_t *dev_desc);
184	int test_part_amiga (block_dev_desc_t *dev_desc);	184	int test_part_amiga (block_dev_desc_t *dev_desc);
185	#endif	185	#endif
186		186
187	#ifdef CONFIG_EFI_PARTITION	187	#ifdef CONFIG_EFI_PARTITION
188	#include <part_efi.h>	188	#include <part_efi.h>
189	/* disk/part_efi.c */	189	/* disk/part_efi.c */
190	int get_partition_info_efi (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);	190	int get_partition_info_efi (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
191	void print_part_efi (block_dev_desc_t *dev_desc);	191	void print_part_efi (block_dev_desc_t *dev_desc);
192	int test_part_efi (block_dev_desc_t *dev_desc);	192	int test_part_efi (block_dev_desc_t *dev_desc);
193		193
194	/**	194	/**
195	* write_gpt_table() - Write the GUID Partition Table to disk	195	* write_gpt_table() - Write the GUID Partition Table to disk
196	*	196	*
197	* @param dev_desc - block device descriptor	197	* @param dev_desc - block device descriptor
198	* @param gpt_h - pointer to GPT header representation	198	* @param gpt_h - pointer to GPT header representation
199	* @param gpt_e - pointer to GPT partition table entries	199	* @param gpt_e - pointer to GPT partition table entries
200	*	200	*
201	* @return - zero on success, otherwise error	201	* @return - zero on success, otherwise error
202	*/	202	*/
203	int write_gpt_table(block_dev_desc_t *dev_desc,	203	int write_gpt_table(block_dev_desc_t *dev_desc,
204	gpt_header gpt_h, gpt_entry gpt_e);	204	gpt_header gpt_h, gpt_entry gpt_e);
205		205
206	/**	206	/**
207	* gpt_fill_pte(): Fill the GPT partition table entry	207	* gpt_fill_pte(): Fill the GPT partition table entry
208	*	208	*
209	* @param gpt_h - GPT header representation	209	* @param gpt_h - GPT header representation
210	* @param gpt_e - GPT partition table entries	210	* @param gpt_e - GPT partition table entries
211	* @param partitions - list of partitions	211	* @param partitions - list of partitions
212	* @param parts - number of partitions	212	* @param parts - number of partitions
213	*	213	*
214	* @return zero on success	214	* @return zero on success
215	*/	215	*/
216	int gpt_fill_pte(gpt_header gpt_h, gpt_entry gpt_e,	216	int gpt_fill_pte(gpt_header gpt_h, gpt_entry gpt_e,
217	disk_partition_t *partitions, int parts);	217	disk_partition_t *partitions, int parts);
218		218
219	/**	219	/**
220	* gpt_fill_header(): Fill the GPT header	220	* gpt_fill_header(): Fill the GPT header
221	*	221	*
222	* @param dev_desc - block device descriptor	222	* @param dev_desc - block device descriptor
223	* @param gpt_h - GPT header representation	223	* @param gpt_h - GPT header representation
224	* @param str_guid - disk guid string representation	224	* @param str_guid - disk guid string representation
225	* @param parts_count - number of partitions	225	* @param parts_count - number of partitions
226	*	226	*
227	* @return - error on str_guid conversion error	227	* @return - error on str_guid conversion error
228	*/	228	*/
229	int gpt_fill_header(block_dev_desc_t dev_desc, gpt_header gpt_h,	229	int gpt_fill_header(block_dev_desc_t dev_desc, gpt_header gpt_h,
230	char *str_guid, int parts_count);	230	char *str_guid, int parts_count);
231		231
232	/**	232	/**
233	* gpt_restore(): Restore GPT partition table	233	* gpt_restore(): Restore GPT partition table
234	*	234	*
235	* @param dev_desc - block device descriptor	235	* @param dev_desc - block device descriptor
236	* @param str_disk_guid - disk GUID	236	* @param str_disk_guid - disk GUID
237	* @param partitions - list of partitions	237	* @param partitions - list of partitions
238	* @param parts - number of partitions	238	* @param parts - number of partitions
239	*	239	*
240	* @return zero on success	240	* @return zero on success
241	*/	241	*/
242	int gpt_restore(block_dev_desc_t dev_desc, char str_disk_guid,	242	int gpt_restore(block_dev_desc_t dev_desc, char str_disk_guid,
243	disk_partition_t *partitions, const int parts_count);	243	disk_partition_t *partitions, const int parts_count);
244	#endif	244	#endif
245		245
246	#endif /* _PART_H */	246	#endif /* _PART_H */
247		247

1	/*	1	/*
2	* Copyright (C) 2008 RuggedCom, Inc.	2	* Copyright (C) 2008 RuggedCom, Inc.
3	* Richard Retanubun <RichardRetanubun@RuggedCom.com>	3	* Richard Retanubun <RichardRetanubun@RuggedCom.com>
4	*	4	*
5	* See file CREDITS for list of people who contributed to this	5	* See file CREDITS for list of people who contributed to this
6	* project.	6	* project.
7	*	7	*
8	* This program is free software; you can redistribute it and/or	8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License as	9	* modify it under the terms of the GNU General Public License as
10	* published by the Free Software Foundation; either version 2 of	10	* published by the Free Software Foundation; either version 2 of
11	* the License, or (at your option) any later version.	11	* the License, or (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21	* MA 02111-1307 USA	21	* MA 02111-1307 USA
22	*/	22	*/
23		23
24	/*	24	/*
25	* Problems with CONFIG_SYS_64BIT_LBA:	25	* Problems with CONFIG_SYS_64BIT_LBA:
26	*	26	*
27	* struct disk_partition.start in include/part.h is sized as ulong.	27	* struct disk_partition.start in include/part.h is sized as ulong.
28	* When CONFIG_SYS_64BIT_LBA is activated, lbaint_t changes from ulong to uint64_t.	28	* When CONFIG_SYS_64BIT_LBA is activated, lbaint_t changes from ulong to uint64_t.
29	* For now, it is cast back to ulong at assignment.	29	* For now, it is cast back to ulong at assignment.
30	*	30	*
31	* This limits the maximum size of addressable storage to < 2 Terra Bytes	31	* This limits the maximum size of addressable storage to < 2 Terra Bytes
32	*/	32	*/
33	#include <asm/unaligned.h>	33	#include <asm/unaligned.h>
34	#include <common.h>	34	#include <common.h>
35	#include <command.h>	35	#include <command.h>
36	#include <ide.h>	36	#include <ide.h>
37	#include <malloc.h>	37	#include <malloc.h>
38	#include <part_efi.h>	38	#include <part_efi.h>
39	#include <linux/ctype.h>	39	#include <linux/ctype.h>
40		40