diff --git a/arch/sandbox/cpu/os.c b/arch/sandbox/cpu/os.c
index 1c4aa3f..43872e8 100644
--- a/arch/sandbox/cpu/os.c
+++ b/arch/sandbox/cpu/os.c
@@ -385,7 +385,7 @@ const char *os_dirent_get_typename(enum os_dirent_t type)
 	return os_dirent_typename[OS_FILET_UNKNOWN];
 }
 
-ssize_t os_get_filesize(const char *fname)
+int os_get_filesize(const char *fname, loff_t *size)
 {
 	struct stat buf;
 	int ret;
@@ -393,7 +393,8 @@ ssize_t os_get_filesize(const char *fname)
 	ret = stat(fname, &buf);
 	if (ret)
 		return ret;
-	return buf.st_size;
+	*size = buf.st_size;
+	return 0;
 }
 
 void os_putc(int ch)
@@ -427,10 +428,10 @@ int os_read_ram_buf(const char *fname)
 {
 	struct sandbox_state *state = state_get_current();
 	int fd, ret;
-	int size;
+	loff_t size;
 
-	size = os_get_filesize(fname);
-	if (size < 0)
+	ret = os_get_filesize(fname, &size);
+	if (ret < 0)
 		return -ENOENT;
 	if (size != state->ram_size)
 		return -ENOSPC;
diff --git a/arch/sandbox/cpu/state.c b/arch/sandbox/cpu/state.c
index 59adad6..07d2aea 100644
--- a/arch/sandbox/cpu/state.c
+++ b/arch/sandbox/cpu/state.c
@@ -49,12 +49,12 @@ static int state_ensure_space(int extra_size)
 
 static int state_read_file(struct sandbox_state *state, const char *fname)
 {
-	int size;
+	loff_t size;
 	int ret;
 	int fd;
 
-	size = os_get_filesize(fname);
-	if (size < 0) {
+	ret = os_get_filesize(fname, &size);
+	if (ret < 0) {
 		printf("Cannot find sandbox state file '%s'\n", fname);
 		return -ENOENT;
 	}
diff --git a/common/board_f.c b/common/board_f.c
index e6aa298..a1ac8fe 100644
--- a/common/board_f.c
+++ b/common/board_f.c
@@ -291,7 +291,7 @@ static int read_fdt_from_file(void)
 	struct sandbox_state *state = state_get_current();
 	const char *fname = state->fdt_fname;
 	void *blob;
-	ssize_t size;
+	loff_t size;
 	int err;
 	int fd;
 
@@ -304,8 +304,8 @@ static int read_fdt_from_file(void)
 		return -EINVAL;
 	}
 
-	size = os_get_filesize(fname);
-	if (size < 0) {
+	err = os_get_filesize(fname, &size);
+	if (err < 0) {
 		printf("Failed to file FDT file '%s'\n", fname);
 		return -ENOENT;
 	}
diff --git a/common/cmd_fat.c b/common/cmd_fat.c
index 633fbf1..efba9da 100644
--- a/common/cmd_fat.c
+++ b/common/cmd_fat.c
@@ -100,7 +100,8 @@ U_BOOT_CMD(
 static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	long size;
+	loff_t size;
+	int ret;
 	unsigned long addr;
 	unsigned long count;
 	block_dev_desc_t *dev_desc = NULL;
@@ -127,15 +128,15 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 	count = simple_strtoul(argv[5], NULL, 16);
 
 	buf = map_sysmem(addr, count);
-	size = file_fat_write(argv[4], buf, count);
+	ret = file_fat_write(argv[4], buf, count, &size);
 	unmap_sysmem(buf);
-	if (size == -1) {
+	if (ret == -1) {
 		printf("\n** Unable to write \"%s\" from %s %d:%d **\n",
 			argv[4], argv[1], dev, part);
 		return 1;
 	}
 
-	printf("%ld bytes written\n", size);
+	printf("%llu bytes written\n", size);
 
 	return 0;
 }
diff --git a/common/cmd_md5sum.c b/common/cmd_md5sum.c
index 3ac8cc4..bd6defd 100644
--- a/common/cmd_md5sum.c
+++ b/common/cmd_md5sum.c
@@ -11,6 +11,7 @@
 #include <common.h>
 #include <command.h>
 #include <u-boot/md5.h>
+#include <asm/io.h>
 
 /*
  * Store the resulting sum to an address or variable
@@ -135,6 +136,7 @@ static int do_md5sum(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	unsigned long addr, len;
 	unsigned int i;
 	u8 output[16];
+	void *buf;
 
 	if (argc < 3)
 		return CMD_RET_USAGE;
@@ -142,7 +144,10 @@ static int do_md5sum(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	addr = simple_strtoul(argv[1], NULL, 16);
 	len = simple_strtoul(argv[2], NULL, 16);
 
-	md5_wd((unsigned char *) addr, len, output, CHUNKSZ_MD5);
+	buf = map_sysmem(addr, len);
+	md5_wd(buf, len, output, CHUNKSZ_MD5);
+	unmap_sysmem(buf);
+
 	printf("md5 for %08lx ... %08lx ==> ", addr, addr + len - 1);
 	for (i = 0; i < 16; i++)
 		printf("%02x", output[i]);
diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
index 33d69c9..3b8df3f 100644
--- a/fs/ext4/ext4_common.c
+++ b/fs/ext4/ext4_common.c
@@ -1891,6 +1891,7 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
 {
 	unsigned int fpos = 0;
 	int status;
+	loff_t actread;
 	struct ext2fs_node *diro = (struct ext2fs_node *) dir;
 
 #ifdef DEBUG
@@ -1908,8 +1909,8 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
 
 		status = ext4fs_read_file(diro, fpos,
 					   sizeof(struct ext2_dirent),
-					   (char *) &dirent);
-		if (status < 1)
+					   (char *)&dirent, &actread);
+		if (status < 0)
 			return 0;
 
 		if (dirent.namelen != 0) {
@@ -1920,8 +1921,9 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
 			status = ext4fs_read_file(diro,
 						  fpos +
 						  sizeof(struct ext2_dirent),
-						  dirent.namelen, filename);
-			if (status < 1)
+						  dirent.namelen, filename,
+						  &actread);
+			if (status < 0)
 				return 0;
 
 			fdiro = zalloc(sizeof(struct ext2fs_node));
@@ -2003,8 +2005,8 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
 					printf("< ? > ");
 					break;
 				}
-				printf("%10d %s\n",
-					__le32_to_cpu(fdiro->inode.size),
+				printf("%10u %s\n",
+				       __le32_to_cpu(fdiro->inode.size),
 					filename);
 			}
 			free(fdiro);
@@ -2019,6 +2021,7 @@ static char *ext4fs_read_symlink(struct ext2fs_node *node)
 	char *symlink;
 	struct ext2fs_node *diro = node;
 	int status;
+	loff_t actread;
 
 	if (!diro->inode_read) {
 		status = ext4fs_read_inode(diro->data, diro->ino, &diro->inode);
@@ -2035,7 +2038,7 @@ static char *ext4fs_read_symlink(struct ext2fs_node *node)
 	} else {
 		status = ext4fs_read_file(diro, 0,
 					   __le32_to_cpu(diro->inode.size),
-					   symlink);
+					   symlink, &actread);
 		if (status == 0) {
 			free(symlink);
 			return 0;
@@ -2169,11 +2172,10 @@ int ext4fs_find_file(const char *path, struct ext2fs_node *rootnode,
 	return 1;
 }
 
-int ext4fs_open(const char *filename)
+int ext4fs_open(const char *filename, loff_t *len)
 {
 	struct ext2fs_node *fdiro = NULL;
 	int status;
-	int len;
 
 	if (ext4fs_root == NULL)
 		return -1;
@@ -2190,10 +2192,10 @@ int ext4fs_open(const char *filename)
 		if (status == 0)
 			goto fail;
 	}
-	len = __le32_to_cpu(fdiro->inode.size);
+	*len = __le32_to_cpu(fdiro->inode.size);
 	ext4fs_file = fdiro;
 
-	return len;
+	return 0;
 fail:
 	ext4fs_free_node(fdiro, &ext4fs_root->diropen);
 
diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h
index 5fa1719..48fd2ac 100644
--- a/fs/ext4/ext4_common.h
+++ b/fs/ext4/ext4_common.h
@@ -50,8 +50,8 @@ static inline void *zalloc(size_t size)
 
 int ext4fs_read_inode(struct ext2_data *data, int ino,
 		      struct ext2_inode *inode);
-int ext4fs_read_file(struct ext2fs_node *node, int pos,
-		unsigned int len, char *buf);
+int ext4fs_read_file(struct ext2fs_node *node, loff_t pos, loff_t len,
+		     char *buf, loff_t *actread);
 int ext4fs_find_file(const char *path, struct ext2fs_node *rootnode,
 			struct ext2fs_node **foundnode, int expecttype);
 int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c
index cbdc220..ae1c47d 100644
--- a/fs/ext4/ext4fs.c
+++ b/fs/ext4/ext4fs.c
@@ -45,8 +45,8 @@ void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot)
  * Optimized read file API : collects and defers contiguous sector
  * reads into one potentially more efficient larger sequential read action
  */
-int ext4fs_read_file(struct ext2fs_node *node, int pos,
-		unsigned int len, char *buf)
+int ext4fs_read_file(struct ext2fs_node *node, loff_t pos,
+		loff_t len, char *buf, loff_t *actread)
 {
 	struct ext_filesystem *fs = get_fs();
 	int i;
@@ -150,7 +150,8 @@ int ext4fs_read_file(struct ext2fs_node *node, int pos,
 		previous_block_number = -1;
 	}
 
-	return len;
+	*actread  = len;
+	return 0;
 }
 
 int ext4fs_ls(const char *dirname)
@@ -176,23 +177,24 @@ int ext4fs_ls(const char *dirname)
 
 int ext4fs_exists(const char *filename)
 {
-	int file_len;
+	loff_t file_len;
+	int ret;
 
-	file_len = ext4fs_open(filename);
-	return file_len >= 0;
+	ret = ext4fs_open(filename, &file_len);
+	return ret == 0;
 }
 
-int ext4fs_size(const char *filename)
+int ext4fs_size(const char *filename, loff_t *size)
 {
-	return ext4fs_open(filename);
+	return ext4fs_open(filename, size);
 }
 
-int ext4fs_read(char *buf, unsigned len)
+int ext4fs_read(char *buf, loff_t len, loff_t *actread)
 {
 	if (ext4fs_root == NULL || ext4fs_file == NULL)
 		return 0;
 
-	return ext4fs_read_file(ext4fs_file, 0, len, buf);
+	return ext4fs_read_file(ext4fs_file, 0, len, buf, actread);
 }
 
 int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
@@ -208,18 +210,19 @@ int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
 	return 0;
 }
 
-int ext4_read_file(const char *filename, void *buf, int offset, int len)
+int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		   loff_t *len_read)
 {
-	int file_len;
-	int len_read;
+	loff_t file_len;
+	int ret;
 
 	if (offset != 0) {
 		printf("** Cannot support non-zero offset **\n");
 		return -1;
 	}
 
-	file_len = ext4fs_open(filename);
-	if (file_len < 0) {
+	ret = ext4fs_open(filename, &file_len);
+	if (ret < 0) {
 		printf("** File not found %s **\n", filename);
 		return -1;
 	}
@@ -227,7 +230,7 @@ int ext4_read_file(const char *filename, void *buf, int offset, int len)
 	if (len == 0)
 		len = file_len;
 
-	len_read = ext4fs_read(buf, len);
+	ret = ext4fs_read(buf, len, len_read);
 
-	return len_read;
+	return ret;
 }
diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 561921f..df8705f 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -317,32 +317,33 @@ get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
 /*
  * Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr'
  * into 'buffer'.
- * Return the number of bytes read or -1 on fatal errors.
+ * Update the number of bytes read in *gotsize or return -1 on fatal errors.
  */
 __u8 get_contents_vfatname_block[MAX_CLUSTSIZE]
 	__aligned(ARCH_DMA_MINALIGN);
 
-static long
-get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
-	     __u8 *buffer, unsigned long maxsize)
+static int
+get_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos,
+	     __u8 *buffer, loff_t maxsize, loff_t *gotsize)
 {
-	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
+	loff_t filesize = FAT2CPU32(dentptr->size);
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust, newclust;
-	unsigned long actsize;
+	loff_t actsize;
 
-	debug("Filesize: %ld bytes\n", filesize);
+	*gotsize = 0;
+	debug("Filesize: %llu bytes\n", filesize);
 
 	if (pos >= filesize) {
-		debug("Read position past EOF: %lu\n", pos);
-		return gotsize;
+		debug("Read position past EOF: %llu\n", pos);
+		return 0;
 	}
 
 	if (maxsize > 0 && filesize > pos + maxsize)
 		filesize = pos + maxsize;
 
-	debug("%ld bytes\n", filesize);
+	debug("%llu bytes\n", filesize);
 
 	actsize = bytesperclust;
 
@@ -352,7 +353,7 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize += bytesperclust;
 	}
@@ -373,16 +374,16 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 		filesize -= actsize;
 		actsize -= pos;
 		memcpy(buffer, get_contents_vfatname_block + pos, actsize);
-		gotsize += actsize;
+		*gotsize += actsize;
 		if (!filesize)
-			return gotsize;
+			return 0;
 		buffer += actsize;
 
 		curclust = get_fatent(mydata, curclust);
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 	}
 
@@ -398,7 +399,7 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
 				debug("curclust: 0x%x\n", newclust);
 				debug("Invalid FAT entry\n");
-				return gotsize;
+				return 0;
 			}
 			endclust = newclust;
 			actsize += bytesperclust;
@@ -410,14 +411,14 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 			printf("Error reading cluster\n");
 			return -1;
 		}
-		gotsize += actsize;
-		return gotsize;
+		*gotsize += actsize;
+		return 0;
 getit:
 		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			printf("Error reading cluster\n");
 			return -1;
 		}
-		gotsize += (int)actsize;
+		*gotsize += (int)actsize;
 		filesize -= actsize;
 		buffer += actsize;
 
@@ -425,7 +426,7 @@ getit:
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			printf("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize = bytesperclust;
 		endclust = curclust;
@@ -633,8 +634,8 @@ static dir_entry *get_dentfromdir(fsdata *mydata, int startsect,
 						}
 						if (doit) {
 							if (dirc == ' ') {
-								printf(" %8ld   %s%c\n",
-									(long)FAT2CPU32(dentptr->size),
+								printf(" %8u   %s%c\n",
+								       FAT2CPU32(dentptr->size),
 									l_name,
 									dirc);
 							} else {
@@ -690,8 +691,8 @@ static dir_entry *get_dentfromdir(fsdata *mydata, int startsect,
 
 				if (doit) {
 					if (dirc == ' ') {
-						printf(" %8ld   %s%c\n",
-							(long)FAT2CPU32(dentptr->size),
+						printf(" %8u   %s%c\n",
+						       FAT2CPU32(dentptr->size),
 							s_name, dirc);
 					} else {
 						printf("            %s%c\n",
@@ -806,9 +807,9 @@ exit:
 __u8 do_fat_read_at_block[MAX_CLUSTSIZE]
 	__aligned(ARCH_DMA_MINALIGN);
 
-long
-do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-	       unsigned long maxsize, int dols, int dogetsize)
+int
+do_fat_read_at(const char *filename, loff_t pos, void *buffer, loff_t maxsize,
+	       int dols, int dogetsize, loff_t *size)
 {
 	char fnamecopy[2048];
 	boot_sector bs;
@@ -821,7 +822,7 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 	__u32 cursect;
 	int idx, isdir = 0;
 	int files = 0, dirs = 0;
-	long ret = -1;
+	int ret = -1;
 	int firsttime;
 	__u32 root_cluster = 0;
 	int rootdir_size = 0;
@@ -974,8 +975,8 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 						}
 						if (doit) {
 							if (dirc == ' ') {
-								printf(" %8ld   %s%c\n",
-									(long)FAT2CPU32(dentptr->size),
+								printf(" %8u   %s%c\n",
+								       FAT2CPU32(dentptr->size),
 									l_name,
 									dirc);
 							} else {
@@ -1032,8 +1033,8 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 				}
 				if (doit) {
 					if (dirc == ' ') {
-						printf(" %8ld   %s%c\n",
-							(long)FAT2CPU32(dentptr->size),
+						printf(" %8u   %s%c\n",
+						       FAT2CPU32(dentptr->size),
 							s_name, dirc);
 					} else {
 						printf("            %s%c\n",
@@ -1102,7 +1103,7 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 			if (dols == LS_ROOT) {
 				printf("\n%d file(s), %d dir(s)\n\n",
 				       files, dirs);
-				ret = 0;
+				*size = 0;
 			}
 			goto exit;
 		}
@@ -1141,7 +1142,7 @@ rootdir_done:
 		if (get_dentfromdir(mydata, startsect, subname, dentptr,
 				     isdir ? 0 : dols) == NULL) {
 			if (dols && !isdir)
-				ret = 0;
+				*size = 0;
 			goto exit;
 		}
 
@@ -1152,21 +1153,24 @@ rootdir_done:
 			subname = nextname;
 	}
 
-	if (dogetsize)
-		ret = FAT2CPU32(dentptr->size);
-	else
-		ret = get_contents(mydata, dentptr, pos, buffer, maxsize);
-	debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);
+	if (dogetsize) {
+		*size = FAT2CPU32(dentptr->size);
+		ret = 0;
+	} else {
+		ret = get_contents(mydata, dentptr, pos, buffer, maxsize, size);
+	}
+	debug("Size: %u, got: %llu\n", FAT2CPU32(dentptr->size), *size);
 
 exit:
 	free(mydata->fatbuf);
 	return ret;
 }
 
-long
-do_fat_read(const char *filename, void *buffer, unsigned long maxsize, int dols)
+int
+do_fat_read(const char *filename, void *buffer, loff_t maxsize, int dols,
+	    loff_t *actread)
 {
-	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0);
+	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0, actread);
 }
 
 int file_fat_detectfs(void)
@@ -1233,44 +1237,50 @@ int file_fat_detectfs(void)
 
 int file_fat_ls(const char *dir)
 {
-	return do_fat_read(dir, NULL, 0, LS_YES);
+	loff_t size;
+
+	return do_fat_read(dir, NULL, 0, LS_YES, &size);
 }
 
 int fat_exists(const char *filename)
 {
-	int sz;
-	sz = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);
-	return sz >= 0;
+	int ret;
+	loff_t size;
+	ret = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, &size);
+	return ret == 0;
 }
 
-int fat_size(const char *filename)
+int fat_size(const char *filename, loff_t *size)
 {
-	return do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);
+	return do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, size);
 }
 
-long file_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-		      unsigned long maxsize)
+int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
+		     loff_t maxsize, loff_t *actread)
 {
 	printf("reading %s\n", filename);
-	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0);
+	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0,
+			      actread);
 }
 
-long file_fat_read(const char *filename, void *buffer, unsigned long maxsize)
+int file_fat_read(const char *filename, void *buffer, loff_t maxsize,
+		  loff_t *actread)
 {
-	return file_fat_read_at(filename, 0, buffer, maxsize);
+	return file_fat_read_at(filename, 0, buffer, maxsize, actread);
 }
 
-int fat_read_file(const char *filename, void *buf, int offset, int len)
+int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		  loff_t *actread)
 {
-	int len_read;
+	int ret;
 
-	len_read = file_fat_read_at(filename, offset, buf, len);
-	if (len_read == -1) {
+	ret = file_fat_read_at(filename, offset, buf, len, actread);
+	if (ret < 0) {
 		printf("** Unable to read file %s **\n", filename);
 		return -1;
 	}
 
-	return len_read;
+	return 0;
 }
 
 void fat_close(void)
diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 24ed5d3..259bf7c 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -660,24 +660,26 @@ static int clear_fatent(fsdata *mydata, __u32 entry)
 /*
  * Write at most 'maxsize' bytes from 'buffer' into
  * the file associated with 'dentptr'
- * Return the number of bytes read or -1 on fatal errors.
+ * Update the number of bytes written in actwrite and return 0
+ * or return -1 on fatal errors.
  */
 static int
 set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
-	      unsigned long maxsize)
+	      loff_t maxsize, loff_t *gotsize)
 {
-	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
+	loff_t filesize = FAT2CPU32(dentptr->size);
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust = 0, newclust = 0;
-	unsigned long actsize;
+	loff_t actsize;
 
-	debug("Filesize: %ld bytes\n", filesize);
+	*gotsize = 0;
+	debug("Filesize: %llu bytes\n", filesize);
 
 	if (maxsize > 0 && filesize > maxsize)
 		filesize = maxsize;
 
-	debug("%ld bytes\n", filesize);
+	debug("%llu bytes\n", filesize);
 
 	actsize = bytesperclust;
 	endclust = curclust;
@@ -692,7 +694,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
 				debug("curclust: 0x%x\n", newclust);
 				debug("Invalid FAT entry\n");
-				return gotsize;
+				return 0;
 			}
 			endclust = newclust;
 			actsize += bytesperclust;
@@ -724,7 +726,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			newclust = 0xfffffff;
 		set_fatent_value(mydata, endclust, newclust);
 
-		return gotsize;
+		return 0;
 getit:
 		if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			debug("error: writing cluster\n");
@@ -737,7 +739,7 @@ getit:
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize = bytesperclust;
 		curclust = endclust = newclust;
@@ -766,7 +768,7 @@ static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
  * exceed the size of the block device
  * Return -1 when overflow occurs, otherwise return 0
  */
-static int check_overflow(fsdata *mydata, __u32 clustnum, unsigned long size)
+static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
 {
 	__u32 startsect, sect_num;
 
@@ -924,7 +926,7 @@ static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
 }
 
 static int do_fat_write(const char *filename, void *buffer,
-	unsigned long size)
+	loff_t size, loff_t *actwrite)
 {
 	dir_entry *dentptr, *retdent;
 	__u32 startsect;
@@ -936,8 +938,8 @@ static int do_fat_write(const char *filename, void *buffer,
 	int cursect;
 	int ret = -1, name_len;
 	char l_filename[VFAT_MAXLEN_BYTES];
-	int write_size = size;
 
+	*actwrite = size;
 	dir_curclust = 0;
 
 	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
@@ -1015,7 +1017,7 @@ static int do_fat_write(const char *filename, void *buffer,
 
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 
@@ -1025,13 +1027,12 @@ static int do_fat_write(const char *filename, void *buffer,
 			goto exit;
 		}
 
-		ret = set_contents(mydata, retdent, buffer, size);
+		ret = set_contents(mydata, retdent, buffer, size, actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
-		debug("attempt to write 0x%x bytes\n", write_size);
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
 
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
@@ -1061,7 +1062,7 @@ static int do_fat_write(const char *filename, void *buffer,
 
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 
@@ -1069,13 +1070,13 @@ static int do_fat_write(const char *filename, void *buffer,
 		fill_dentry(mydata, empty_dentptr, filename,
 			start_cluster, size, 0x20);
 
-		ret = set_contents(mydata, empty_dentptr, buffer, size);
+		ret = set_contents(mydata, empty_dentptr, buffer, size,
+				   actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
-		debug("attempt to write 0x%x bytes\n", write_size);
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
 
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
@@ -1096,11 +1097,12 @@ static int do_fat_write(const char *filename, void *buffer,
 
 exit:
 	free(mydata->fatbuf);
-	return ret < 0 ? ret : write_size;
+	return ret;
 }
 
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize)
+int file_fat_write(const char *filename, void *buffer, loff_t maxsize,
+		   loff_t *actwrite)
 {
 	printf("writing %s\n", filename);
-	return do_fat_write(filename, buffer, maxsize);
+	return do_fat_write(filename, buffer, maxsize, actwrite);
 }
diff --git a/fs/fat/file.c b/fs/fat/file.c
index d910c46..b608883 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -162,8 +162,8 @@ file_ls(const char *dir)
 	return filesystems[current_filesystem].ls(arg);
 }
 
-long
-file_read(const char *filename, void *buffer, unsigned long maxsize)
+int
+file_read(const char *filename, void *buffer, loff_t maxsize, loff_t *actread)
 {
 	char fullpath[1024];
 	const char *arg;
@@ -180,5 +180,6 @@ file_read(const char *filename, void *buffer, unsigned long maxsize)
 		arg = fullpath;
 	}
 
-	return filesystems[current_filesystem].read(arg, buffer, maxsize);
+	return filesystems[current_filesystem].read(arg, buffer, maxsize,
+						    actread);
 }
diff --git a/fs/fs.c b/fs/fs.c
index dd680f3..6b07bc7 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -46,19 +46,21 @@ static inline int fs_exists_unsupported(const char *filename)
 	return 0;
 }
 
-static inline int fs_size_unsupported(const char *filename)
+static inline int fs_size_unsupported(const char *filename, loff_t *size)
 {
 	return -1;
 }
 
 static inline int fs_read_unsupported(const char *filename, void *buf,
-				      int offset, int len)
+				      loff_t offset, loff_t len,
+				      loff_t *actread)
 {
 	return -1;
 }
 
 static inline int fs_write_unsupported(const char *filename, void *buf,
-				      int offset, int len)
+				      loff_t offset, loff_t len,
+				      loff_t *actwrite)
 {
 	return -1;
 }
@@ -82,9 +84,11 @@ struct fstype_info {
 		     disk_partition_t *fs_partition);
 	int (*ls)(const char *dirname);
 	int (*exists)(const char *filename);
-	int (*size)(const char *filename);
-	int (*read)(const char *filename, void *buf, int offset, int len);
-	int (*write)(const char *filename, void *buf, int offset, int len);
+	int (*size)(const char *filename, loff_t *size);
+	int (*read)(const char *filename, void *buf, loff_t offset,
+		    loff_t len, loff_t *actread);
+	int (*write)(const char *filename, void *buf, loff_t offset,
+		     loff_t len, loff_t *actwrite);
 	void (*close)(void);
 };
 
@@ -233,20 +237,21 @@ int fs_exists(const char *filename)
 	return ret;
 }
 
-int fs_size(const char *filename)
+int fs_size(const char *filename, loff_t *size)
 {
 	int ret;
 
 	struct fstype_info *info = fs_get_info(fs_type);
 
-	ret = info->size(filename);
+	ret = info->size(filename, size);
 
 	fs_close();
 
 	return ret;
 }
 
-int fs_read(const char *filename, ulong addr, int offset, int len)
+int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
+	    loff_t *actread)
 {
 	struct fstype_info *info = fs_get_info(fs_type);
 	void *buf;
@@ -257,11 +262,11 @@ int fs_read(const char *filename, ulong addr, int offset, int len)
 	 * means read the whole file.
 	 */
 	buf = map_sysmem(addr, len);
-	ret = info->read(filename, buf, offset, len);
+	ret = info->read(filename, buf, offset, len, actread);
 	unmap_sysmem(buf);
 
 	/* If we requested a specific number of bytes, check we got it */
-	if (ret >= 0 && len && ret != len) {
+	if (ret == 0 && len && *actread != len) {
 		printf("** Unable to read file %s **\n", filename);
 		ret = -1;
 	}
@@ -270,14 +275,15 @@ int fs_read(const char *filename, ulong addr, int offset, int len)
 	return ret;
 }
 
-int fs_write(const char *filename, ulong addr, int offset, int len)
+int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
+	     loff_t *actwrite)
 {
 	struct fstype_info *info = fs_get_info(fs_type);
 	void *buf;
 	int ret;
 
 	buf = map_sysmem(addr, len);
-	ret = info->write(filename, buf, offset, len);
+	ret = info->write(filename, buf, offset, len, actwrite);
 	unmap_sysmem(buf);
 
 	if (ret >= 0 && ret != len) {
@@ -292,7 +298,7 @@ int fs_write(const char *filename, ulong addr, int offset, int len)
 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		int fstype)
 {
-	int size;
+	loff_t size;
 
 	if (argc != 4)
 		return CMD_RET_USAGE;
@@ -300,8 +306,7 @@ int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
 		return 1;
 
-	size = fs_size(argv[3]);
-	if (size < 0)
+	if (fs_size(argv[3], &size) < 0)
 		return CMD_RET_FAILURE;
 
 	setenv_hex("filesize", size);
@@ -315,9 +320,10 @@ int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 	unsigned long addr;
 	const char *addr_str;
 	const char *filename;
-	unsigned long bytes;
-	unsigned long pos;
-	int len_read;
+	loff_t bytes;
+	loff_t pos;
+	loff_t len_read;
+	int ret;
 	unsigned long time;
 	char *ep;
 
@@ -359,12 +365,12 @@ int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		pos = 0;
 
 	time = get_timer(0);
-	len_read = fs_read(filename, addr, pos, bytes);
+	ret = fs_read(filename, addr, pos, bytes, &len_read);
 	time = get_timer(time);
-	if (len_read <= 0)
+	if (ret < 0)
 		return 1;
 
-	printf("%d bytes read in %lu ms", len_read, time);
+	printf("%llu bytes read in %lu ms", len_read, time);
 	if (time > 0) {
 		puts(" (");
 		print_size(len_read / time * 1000, "/s");
@@ -408,9 +414,10 @@ int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 {
 	unsigned long addr;
 	const char *filename;
-	unsigned long bytes;
-	unsigned long pos;
-	int len;
+	loff_t bytes;
+	loff_t pos;
+	loff_t len;
+	int ret;
 	unsigned long time;
 
 	if (argc < 6 || argc > 7)
@@ -428,12 +435,12 @@ int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		pos = 0;
 
 	time = get_timer(0);
-	len = fs_write(filename, addr, pos, bytes);
+	ret = fs_write(filename, addr, pos, bytes, &len);
 	time = get_timer(time);
-	if (len <= 0)
+	if (ret < 0)
 		return 1;
 
-	printf("%d bytes written in %lu ms", len, time);
+	printf("%llu bytes written in %lu ms", len, time);
 	if (time > 0) {
 		puts(" (");
 		print_size(len / time * 1000, "/s");
diff --git a/fs/sandbox/sandboxfs.c b/fs/sandbox/sandboxfs.c
index ba6402c..d4d8378 100644
--- a/fs/sandbox/sandboxfs.c
+++ b/fs/sandbox/sandboxfs.c
@@ -16,7 +16,7 @@ int sandbox_fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
 long sandbox_fs_read_at(const char *filename, unsigned long pos,
 			     void *buffer, unsigned long maxsize)
 {
-	ssize_t size;
+	loff_t size;
 	int fd, ret;
 
 	fd = os_open(filename, OS_O_RDONLY);
@@ -27,8 +27,16 @@ long sandbox_fs_read_at(const char *filename, unsigned long pos,
 		os_close(fd);
 		return ret;
 	}
-	if (!maxsize)
-		maxsize = os_get_filesize(filename);
+	if (!maxsize) {
+		ret = os_get_filesize(filename, &size);
+		if (ret) {
+			os_close(fd);
+			return ret;
+		}
+
+		maxsize = size;
+	}
+
 	size = os_read(fd, buffer, maxsize);
 	os_close(fd);
 
@@ -74,15 +82,16 @@ int sandbox_fs_ls(const char *dirname)
 
 int sandbox_fs_exists(const char *filename)
 {
-	ssize_t sz;
+	loff_t sz;
+	int ret;
 
-	sz = os_get_filesize(filename);
-	return sz >= 0;
+	ret = os_get_filesize(filename, &sz);
+	return ret == 0;
 }
 
-int sandbox_fs_size(const char *filename)
+int sandbox_fs_size(const char *filename, loff_t *size)
 {
-	return os_get_filesize(filename);
+	return os_get_filesize(filename, size);
 }
 
 void sandbox_fs_close(void)
diff --git a/include/configs/sandbox.h b/include/configs/sandbox.h
index ee4b244..9c79b55 100644
--- a/include/configs/sandbox.h
+++ b/include/configs/sandbox.h
@@ -57,6 +57,7 @@
 #define CONFIG_DOS_PARTITION
 #define CONFIG_HOST_MAX_DEVICES 4
 #define CONFIG_CMD_FS_GENERIC
+#define CONFIG_CMD_MD5SUM
 
 #define CONFIG_SYS_VSNPRINTF
 
diff --git a/include/ext4fs.h b/include/ext4fs.h
index 6c419f3..94c28f4 100644
--- a/include/ext4fs.h
+++ b/include/ext4fs.h
@@ -125,24 +125,25 @@ int ext4fs_init(void);
 void ext4fs_deinit(void);
 int ext4fs_filename_check(char *filename);
 int ext4fs_write(const char *fname, unsigned char *buffer,
-				unsigned long sizebytes);
+		 unsigned long sizebytes);
 #endif
 
 struct ext_filesystem *get_fs(void);
-int ext4fs_open(const char *filename);
-int ext4fs_read(char *buf, unsigned len);
+int ext4fs_open(const char *filename, loff_t *len);
+int ext4fs_read(char *buf, loff_t len, loff_t *actread);
 int ext4fs_mount(unsigned part_length);
 void ext4fs_close(void);
 void ext4fs_reinit_global(void);
 int ext4fs_ls(const char *dirname);
 int ext4fs_exists(const char *filename);
-int ext4fs_size(const char *filename);
+int ext4fs_size(const char *filename, loff_t *size);
 void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot);
 int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf);
 void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
 long int read_allocated_block(struct ext2_inode *inode, int fileblock);
 int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
 		 disk_partition_t *fs_partition);
-int ext4_read_file(const char *filename, void *buf, int offset, int len);
+int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		   loff_t *actread);
 int ext4_read_superblock(char *buffer);
 #endif
diff --git a/include/fat.h b/include/fat.h
index 20ca3f3..35072df 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -178,8 +178,8 @@ typedef struct {
 
 typedef int	(file_detectfs_func)(void);
 typedef int	(file_ls_func)(const char *dir);
-typedef long	(file_read_func)(const char *filename, void *buffer,
-				 unsigned long maxsize);
+typedef int	(file_read_func)(const char *filename, void *buffer,
+				 loff_t maxsize, loff_t *actread);
 
 struct filesystem {
 	file_detectfs_func	*detect;
@@ -198,15 +198,18 @@ int file_cd(const char *path);
 int file_fat_detectfs(void);
 int file_fat_ls(const char *dir);
 int fat_exists(const char *filename);
-int fat_size(const char *filename);
-long file_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-		      unsigned long maxsize);
-long file_fat_read(const char *filename, void *buffer, unsigned long maxsize);
+int fat_size(const char *filename, loff_t *size);
+int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
+		     loff_t maxsize, loff_t *actread);
+int file_fat_read(const char *filename, void *buffer, loff_t maxsize,
+		  loff_t *actread);
 const char *file_getfsname(int idx);
 int fat_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
 int fat_register_device(block_dev_desc_t *dev_desc, int part_no);
 
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize);
-int fat_read_file(const char *filename, void *buf, int offset, int len);
+int file_fat_write(const char *filename, void *buffer, loff_t maxsize,
+		   loff_t *actwrite);
+int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		  loff_t *actread);
 void fat_close(void);
 #endif /* _FAT_H_ */
diff --git a/include/fs.h b/include/fs.h
index 06a45f2..61ff572 100644
--- a/include/fs.h
+++ b/include/fs.h
@@ -55,7 +55,7 @@ int fs_exists(const char *filename);
  *
  * Returns the file's size in bytes, or a negative value if it doesn't exist.
  */
-int fs_size(const char *filename);
+int fs_size(const char *filename, loff_t *size);
 
 /*
  * Read file "filename" from the partition previously set by fs_set_blk_dev(),
@@ -66,7 +66,8 @@ int fs_size(const char *filename);
  *
  * Returns number of bytes read on success. Returns <= 0 on error.
  */
-int fs_read(const char *filename, ulong addr, int offset, int len);
+int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
+	    loff_t *actread);
 
 /*
  * Write file "filename" to the partition previously set by fs_set_blk_dev(),
@@ -76,7 +77,8 @@ int fs_read(const char *filename, ulong addr, int offset, int len);
  *
  * Returns number of bytes read on success. Returns <= 0 on error.
  */
-int fs_write(const char *filename, ulong addr, int offset, int len);
+int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
+	     loff_t *actwrite);
 
 /*
  * Common implementation for various filesystem commands, optionally limited
diff --git a/include/os.h b/include/os.h
index 0230a7f..cfefc8c 100644
--- a/include/os.h
+++ b/include/os.h
@@ -219,7 +219,7 @@ const char *os_dirent_get_typename(enum os_dirent_t type);
  * @param fname		Filename to check
  * @return size of file, or -1 if an error ocurred
  */
-ssize_t os_get_filesize(const char *fname);
+int os_get_filesize(const char *fname, loff_t *size);
 
 /**
  * Write a character to the controlling OS terminal
diff --git a/include/sandboxfs.h b/include/sandboxfs.h
index e7c3262..ea11168 100644
--- a/include/sandboxfs.h
+++ b/include/sandboxfs.h
@@ -26,8 +26,10 @@ long sandbox_fs_read_at(const char *filename, unsigned long pos,
 void sandbox_fs_close(void);
 int sandbox_fs_ls(const char *dirname);
 int sandbox_fs_exists(const char *filename);
-int sandbox_fs_size(const char *filename);
-int fs_read_sandbox(const char *filename, void *buf, int offset, int len);
-int fs_write_sandbox(const char *filename, void *buf, int offset, int len);
+int sandbox_fs_size(const char *filename, loff_t *size);
+int fs_read_sandbox(const char *filename, void *buf, loff_t offset, loff_t len,
+		    loff_t *size);
+int fs_write_sandbox(const char *filename, void *buf, loff_t offset,
+		     loff_t len, loff_t *actwrite);
 
 #endif
diff --git a/test/fs/testfs.sh b/test/fs/testfs.sh
new file mode 100644
index 0000000..5561e56
--- /dev/null
+++ b/test/fs/testfs.sh
@@ -0,0 +1,306 @@
+#!/bin/bash
+# (C) Copyright 2014 Suriyan Ramasami
+#
+#  SPDX-License-Identifier:	GPL-2.0+
+#
+
+# Call with parameter clean to remove all its generated files and exit
+
+IMG=./3GB
+TMPMOUNT=tmpmount
+SFILE=1MB.file
+BFILE=2.5GB.file
+MD5FILE=./md5s.list
+
+# Output files
+OUT=test.output
+
+# All out files will have the above prefix and a .out suffix
+rm -f ${MD5FILE}.* ${OUT}.*.out
+
+if [ "$1" = "clean" ]; then
+	rm -f *.img
+	exit
+fi
+
+MB1=${TMPMOUNT}/${SFILE}
+GB2p5=${TMPMOUNT}/${BFILE}
+
+# 1st parameter is the prefix name of the image file
+# 2nd parameter is the filesystem - vfat ext4 etc
+# The final image file is $1.$2.img
+# Returns the actual image created.
+function CreateImg() {
+	THE_IMG=$1.$2.img
+
+	# Create image if not already present - saves time, while debugging
+
+	if [ ! -f ${THE_IMG} ]; then
+		fallocate -l 3G ${THE_IMG} &> /dev/null
+		if [ "$2" = "ext4" ]; then
+		      mkfs.${2} ${THE_IMG} &> /dev/null <<EOF
+y
+EOF
+		else
+			mkfs.${2} ${THE_IMG} &> /dev/null
+		fi
+	fi
+	echo "${THE_IMG}"
+}
+
+# First parameter is image file
+# Second parameter is image file format - vfat/ext4
+# Third parameter which is prepended to the ls/load commands
+#   Example: load vs fatload
+# Assumes SFILE and BfILE are set in env
+function TestImg() {
+	THE_IMG="${1}"
+	PREFIX="${3}"
+
+	# In u-boot commands, <interface> stands for host or hostfs
+	# hostfs maps to the host fs.
+	# host maps to the "sb bind" that we do
+
+	../../u-boot << EOF
+
+sb bind 0 ${THE_IMG}
+${PREFIX}ls host 0:0 /
+#
+# 1MB is 0x0010 0000
+${PREFIX}size host 0:0 ${SFILE}
+printenv filesize
+setenv filesize
+
+# 2.5GB (1024*1024*2500) is 0x9C40 0000
+${PREFIX}size host 0:0 ${BFILE}
+printenv filesize
+setenv filesize
+
+# Notes about load operation
+# If I use 0x01000000 I get DMA misaligned error message
+# Last two parameters are size and offset.
+
+# Read full 1MB of small file
+${PREFIX}load host 0:0 0x01000008 ${SFILE}
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# First 1MB of big file
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00100000 0x0
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# Last 1MB of big file - fails for ext as no offset support
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00100000 0x9C300000
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# One from the last 1MB chunk of 2GB - fails for ext
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00100000 0x7FF00000
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# One from the start 1MB chunk from 2GB - fails for ext
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00100000 0x80000000
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# One 1MB chunk crossing the 2GB boundary - fails for ext
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00100000 0x7FF80000
+printenv filesize
+md5sum 0x01000008 \$filesize
+setenv filesize
+
+# 2MB chunk from the last 1MB of big file - Generic failure case
+${PREFIX}load host 0:0 0x01000008 ${BFILE} 0x00200000 0x9C300000
+printenv filesize
+#
+
+reset
+
+EOF
+}
+
+# Assume 1st argument is the name of the image file.
+# Assume 2nd argument is the file where we generate the md5s of the
+# files generated with the appropriate start and length that we use to test
+function CreateFilesInImg() {
+	THE_IMG="$1"
+	MD5OUT="$2"
+
+	# Create a big file in this image.
+	# Note that we work only on the start 1MB, couple MBs in the 2GB range
+	# and the last 1 MB of the huge 2.5GB file.
+	# So, just put random values only in those areas.
+	mkdir -p ${TMPMOUNT}
+	sudo mount -o loop ${THE_IMG} ${TMPMOUNT}
+	if [ ! -f ${GB2p5} ]; then
+		sudo dd if=/dev/urandom of=${GB2p5} bs=1M count=1 \
+			2> /dev/null
+		sudo dd if=/dev/urandom of=${GB2p5} bs=1M count=2 seek=2047 \
+			2> /dev/null
+		sudo dd if=/dev/urandom of=${GB2p5} bs=1M count=1 seek=2499 \
+			2> /dev/null
+	fi
+
+	# Create a small file in this image.
+	if [ ! -f ${MB1} ]; then
+		sudo dd if=/dev/urandom of=${MB1} bs=1M count=1 2> /dev/null
+	fi
+
+	# Generate the md5sums of reads that we will test against small file
+	dd if=${MB1} bs=1M skip=0 count=1 2> /dev/null | md5sum > ${MD5OUT}
+
+	# Generate the md5sums of reads that we will test against big file
+	# One from beginning of file.
+	dd if=${GB2p5} bs=1M skip=0 count=1 2> /dev/null | md5sum >> ${MD5OUT}
+
+	# One from end of file.
+	dd if=${GB2p5} bs=1M skip=2499 count=1 \
+		2> /dev/null | md5sum >> ${MD5OUT}
+
+	# One from the last 1MB chunk of 2GB
+	dd if=${GB2p5} bs=1M skip=2047 count=1 \
+		2> /dev/null | md5sum >> ${MD5OUT}
+
+	# One from the start 1MB chunk from 2GB
+	dd if=${GB2p5} bs=1M skip=2048 count=1 \
+		2> /dev/null | md5sum >> ${MD5OUT}
+
+	# One 1MB chunk crossing the 2GB boundary
+	dd if=${GB2p5} bs=512K skip=4095 count=2 \
+		2> /dev/null | md5sum >> ${MD5OUT}
+
+	sync
+	sudo umount tmpmount
+	rmdir tmpmount
+}
+
+# First parameter is the text
+# if $? is 0 its a pass, else a fail
+function PassFail() {
+
+	if [ $? -eq 0 ]; then
+		echo pass - "$1"
+	else
+		echo FAIL - "$1"
+	fi
+}
+
+# Parameter 1 is the string which leads to an md5 generation
+# Parameter 2 is the file we grep for that string
+# Parameter 3 is the name of the file which has md5s in it
+# Parameter 4 is the line # in the md5 file that we match it against
+CheckMD5() {
+
+	md5src=`grep -A6 "$1" "$2" | grep "md5 for"`
+	md5src=($md5src)
+	md5src=${md5src[6]}
+	md5dst=`sed -n $4p $3`
+	md5dst=($md5dst)
+	md5dst=${md5dst[0]}
+	[ "$md5src" = "$md5dst" ]
+	PassFail "$1"
+}
+
+# First parameter is the name of the output file to check
+# Second parameter is the name of the file containing the md5 expected
+function CheckResults() {
+	OUTFILE="$1"
+	MD5="$2"
+
+	echo "------------------- Start $1 ---------------------"
+	# Check if the ls is showing correct results for 2.5 gb file
+	grep -A6 "ls host 0:0" $OUTFILE | grep 2621440000 | grep -iq 2.5gb.file
+	PassFail "ls host 0:0 of 2.5 GB file"
+
+	# Check if the ls is showing correct results for 1 mb file
+	grep -A6 "ls host 0:0" $OUTFILE | grep 1048576 | grep -iq 1mb.file
+	PassFail "ls host 0:0 of 1 MB file"
+
+	# Check size command on 1MB.file
+	grep -A3 "size host 0:0 1MB.file" $OUTFILE | grep -q "filesize=100000"
+	PassFail "size host 0:0 1MB.file"
+
+	# Check size command on 2.5GB.file
+	grep -A3 "size host 0:0 2.5GB.file" $OUTFILE \
+		| grep -q "filesize=9c400000"
+	PassFail "size host 0:0 2.5GB.file"
+
+	# Check read full mb of 1MB.file
+	grep -A6 "load host 0:0 0x01000008 1MB.file" $OUTFILE | \
+		grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 1MB.file sz"
+	CheckMD5 "load host 0:0 0x01000008 1MB.file" $OUTFILE $MD5 1
+
+	# Check first mb of 2.5GB.file
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x0" \
+		$OUTFILE | grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x0 sz"
+	CheckMD5 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x0" \
+		$OUTFILE $MD5 2
+
+	# Check last mb of 2.5GB.file
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x9C300000" \
+		$OUTFILE | grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x9C300000 sz"
+	CheckMD5 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x9C300000" \
+		$OUTFILE $MD5 3
+
+	# Check last 1mb chunk of 2gb from 2.5GB file
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF00000" \
+		$OUTFILE | grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF00000 sz"
+	CheckMD5 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF00000" \
+		$OUTFILE $MD5 4
+
+	# Check first 1mb chunk after 2gb from 2.5GB file
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x80000000" \
+		$OUTFILE | grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x80000000 sz"
+	CheckMD5 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x80000000" \
+		$OUTFILE $MD5 5
+
+	# Check 1mb chunk crossing the 2gb boundary from 2.5GB file
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF80000" \
+		$OUTFILE | grep -q "filesize=100000"
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF80000 sz"
+	CheckMD5 "load host 0:0 0x01000008 2.5GB.file 0x00100000 0x7FF80000" \
+		$OUTFILE $MD5 6
+
+	# Check 2mb chunk from the last 1MV of 2.5GB file - generic failure case
+	grep -A6 "load host 0:0 0x01000008 2.5GB.file 0x00200000 0x9C300000" \
+		$OUTFILE | grep -q 'Error: "filesize" not defined'
+	PassFail "load host 0:0 0x01000008 2.5GB.file 0x00200000 0x9C300000 sz"
+
+	echo "------------------- End $1 ---------------------"
+	echo ""
+}
+
+for fs in fat ext4; do
+
+	if [ $fs = "fat" ]; then
+		FS=vfat
+	else
+		FS=$fs
+	fi
+	echo "Creating $FS image if not already present."
+	ACTIMG=`CreateImg ${IMG} ${FS}`
+
+	echo "Creating files in $FS image if not already present."
+	CreateFilesInImg ${ACTIMG} ${MD5FILE}.${fs}
+
+	TestImg ${ACTIMG} ${fs} > ${OUT}.${fs}.out
+
+	CheckResults ${OUT}.${fs}.out ${MD5FILE}.${fs}
+
+	TestImg ${ACTIMG} "" > ${OUT}.fs.${fs}.out
+
+	CheckResults ${OUT}.fs.${fs}.out ${MD5FILE}.${fs}
+done
+
